mistralai 1.0.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

mistralai/models/jobs_api_routes_fine_tuning_get_fine_tuning_jobop.py

@@ -3,16 +3,16 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class JobsAPIRoutesFineTuningGetFineTuningJobRequestTypedDict(TypedDict):
     job_id: str
     r"""The ID of the job to analyse."""
-    
+
 
 class JobsAPIRoutesFineTuningGetFineTuningJobRequest(BaseModel):
-    job_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    job_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
     r"""The ID of the job to analyse."""
-    

mistralai/models/jobs_api_routes_fine_tuning_get_fine_tuning_jobsop.py

@@ -5,13 +5,25 @@ from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import FieldMetadata, QueryParamMetadata
 from pydantic import model_serializer
-from typing import Literal, Optional, TypedDict
-from typing_extensions import Annotated, NotRequired
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-QueryParamStatus = Literal["QUEUED", "STARTED", "VALIDATING", "VALIDATED", "RUNNING", "FAILED_VALIDATION", "FAILED", "SUCCESS", "CANCELLED", "CANCELLATION_REQUESTED"]
+QueryParamStatus = Literal[
+    "QUEUED",
+    "STARTED",
+    "VALIDATING",
+    "VALIDATED",
+    "RUNNING",
+    "FAILED_VALIDATION",
+    "FAILED",
+    "SUCCESS",
+    "CANCELLED",
+    "CANCELLATION_REQUESTED",
+]
 r"""The current job state to filter on. When set, the other results are not displayed."""
 
+
 class JobsAPIRoutesFineTuningGetFineTuningJobsRequestTypedDict(TypedDict):
     page: NotRequired[int]
     r"""The page number of the results to be returned."""
@@ -31,32 +43,84 @@ class JobsAPIRoutesFineTuningGetFineTuningJobsRequestTypedDict(TypedDict):
     r"""The Weight and Biases run name to filter on. When set, the other results are not displayed."""
     suffix: NotRequired[Nullable[str]]
     r"""The model suffix to filter on. When set, the other results are not displayed."""
-    
+
 
 class JobsAPIRoutesFineTuningGetFineTuningJobsRequest(BaseModel):
