oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.9rc1__py3-none-any.whl

ads/common/oci_mixin.py

@@ -0,0 +1,957 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2021, 2024 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+"""Contains Mixins for integrating OCI data models
+"""
+import inspect
+import json
+import logging
+import os
+import re
+import traceback
+from datetime import date, datetime
+from enum import Enum
+from typing import Callable, Optional, Union
+
+import oci
+import yaml
+from dateutil import tz
+from dateutil.parser import parse
+from oci._vendor import six
+
+from ads.common import auth
+from ads.common.decorator.utils import class_or_instance_method
+from ads.common.utils import camel_to_snake
+from ads.config import COMPARTMENT_OCID
+
+logger = logging.getLogger(__name__)
+
+LIFECYCLE_STOP_STATE = ("SUCCEEDED", "FAILED", "CANCELED", "DELETED")
+WORK_REQUEST_STOP_STATE = ("SUCCEEDED", "FAILED", "CANCELED")
+DEFAULT_WAIT_TIME = 1200
+DEFAULT_POLL_INTERVAL = 10
+WORK_REQUEST_PERCENTAGE = 100
+
+
+class MergeStrategy(Enum):
+    OVERRIDE = "override"
+    MERGE = "merge"
+
+
+class OCIModelNotExists(Exception):  # pragma: no cover
+    pass
+
+
+class OCIClientMixin:
+    """Mixin class for representing OCI resource/service with OCI client.
+
+    Most OCI requests requires a client for making the connection.
+    Usually the same client will be used for the requests related the same resource/service type.
+    This Mixin adds a "client" property to simplify accessing the client.
+    The actual client will be initialize lazily so that it is not required for a sub-class
+    To use the client, sub-class should override the init_client() method pass in the "client" keyword argument.
+    For example:
+
+    @class_or_instance_method
+    def init_client(cls, **kwargs) -> oci.logging.LoggingManagementClient:
+        return cls._init_client(client=oci.logging.LoggingManagementClient, **kwargs)
+
+    Instance methods in the sub-class can use self.client to access the client.
+    The init_client() method is a class method used to create the client.
+    Any class method using the client should use init_client() to create the client.
+    The call to this method may come from an instance or a class.
+    When the method is called from a class,
+        the default authentication configured at ADS level with ads.set_auth() will be used.
+    When the method is called from an instance,
+        the config, signer and kwargs specified when initializing the instance will be used.
+    The sub-class's __init__ method should take config, signer and client_kwargs as argument,
+        then pass them to the __init__ method of this class.
+    This allows users to override the authentication and client initialization parameters.
+    For example, log_group = OCILogGroup(config=config, signer=signer, client_kwargs=kwargs)
+    """
+
+    config = None
+    signer = None
+    kwargs = None
+
+    @class_or_instance_method
+    def _get_auth(cls):
+        client_kwargs = dict(retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY)
+        if cls.kwargs:
+            client_kwargs.update(cls.kwargs)
+
+        if cls.config is None and cls.signer is None:
+            oci_auth = auth.default_signer(client_kwargs)
+        elif not cls.signer and cls.config:
+            oci_auth = {"config": cls.config, "client_kwargs": client_kwargs}
+        else:
+            oci_auth = {
+                "config": cls.config,
+                "signer": cls.signer,
+                "client_kwargs": client_kwargs,
+            }
+        return oci_auth
+
+    @class_or_instance_method
+    def init_client(cls, **kwargs):
+        """Initializes the OCI client specified in the "client" keyword argument
+        Sub-class should override this method and call cls._init_client(client=OCI_CLIENT)
+
+        Parameters
+        ----------
+        **kwargs :
+            Additional keyword arguments for initializing the OCI client.
+
+        Returns
+        -------
+            An instance of OCI client.
+
+        """
+        return cls._init_client(**kwargs)
+
+    @class_or_instance_method
+    def _init_client(cls, client, **kwargs):
+        """Initializes the OCI client specified in the "client" argument
+
+        Parameters
+        ----------
+        client :
+            The OCI client class to be initialized, e.g., oci.data_science.DataScienceClient
+        **kwargs :
+            Additional keyword arguments for initializing the OCI client.
+
+        Returns
+        -------
+            An instance of OCI client.
+
+        """
+        auth = cls._get_auth()
+        auth_kwargs = auth.pop("client_kwargs", {})
+        if kwargs:
+            auth_kwargs.update(kwargs)
+        auth.update(auth_kwargs)
+        return client(**auth)
+
+    @class_or_instance_method
+    def create_instance(obj, *args, **kwargs):
+        """Creates an instance using the same authentication as the class or an existing instance.
+        If this method is called by a class, the default ADS authentication method will be used.
+        If this method is called by an instance, the authentication method set in the instance will be used.
+        """
+        # Here cls could be a class or an instance.
+        # If it is a class, it can be used to create the new instance directly.
+        # If it is an instance, the new instance should be created using cls.__class__.
+        # Calling the classmethod _create_instance() will make sure that class will be used.
+        return obj._create_instance(
+            config=obj.config,
+            signer=obj.signer,
+            client_kwargs=obj.kwargs,
+            *args,
+            **kwargs,
+        )
+
+    @classmethod
+    def _create_instance(cls, *args, **kwargs):
+        """Initialize an instance."""
+        return cls(*args, **kwargs)
+
+    def __init__(self, config=None, signer=None, client_kwargs=None) -> None:
+        """Initializes a service/resource with OCI client as a property.
+        If config or signer is specified, it will be used to initialize the OCI client.
+        If neither of them is specified, the client will be initialized with ads.common.auth.default_signer.
+        If both of them are specified, both of them will be passed into the OCI client,
+            and the authentication will be determined by OCI Python SDK.
+
+        Parameters
+        ----------
+        config : dict, optional
+            OCI API key config dictionary, by default None.
+        signer : oci.signer.Signer, optional
+            OCI authentication signer, by default None.
+        client_kwargs : dict, optional
+            Additional keyword arguments for initializing the OCI client.
+        """
+        super().__init__()
+        self.config = config
+        self.signer = signer
+        self.kwargs = client_kwargs
+        self._client = None
+
+    @property
+    def auth(self) -> dict:
+        """The ADS authentication config used to initialize the client.
+        This auth has the same format as those obtained by calling functions in ads.common.auth.
+        The config is a dict containing the following key-value pairs:
+        config: The config contains the config loaded from the configuration loaded from `oci_config`.
+        signer: The signer contains the signer object created from the api keys.
+        client_kwargs: client_kwargs contains the `client_kwargs` that was passed in as input parameter.
+        """
+        return self._get_auth()
+
+    @property
+    def client(self):
+        """OCI client"""
+        if self._client is None:
+            self._client = self.init_client()
+        return self._client
+
+
+class OCISerializableMixin(OCIClientMixin):
+    """Mixin class containing OCI serialization/de-serialization methods.
+    These methods are copied and modified from the OCI BaseClient.
+
+    """
+
+    type_mappings = None
+
+    def serialize(self):
+        """Serialize the model to a dictionary that is ready to be send to OCI API.
+
+        Returns
+        -------
+        dict
+            A dictionary that is ready to be send to OCI API.
+
+        """
+        return self.client.base_client.sanitize_for_serialization(self)
+
+    @staticmethod
+    def _parse_kwargs(attribute_map: dict, **kwargs):
+        """Parse kwargs to make all key in camel format."""
+        parsed_kwargs = {}
+        for key, val in kwargs.items():
+            if key in attribute_map:
+                parsed_kwargs[attribute_map[key]] = val
+            else:
+                parsed_kwargs[key] = val
+
+        return parsed_kwargs
+
+    @class_or_instance_method
+    def deserialize(cls, data, to_cls):
+        """De-serialize data from dictionary to an OCI model"""
+        if cls.type_mappings is None:
+            cls.type_mappings = cls.init_client().base_client.type_mappings
+
+        if data is None:
+            return None
+
+        # This is a work around for enums not being present
+        # in the type mappings.
+        # See OraclePythonSdkCodegen removeEnumsFromModelGeneration().
+        if to_cls in cls.type_mappings:
+            to_cls = cls.type_mappings[to_cls]
+
+            if isinstance(data, dict):
+                data = cls._parse_kwargs(to_cls().attribute_map, **data)
+        else:
+            return cls.__deserialize_primitive(data, to_cls)
+
+        if hasattr(to_cls, "get_subtype"):
+            # Return the object as is if it is already deserialized.
+            if isinstance(data, to_cls) or issubclass(data.__class__, to_cls):
+                return data
+
+            # Use the discriminator value to get the correct subtype.
+            to_cls = to_cls.get_subtype(data)  # get_subtype returns a str
+            to_cls = cls.type_mappings[to_cls]
+
+            # kwargs needs to be parsed again as there are more attributes in the sub types.
+            if isinstance(data, dict):
+                data = cls._parse_kwargs(to_cls().attribute_map, **data)
+
+        if to_cls in [int, float, six.u, bool]:
+            return cls.__deserialize_primitive(data, to_cls)
+        elif to_cls == object:
+            return data
+        elif to_cls == date:
+            return cls.__deserialize_date(data)
+        elif to_cls == datetime:
+            return cls.__deserialize_datetime(data)
+        else:
+            return cls.__deserialize_model(data, to_cls)
+
+    @class_or_instance_method
+    def __deserialize_model(cls, data, to_cls):
+        """De-serializes list or dict to model."""
+        if isinstance(data, to_cls):
+            return data
+
+        instance = to_cls()
+
+        for attr, attr_type in instance.swagger_types.items():
+            property = instance.attribute_map[attr]
+            if property in data:
+                value = data[property]
+                setattr(instance, attr, cls.deserialize(value, attr_type))
+
+        return instance
+
+    @staticmethod
+    def __deserialize_primitive(data, cls):
+        """De-serializes string to primitive type."""
+        try:
+            value = cls(data)
+        except UnicodeEncodeError:
+            value = data
+        except TypeError:
+            value = data
+        return value
+
+    @staticmethod
+    def __deserialize_date(string):
+        """De-serializes string to date."""
+        try:
+            return parse(string).date()
+        except ImportError:
+            return string
+        except ValueError:
+            raise Exception("Failed to parse `{0}` into a date object".format(string))
+
+    @staticmethod
+    def __deserialize_datetime(string):
+        """De-serializes string to datetime.
+
+        The string should be in iso8601 datetime format.
+        """
+        if isinstance(string, datetime):
+            return string
+        try:
+            # If this parser creates a date without raising an exception
+            # then the time zone is utc and needs to be set.
+            naivedatetime = datetime.strptime(string, "%Y-%m-%dT%H:%M:%S.%fZ")
+            awaredatetime = naivedatetime.replace(tzinfo=tz.tzutc())
+            return awaredatetime
+
+        except ValueError:
+            try:
+                return parse(string)
+            except ImportError:
+                return string
+            except ValueError:
+                raise Exception(
+                    "Failed to parse `{0}` into a datetime object".format(string)
+                )
+        except ImportError:
+            return string
+
+
+class OCIModelMixin(OCISerializableMixin):
+    """Mixin class to operate OCI model.
+    OCI resources are represented by models in the OCI Python SDK.
+
+    Unifying OCI models for the same resource
+    -----------------------------------------
+    OCI SDK uses different models to represent the same resource for different operations.
+    For example, CreateLogDetails is used when creating a log resource,
+        while LogSummary is returned when listing the log resources.
+    However, both CreateLogDetails and LogSummary have the same commonly used attribute like
+        compartment_id, display_name, log_type, etc.
+    In general, there is a class with a super set of all properties.
+    For example, the Log class contains all properties of CreateLogDetails and LogSummary,
+        as well as other classes representing an OCI log resource.
+    A subclass can be implemented with this Mixin to unify the OCI models,
+        so that all properties are available to the user.
+    For example, if we define the Mixin model as ``class OCILog(OCIModelMixin, oci.logging.models.Log)``,
+        users will be able to access properties like ``OCILog().display_name``
+    Since this sub-class contains all the properties, it can be converted to any related OCI model in an operation.
+    For example, we can create ``CreateLogDetails`` from ``OCILog`` by extracting a subset of the properties.
+    When listing the resources, properties from ``LogSummary`` can be used to update
+        the corresponding properties of ``OCILog``.
+    Such convertion can be done be the generic methods provided by this Mixin.
+    Although OCI SDK accepts dictionary (JSON) data instead of objects like CreateLogDetails when creating or
+        updating the resource, the structure and keys of the dictionary is not easy for a user to remember.
+    It is also unnecessary for the users to construct the entire dictionary if they only want to update a single value.
+
+    This Mixin class should be the first parent as the class from OCI SDK does not call ``super().__init__()``
+        in its ``__init__()`` constructor.
+    Mixin properties may not be intialized correctly if ``super().__init__()`` is not called.
+
+
+    Provide generic methods for CRUDL operations
+    --------------------------------------------
+    Since OCI SDK uses different models in CRUDL operations,
+        this Mixin provides the following method to convert between them.
+    An OCI model instance can be any OCI model of the resource containing some properties, e.g. LogSummary
+    ``from_oci_model()`` static method can be used to initialize a new instance from an OCI model instance.
+    ``update_from_oci_model()`` can be used to update the existing properties from an OCI model instance.
+    ``to_oci_model()`` can be used to extract properties from the Mixin model to OCI model.
+
+    """
+
+    # Regex pattern matching the module name of an OCI model.
+    OCI_MODEL_PATTERN = r"(oci|feature_store_client).[^.]+\.models[\..*]?"
+    # Constants
+    CONS_COMPARTMENT_ID = "compartment_id"
+
+    @staticmethod
+    def check_compartment_id(compartment_id: Optional[str]) -> str:
+        """Checks if a compartment ID has value and
+            return the value from NB_SESSION_COMPARTMENT_OCID environment variable if it is not specified.
+
+        Parameters
+        ----------
+        compartment_id : str
+            Compartment OCID or None
+
+        Returns
+        -------
+        type
+            str: Compartment OCID
+
+        Raises
+        ------
+        ValueError
+            compartment_id is not specified and NB_SESSION_COMPARTMENT_OCID environment variable is not set
+
+        """
+        compartment_id = compartment_id or COMPARTMENT_OCID
+        if not compartment_id:
+            raise ValueError("Specify compartment OCID.")
+        return compartment_id
+
+    @class_or_instance_method
+    def list_resource(
+        cls, compartment_id: str = None, limit: int = 0, **kwargs
+    ) -> list:
+        """Generic method to list OCI resources
+
+        Parameters
+        ----------
+        compartment_id : str
+            Compartment ID of the OCI resources. Defaults to None.
+            If compartment_id is not specified,
+            the value of NB_SESSION_COMPARTMENT_OCID in environment variable will be used.
+        limit : int
+            The maximum number of items to return. Defaults to 0, All items will be returned
+        **kwargs :
+            Additional keyword arguments to filter the resource.
+            The kwargs are passed into OCI API.
+
+        Returns
+        -------
+        list
+            A list of OCI resources
+
+        Raises
+        ------
+        NotImplementedError
+            List method is not supported or implemented.
+
+        """
+        if limit:
+            items = cls._find_oci_method("list")(
+                cls.check_compartment_id(compartment_id), limit=limit, **kwargs
+            ).data
+        else:
+            items = oci.pagination.list_call_get_all_results(
+                cls._find_oci_method("list"),
+                cls.check_compartment_id(compartment_id),
+                **kwargs,
+            ).data
+        return [cls.from_oci_model(item) for item in items]
+
+    @classmethod
+    def _find_oci_parent(cls):
+        """Finds the parent OCI model class
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        class
+            An OCI model class
+
+        Raises
+        ------
+        AttributeError
+            If the class if not inherit from an OCI model.
+
+        """
+        oci_model = None
+        for parent in inspect.getmro(cls):
+            if re.match(OCIModelMixin.OCI_MODEL_PATTERN, parent.__module__):
+                oci_model = parent
+                break
+        if not oci_model:
+            raise AttributeError(f"{cls.__name__} is not inherited from an OCI model.")
+        return oci_model
+
+    @class_or_instance_method
+    def _find_oci_method(cls, method: str) -> Callable:
+        """Finds the OCI method for operations like get/list
+
+        Parameters
+        ----------
+        method : str
+            The operation to be performed, e.g. get, list, delete
+
+
+        Returns
+        -------
+        callable
+            The method from OCI client to perform the operation.
+
+        """
+        client = cls.init_client()
+
+        user_define_method = f"oci_{method}_method".upper()
+        if hasattr(cls, user_define_method) and getattr(cls, user_define_method):
+            return getattr(cls, user_define_method).__get__(client, client.__class__)
+
+        oci_class = cls._find_oci_parent()
+        if method == "list":
+            method_name = f"{method}_{camel_to_snake(oci_class.__name__)}s"
+        else:
+            method_name = f"{method}_{camel_to_snake(oci_class.__name__)}"
+
+        if hasattr(client, method_name):
+            return getattr(client, method_name)
+
+        raise NotImplementedError(
+            f"{str(oci_class)} does not have {method_name} method. "
+            f"Define {user_define_method} in {str(cls)}"
+        )
+
+    @class_or_instance_method
+    def from_oci_model(cls, oci_instance):
+        """Initialize an instance from an instance of OCI model.
+
+        Parameters
+        ----------
+        oci_instance :
+            An instance of an OCI model.
+
+        """
+        oci_model = cls._find_oci_parent()
+        kwargs = {}
+        for attr in oci_model().swagger_types.keys():
+            if hasattr(oci_instance, attr):
+                kwargs[attr] = getattr(oci_instance, attr)
+        instance = cls.create_instance(**kwargs)
+        if hasattr(oci_instance, "attribute_map"):
+            instance._oci_attributes = oci_instance.attribute_map
+        return instance
+
+    @class_or_instance_method
+    def from_dict(cls, data):
+        """Initialize an instance from a dictionary.
+
+        Parameters
+        ----------
+        data : dict
+            A dictionary containing the properties to initialize the class.
+
+        """
+        return cls.create_instance(**data)
+
+    @class_or_instance_method
+    def deserialize(cls, data: dict, to_cls: str = None):
+        """Deserialize data
+
+        Parameters
+        ----------
+        data : dict
+            A dictionary containing the data to be deserialized.
+
+        to_cls : str
+            The name of the OCI model class to be initialized using the data.
+            The OCI model class must be from the same OCI service of the OCI client (self.client).
+            Defaults to None, the parent OCI model class name will be used
+            if current class is inherited from an OCI model.
+            If parent OCI model class is not found or not from the same OCI service,
+            the data will be returned as is.
+
+        """
+        if to_cls is None:
+            oci_model = cls._find_oci_parent()
+            to_cls = oci_model.__name__
+        return super().deserialize(data, to_cls)
+
+    @class_or_instance_method
+    def _get(cls, ocid):
+        get_method = cls._find_oci_method("get")
+        return get_method(ocid).data
+
+    @class_or_instance_method
+    def from_ocid(cls, ocid: str):
+        """Initializes an object from OCID
+
+        Parameters
+        ----------
+        ocid : str
+            The OCID of the object
+
+        """
+        oci_instance = cls._get(ocid)
+        return cls.from_oci_model(oci_instance)
+
+    def __init__(
+        self,
+        config: dict = None,
+        signer: oci.signer.Signer = None,
+        client_kwargs: dict = None,
+        **kwargs,
+    ) -> None:
+        # Initialize an empty object
+        super().__init__(config=config, signer=signer, client_kwargs=client_kwargs)
+
+        if kwargs:
+            self.update_from_oci_model(
+                self.deserialize(kwargs), merge_strategy=MergeStrategy.MERGE
+            )
+        # When from_oci_model is called to initialize the object from an OCI model,
+        # _oci_attributes stores the attribute names from the OCI model
+        # This is used to determine if an additional get request should be called to get additional attributes.
+        # For example, some attributes are not included in the results from OCI list request.
+        # When user access such attributes, an additional get request should be made to get the data from OCI.
+        # See __getattribute__() for the implementation.
+        self._oci_attributes = {}
+
+    @property
+    def name(self) -> str:
+        """Gets the name of the object."""
+        if hasattr(self, "display_name"):
+            return getattr(self, "display_name")
+        return ""
+
+    @name.setter
+    def name(self, value: str):
+        """Sets the name of the object.
+
+        Parameters
+        ----------
+        value : str
+            The name of the object.
+        """
+        setattr(self, "display_name", value)
+
+    def load_properties_from_env(self):
+        """Loads properties from the environment"""
+        env_var_mapping = {
+            "project_id": ["PROJECT_OCID"],
+            OCIModelMixin.CONS_COMPARTMENT_ID: [
+                "JOB_RUN_COMPARTMENT_OCID",
+                "NB_SESSION_COMPARTMENT_OCID",
+            ],
+        }
+        for attr, env_names in env_var_mapping.items():
+            try:
+                env_value = next(
+                    os.environ.get(env_name)
+                    for env_name in env_names
+                    if os.environ.get(env_name, None) is not None
+                )
+                if getattr(self, attr, "") is None:
+                    setattr(self, attr, env_value)
+            except:
+                pass
+
+    def to_oci_model(self, oci_model):
+        """Converts the object into an instance of OCI data model.
+
+        Parameters
+        ----------
+        oci_model : class or str
+            The OCI model to be converted to. This can be a string of the model name.
+        type_mapping : dict
+            A dictionary mapping the models.
+            Returns: An instance of the oci_model
+
+        Returns
+        -------
+
+        """
+        if isinstance(oci_model, str):
+            oci_model_name = oci_model
+        else:
+            oci_model_name = oci_model.__name__
+        data = json.dumps(self.to_dict()).encode("utf8")
+        return self.client.base_client.deserialize_response_data(data, oci_model_name)
+
+    @staticmethod
+    def flatten(data: dict) -> dict:
+        """Flattens a nested dictionary.
+
+        Parameters
+        ----------
+        data : A nested dictionary
+
+
+        Returns
+        -------
+        dict
+            The flattened dictionary.
+
+        """
+        flatten_dict = {}
+        for key, value in data.items():
+            if isinstance(value, dict):
+                flatten_dict.update(OCIModelMixin.flatten(value))
+            else:
+                flatten_dict[key] = value
+        return flatten_dict
+
+    def to_dict(self, flatten: bool = False) -> dict:
+        """Converts the properties to a dictionary
+
+        Parameters
+        ----------
+        flatten :
+             (Default value = False)
+
+        Returns
+        -------
+
+        """
+        data = self.serialize()
+        if flatten:
+            data = OCIModelMixin.flatten(data)
+        return data
+
+    def update_from_oci_model(
+        self, oci_model_instance, merge_strategy: MergeStrategy = MergeStrategy.OVERRIDE
+    ):
+        """Updates the properties from OCI model with the same properties.
+
+        Parameters
+        ----------
+        oci_model_instance :
+            An instance of OCI model, which should have the same properties of this class.
+        """
+        for attr in self.swagger_types.keys():
+            if (
+                hasattr(oci_model_instance, attr)
+                and getattr(oci_model_instance, attr)
+                and (
+                    not hasattr(self, attr)
+                    or not getattr(self, attr)
+                    or merge_strategy == MergeStrategy.OVERRIDE
+                )
+            ):
+                setattr(self, attr, getattr(oci_model_instance, attr))
+
+        if hasattr(oci_model_instance, "attribute_map"):
+            self._oci_attributes = oci_model_instance.attribute_map
+        return self
+
+    def sync(self, merge_strategy: MergeStrategy = MergeStrategy.OVERRIDE):
+        """Refreshes the properties of the object from OCI"""
+        return self.update_from_oci_model(
+            self.from_ocid(self.id), merge_strategy=merge_strategy
+        )
+
+    def delete(self):
+        """Deletes the resource"""
+        delete_method = self._find_oci_method("delete")
+        delete_method(self.id)
+        return self
+
+    def __getattribute__(self, name: str):
+        """Returns an attribute value of the resource.
+
+        This method will try to sync the values from OCI service when it is not already available locally.
+        Some attribute value may not be available locally if the previous OCI API call returns an OCI model
+        that contains only a subset of the attributes.
+        For example, JobSummary model contains only a subset of the attributes from the Job model.
+
+        Parameters
+        ----------
+        name : str
+            Attribute name.
+        """
+        skip_lookup = ["id", "attribute_map", "_oci_attributes"]
+
+        if name in skip_lookup or name.startswith("_"):
+            return super().__getattribute__(name)
+
+        # Ignore if _oci_attributes is not initialized
+        if not hasattr(self, "_oci_attributes"):
+            return super().__getattribute__(name)
+
+        if (
+            hasattr(self, "attribute_map")
+            and name in self.attribute_map
+            and name not in self._oci_attributes
+            and hasattr(self, "id")
+            and self.id
+        ):
+            # Do not sync if it is in the sync process
+            stack = traceback.extract_stack()
+            for frame in reversed(stack):
+                if frame.name == "sync":
+                    return super().__getattribute__(name)
+            # Sync only if there is no value
+            if not super().__getattribute__(name):
+                try:
+                    self.sync(merge_strategy=MergeStrategy.MERGE)
+                except oci.exceptions.ServiceError as ex:
+                    # 400 errors are usually cause by the user
+                    if ex.status == 400:
+                        logger.error("%s - %s: %s", self.__class__, ex.code, ex.message)
+                        self._oci_attributes = self.attribute_map
+                    else:
+                        logger.error(
+                            "Failed to synchronize the properties of %s due to service error:\n%s",
+                            self.__class__,
+                            traceback.format_exc(),
+                        )
+                except Exception:
+                    logger.error(
+                        "Failed to synchronize the properties of %s.\n%s",
+                        self.__class__,
+                        traceback.format_exc(),
+                    )
+        return super().__getattribute__(name)
+
+    @property
+    def status(self) -> Optional[str]:
+        """Status of the object.
+
+        Returns
+        -------
+        str
+            Status of the object.
+        """
+        if not self.lifecycle_state or not self.lifecycle_state in LIFECYCLE_STOP_STATE:
+            self.sync()
+        return self.lifecycle_state
+
+    def __repr__(self) -> str:
+        """Displays the object as YAML."""
+        return self.to_yaml()
+
+    def to_yaml(self) -> str:
+        """Serializes the object into YAML string.
+
+        Returns
+        -------
+        str
+            YAML stored in a string.
+        """
+        return yaml.safe_dump(self.to_dict())
+
+
+class OCIWorkRequestMixin:
+    """Mixin class containing methods related to OCI work request"""
+
+    def wait_for_work_request(
+        self,
+        work_request_id: str,
+        wait_for_state: Union[str, tuple],
+        max_wait_seconds: int = None,
+        wait_interval_seconds: int = None,
+    ):
+        """Wait for a work request to be completed.
+
+        Parameters
+        ----------
+        work_request_id : str
+            OCI work request ID
+        wait_for_state : str or tuple
+            The state to wait for. Must be a tuple for multiple states.
+        max_wait_seconds : int
+            Max wait seconds for the work request. Defaults to None (Default value from OCI SDK will be used).
+        wait_interval_seconds : int
+            Interval in seconds between each status check. Defaults to None (Default value from OCI SDK will be used).
+
+        Returns
+        -------
+        Response
+            OCI API Response
+
+        """
+        result = None
+        if hasattr(self.client, "get_work_request") and callable(
+            getattr(self.client, "get_work_request")
+        ):
+            try:
+                wait_period_kwargs = {}
+                if max_wait_seconds is not None:
+                    wait_period_kwargs["max_wait_seconds"] = max_wait_seconds
+                if wait_interval_seconds is not None:
+                    wait_period_kwargs["max_interval_seconds"] = wait_interval_seconds
+
+                logger.debug(
+                    "Action completed. Waiting until the work request has entered state: %s",
+                    wait_for_state,
+                )
+                result = oci.wait_until(
+                    self.client,
+                    self.client.get_work_request(work_request_id),
+                    "status",
+                    wait_for_state,
+                    **wait_period_kwargs,
+                )
+            except oci.exceptions.MaximumWaitTimeExceeded:
+                # If we fail, we should show an error, but we should still provide the information to the customer
+                logger.error(
+                    "Failed to wait until the work request %s entered the specified state. Maximum wait time exceeded",
+                    work_request_id,
+                )
+            except Exception:
+                logger.error(
+                    "Encountered error while waiting for work request to enter the specified state."
+                )
+                raise
+        else:
+            logger.error(
+                "%s does not support wait for the work request to enter the specified state",
+                str(self.client.__class__),
+            )
+        return result
+
+    def get_work_request_response(
+        self,
+        response: str,
+        wait_for_state: Union[str, tuple],
+        success_state: str,
+        max_wait_seconds: int = None,
+        wait_interval_seconds: int = None,
+        error_msg: str = "",
+    ):
+        if "opc-work-request-id" in response.headers:
+            opc_work_request_id = response.headers.get("opc-work-request-id")
+            work_request_response = self.wait_for_work_request(
+                opc_work_request_id,
+                wait_for_state=wait_for_state,
+                max_wait_seconds=max_wait_seconds,
+                wait_interval_seconds=wait_interval_seconds,
+            )
+            # Raise an error if the failed to create the resource.
+            if work_request_response.data.status != success_state:
+                raise oci.exceptions.RequestException(
+                    f"{error_msg}\n" + str(work_request_response.data)
+                )
+
+        else:
+            # This will likely never happen as OCI SDK will raise an error if the HTTP request is not successful.
+            raise oci.exceptions.RequestException(
+                f"opc-work-request-id not found in response headers: {response.headers}"
+            )
+        return work_request_response
+
+
+class OCIModelWithNameMixin:
+    """Mixin class to operate OCI model which contains name property."""
+
+    @classmethod
+    def from_name(cls, name: str, compartment_id: Optional[str] = None):
+        """Initializes an object from name.
+
+        Parameters
+        ----------
+        name: str
+            The name of the object.
+        compartment_id: (str, optional). Defaults to None.
+            Compartment OCID of the OCI resources. If `compartment_id` is not specified,
+            the value will be taken from environment variables.
+        """
+        res = cls.list_resource(compartment_id=compartment_id, limit=1, name=name)
+        if not res:
+            raise OCIModelNotExists()
+        return cls.from_oci_model(res[0])