truefoundry 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

truefoundry/ml/autogen/client/api/mlfoundry_artifacts_api.py

@@ -79,6 +79,9 @@ from truefoundry.ml.autogen.client.models.export_deployment_files_request_dto im
 from truefoundry.ml.autogen.client.models.finalize_artifact_version_request_dto import (
     FinalizeArtifactVersionRequestDto,
 )
+from truefoundry.ml.autogen.client.models.get_artifact_version_aliases_response_dto import (
+    GetArtifactVersionAliasesResponseDto,
+)
 from truefoundry.ml.autogen.client.models.get_signed_url_for_dataset_write_request_dto import (
     GetSignedURLForDatasetWriteRequestDto,
 )
@@ -5338,6 +5341,152 @@ class MlfoundryArtifactsApi:
             _request_auth=_params.get("_request_auth"),
         )
 
+    @validate_arguments
+    def get_version_aliases_for_artifact_get(
+        self, artifact_id: StrictStr, **kwargs
+    ) -> GetArtifactVersionAliasesResponseDto:  # noqa: E501
+        """Get Version Aliases For Artifact  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_version_aliases_for_artifact_get(artifact_id, async_req=True)
+        >>> result = thread.get()
+
+        :param artifact_id: (required)
+        :type artifact_id: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: GetArtifactVersionAliasesResponseDto
+        """
+        kwargs["_return_http_data_only"] = True
+        if "_preload_content" in kwargs:
+            message = "Error! Please call the get_version_aliases_for_artifact_get_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        return self.get_version_aliases_for_artifact_get_with_http_info(
+            artifact_id, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def get_version_aliases_for_artifact_get_with_http_info(
+        self, artifact_id: StrictStr, **kwargs
+    ) -> ApiResponse:  # noqa: E501
+        """Get Version Aliases For Artifact  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_version_aliases_for_artifact_get_with_http_info(artifact_id, async_req=True)
+        >>> result = thread.get()
+
+        :param artifact_id: (required)
+        :type artifact_id: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(GetArtifactVersionAliasesResponseDto, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["artifact_id"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_version_aliases_for_artifact_get" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        if _params.get("artifact_id") is not None:  # noqa: E501
+            _query_params.append(("artifact_id", _params["artifact_id"]))
+
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["HTTPBearer", "APIKeyCookie"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "GetArtifactVersionAliasesResponseDto",
+            "422": "HTTPValidationError",
+        }
+
+        return self.api_client.call_api(
+            "/api/2.0/mlflow/mlfoundry-artifacts/artifacts/get-version-aliases",
+            "GET",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
     @validate_arguments
     def list_artifact_versions_post(
         self,

truefoundry/ml/autogen/client/models/__init__.py

@@ -155,6 +155,9 @@ from truefoundry.ml.autogen.client.models.finalize_artifact_version_request_dto
     FinalizeArtifactVersionRequestDto,
 )
 from truefoundry.ml.autogen.client.models.framework import Framework
+from truefoundry.ml.autogen.client.models.get_artifact_version_aliases_response_dto import (
+    GetArtifactVersionAliasesResponseDto,
+)
 from truefoundry.ml.autogen.client.models.get_experiment_response_dto import (
     GetExperimentResponseDto,
 )

truefoundry/ml/autogen/client/models/artifact_version_manifest.py

@@ -42,12 +42,35 @@ class ArtifactVersionManifest(BaseModel):
         default=...,
         description="+label=Metadata +docs=Metadata for the artifact or model version +usage=Metadata for the artifact or model version +uiType=JsonInput",
     )
+    version_alias: Optional[constr(strict=True, max_length=128)] = Field(
+        default=None,
+        description="+label=Version Alias +usage=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc) +docs=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc) +message=The version alias should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc)",
+    )
     type: Optional[StrictStr] = "artifact-version"
     source: Source = Field(...)
     step: Optional[conint(strict=True, ge=0)] = Field(
         default=0, description="+label=Step"
     )
-    __properties = ["description", "metadata", "type", "source", "step"]
+    __properties = [
+        "description",
+        "metadata",
+        "version_alias",
+        "type",
+        "source",
+        "step",
+    ]
+
+    @validator("version_alias")
+    def version_alias_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^v[a-zA-Z0-9.-]*([a-zA-Z0-9]+)$", value):
+            raise ValueError(
+                r"must validate the regular expression /^v[a-zA-Z0-9.-]*([a-zA-Z0-9]+)$/"
+            )
+        return value
 
     @validator("type")
     def type_validate_enum(cls, value):
@@ -99,6 +122,7 @@ class ArtifactVersionManifest(BaseModel):
             {
                 "description": obj.get("description"),
                 "metadata": obj.get("metadata"),
+                "version_alias": obj.get("version_alias"),
                 "type": obj.get("type")
                 if obj.get("type") is not None
                 else "artifact-version",

truefoundry/ml/autogen/client/models/get_artifact_version_aliases_response_dto.py

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+
+from truefoundry.pydantic_v1 import BaseModel, Field, StrictStr, conlist
+
+
+class GetArtifactVersionAliasesResponseDto(BaseModel):
+    """
+    GetArtifactVersionAliasesResponseDto
+    """
+
+    version_aliases: conlist(StrictStr) = Field(...)
+    __properties = ["version_aliases"]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GetArtifactVersionAliasesResponseDto:
+        """Create an instance of GetArtifactVersionAliasesResponseDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GetArtifactVersionAliasesResponseDto:
+        """Create an instance of GetArtifactVersionAliasesResponseDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GetArtifactVersionAliasesResponseDto.parse_obj(obj)
+
+        _obj = GetArtifactVersionAliasesResponseDto.parse_obj(
+            {"version_aliases": obj.get("version_aliases")}
+        )
+        return _obj

truefoundry/ml/autogen/client/models/model_version_manifest.py

@@ -46,6 +46,10 @@ class ModelVersionManifest(BaseModel):
         default=...,
         description="+label=Metadata +docs=Metadata for the artifact or model version +usage=Metadata for the artifact or model version +uiType=JsonInput",
     )
+    version_alias: Optional[constr(strict=True, max_length=128)] = Field(
+        default=None,
+        description="+label=Version Alias +usage=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc) +docs=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc) +message=The version alias should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc)",
+    )
     type: Optional[StrictStr] = "model-version"
     source: Source1 = Field(...)
     framework: Optional[Framework] = None
@@ -56,6 +60,7 @@ class ModelVersionManifest(BaseModel):
     __properties = [
         "description",
         "metadata",
+        "version_alias",
         "type",
         "source",
         "framework",
@@ -63,6 +68,18 @@ class ModelVersionManifest(BaseModel):
         "step",
     ]
 
+    @validator("version_alias")
+    def version_alias_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^v[a-zA-Z0-9.-]*([a-zA-Z0-9]+)$", value):
+            raise ValueError(
+                r"must validate the regular expression /^v[a-zA-Z0-9.-]*([a-zA-Z0-9]+)$/"
+            )
+        return value
+
     @validator("type")
     def type_validate_enum(cls, value):
         """Validates the enum"""
@@ -119,6 +136,7 @@ class ModelVersionManifest(BaseModel):
             {
                 "description": obj.get("description"),
                 "metadata": obj.get("metadata"),
+                "version_alias": obj.get("version_alias"),
                 "type": obj.get("type")
                 if obj.get("type") is not None
                 else "model-version",

truefoundry/ml/autogen/client_README.md

@@ -121,6 +121,7 @@ Class | Method | HTTP request | Description
 *MlfoundryArtifactsApi* | [**get_signed_urls_for_dataset_write_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#get_signed_urls_for_dataset_write_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/datasets/get-signed-urls-for-write | Get Signed Urls For Dataset Write
 *MlfoundryArtifactsApi* | [**get_signed_urls_for_read_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#get_signed_urls_for_read_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/artifact-versions/get-signed-urls-for-read | Get Signed Urls For Read
 *MlfoundryArtifactsApi* | [**get_signed_urls_for_write_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#get_signed_urls_for_write_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/artifact-versions/get-signed-urls-for-write | Get Signed Urls For Write
+*MlfoundryArtifactsApi* | [**get_version_aliases_for_artifact_get**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#get_version_aliases_for_artifact_get) | **GET** /api/2.0/mlflow/mlfoundry-artifacts/artifacts/get-version-aliases | Get Version Aliases For Artifact
 *MlfoundryArtifactsApi* | [**list_artifact_versions_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#list_artifact_versions_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/artifact-versions/list | List Artifact Versions
 *MlfoundryArtifactsApi* | [**list_artifacts_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#list_artifacts_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/artifacts/list | List Artifacts
 *MlfoundryArtifactsApi* | [**list_datasets_post**](truefoundry/ml/autogen/client/docs/MlfoundryArtifactsApi.md#list_datasets_post) | **POST** /api/2.0/mlflow/mlfoundry-artifacts/datasets/list | List Datasets
@@ -219,6 +220,7 @@ Class | Method | HTTP request | Description
  - [FileInfoDto](truefoundry/ml/autogen/client/docs/FileInfoDto.md)
  - [FinalizeArtifactVersionRequestDto](truefoundry/ml/autogen/client/docs/FinalizeArtifactVersionRequestDto.md)
  - [Framework](truefoundry/ml/autogen/client/docs/Framework.md)
+ - [GetArtifactVersionAliasesResponseDto](truefoundry/ml/autogen/client/docs/GetArtifactVersionAliasesResponseDto.md)
  - [GetExperimentResponseDto](truefoundry/ml/autogen/client/docs/GetExperimentResponseDto.md)
  - [GetLatestRunLogResponseDto](truefoundry/ml/autogen/client/docs/GetLatestRunLogResponseDto.md)
  - [GetMetricHistoryResponse](truefoundry/ml/autogen/client/docs/GetMetricHistoryResponse.md)

truefoundry/ml/autogen/entities/artifacts.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  artifacts.json
-#   timestamp: 2024-12-09T09:04:12+00:00
+#   timestamp: 2025-01-03T09:11:54+00:00
 
 from __future__ import annotations
 
@@ -58,6 +58,12 @@ class BaseArtifactVersion(BaseModel):
         ...,
         description="+label=Metadata\n+docs=Metadata for the artifact or model version\n+usage=Metadata for the artifact or model version\n+uiType=JsonInput",
     )
+    version_alias: Optional[
+        constr(regex=r"^v[a-zA-Z0-9.-]*([a-zA-Z0-9]+)$", max_length=128)
+    ] = Field(
+        None,
+        description="+label=Version Alias\n+usage=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc)\n+docs=The version alias for artifact or model version which should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc)\n+message=The version alias should start with 'v' followed by alphanumeric and it can include '.' and '-' in between (e.g. v1.0.0, v-prod, v-dev, etc)",
+    )
 
 
 class MimeType(str, Enum):

truefoundry/ml/clients/servicefoundry_client.py

@@ -1,36 +1,57 @@
-from typing import Optional
+import functools
 
 from truefoundry.common.constants import (
     SERVICEFOUNDRY_CLIENT_MAX_RETRIES,
     VERSION_PREFIX,
 )
+from truefoundry.common.exceptions import HttpRequestException
+from truefoundry.common.request_utils import (
+    http_request,
+    request_handling,
+    requests_retry_session,
+)
 from truefoundry.common.servicefoundry_client import (
     ServiceFoundryServiceClient as BaseServiceFoundryServiceClient,
 )
-from truefoundry.ml.clients.entities import (
-    HostCreds,
-)
-from truefoundry.ml.clients.utils import http_request_safe
 from truefoundry.ml.exceptions import MlFoundryException
 
 
 class ServiceFoundryServiceClient(BaseServiceFoundryServiceClient):
-    # TODO (chiragjn): Rename tracking_uri to tfy_host
-    def __init__(self, tracking_uri: str, token: Optional[str] = None):
-        super().__init__(base_url=tracking_uri)
-        self.host_creds = HostCreds(host=self._api_server_url, token=token)
+    def __init__(self, tfy_host: str, token: str):
+        super().__init__(tfy_host=tfy_host)
+        self._token = token
+
+    @functools.cached_property
+    def _min_cli_version_required(self) -> str:
+        # TODO (chiragjn): read the mlfoundry min cli version from the config?
+        return self.python_sdk_config.truefoundry_cli_min_version
 
     def get_integration_from_id(self, integration_id: str):
         integration_id = integration_id or ""
-        response = http_request_safe(
-            host_creds=self.host_creds,
-            endpoint=f"{VERSION_PREFIX}/provider-accounts/provider-integrations",
-            params={"id": integration_id, "type": "blob-storage"},
+        session = requests_retry_session(retries=SERVICEFOUNDRY_CLIENT_MAX_RETRIES)
+        response = http_request(
             method="get",
+            url=f"{self._api_server_url}/{VERSION_PREFIX}/provider-accounts/provider-integrations",
+            token=self._token,
             timeout=3,
-            max_retries=SERVICEFOUNDRY_CLIENT_MAX_RETRIES,
+            params={"id": integration_id, "type": "blob-storage"},
+            session=session,
         )
-        data = response.json()
+
+        try:
+            data = request_handling(response)
+            assert isinstance(data, dict)
+        except HttpRequestException as he:
+            raise MlFoundryException(
+                f"Failed to get storage integration from id: {integration_id}. Error: {he.message}",
+                status_code=he.status_code,
+            ) from None
+        except Exception as e:
+            raise MlFoundryException(
+                f"Failed to get storage integration from id: {integration_id}. Error: {str(e)}"
+            ) from None
+
+        # TODO (chiragjn): Parse this using Pydantic
         if (
             data.get("providerIntegrations")
             and len(data["providerIntegrations"]) > 0

truefoundry/ml/exceptions.py

@@ -1,8 +1,9 @@
 from typing import Optional
 
 
+# TODO (chiragjn): We need to establish uniform exception handling across codebase
 class MlFoundryException(Exception):
-    def __init__(self, message, status_code: Optional[int] = None):
+    def __init__(self, message: str, status_code: Optional[int] = None):
         self.message = str(message)
         self.status_code = status_code
         super().__init__(message)

truefoundry/ml/log_types/artifacts/artifact.py

@@ -5,11 +5,11 @@ import os
 import tempfile
 import typing
 import uuid
+import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional, Union
 
-from pydantic import StrictStr
-
+from truefoundry.common.warnings import TrueFoundryDeprecationWarning
 from truefoundry.ml.artifact.truefoundry_artifact_repo import (
     ArtifactIdentifier,
     MlFoundryArtifactsRepository,
@@ -43,7 +43,7 @@ from truefoundry.ml.log_types.artifacts.utils import (
 )
 from truefoundry.ml.logger import logger
 from truefoundry.ml.session import _get_api_client
-from truefoundry.pydantic_v1 import BaseModel, Extra
+from truefoundry.pydantic_v1 import BaseModel, Extra, StrictStr
 
 if TYPE_CHECKING:
     from truefoundry.ml.mlfoundry_run import MlFoundryRun
@@ -84,6 +84,7 @@ class ArtifactVersion:
         self._deleted = False
         self._description: str = ""
         self._metadata: Dict[str, Any] = {}
+        self._version_alias: Optional[str] = None
         self._set_mutable_attrs()
 
     @classmethod
@@ -131,9 +132,13 @@ class ArtifactVersion:
             manifest = self._artifact_version.manifest.actual_instance
             self._description = manifest.description or ""
             self._metadata = copy.deepcopy(manifest.metadata)
+            self._version_alias = manifest.version_alias or None
         else:
             self._description = self._artifact_version.description or ""
-            self._metadata = copy.deepcopy(self._artifact_version.artifact_metadata)
+            self._metadata = copy.deepcopy(
+                self._artifact_version.artifact_metadata or {}
+            )
+            self._version_alias = None
 
     def _refetch_artifact_version(self, reset_mutable_attrs: bool = True):
         _artifact_version = (
@@ -205,6 +210,33 @@ class ArtifactVersion:
         _validate_artifact_metadata(value)
         self._metadata = copy.deepcopy(value)
 
+    @property
+    def version_alias(self) -> Optional[str]:
+        """
+        Get version alias for the current artifact version
+        """
+        if not self._artifact_version.manifest:
+            warnings.warn(
+                message="This artifact version was created using an older serialization format. version alias does not exist",
+                category=TrueFoundryDeprecationWarning,
+                stacklevel=2,
+            )
+        return self._version_alias
+
+    @version_alias.setter
+    def version_alias(self, value: Optional[str]):
+        """
+        Set the version alias for current artifact version
+        """
+        if not self._artifact_version.manifest:
+            warnings.warn(
+                message="This artifact version was created using an older serialization format. version alias will not be updated",
+                category=TrueFoundryDeprecationWarning,
+                stacklevel=2,
+            )
+            return
+        self._version_alias = value
+
     @property
     def created_at(self) -> Optional[datetime.datetime]:
         """Get the time at which artifact was created"""
@@ -367,6 +399,7 @@ class ArtifactVersion:
             assert isinstance(manifest, ArtifactVersionManifest)
             manifest.description = self.description
             manifest.metadata = self.metadata
+            manifest.version_alias = self.version_alias
         else:
             manifest = None
         try:

truefoundry/ml/log_types/artifacts/model.py

@@ -10,6 +10,7 @@ import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
+from truefoundry.common.warnings import TrueFoundryDeprecationWarning
 from truefoundry.ml.artifact.truefoundry_artifact_repo import (
     ArtifactIdentifier,
     MlFoundryArtifactsRepository,
@@ -52,7 +53,7 @@ from truefoundry.ml.model_framework import (
     auto_update_model_framework_details,
 )
 from truefoundry.ml.session import _get_api_client
-from truefoundry.pydantic_v1 import BaseModel, Extra
+from truefoundry.pydantic_v1 import BaseModel, Extra, parse_obj_as
 
 if TYPE_CHECKING:
     import numpy as np
@@ -108,6 +109,7 @@ class ModelVersion:
         self._metadata: Dict[str, Any] = {}
         self._environment: Optional[ModelVersionEnvironment] = None
         self._framework: Optional[ModelFrameworkType] = None
+        self._version_alias: Optional[str] = None
         self._set_mutable_attrs()
 
     @classmethod
@@ -147,21 +149,26 @@ class ModelVersion:
 
     def _set_mutable_attrs(self):
         if self._model_version.manifest:
-            self._description = self._model_version.manifest.description or ""
-            self._metadata = copy.deepcopy(self._model_version.manifest.metadata)
-            self._environment = copy.deepcopy(self._model_version.manifest.environment)
+            manifest = self._model_version.manifest
+            self._description = manifest.description or ""
+            self._metadata = copy.deepcopy(manifest.metadata)
+            self._environment = copy.deepcopy(manifest.environment)
             self._framework = (
-                copy.deepcopy(self._model_version.manifest.framework.actual_instance)
-                if self._model_version.manifest.framework
+                parse_obj_as(
+                    ModelFrameworkType, manifest.framework.actual_instance.to_dict()
+                )
+                if manifest.framework
                 else None
             )
+            self._version_alias = self._model_version.manifest.version_alias or None
         else:
             self._description = self._model_version.description or ""
-            self._metadata = copy.deepcopy(self._model_version.artifact_metadata)
+            self._metadata = copy.deepcopy(self._model_version.artifact_metadata or {})
             self._environment = None
             self._framework = _ModelFramework.to_model_framework_type(
                 self._model_version.model_framework
             )
+            self._version_alias = None
 
     def _refetch_model_version(self, reset_mutable_attrs: bool = True):
         _model_version = self._mlfoundry_artifacts_api.get_model_version_get(
@@ -231,18 +238,51 @@ class ModelVersion:
         _validate_artifact_metadata(value)
         self._metadata = copy.deepcopy(value)
 
+    @property
+    def version_alias(self) -> Optional[str]:
+        """
+        Get version alias for the current model version
+        """
+        if not self._model_version.manifest:
+            warnings.warn(
+                message="This model version was created using an older serialization format. version alias does not exist",
+                category=TrueFoundryDeprecationWarning,
+                stacklevel=2,
+            )
+        return self._version_alias
+
+    @version_alias.setter
+    def version_alias(self, value: Optional[str]):
+        """
+        Set the version alias for current artifact version
+        """
+        if not self._model_version.manifest:
+            warnings.warn(
+                message="This model version was created using an older serialization format. version alias will not be updated",
+                category=TrueFoundryDeprecationWarning,
+                stacklevel=2,
+            )
+            return
+        self._version_alias = value
+
     @property
     def environment(self) -> Optional[ModelVersionEnvironment]:
         """Get the environment details for the model"""
+        if not self._model_version.manifest:
+            warnings.warn(
+                message="This model version was created using an older serialization format. environment does not exist, returning None",
+                category=TrueFoundryDeprecationWarning,
+                stacklevel=2,
+            )
         return self._environment
 
     @environment.setter
-    def environment(self, value: Optional[Dict[str, Any]]):
+    def environment(self, value: Optional[ModelVersionEnvironment]):
         """set the environment details for the model"""
         if not self._model_version.manifest:
             warnings.warn(
                 message="This model version was created using an older serialization format. Environment will not be updated",
-                category=DeprecationWarning,
+                category=TrueFoundryDeprecationWarning,
                 stacklevel=2,
             )
             return
@@ -261,7 +301,7 @@ class ModelVersion:
         if not self._model_version.manifest:
             warnings.warn(
                 message="This model version was created using an older serialization format. Framework will not be updated",
-                category=DeprecationWarning,
+                category=TrueFoundryDeprecationWarning,
                 stacklevel=2,
             )
             return
@@ -449,6 +489,7 @@ class ModelVersion:
             self._model_version.manifest.framework = (
                 Framework.from_dict(self.framework.dict()) if self.framework else None
             )
+            self._model_version.manifest.version_alias = self.version_alias
         try:
             _model_version = self._mlfoundry_artifacts_api.update_model_version_post(
                 update_model_version_request_dto=UpdateModelVersionRequestDto(