oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10__py3-none-any.whl

ads/model/model_metadata.py

@@ -0,0 +1,1810 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2021, 2025 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import json
+import logging
+import os
+import sys
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import fsspec
+import git
+import oci.data_science.models
+import pandas as pd
+import yaml
+from oci.util import to_dict
+
+from ads.common import logger
+from ads.common.error import ChangesNotCommitted
+from ads.common.extended_enum import ExtendedEnum
+from ads.common.object_storage_details import ObjectStorageDetails
+from ads.common.serializer import DataClassSerializable
+from ads.common.utils import parse_bool
+from ads.dataset import factory
+
+try:
+    from yaml import CDumper as dumper
+except:
+    from yaml import Dumper as dumper
+
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+logger = logging.getLogger("ADS")
+
+METADATA_SIZE_LIMIT = 32000
+METADATA_VALUE_LENGTH_LIMIT = 255
+METADATA_DESCRIPTION_LENGTH_LIMIT = 255
+_METADATA_EMPTY_VALUE = "NA"
+CURRENT_WORKING_DIR = "."
+
+_sentinel = object()
+
+
+class MetadataSizeTooLarge(ValueError):
+    """Maximum allowed size for model metadata has been exceeded.
+    See https://docs.oracle.com/en-us/iaas/data-science/using/models_saving_catalog.htm for more details.
+    """
+
+    def __init__(self, size: int):
+        super().__init__(
+            f"The metadata is `{size}` bytes and exceeds "
+            f"the size limit of `{METADATA_SIZE_LIMIT}` bytes. "
+            "Reduce the metadata size."
+        )
+
+
+class MetadataValueTooLong(ValueError):
+    """Maximum allowed length of metadata value has been exceeded.
+    See https://docs.oracle.com/en-us/iaas/data-science/using/models_saving_catalog.htm for more details.
+    """
+
+    def __init__(self, key: str, length: int):
+        super().__init__(
+            f"The custom metadata value of `{key}` is `{length}` characters and exceeds "
+            f"the length limit of `{METADATA_VALUE_LENGTH_LIMIT}` characters."
+        )
+
+
+class MetadataDescriptionTooLong(ValueError):
+    """Maximum allowed length of metadata description has been exceeded.
+    See https://docs.oracle.com/en-us/iaas/data-science/using/models_saving_catalog.htm for more details.
+    """
+
+    def __init__(self, key: str, length: int):
+        super().__init__(
+            f"The custom metadata description of `{key}` is `{length}` characters and exceeds "
+            f"the length limit of `{METADATA_DESCRIPTION_LENGTH_LIMIT}` characters."
+        )
+
+
+class MetadataCustomPrintColumns(ExtendedEnum):
+    KEY = "Key"
+    VALUE = "Value"
+    DESCRIPTION = "Description"
+    CATEGORY = "Category"
+    HAS_ARTIFACT = "HasArtifact"
+
+
+class MetadataTaxonomyPrintColumns(ExtendedEnum):
+    KEY = "Key"
+    VALUE = "Value"
+    HAS_ARTIFACT = "HasArtifact"
+
+
+class MetadataTaxonomyKeys(ExtendedEnum):
+    USE_CASE_TYPE = "UseCaseType"
+    FRAMEWORK = "Framework"
+    FRAMEWORK_VERSION = "FrameworkVersion"
+    ALGORITHM = "Algorithm"
+    HYPERPARAMETERS = "Hyperparameters"
+    ARTIFACT_TEST_RESULT = "ArtifactTestResults"
+    # README = "Readme"
+    # LICENSE = "License"
+    # DEPLOYMENT_CONFIGURATION = "DeploymentConfiguration"
+    # FINETUNE_CONFIGURATION = "FineTuneConfiguration"
+
+
+class MetadataCustomKeys(ExtendedEnum):
+    SLUG_NAME = "SlugName"
+    CONDA_ENVIRONMENT = "CondaEnvironment"
+    CONDA_ENVIRONMENT_PATH = "CondaEnvironmentPath"
+    ENVIRONMENT_TYPE = "EnvironmentType"
+    MODEL_ARTIFACTS = "ModelArtifacts"
+    TRAINING_DATASET = "TrainingDataset"
+    VALIDATION_DATASET = "ValidationDataset"
+    MODEL_SERIALIZATION_FORMAT = "ModelSerializationFormat"
+    TRAINING_DATASET_SIZE = "TrainingDatasetSize"
+    VALIDATION_DATASET_SIZE = "ValidationDatasetSize"
+    TRAINING_DATASET_NUMBER_OF_ROWS = "TrainingDatasetNumberOfRows"
+    TRAINING_DATASET_NUMBER_OF_COLS = "TrainingDatasetNumberOfCols"
+    VALIDATION_DATASET_NUMBER_OF_ROWS = "ValidationDatasetNumberOfRows"
+    VALIDATION_DATASET_NUMBER_OF_COLS = "ValidationDataSetNumberOfCols"
+    CLIENT_LIBRARY = "ClientLibrary"
+    MODEL_FILE_NAME = "ModelFileName"
+
+
+class MetadataCustomCategory(ExtendedEnum):
+    PERFORMANCE = "Performance"
+    TRAINING_PROFILE = "Training Profile"
+    TRAINING_AND_VALIDATION_DATASETS = "Training and Validation Datasets"
+    TRAINING_ENV = "Training Environment"
+    OTHER = "Other"
+
+
+class UseCaseType(ExtendedEnum):
+    BINARY_CLASSIFICATION = "binary_classification"
+    REGRESSION = "regression"
+    MULTINOMIAL_CLASSIFICATION = "multinomial_classification"
+    CLUSTERING = "clustering"
+    RECOMMENDER = "recommender"
+    DIMENSIONALITY_REDUCTION = "dimensionality_reduction/representation"
+    TIME_SERIES_FORECASTING = "time_series_forecasting"
+    ANOMALY_DETECTION = "anomaly_detection"
+    TOPIC_MODELING = "topic_modeling"
+    NER = "ner"
+    SENTIMENT_ANALYSIS = "sentiment_analysis"
+    IMAGE_CLASSIFICATION = "image_classification"
+    OBJECT_LOCALIZATION = "object_localization"
+    OTHER = "other"
+
+
+class Framework(ExtendedEnum):
+    SCIKIT_LEARN = "scikit-learn"
+    XGBOOST = "xgboost"
+    TENSORFLOW = "tensorflow"
+    PYTORCH = "pytorch"
+    MXNET = "mxnet"
+    KERAS = "keras"
+    LIGHT_GBM = "lightgbm"
+    PYMC3 = "pymc3"
+    PYOD = "pyod"
+    SPACY = "spacy"
+    PROPHET = "prophet"
+    SKTIME = "sktime"
+    STATSMODELS = "statsmodels"
+    CUML = "cuml"
+    ORACLE_AUTOML = "oracle_automl"
+    H20 = "h2o"
+    TRANSFORMERS = "transformers"
+    NLTK = "nltk"
+    EMCEE = "emcee"
+    PYSTAN = "pystan"
+    BERT = "bert"
+    GENSIM = "gensim"
+    FLAIR = "flair"
+    WORD2VEC = "word2vec"
+    ENSEMBLE = "ensemble"
+    SPARK = "pyspark"
+    EMBEDDING_ONNX = "embedding_onnx"
+    OTHER = "other"
+
+
+class ModelMetadataItem(ABC):
+    """The base abstract class representing model metadata item.
+
+    Methods
+    -------
+    to_dict(self) -> Dict
+        Serializes model metadata item to dictionary.
+    from_dict(cls, data: Dict) -> ModelMetadataItem
+        Constructs an instance of ModelMetadataItem from a dictionary.
+    to_yaml(self)
+        Serializes model metadata item to YAML.
+    size(self) -> int
+        Returns the size of the metadata in bytes.
+    to_json(self) -> JSON
+        Serializes metadata item to JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata item value to a local file or object storage.
+    validate(self) -> bool
+        Validates metadata item.
+    """
+
+    _FIELDS = []
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "ModelMetadataItem":
+        """Constructs an instance of `ModelMetadataItem` from a dictionary.
+
+        Parameters
+        ----------
+        data : Dict
+            Metadata item in a dictionary format.
+
+        Returns
+        -------
+        ModelMetadataItem
+            An instance of model metadata item.
+        """
+        return cls(**data or {})
+
+    def to_dict(self) -> dict:
+        """Serializes model metadata item to dictionary.
+
+        Returns
+        -------
+        dict
+            The dictionary representation of model metadata item.
+        """
+        return {field: getattr(self, field) for field in self._FIELDS}
+
+    def to_yaml(self):
+        """Serializes model metadata item to YAML.
+
+        Returns
+        -------
+        Yaml
+            The model metadata item in a YAML representation.
+        """
+        return yaml.dump(self.to_dict(), Dumper=dumper)
+
+    def size(self) -> int:
+        """Returns the size of the model metadata in bytes.
+
+        Returns
+        -------
+        int
+            The size of model metadata in bytes.
+        """
+        return len(json.dumps(self.to_dict()).encode("utf-16"))
+
+    def to_json(self):
+        """Serializes metadata item into a JSON.
+
+        Returns
+        -------
+        JSON
+            The metadata item in a JSON representation.
+        """
+        return json.dumps(self.to_dict())
+
+    def to_json_file(
+        self,
+        file_path: str,
+        storage_options: dict = None,
+    ) -> None:
+        """Saves the metadata item value to a local file or object storage.
+
+        Parameters
+        ----------
+        file_path : str
+            The file path to store the data.
+            "oci://bucket_name@namespace/folder_name/"
+            "oci://bucket_name@namespace/folder_name/result.json"
+            "path/to/local/folder"
+            "path/to/local/folder/result.json"
+        storage_options : dict. Default None
+            Parameters passed on to the backend filesystem class.
+            Defaults to `options` set using `DatasetFactory.set_default_storage()`.
+
+        Returns
+        -------
+        None
+            Nothing.
+
+        Raises
+        ------
+            ValueError: When file path is empty.
+            TypeError: When file path not a string.
+
+        Examples
+        --------
+        >>> metadata_item = ModelCustomMetadataItem(key="key1", value="value1")
+        >>> storage_options = {"config": oci.config.from_file(os.path.join("~/.oci", "config"))}
+        >>> storage_options
+        {'log_requests': False,
+            'additional_user_agent': '',
+            'pass_phrase': None,
+            'user': '<user-id>',
+            'fingerprint': '05:15:2b:b1:46:8a:32:ec:e2:69:5b:32:01:**:**:**)',
+            'tenancy': '<tenency-id>',
+            'region': 'us-ashburn-1',
+            'key_file': '/home/datascience/.oci/oci_api_key.pem'}
+        >>> metadata_item.to_json_file(file_path = 'oci://bucket_name@namespace/folder_name/file.json', storage_options=storage_options)
+        >>> metadata_item.to_json_file("path/to/local/folder/file.json")
+        """
+        if not file_path:
+            raise ValueError("File path must be specified.")
+
+        if not isinstance(file_path, str):
+            raise TypeError("File path must be a string.")
+
+        if not Path(os.path.basename(file_path)).suffix:
+            file_path = os.path.join(file_path, f"{self.key}.json")
+
+        if not storage_options:
+            storage_options = factory.default_storage_options or {"config": {}}
+
+        with fsspec.open(
+            file_path,
+            mode="w",
+            **(storage_options),
+        ) as f:
+            f.write(json.dumps(self.value))
+
+    def _to_oci_metadata(self):
+        """Converts metadata item to OCI metadata item."""
+        dict = self.to_dict()
+        if not dict["value"]:
+            return oci.data_science.models.Metadata(**dict)
+        if isinstance(dict["value"], (str, int, float)):
+            dict["value"] = str(dict["value"]).replace("NaN", "null")
+        else:
+            dict["value"] = json.dumps(dict["value"]).replace("NaN", "null")
+        return oci.data_science.models.Metadata(**dict)
+
+    @classmethod
+    def _from_oci_metadata(cls, oci_metadata_item) -> "ModelMetadataItem":
+        """Creates a new metadata item from the OCI metadata item."""
+        oci_metadata_item = to_dict(oci_metadata_item)
+        key_value_map = {field: oci_metadata_item.get(field) for field in cls._FIELDS}
+        if isinstance(key_value_map["value"], str):
+            try:
+                key_value_map["value"] = json.loads(oci_metadata_item.get("value"))
+                key_value_map["has_artifact"] = parse_bool(
+                    oci_metadata_item.get("has_artifact")
+                )
+            except Exception:
+                pass
+        return cls(**key_value_map)
+
+    def __hash__(self):
+        return hash(self.key.lower())
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
+    def __repr__(self):
+        return self.to_yaml()
+
+    @abstractmethod
+    def validate(self) -> bool:
+        """Validates metadata item.
+
+        Returns
+        -------
+        bool
+            True if validation passed.
+        """
+        pass
+
+
+class ModelTaxonomyMetadataItem(ModelMetadataItem):
+    """Class that represents model taxonomy metadata item.
+
+    Attributes
+    ----------
+    key: str
+        The model metadata item key.
+    value: str
+        The model metadata item value.
+
+    Methods
+    -------
+    reset(self) -> None
+        Resets model metadata item.
+    to_dict(self) -> Dict
+        Serializes model metadata item to dictionary.
+    from_dict(cls) -> ModelTaxonomyMetadataItem
+        Constructs model metadata item from dictionary.
+    to_yaml(self)
+        Serializes model metadata item to YAML.
+    size(self) -> int
+        Returns the size of the metadata in bytes.
+    update(self, value: str = "") -> None
+        Updates metadata item information.
+    to_json(self) -> JSON
+        Serializes metadata item into a JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata item value to a local file or object storage.
+    validate(self) -> bool
+        Validates metadata item.
+    """
+
+    _FIELDS = ["key", "value", "has_artifact"]
+
+    def __init__(self, key: str, value: str = None, has_artifact: bool = False):
+        self.key = key
+        self.value = value
+        self.has_artifact = has_artifact
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @key.setter
+    def key(self, key: str):
+        """The model metadata key setter.
+
+        Raises
+        ------
+        TypeError
+            If provided key is not a string.
+        ValueError
+            If provided key is already setup.
+            If provided key is empty.
+        """
+        if hasattr(self, "_key"):
+            raise ValueError("The key field is immutable and cannot be changed.")
+        if not isinstance(key, str):
+            raise TypeError("The key must be a string.")
+        if key is None or key == "":
+            raise ValueError("The key cannot be empty.")
+        self._key = key
+
+    @property
+    def has_artifact(self) -> bool:
+        return self._has_artifact
+
+    @has_artifact.setter
+    def has_artifact(self, has_artifact: bool):
+        self._has_artifact = has_artifact is True
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    @value.setter
+    def value(self, value: str):
+        """The model metadata value setter. Accepts any JSON serializable value.
+
+        Raises
+        ------
+        ValueError
+            If provided value cannot be serialized to JSON.
+        """
+        if value is None or value == "":
+            self._value = value
+            return
+
+        try:
+            json.dumps(value)
+        except TypeError:
+            raise ValueError(
+                f"An error occurred in attempt to serialize the value of {self.key} to JSON. "
+                "The value must be JSON serializable."
+            )
+
+        self._value = value
+
+    def reset(self) -> None:
+        """Resets model metadata item.
+
+        Resets value to None.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.update(value=None)
+
+    def update(self, value: str, has_artifact: bool = False) -> None:
+        """Updates metadata item value.
+
+        Parameters
+        ----------
+        value: str
+            The value of model metadata item.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.value = value
+        self.has_artifact = has_artifact
+
+    def validate(self) -> bool:
+        """Validates metadata item.
+
+        Returns
+        -------
+        bool
+            True if validation passed.
+
+        Raises
+        ------
+        ValueError
+            If invalid UseCaseType provided.
+            If invalid Framework provided.
+        """
+        if (
+            self.key.lower() == MetadataTaxonomyKeys.USE_CASE_TYPE.lower()
+            and self.value
+            and (not isinstance(self.value, str) or self.value not in UseCaseType)
+        ):
+            raise ValueError(
+                f"Invalid value of `UseCaseType`. Choose from {UseCaseType.values()}."
+            )
+        if (
+            self.key.lower() == MetadataTaxonomyKeys.FRAMEWORK.lower()
+            and self.value
+            and (not isinstance(self.value, str) or self.value not in Framework)
+        ):
+            raise ValueError(
+                f"Invalid value of `Framework`. Choose from {Framework.values()}."
+            )
+        return True
+
+
+class ModelCustomMetadataItem(ModelTaxonomyMetadataItem):
+    """Class that represents model custom metadata item.
+
+    Attributes
+    ----------
+    key: str
+        The model metadata item key.
+    value: str
+        The model metadata item value.
+    description: str
+        The model metadata item description.
+    category: str
+        The model metadata item category.
+
+    Methods
+    -------
+    reset(self) -> None
+        Resets model metadata item.
+    to_dict(self)->dict
+        Serializes model metadata item to dictionary.
+    from_dict(cls) -> ModelCustomMetadataItem
+        Constructs model metadata item from dictionary.
+    to_yaml(self)
+        Serializes model metadata item to YAML.
+    size(self) -> int
+        Returns the size of the metadata in bytes.
+    update(self, value: str = "", description: str = "", category: str = "") -> None
+        Updates metadata item information.
+    to_json(self) -> JSON
+        Serializes metadata item into a JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata item value to a local file or object storage.
+    validate(self) -> bool
+        Validates metadata item.
+    """
+
+    _FIELDS = ["key", "value", "description", "category", "has_artifact"]
+
+    def __init__(
+        self,
+        key: str,
+        value: str = None,
+        description: str = None,
+        category: str = None,
+        has_artifact: bool = False,
+    ):
+        super().__init__(key=key, value=value)
+        self.description = description
+        self.category = category
+        self.has_artifact = has_artifact
+
+    @property
+    def description(self) -> str:
+        return self._description
+
+    @description.setter
+    def description(self, description: str):
+        """The model metadata description setter.
+
+        Raises
+        ------
+        TypeError
+            If provided key is not a string.
+        """
+        if description != None and not isinstance(description, str):
+            raise TypeError("The description must be a string.")
+
+        self._description = description
+
+    @property
+    def has_artifact(self) -> bool:
+        return self._has_artifact
+
+    @has_artifact.setter
+    def has_artifact(self, has_artifact: bool):
+        if not has_artifact:
+            self._has_artifact = False
+        else:
+            self._has_artifact = has_artifact
+
+    @property
+    def category(self) -> str:
+        return self._category
+
+    @category.setter
+    def category(self, category: str):
+        """The model metadata category setter.
+
+        Raises
+        ------
+        TypeError
+            If provided category is not a string.
+        ValueError
+            If provided category not supported.
+        """
+        if not category:
+            self._category = None
+            return
+
+        if not isinstance(category, str):
+            raise TypeError(
+                f"Invalid category type for the {self.key}."
+                "The category must be a string."
+            )
+
+        if category not in MetadataCustomCategory:
+            raise ValueError(
+                f"Invalid category value for the {self.key}. "
+                f"Choose from {MetadataCustomCategory.values()}."
+            )
+
+        self._category = category
+
+    def reset(self) -> None:
+        """Resets model metadata item.
+
+        Resets value, description and category to None.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.update(value=None, description=None, category=None)
+
+    def update(
+        self, value: str, description: str, category: str, has_artifact: bool = False
+    ) -> None:
+        """Updates metadata item.
+
+        Parameters
+        ----------
+        value: str
+            The value of model metadata item.
+        description: str
+            The description of model metadata item.
+        category: str
+            The category of model metadata item.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.value = value
+        self.description = description
+        self.category = category
+        self.has_artifact = has_artifact
+
+    def _to_oci_metadata(self):
+        """Converts metadata item to OCI metadata item."""
+        oci_metadata_item = super()._to_oci_metadata()
+        if not oci_metadata_item.value:
+            oci_metadata_item.value = _METADATA_EMPTY_VALUE
+        if not oci_metadata_item.category:
+            oci_metadata_item.category = MetadataCustomCategory.OTHER
+        if not oci_metadata_item.has_artifact:
+            oci_metadata_item.has_artifact = False
+        return oci_metadata_item
+
+    def validate(self) -> bool:
+        """Validates metadata item.
+
+        Returns
+        -------
+        bool
+            True if validation passed.
+
+        Raises
+        ------
+        ValueError
+            If invalid category provided.
+        MetadataValueTooLong
+            If value exceeds the length limit.
+        """
+        if self.category and self.category not in MetadataCustomCategory:
+            raise ValueError(
+                f"Invalid category value for the {self.key}. "
+                f"Choose from {MetadataCustomCategory.values()}."
+            )
+
+        if self.value:
+            value = (
+                self.value if isinstance(self.value, str) else json.dumps(self.value)
+            )
+            if len(value) > METADATA_VALUE_LENGTH_LIMIT:
+                raise MetadataValueTooLong(self.key, len(value))
+
+        if (
+            self.description
+            and len(self.description) > METADATA_DESCRIPTION_LENGTH_LIMIT
+        ):
+            raise MetadataDescriptionTooLong(self.key, len(self.description))
+
+        return True
+
+
+class ModelMetadata(ABC):
+    """The base abstract class representing model metadata.
+
+    Methods
+    -------
+    get(self, key: str) -> ModelMetadataItem
+        Returns the model metadata item by provided key.
+    reset(self) -> None
+        Resets all model metadata items to empty values.
+    to_dataframe(self) -> pd.DataFrame
+        Returns the model metadata list in a data frame format.
+    size(self) -> int
+        Returns the size of the model metadata in bytes.
+    validate(self) -> bool
+        Validates metadata.
+    to_dict(self)
+        Serializes model metadata into a dictionary.
+    from_dict(cls) -> ModelMetadata
+        Constructs model metadata from dictionary.
+    to_yaml(self)
+        Serializes model metadata into a YAML.
+    to_json(self)
+        Serializes model metadata into a JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata to a local file or object storage.
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """Initializes Model Metadata."""
+        self._items = set()
+
+    def get(
+        self, key: str, value: Optional[Any] = _sentinel
+    ) -> Union[ModelMetadataItem, Any]:
+        """Returns the model metadata item by provided key.
+
+        Parameters
+        ----------
+        key: str
+            The key of model metadata item.
+        value: (str, optional)
+            A value to return if the specified key does not exist. Defaults to `object()`.
+            If default value not specified, the ValueError will be returned.
+
+        Returns
+        -------
+        ModelMetadataItem
+            The model metadata item.
+
+        Raises
+        ------
+        ValueError
+            If provided key is empty or metadata item not found.
+        """
+        if key is None or not isinstance(key, str) or key == "":
+            raise ValueError("The key must not be an empty string.")
+        for item in self._items:
+            if item.key.lower() == key.lower():
+                return item
+
+        if value is _sentinel:
+            raise ValueError(f"The metadata with {key} not found.")
+
+        return value
+
+    def reset(self) -> None:
+        """Resets all model metadata items to empty values.
+
+        Resets value, description and category to None for every metadata item.
+        """
+        for item in self._items:
+            item.reset()
+
+    def size(self) -> int:
+        """Returns the size of the model metadata in bytes.
+
+        Returns
+        -------
+        int
+            The size of model metadata in bytes.
+        """
+        return sum(item.size() for item in self._items)
+
+    def validate_size(self) -> bool:
+        """Validates model metadata size.
+
+        Validates the size of metadata. Throws an error if the size of the metadata
+        exceeds expected value.
+
+        Returns
+        -------
+        bool
+            True if metadata size is valid.
+
+        Raises
+        ------
+        MetadataSizeTooLarge
+            If the size of the metadata exceeds expected value.
+        """
+        if self.size() > METADATA_SIZE_LIMIT:
+            raise MetadataSizeTooLarge(self.size())
+        return True
+
+    def validate(self) -> bool:
+        """Validates model metadata.
+
+        Returns
+        -------
+        bool
+            True if metadata is valid.
+        """
+        for item in self._items:
+            item.validate()
+        return True
+
+    def to_dict(self):
+        """Serializes model metadata into a dictionary.
+
+        Returns
+        -------
+        Dict
+            The model metadata in a dictionary representation.
+        """
+        return {"data": [item.to_dict() for item in self._items]}
+
+    def to_yaml(self):
+        """Serializes model metadata into a YAML.
+
+        Returns
+        -------
+        Yaml
+            The model metadata in a YAML representation.
+        """
+        return yaml.dump(self.to_dict(), Dumper=dumper)
+
+    def to_json(self):
+        """Serializes model metadata into a JSON.
+
+        Returns
+        -------
+        JSON
+            The model metadata in a JSON representation.
+        """
+        return json.dumps(self.to_dict())
+
+    @property
+    def keys(self) -> Tuple[str]:
+        """Returns all registered metadata keys.
+
+        Returns
+        -------
+        Tuple[str]
+            The list of metadata keys.
+        """
+        return tuple(item.key for item in self._items)
+
+    def _to_oci_metadata(self):
+        """Convert to a list of `oci.data_science.models.Metadata` objects.
+
+        Returns
+        -------
+        list[oci.data_science.models.Metadata]
+            A list of oci data science model metadata.
+
+        Examples
+        --------
+        >>> metadata_taxonomy = ModelTaxonomyMetadata()
+        >>> metadata_taxonomy.get(key="FrameworkVersion").update(value="2.3.1")
+        >>> metadata_taxonomy._to_oci_metadata()
+        [{
+        "key": "FrameworkVersion",
+        "value": "2.3.1"
+        },
+        {
+        "key": "UseCaseType",
+        "value": null
+        },
+        {
+        "key": "Algorithm",
+        "value": null
+        },
+        {
+        "key": "Framework",
+        "value": null
+        },
+        {
+        "key": "Hyperparameters",
+        "value": null
+        }]
+        """
+        return [item._to_oci_metadata() for item in self._items]
+
+    def to_json_file(
+        self,
+        file_path: str,
+        storage_options: dict = None,
+    ) -> None:
+        """Saves the metadata to a local file or object storage.
+
+        Parameters
+        ----------
+        file_path : str
+            The file path to store the data.
+            "oci://bucket_name@namespace/folder_name/"
+            "oci://bucket_name@namespace/folder_name/metadata.json"
+            "path/to/local/folder"
+            "path/to/local/folder/metadata.json"
+        storage_options : dict. Default None
+            Parameters passed on to the backend filesystem class.
+            Defaults to `options` set using `DatasetFactory.set_default_storage()`.
+
+        Returns
+        -------
+        None
+            Nothing.
+
+        Raises
+        ------
+            ValueError: When file path is empty.
+            TypeError: When file path not a string.
+
+        Examples
+        --------
+        >>> metadata = ModelTaxonomyMetadataItem()
+        >>> storage_options = {"config": oci.config.from_file(os.path.join("~/.oci", "config"))}
+        >>> storage_options
+        {'log_requests': False,
+            'additional_user_agent': '',
+            'pass_phrase': None,
+            'user': '<user-id>',
+            'fingerprint': '05:15:2b:b1:46:8a:32:ec:e2:69:5b:32:01:**:**:**)',
+            'tenancy': '<tenancy-id>',
+            'region': 'us-ashburn-1',
+            'key_file': '/home/datascience/.oci/oci_api_key.pem'}
+        >>> metadata.to_json_file(file_path = 'oci://bucket_name@namespace/folder_name/metadata_taxonomy.json', storage_options=storage_options)
+        >>> metadata_item.to_json_file("path/to/local/folder/metadata_taxonomy.json")
+        """
+        if not file_path:
+            raise ValueError("File path must be specified.")
+
+        if not isinstance(file_path, str):
+            raise TypeError("File path must be a string.")
+
+        if not Path(os.path.basename(file_path)).suffix:
+            file_path = os.path.join(file_path, f"{self.__class__.__name__}.json")
+
+        if not storage_options:
+            storage_options = factory.default_storage_options or {"config": {}}
+
+        with fsspec.open(
+            file_path,
+            mode="w",
+            **(storage_options),
+        ) as f:
+            f.write(self.to_json())
+
+    def __getitem__(self, key: str) -> ModelMetadataItem:
+        return self.get(key)
+
+    def __repr__(self):
+        return self.to_yaml()
+
+    def __len__(self):
+        return len(self._items)
+
+    @abstractmethod
+    def _from_oci_metadata(cls, metadata_list):
+        pass
+
+    @abstractmethod
+    def to_dataframe(self) -> pd.DataFrame:
+        """Returns the model metadata list in a data frame format.
+
+        Returns
+        -------
+        `pandas.DataFrame`
+            The model metadata in a dataframe format.
+        """
+        pass
+
+    @abstractmethod
+    def from_dict(cls, data: Dict) -> "ModelMetadata":
+        """Constructs an instance of `ModelMetadata` from a dictionary.
+
+        Parameters
+        ----------
+        data : Dict
+            Model metadata in a dictionary format.
+
+        Returns
+        -------
+        ModelMetadata
+            An instance of model metadata.
+        """
+        pass
+
+
+class ModelCustomMetadata(ModelMetadata):
+    """Class that represents Model Custom Metadata.
+
+    Methods
+    -------
+    get(self, key: str) -> ModelCustomMetadataItem
+        Returns the model metadata item by provided key.
+    reset(self) -> None
+        Resets all model metadata items to empty values.
+    to_dataframe(self) -> pd.DataFrame
+        Returns the model metadata list in a data frame format.
+    size(self) -> int
+        Returns the size of the model metadata in bytes.
+    validate(self) -> bool
+        Validates metadata.
+    to_dict(self)
+        Serializes model metadata into a dictionary.
+    from_dict(cls) -> ModelCustomMetadata
+        Constructs model metadata from dictionary.
+    to_yaml(self)
+        Serializes model metadata into a YAML.
+    add(self, key: str, value: str, description: str = "", category: str = MetadataCustomCategory.OTHER, replace: bool = False) -> None:
+        Adds a new model metadata item. Replaces existing one if replace flag is True.
+    remove(self, key: str) -> None
+        Removes a model metadata item by key.
+    clear(self) -> None
+        Removes all metadata items.
+    isempty(self) -> bool
+        Checks if metadata is empty.
+    to_json(self)
+        Serializes model metadata into a JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata to a local file or object storage.
+
+    Examples
+    --------
+    >>> metadata_custom = ModelCustomMetadata()
+    >>> metadata_custom.add(key="format", value="pickle")
+    >>> metadata_custom.add(key="note", value="important note", description="some description")
+    >>> metadata_custom["format"].description = "some description"
+    >>> metadata_custom.to_dataframe()
+                        Key              Value         Description      Category
+    ----------------------------------------------------------------------------
+    0                format             pickle    some description  user defined
+    1                  note     important note    some description  user defined
+    >>> metadata_custom
+        metadata:
+        - category: user defined
+          description: some description
+          key: format
+          value: pickle
+        - category: user defined
+          description: some description
+          key: note
+          value: important note
+    >>> metadata_custom.remove("format")
+    >>> metadata_custom
+        metadata:
+        - category: user defined
+          description: some description
+          key: note
+          value: important note
+    >>> metadata_custom.to_dict()
+        {'metadata': [{
+                'key': 'note',
+                'value': 'important note',
+                'category': 'user defined',
+                'description': 'some description'
+            }]}
+    >>> metadata_custom.reset()
+    >>> metadata_custom
+        metadata:
+        - category: None
+          description: None
+          key: note
+          value: None
+    >>> metadata_custom.clear()
+    >>> metadata_custom.to_dataframe()
+                        Key              Value         Description      Category
+    ----------------------------------------------------------------------------
+    """
+
+    def __init__(self):
+        """Initializes custom model metadata."""
+        self._items = set()
+
+    def add(
+        self,
+        key: str,
+        value: str,
+        description: str = "",
+        category: str = MetadataCustomCategory.OTHER,
+        replace: bool = False,
+    ) -> None:
+        """Adds a new model metadata item. Overrides the existing one if replace flag is True.
+
+        Parameters
+        ----------
+        key: str
+            The metadata item key.
+        value: str
+            The metadata item value.
+        description: str
+            The metadata item description.
+        category: str
+            The metadata item category.
+        replace: bool
+            Overrides the existing metadata item if replace flag is True.
+
+        Returns
+        -------
+        None
+            Nothing.
+
+        Raises
+        ------
+        TypeError
+            If provided key is not a string.
+            If provided description not a string.
+        ValueError
+            If provided key is empty.
+            If provided value is empty.
+            If provided value cannot be serialized to JSON.
+            If item with provided key is already registered and replace flag is False.
+            If provided category is not supported.
+        MetadataValueTooLong
+            If the length of provided value exceeds 255 charracters.
+        MetadataDescriptionTooLong
+            If the length of provided description exceeds 255 charracters.
+        """
+
+        if not category:
+            category = MetadataCustomCategory.OTHER
+
+        if key is None or key == "":
+            raise ValueError("The key cannot be empty.")
+
+        if value is None or value == "":
+            raise ValueError("The value cannot be empty.")
+
+        if not isinstance(key, str):
+            raise TypeError("The key must be a string.")
+
+        if not isinstance(category, str):
+            raise TypeError("The category must be a string.")
+
+        if category not in MetadataCustomCategory:
+            raise ValueError(
+                f"Invalid category value. "
+                f"Choose from {MetadataCustomCategory.values()}."
+            )
+
+        if description and not isinstance(description, str):
+            raise TypeError("The description must be a string.")
+
+        try:
+            tmp_value = json.dumps(value)
+        except TypeError:
+            raise ValueError(
+                f"An error occurred in attempt to serialize the value of `{key}` to JSON. "
+                "The value must be JSON serializable."
+            )
+
+        if len(tmp_value) > METADATA_VALUE_LENGTH_LIMIT:
+            raise MetadataValueTooLong(key, len(tmp_value))
+
+        if description and len(description) > METADATA_DESCRIPTION_LENGTH_LIMIT:
+            raise MetadataDescriptionTooLong(key, len(description))
+
+        if not replace and key in self.keys:
+            raise ValueError(
+                f"The metadata item with key {key} is already registered. "
+                "Use replace=True to overwrite."
+            )
+
+        self._add(
+            ModelCustomMetadataItem(
+                key=key,
+                value=value,
+                description=description,
+                category=category,
+            ),
+            replace=replace,
+        )
+
+    def _add(self, item: ModelCustomMetadataItem, replace=False) -> None:
+        """Adds a new model metadata item.
+
+        Overrides the existing one if replace flag is True.
+
+        Parameters
+        ----------
+        item: ModelCustomMetadataItem
+            The model metadata item.
+        replace: bool
+            Overrides the existing metadata item if replace flag is True.
+
+        Returns
+        -------
+        None
+            Nothing.
+
+        Raises
+        ------
+        ValueError
+            If item is already registered and replace flag is False.
+        TypeError
+            If input data has a wrong format.
+        """
+        if not isinstance(item, ModelCustomMetadataItem):
+            raise TypeError(
+                "Argument must be an instance of the class ModelCustomMetadataItem."
+            )
+        if not replace and item in self._items:
+            raise ValueError(
+                f"The metadata item with key {item.key} is already registered. "
+                "Use replace=True to overwrite."
+            )
+        self._items.discard(item)
+        self._items.add(item)
+
+    def _add_many(self, items: List[ModelCustomMetadataItem], replace=False) -> None:
+        """Adds model metadata items into model metadata.
+
+        Overrides the existing ones if replace flag is True.
+
+        Parameters
+        ----------
+        items: List[ModelCustomMetadataItem]
+            The list of model metadata items.
+        replace: bool
+            Overrides the existing metadata items if replace flag is True.
+
+        Returns
+        -------
+        None
+            Nothing.
+
+        Raises
+        ------
+        TypeError
+            If input data has wrong format.
+        """
+        if not isinstance(items, list):
+            raise TypeError("Argument must be a list of model metadata items.")
+        for item in items:
+            self._add(item, replace)
+
+    def set_training_data(self, path: str, data_size: str = None):
+        """Adds training_data path and data size information into model custom metadata.
+
+        Parameters
+        ----------
+        path: str
+            The path where the training_data is stored.
+        data_size: str
+            The size of the training_data.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.add(
+            key=MetadataCustomKeys.TRAINING_DATASET,
+            value=path,
+            category=MetadataCustomCategory.TRAINING_AND_VALIDATION_DATASETS,
+            description="The path where training dataset path are stored.",
+            replace=True,
+        )
+        if data_size is not None:
+            self.add(
+                key=MetadataCustomKeys.TRAINING_DATASET_SIZE,
+                value=data_size,
+                category=MetadataCustomCategory.TRAINING_AND_VALIDATION_DATASETS,
+                description="The size of the training data.",
+                replace=True,
+            )
+
+    def set_validation_data(self, path: str, data_size: str = None):
+        """Adds validation_data path and data size information into model custom metadata.
+
+        Parameters
+        ----------
+        path: str
+            The path where the validation_data is stored.
+        data_size: str
+            The size of the validation_data.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self.add(
+            key=MetadataCustomKeys.VALIDATION_DATASET,
+            value=path,
+            category=MetadataCustomCategory.TRAINING_AND_VALIDATION_DATASETS,
+            description="The path where validation dataset path are stored.",
+            replace=True,
+        )
+        if data_size is not None:
+            self.add(
+                key=MetadataCustomKeys.VALIDATION_DATASET_SIZE,
+                value=data_size,
+                category=MetadataCustomCategory.TRAINING_AND_VALIDATION_DATASETS,
+                description="The size of the validation data.",
+                replace=True,
+            )
+
+    def remove(self, key: str) -> None:
+        """Removes a model metadata item.
+
+        Parameters
+        ----------
+        key: str
+            The key of the metadata item that should be removed.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self._items.discard(self.get(key))
+
+    def clear(self) -> None:
+        """Removes all metadata items.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        self._items.clear()
+
+    def isempty(self) -> bool:
+        """Checks if metadata is empty.
+
+        Returns
+        -------
+        bool
+            True if metadata is empty, False otherwise.
+        """
+        return len(self._items) == 0
+
+    @classmethod
+    def _from_oci_metadata(cls, metadata_list):
+        """Convert from list of OCI metadata list to an ModelCustomMetadata object.
+
+        Returns
+        -------
+        ModelCustomMetadata
+            A `ModelCustomMetadata` instance.
+        """
+        metadata = cls()
+        for item in metadata_list:
+            metadata._add(
+                ModelCustomMetadataItem._from_oci_metadata(item), replace=True
+            )
+        return metadata
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """Returns the model metadata list in a data frame format.
+
+        Returns
+        -------
+        `pandas.DataFrame`
+            The model metadata in a dataframe format.
+        """
+        return (
+            pd.DataFrame(
+                (
+                    (
+                        item.key,
+                        item.value,
+                        item.description,
+                        item.category,
+                        item.has_artifact,
+                    )
+                    for item in self._items
+                ),
+                columns=[value for value in MetadataCustomPrintColumns.values()],
+            )
+            .sort_values(by=[MetadataCustomPrintColumns.KEY])
+            .reset_index(drop=True)
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "ModelCustomMetadata":
+        """Constructs an instance of `ModelCustomMetadata` from a dictionary.
+
+        Parameters
+        ----------
+        data : Dict
+            Model metadata in a dictionary format.
+
+        Returns
+        -------
+        ModelCustomMetadata
+            An instance of model custom metadata.
+
+        Raises
+        ------
+        ValueError
+            In case of the wrong input data format.
+        """
+        if (
+            not data
+            or not isinstance(data, Dict)
+            or "data" not in data
+            or not isinstance(data["data"], List)
+        ):
+            raise ValueError(
+                "An error occurred when attempting to deserialize the model custom metadata from a dictionary. "
+                "The input data must be a dictionary with `data` key. Example: `{'data': []}`"
+            )
+
+        metadata = cls()
+        for item in data["data"]:
+            metadata._add(ModelCustomMetadataItem.from_dict(item), replace=True)
+        return metadata
+
+
+class ModelTaxonomyMetadata(ModelMetadata):
+    """Class that represents Model Taxonomy Metadata.
+
+    Methods
+    -------
+    get(self, key: str) -> ModelTaxonomyMetadataItem
+        Returns the model metadata item by provided key.
+    reset(self) -> None
+        Resets all model metadata items to empty values.
+    to_dataframe(self) -> pd.DataFrame
+        Returns the model metadata list in a data frame format.
+    size(self) -> int
+        Returns the size of the model metadata in bytes.
+    validate(self) -> bool
+        Validates metadata.
+    to_dict(self)
+        Serializes model metadata into a dictionary.
+    from_dict(cls) -> ModelTaxonomyMetadata
+        Constructs model metadata from dictionary.
+    to_yaml(self)
+        Serializes model metadata into a YAML.
+    to_json(self)
+        Serializes model metadata into a JSON.
+    to_json_file(self, file_path: str, storage_options: dict = None) -> None
+        Saves the metadata to a local file or object storage.
+
+    Examples
+    --------
+    >>> metadata_taxonomy = ModelTaxonomyMetadata()
+    >>> metadata_taxonomy.to_dataframe()
+                    Key                   Value
+    --------------------------------------------
+    0        UseCaseType   binary_classification
+    1          Framework                 sklearn
+    2   FrameworkVersion                   0.2.2
+    3          Algorithm               algorithm
+    4    Hyperparameters                      {}
+
+    >>> metadata_taxonomy.reset()
+    >>> metadata_taxonomy.to_dataframe()
+                    Key                    Value
+    --------------------------------------------
+    0        UseCaseType                    None
+    1          Framework                    None
+    2   FrameworkVersion                    None
+    3          Algorithm                    None
+    4    Hyperparameters                    None
+
+    >>> metadata_taxonomy
+        metadata:
+        - key: UseCaseType
+          category: None
+          description: None
+          value: None
+    """
+
+    def __init__(self):
+        super().__init__()
+        for key in MetadataTaxonomyKeys.values():
+            self._items.add(ModelTaxonomyMetadataItem(key=key))
+
+    def _populate_from_map(self, map: Dict[str, str]) -> None:
+        """Populates metadata information from map.
+
+        Parameters
+        ----------
+        map: Dict[str, str]
+            The key/value map with model metadata information.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        for value in MetadataTaxonomyKeys.values():
+            if value in map:
+                self[value].update(value=map[value])
+
+    @classmethod
+    def _from_oci_metadata(cls, metadata_list):
+        """
+        Convert from list of oci metadata to a ModelTaxonomyMetadata object.
+
+        Parameters
+        ----------
+        metadata_list: List
+            List of oci metadata.
+
+        Returns
+        -------
+        ModelTaxonomyMetadata
+            A `ModelTaxonomyMetadata` instance.
+        """
+        metadata = cls()
+        for oci_item in metadata_list:
+            item = ModelTaxonomyMetadataItem._from_oci_metadata(oci_item)
+            if item.key in metadata.keys:
+                metadata[item.key].update(
+                    value=item.value, has_artifact=item.has_artifact
+                )
+            else:
+                metadata._items.add(item)
+        return metadata
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """Returns the model metadata list in a data frame format.
+
+        Returns
+        -------
+        `pandas.DataFrame`
+            The model metadata in a dataframe format.
+        """
+        return (
+            pd.DataFrame(
+                ((item.key, item.value, item.has_artifact) for item in self._items),
+                columns=[value for value in MetadataTaxonomyPrintColumns.values()],
+            )
+            .sort_values(by=[MetadataTaxonomyPrintColumns.KEY])
+            .reset_index(drop=True)
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "ModelTaxonomyMetadata":
+        """Constructs an instance of `ModelTaxonomyMetadata` from a dictionary.
+
+        Parameters
+        ----------
+        data : Dict
+            Model metadata in a dictionary format.
+
+        Returns
+        -------
+        ModelTaxonomyMetadata
+            An instance of model taxonomy metadata.
+
+        Raises
+        ------
+        ValueError
+            In case of the wrong input data format.
+        """
+        if (
+            not data
+            or not isinstance(data, Dict)
+            or "data" not in data
+            or not isinstance(data["data"], List)
+        ):
+            raise ValueError(
+                "An error occurred when attempting to deserialize the model taxonomy metadata from a dictionary. "
+                "The input data must be a dictionary with `data` key. Example: `{'data': []}`"
+            )
+
+        metadata = cls()
+        for item in data["data"]:
+            item = ModelTaxonomyMetadataItem.from_dict(item)
+            if item.key in metadata.keys:
+                metadata[item.key].update(value=item.value)
+            else:
+                metadata._items.add(item)
+        return metadata
+
+
+@dataclass(repr=True)
+class ModelProvenanceMetadata(DataClassSerializable):
+    """ModelProvenanceMetadata class.
+
+    Examples
+    --------
+    >>> provenance_metadata = ModelProvenanceMetadata.fetch_training_code_details()
+    ModelProvenanceMetadata(repo=<git.repo.base.Repo '/home/datascience/.git'>, git_branch='master', git_commit='99ad04c31803f1d4ffcc3bf4afbd6bcf69a06af2', repository_url='file:///home/datascience', "", "")
+    >>> provenance_metadata.assert_path_not_dirty("your_path", ignore=False)
+    """
+
+    repo: str = field(default=None, metadata={"serializable": False})
+    git_branch: str = None
+    git_commit: str = None
+    repository_url: str = None
+    training_script_path: str = None
+    training_id: str = None
+    artifact_dir: str = None
+
+    @classmethod
+    def fetch_training_code_details(
+        cls,
+        training_script_path: str = None,
+        training_id: str = None,
+        artifact_dir: str = None,
+    ):
+        """Fetches the training code details: repo, git_branch, git_commit, repository_url, training_script_path and training_id.
+
+        Parameters
+        ----------
+        training_script_path: (str, optional). Defaults to None.
+            Training script path.
+        training_id: (str, optional). Defaults to None.
+            The training OCID for model.
+        artifact_dir: str
+            artifact directory to store the files needed for deployment.
+
+        Returns
+        -------
+        ModelProvenanceMetadata
+            A ModelProvenanceMetadata instance.
+        """
+        git_dir = CURRENT_WORKING_DIR
+        if training_script_path:
+            if not os.path.exists(training_script_path):
+                logger.warning(
+                    f"Training script {os.path.abspath(training_script_path)} does not exist."
+                )
+            else:
+                training_script_path = os.path.abspath(training_script_path)
+                git_dir = os.path.dirname(training_script_path)
+        repo = git.Repo(git_dir, search_parent_directories=True)
+        # get repository url
+        if len(repo.remotes) > 0:
+            repository_url = (
+                repo.remotes.origin.url
+                if repo.remotes.origin in repo.remotes
+                else list(repo.remotes.values())[0].url
+            )
+        else:
+            repository_url = "file://" + repo.working_dir  # no remote repo
+
+        # get git commit
+        git_branch = None
+        git_commit = None
+
+        try:
+            # get git branch
+            git_branch = format(repo.active_branch)
+            git_commit = format(str(repo.head.commit.hexsha)) or None
+        except Exception:
+            logger.warning("No commit found.")
+        return cls(
+            repo=repo,
+            git_branch=git_branch,
+            git_commit=git_commit,
+            repository_url=repository_url,
+            training_script_path=training_script_path,
+            training_id=training_id,
+            artifact_dir=artifact_dir,
+        )
+
+    def assert_path_not_dirty(self, path: str, ignore: bool):
+        """Checks if all the changes in this path has been commited.
+
+        Parameters
+        ----------
+        path: (str)
+            path.
+        ignore (bool)
+            whether to ignore the changes or not.
+
+        Raises
+        ------
+        ChangesNotCommitted: if there are changes not being commited.
+
+        Returns
+        -------
+        None
+            Nothing.
+        """
+        if ObjectStorageDetails.is_oci_path(path):
+            return
+
+        if self.repo is not None and not ignore:
+            path_abs = os.path.abspath(path)
+            if (
+                os.path.commonpath([path_abs, self.repo.working_dir])
+                == self.repo.working_dir
+            ):
+                path_relpath = os.path.relpath(path_abs, self.repo.working_dir)
+                if self.repo.is_dirty(path=path_relpath) or any(
+                    [
+                        os.path.commonpath([path_relpath, untracked]) == path_relpath
+                        for untracked in self.repo.untracked_files
+                    ]
+                ):
+                    raise ChangesNotCommitted(path_abs)
+
+    def _to_oci_metadata(self) -> oci.data_science.models.ModelProvenance:
+        """Convert to `oci.data_science.models.ModelProvenance` object.
+
+        Returns
+        -------
+        oci.data_science.models.ModelProvenance
+            OCI model provenance object.
+        """
+        return oci.data_science.models.ModelProvenance(
+            repository_url=self.repository_url,
+            git_branch=self.git_branch,
+            git_commit=self.git_commit,
+            script_dir=self.artifact_dir,
+            training_script=self.training_script_path,
+            training_id=self.training_id,
+        )
+
+    @classmethod
+    def _from_oci_metadata(
+        cls, model_provenance: oci.data_science.models.ModelProvenance
+    ) -> "ModelProvenanceMetadata":
+        """Creates a new model provenance metadata item from the `oci.data_science.models.ModelProvenance` object.
+
+        Returns
+        -------
+        ModelProvenanceMetadata
+            Model provenance metadata object.
+        """
+        return ModelProvenanceMetadata(
+            repo=model_provenance.repository_url,
+            git_branch=model_provenance.git_branch,
+            git_commit=model_provenance.git_commit,
+            repository_url=model_provenance.repository_url,
+            training_script_path=model_provenance.training_script,
+            training_id=model_provenance.training_id,
+            artifact_dir=model_provenance.script_dir,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, str]) -> "ModelProvenanceMetadata":
+        """Constructs an instance of ModelProvenanceMetadata from a dictionary.
+
+        Parameters
+        ----------
+        data : Dict[str,str]
+            Model provenance metadata in dictionary format.
+
+        Returns
+        -------
+        ModelProvenanceMetadata
+            An instance of ModelProvenanceMetadata.
+        """
+        return cls(**data or {})
+
+    def to_dict(self) -> dict:
+        """Serializes model provenance metadata into a dictionary.
+
+        Returns
+        -------
+        Dict
+            The dictionary representation of the model provenance metadata.
+        """
+        return {
+            f.name: getattr(self, f.name)
+            for f in fields(self)
+            if ("serializable" not in f.metadata or f.metadata["serializable"])
+        }
+
+    def __repr__(self):
+        """Returns printable version of object.
+
+        Parameters
+        ----------
+        string
+            Serialized version of object as a YAML string
+        """
+        return self.to_yaml()