-    page: Annotated[Optional[int], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = 0
+    page: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 0
     r"""The page number of the results to be returned."""
-    page_size: Annotated[Optional[int], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = 100
+
+    page_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 100
     r"""The number of items to return per page."""
-    model: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    model: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The model name used for fine-tuning to filter on. When set, the other results are not displayed."""
-    created_after: Annotated[OptionalNullable[datetime], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    created_after: Annotated[
+        OptionalNullable[datetime],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The date/time to filter on. When set, the results for previous creation times are not displayed."""
-    created_by_me: Annotated[Optional[bool], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = False
+
+    created_by_me: Annotated[
+        Optional[bool],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = False
     r"""When set, only return results for jobs created by the API caller. Other results are not displayed."""
-    status: Annotated[OptionalNullable[QueryParamStatus], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    status: Annotated[
+        OptionalNullable[QueryParamStatus],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The current job state to filter on. When set, the other results are not displayed."""
-    wandb_project: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    wandb_project: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The Weights and Biases project to filter on. When set, the other results are not displayed."""
-    wandb_name: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    wandb_name: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The Weight and Biases run name to filter on. When set, the other results are not displayed."""
-    suffix: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+
+    suffix: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
     r"""The model suffix to filter on. When set, the other results are not displayed."""
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["page", "page_size", "model", "created_after", "created_by_me", "status", "wandb_project", "wandb_name", "suffix"]
-        nullable_fields = ["model", "created_after", "status", "wandb_project", "wandb_name", "suffix"]
+        optional_fields = [
+            "page",
+            "page_size",
+            "model",
+            "created_after",
+            "created_by_me",
+            "status",
+            "wandb_project",
+            "wandb_name",
+            "suffix",
+        ]
+        nullable_fields = [
+            "model",
+            "created_after",
+            "status",
+            "wandb_project",
+            "wandb_name",
+            "suffix",
+        ]
         null_default_fields = []
 
         serialized = handler(self)
@@ -66,9 +130,13 @@ class JobsAPIRoutesFineTuningGetFineTuningJobsRequest(BaseModel):
         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
+            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
@@ -78,4 +146,3 @@ class JobsAPIRoutesFineTuningGetFineTuningJobsRequest(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/jobs_api_routes_fine_tuning_start_fine_tuning_jobop.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class JobsAPIRoutesFineTuningStartFineTuningJobRequestTypedDict(TypedDict):
     job_id: str
-    
+
 
 class JobsAPIRoutesFineTuningStartFineTuningJobRequest(BaseModel):
-    job_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
-    
+    job_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]

mistralai/models/jobs_api_routes_fine_tuning_unarchive_fine_tuned_modelop.py

@@ -3,16 +3,16 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class JobsAPIRoutesFineTuningUnarchiveFineTunedModelRequestTypedDict(TypedDict):
     model_id: str
     r"""The ID of the model to unarchive."""
-    
+
 
 class JobsAPIRoutesFineTuningUnarchiveFineTunedModelRequest(BaseModel):
-    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    model_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
     r"""The ID of the model to unarchive."""
-    

mistralai/models/jobs_api_routes_fine_tuning_update_fine_tuned_modelop.py

@@ -4,18 +4,22 @@ from __future__ import annotations
 from .updateftmodelin import UpdateFTModelIn, UpdateFTModelInTypedDict
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata, RequestMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class JobsAPIRoutesFineTuningUpdateFineTunedModelRequestTypedDict(TypedDict):
     model_id: str
     r"""The ID of the model to update."""
     update_ft_model_in: UpdateFTModelInTypedDict
-    
+
 
 class JobsAPIRoutesFineTuningUpdateFineTunedModelRequest(BaseModel):
-    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    model_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
     r"""The ID of the model to update."""
-    update_ft_model_in: Annotated[UpdateFTModelIn, FieldMetadata(request=RequestMetadata(media_type="application/json"))]
-    
+
+    update_ft_model_in: Annotated[
+        UpdateFTModelIn,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]

mistralai/models/jobsout.py

@@ -3,20 +3,28 @@
 from __future__ import annotations
 from .jobout import JobOut, JobOutTypedDict
 from mistralai.types import BaseModel
+from mistralai.utils import validate_const
 import pydantic
-from typing import Final, List, Literal, Optional, TypedDict
-from typing_extensions import Annotated, NotRequired
+from pydantic.functional_validators import AfterValidator
+from typing import List, Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 JobsOutObject = Literal["list"]
 
+
 class JobsOutTypedDict(TypedDict):
     total: int
     data: NotRequired[List[JobOutTypedDict]]
-    
+    object: JobsOutObject
+
 
 class JobsOut(BaseModel):
     total: int
+
     data: Optional[List[JobOut]] = None
-    OBJECT: Annotated[Final[Optional[JobsOutObject]], pydantic.Field(alias="object")] = "list" # type: ignore
-    
+
+    OBJECT: Annotated[
+        Annotated[Optional[JobsOutObject], AfterValidator(validate_const("list"))],
+        pydantic.Field(alias="object"),
+    ] = "list"

mistralai/models/legacyjobmetadataout.py

@@ -2,14 +2,17 @@
 
 from __future__ import annotations
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from typing import Final, Literal, Optional, TypedDict
-from typing_extensions import Annotated, NotRequired
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 LegacyJobMetadataOutObject = Literal["job.metadata"]
 
+
 class LegacyJobMetadataOutTypedDict(TypedDict):
     details: str
     expected_duration_seconds: NotRequired[Nullable[int]]
@@ -30,34 +33,74 @@ class LegacyJobMetadataOutTypedDict(TypedDict):
     r"""The number of complete passes through the entire training dataset."""
     training_steps: NotRequired[Nullable[int]]
     r"""The number of training steps to perform. A training step refers to a single update of the model weights during the fine-tuning process. This update is typically calculated using a batch of samples from the training dataset."""
-    
+    object: LegacyJobMetadataOutObject
+
 
 class LegacyJobMetadataOut(BaseModel):
     details: str
+
     expected_duration_seconds: OptionalNullable[int] = UNSET
     r"""The approximated time (in seconds) for the fine-tuning process to complete."""
+
     cost: OptionalNullable[float] = UNSET
     r"""The cost of the fine-tuning job."""
+
     cost_currency: OptionalNullable[str] = UNSET
     r"""The currency used for the fine-tuning job cost."""
+
     train_tokens_per_step: OptionalNullable[int] = UNSET
     r"""The number of tokens consumed by one training step."""
+
     train_tokens: OptionalNullable[int] = UNSET
     r"""The total number of tokens used during the fine-tuning process."""
+
     data_tokens: OptionalNullable[int] = UNSET
     r"""The total number of tokens in the training dataset."""
+
     estimated_start_time: OptionalNullable[int] = UNSET
+
     deprecated: Optional[bool] = True
+
     epochs: OptionalNullable[float] = UNSET
     r"""The number of complete passes through the entire training dataset."""
+
     training_steps: OptionalNullable[int] = UNSET
     r"""The number of training steps to perform. A training step refers to a single update of the model weights during the fine-tuning process. This update is typically calculated using a batch of samples from the training dataset."""
-    OBJECT: Annotated[Final[Optional[LegacyJobMetadataOutObject]], pydantic.Field(alias="object")] = "job.metadata" # type: ignore
-    
+
+    OBJECT: Annotated[
+        Annotated[
+            Optional[LegacyJobMetadataOutObject],
+            AfterValidator(validate_const("job.metadata")),
+        ],
+        pydantic.Field(alias="object"),
+    ] = "job.metadata"
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["expected_duration_seconds", "cost", "cost_currency", "train_tokens_per_step", "train_tokens", "data_tokens", "estimated_start_time", "deprecated", "epochs", "training_steps", "object"]
-        nullable_fields = ["expected_duration_seconds", "cost", "cost_currency", "train_tokens_per_step", "train_tokens", "data_tokens", "estimated_start_time", "epochs", "training_steps"]
+        optional_fields = [
+            "expected_duration_seconds",
+            "cost",
+            "cost_currency",
+            "train_tokens_per_step",
+            "train_tokens",
+            "data_tokens",
+            "estimated_start_time",
+            "deprecated",
+            "epochs",
+            "training_steps",
+            "object",
+        ]
+        nullable_fields = [
+            "expected_duration_seconds",
+            "cost",
+            "cost_currency",
+            "train_tokens_per_step",
+            "train_tokens",
+            "data_tokens",
+            "estimated_start_time",
+            "epochs",
+            "training_steps",
+        ]
         null_default_fields = []
 
         serialized = handler(self)
@@ -67,9 +110,13 @@ class LegacyJobMetadataOut(BaseModel):
         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
+            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
@@ -79,4 +126,3 @@ class LegacyJobMetadataOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/listfilesout.py

@@ -3,15 +3,19 @@
 from __future__ import annotations
 from .fileschema import FileSchema, FileSchemaTypedDict
 from mistralai.types import BaseModel
-from typing import List, TypedDict
+from typing import List
+from typing_extensions import TypedDict
 
 
 class ListFilesOutTypedDict(TypedDict):
     data: List[FileSchemaTypedDict]
     object: str
-    
+    total: int
+
 
 class ListFilesOut(BaseModel):
     data: List[FileSchema]
+
     object: str
-    
+
+    total: int

mistralai/models/metricout.py

@@ -3,25 +3,26 @@
 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
+from typing_extensions import NotRequired, TypedDict
 
 
 class MetricOutTypedDict(TypedDict):
     r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
-    
+
     train_loss: NotRequired[Nullable[float]]
     valid_loss: NotRequired[Nullable[float]]
     valid_mean_token_accuracy: NotRequired[Nullable[float]]
-    
+
 
 class MetricOut(BaseModel):
     r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
-    
+
     train_loss: OptionalNullable[float] = UNSET
+
     valid_loss: OptionalNullable[float] = UNSET
+
     valid_mean_token_accuracy: OptionalNullable[float] = UNSET
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["train_loss", "valid_loss", "valid_mean_token_accuracy"]
@@ -35,9 +36,13 @@ class MetricOut(BaseModel):
         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
+            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
@@ -47,4 +52,3 @@ class MetricOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/modelcapabilities.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 from mistralai.types import BaseModel
-from typing import Optional, TypedDict
-from typing_extensions import NotRequired
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
 
 
 class ModelCapabilitiesTypedDict(TypedDict):
@@ -11,11 +11,16 @@ class ModelCapabilitiesTypedDict(TypedDict):
     completion_fim: NotRequired[bool]
     function_calling: NotRequired[bool]
     fine_tuning: NotRequired[bool]
-    
+    vision: NotRequired[bool]
+
 
 class ModelCapabilities(BaseModel):
     completion_chat: Optional[bool] = True
+
     completion_fim: Optional[bool] = False
+
     function_calling: Optional[bool] = True
+
     fine_tuning: Optional[bool] = False
-    
+
+    vision: Optional[bool] = False

mistralai/models/modellist.py

@@ -1,18 +1,32 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .modelcard import ModelCard, ModelCardTypedDict
+from .basemodelcard import BaseModelCard, BaseModelCardTypedDict
+from .ftmodelcard import FTModelCard, FTModelCardTypedDict
 from mistralai.types import BaseModel
-from typing import List, Optional, TypedDict
-from typing_extensions import NotRequired
+from mistralai.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+DataTypedDict = Union[BaseModelCardTypedDict, FTModelCardTypedDict]
+
+
+Data = Annotated[
+    Union[
+        Annotated[BaseModelCard, Tag("base")], Annotated[FTModelCard, Tag("fine-tuned")]
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
 
 
 class ModelListTypedDict(TypedDict):
     object: NotRequired[str]
-    data: NotRequired[List[ModelCardTypedDict]]
-    
+    data: NotRequired[List[DataTypedDict]]
+
 
 class ModelList(BaseModel):
     object: Optional[str] = "list"
-    data: Optional[List[ModelCard]] = None
-    
+
+    data: Optional[List[Data]] = None

mistralai/models/responseformat.py

@@ -1,18 +1,17 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .responseformats import ResponseFormats
 from mistralai.types import BaseModel
-from typing import Literal, Optional, TypedDict
-from typing_extensions import NotRequired
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
 
 
-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]
-    
+    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 ResponseFormat(BaseModel):
-    type: Optional[ResponseFormats] = "text"
-    
+    type: Optional[ResponseFormats] = None
+    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."""

mistralai/models/responseformats.py

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+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."""

mistralai/models/retrieve_model_v1_models_model_id_getop.py

@@ -1,18 +1,37 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .basemodelcard import BaseModelCard, BaseModelCardTypedDict
+from .ftmodelcard import FTModelCard, FTModelCardTypedDict
 from mistralai.types import BaseModel
-from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from mistralai.utils import FieldMetadata, PathParamMetadata, get_discriminator
+from pydantic import Discriminator, Tag
+from typing import Union
+from typing_extensions import Annotated, TypedDict
 
 
 class RetrieveModelV1ModelsModelIDGetRequestTypedDict(TypedDict):
     model_id: str
     r"""The ID of the model to retrieve."""
-    
+
 
 class RetrieveModelV1ModelsModelIDGetRequest(BaseModel):
-    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    model_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
     r"""The ID of the model to retrieve."""
-    
+
+
+RetrieveModelV1ModelsModelIDGetResponseRetrieveModelV1ModelsModelIDGetTypedDict = Union[
+    BaseModelCardTypedDict, FTModelCardTypedDict
+]
+r"""Successful Response"""
+
+
+RetrieveModelV1ModelsModelIDGetResponseRetrieveModelV1ModelsModelIDGet = Annotated[
+    Union[
+        Annotated[BaseModelCard, Tag("base")], Annotated[FTModelCard, Tag("fine-tuned")]
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""Successful Response"""