teradataml 20.0.0.6__py3-none-any.whl → 20.0.0.7__py3-none-any.whl

teradataml/utils/validators.py

@@ -1,16 +1,19 @@
+import datetime
 import enum
 import numbers
 import os
 import pandas as pd
 from pathlib import Path
 import re
-from teradataml.common.constants import TeradataConstants, PTITableConstants, PythonTypes
+from sqlalchemy import func
+from teradataml.common.constants import TeradataConstants, PTITableConstants, PythonTypes, DataFrameTypes
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.messages import MessageCodes, Messages
 from teradataml.utils.dtypes import _Dtypes, _DtypesMappers, _ListOf, _TupleOf
 from teradataml.options.configure import configure
 from teradataml.dataframe.sql_interfaces import ColumnExpression
 from functools import wraps, reduce
+from teradatasqlalchemy import (PERIOD_DATE, PERIOD_TIMESTAMP)
 
 from teradataml.utils.internal_buffer import _InternalBuffer
 
@@ -1351,27 +1354,36 @@ class _Validators:
         """
         DESCRIPTION:
             Function to validate whether the path specified is a file and if it exists.
-
+            Supports both single file path (str) and list of file paths.
         PARAMETERS:
             file_path:
                 Required Argument.
-                Specifies the path of the file.
-                Types: str
-
+                Specifies the path of the file or list of file paths.
+                Types: str or list of str
         RETURNS:
-            True, if the path is a file and it exists.
-
+            True, if all paths are files and exist.
         RAISES:
             TeradataMLException
-
         EXAMPLES:
-            _Validators._validate_file_exists("/data/mapper.py")
-        """
-        if not Path(file_path).exists() or not os.path.isfile(file_path):
+            Example 1: When a single file path is specified.
+            >>> _Validators._validate_file_exists("/data/mapper.py")
+            Example 2: When a list of file paths is specified.
+            >>> _Validators._validate_file_exists(["/data/mapper.py", "/data/other.py"])
+        """
+        file_paths = [file_path] if isinstance(file_path, str) else file_path
+        invalid_paths = []
+        
+        # Validate if each file path exists and is a file.
+        for fp in file_paths:
+            if not Path(fp).exists() or not os.path.isfile(fp):
+                invalid_paths.append(fp)
+        
+        # If any of the file paths is invalid, raise an exception.
+        if invalid_paths:
             raise TeradataMlException(
-                Messages.get_message(MessageCodes.INPUT_FILE_NOT_FOUND).format(file_path),
+                Messages.get_message(MessageCodes.INPUT_FILE_NOT_FOUND).format(", ".join(invalid_paths)),
                 MessageCodes.INPUT_FILE_NOT_FOUND)
-
+    
         return True
 
     @staticmethod
@@ -1432,6 +1444,7 @@ class _Validators:
     @staticmethod
     @skip_validation()
     def _validate_mutually_exclusive_argument_groups(*arg_groups, all_falsy_check=False,
+                                                     empty_check=False,
                                                      return_all_falsy_status=False):
         """
         DESCRIPTION:
@@ -1448,12 +1461,21 @@ class _Validators:
                 Optional Argument.
                 Specifies whether to throw Teradataml Exception when all arguments in all argument
                 groups hold Falsy/null values.
+                Default Value: False
+                Types: bool
+
+            empty_check:
+                Optional Argument.
+                Specifies whether to treat empty values like empty string and empty list as None or not.
+                When set to True, empty string and empty list are treated as None.
+                Default Value: False
                 Types: bool
 
             return_all_falsy_status:
                 Optional Argument.
                 Specifies whether to return the boolean flag which states if all arguments in all argument
                 groups hold Falsy/null values.
+                Default Value: False
                 Types: bool
 
         RETURNS:
@@ -1474,7 +1496,7 @@ class _Validators:
 
             # Example 2: When groups of arguments are mutually exclusive.
             >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": None},
-            ...                                                          {"arg2": ""},
+            ...                                                          {"arg2": None},
             ...                                                          {"arg3": "arg3", "arg4": "arg4"})
 
             # Example 3: When all groups of arguments hold falsy values
@@ -1499,14 +1521,43 @@ class _Validators:
             ...                                                          {"arg3": None, "arg4": None},
             ...                                                          return_all_falsy_status=True)
             True
+
+            # Example 6: When groups of arguments are mutually exclusive
+            #            considering empty list and empty string as falsy values.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": ""},
+            ...                                                          {"arg2": []},
+            ...                                                          {"arg3": "arg3", "arg4": "arg4"},
+            ...                                                          empty_check=True)
+
+            # Example 7: When all groups of arguments hold falsy values
+            #            considering empty list and empty string as falsy values
+            #            and "all_falsy_check" is set to True.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": ""},
+            ...                                                          {"arg2": []},
+            ...                                                          {"arg3": [], "arg4": None},
+            ...                                                          {"arg5": "", "arg6": None},
+            ...                                                          empty_check=True,
+            ...                                                          all_falsy_check=True)
+            TeradataMlException: [Teradata][teradataml](TDML_2061) Provide either '['arg1']' argument(s) or '['arg2']' argument(s) or '['arg3', 'arg4']' argument(s) or '['arg5', 'arg6']' argument(s).
+
+            # Example 8: When groups of arguments are not mutually exclusive
+            #            considering empty list and empty string as valid values.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": ""},
+            ...                                                          {"arg2": []},
+            ...                                                          {"arg3": "arg3", "arg4": "arg4"})
+            TeradataMlException: [Teradata][teradataml](TDML_2061) Provide either '['arg1']' argument(s) or '['arg2']' argument(s) or '['arg3', 'arg4']' argument(s).
+
         """
         all_groups_falsy = True
         mutually_exclusive_groups = True
         non_falsy_groups = []
         for arg_grp in arg_groups:
-            # TODO: Handling of falsy values can be done in more appropriate way by
-            #  differentiating None/empty string/empty list.
-            is_group_falsy = not any(value for value in arg_grp.values())
+            if empty_check:
+                # Treat empty string and empty list as falsy Value.
+                is_group_falsy = not any(arg_grp.values())
+            else:
+                # Treat only None as falsy Value.
+                is_group_falsy = not any(value is not None for value in arg_grp.values())
             if not is_group_falsy:
                 non_falsy_groups.append(arg_grp)
 
@@ -1731,6 +1782,41 @@ class _Validators:
                                           MessageCodes.DEPENDENT_ARGUMENT)
         return True
     
+    @staticmethod
+    @skip_validation()
+    def _validate_unsupported_argument(arg, arg_name):
+        """
+        DESCRIPTION:
+            Validation to reject unsupported arguments.
+
+        PARAMETERS:
+            arg:
+                Required Argument.
+                Specifies the value passed for the argument that is unsupported.
+                Types: any
+
+            arg_name:
+                Required Argument.
+                Specifies the name of the argument to be printed in error message.
+                Types: str
+
+        RAISES:
+            ValueError, If arg is not None, indicating an unsupported argument was used.
+
+        RETURNS:
+            True, If the argument is not provided (i.e., None), allowing execution to proceed.
+
+        EXAMPLES:
+            _Validators._validate_unsupported_argument(kwargs.get("task_type", None), "task_type")
+            _Validators._validate_unsupported_argument(kwargs.get("is_fraud", None), "is_fraud")
+            _Validators._validate_unsupported_argument(kwargs.get("is_churn", None), "is_churn")
+        """
+        error_code = MessageCodes.UNSUPPORTED_ARGUMENT
+        error_msg = Messages.get_message(error_code, arg_name, arg_name)
+        if arg is not None:
+            raise TeradataMlException(error_msg, error_code)
+        return True
+
     @staticmethod
     @skip_validation()
     def _validate_dependent_method(dependent_mtd, independent_mtd, independent_mtd_calls):
@@ -2626,3 +2712,594 @@ class _Validators:
                                                          required_length),
                                       MessageCodes.INVALID_LIST_LENGTH)
         return True
+
+    @staticmethod
+    @skip_validation()
+    def _validate_non_empty_list_or_valid_selection(arg_list, arg_name):
+        """
+        DESCRIPTION:
+            Validation to ensure that the given list-type argument is not empty or contains only invalid entries
+            like None, '', 'None', etc.
+
+        PARAMETERS:
+            arg_list:
+                Required Argument.
+                Specifies the list or iterable for validation.
+                Types: list
+
+            arg_name:
+                Required Argument.
+                Specifies the argument name.
+                Types: str
+
+        RAISES:
+            ValueError - If the list is None, empty, or contains only invalid values.
+
+        RETURNS:
+            True - If validation passes (non-empty and has valid entries).
+
+        EXAMPLES:
+        >>> _Validators._validate_non_empty_list_or_valid_selection(self.model_list, "List of models")
+        """
+
+        error_code = MessageCodes.LIST_SELECT_NONE_OR_EMPTY
+        if not arg_list or all(x in [None, "None", ""] for x in arg_list):
+            raise TeradataMlException(Messages.get_message(error_code).format(arg_name), error_code)
+        return True
+
+    @staticmethod
+    def _validate_temporal_table_type(df_type, api_type='method', api_name='as_of'):
+        """
+        DESCRIPTION:
+            Function to validate temporal table type.
+
+        PARAMETERS:
+            df_type:
+                Required Argument.
+                Specifies the type of temporal table.
+                Types: str
+
+            api_type:
+                Required Argument.
+                Specifies the type of API.
+                Types: str
+
+            api_name:
+                Required Argument.
+                Specifies the name of API.
+                Types: str
+
+        RETURNS:
+            None.
+
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            >>> _Validators._validate_temporal_table_type('method', 'as_of')
+        """
+        if df_type not in (DataFrameTypes.VALID_TIME_VIEW.name,
+                           DataFrameTypes.TRANSACTION_TIME_VIEW.name,
+                           DataFrameTypes.BI_TEMPORAL_VIEW.name,
+                           DataFrameTypes.BI_TEMPORAL.name,
+                           DataFrameTypes.TRANSACTION_TIME.name,
+                           DataFrameTypes.VALID_TIME.name,
+                           DataFrameTypes.VALID_TIME_VOLATILE_TABLE.name,
+                           DataFrameTypes.TRANSACTION_TIME_VOLATILE_TABLE.name,
+                           DataFrameTypes.BI_TEMPORAL_VOLATILE_TABLE.name
+                           ):
+            raise TeradataMlException(Messages.get_message(MessageCodes.INVALID_USAGE,
+                                                           api_type,
+                                                           "'{}'".format(api_name),
+                                                           "when underlying table or view is temporal type"),
+                                      MessageCodes.INVALID_USAGE)
+
+    @staticmethod
+    def _validate_as_of_arguments(df_type, argument_name='valid_time'):
+        """
+        DESCRIPTION:
+            Function to validate arguments passed for method as_of.
+            One can not pass argument 'valid_time' for a transaction time table
+            One can not pass argument 'transaction_time' for a valid time table.
+            Both the validations are done in this validator.
+
+        PARAMETERS:
+            df_type:
+                Required Argument.
+                Specifies the type of temporal table.
+                Types: str
+
+            argument_name:
+                Optional Argument.
+                Specifies the name of the argument.
+                Default Value: 'valid_time'
+                Types: str
+
+        RETURNS:
+            None.
+
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            >>> _Validators._validate_temporal_table_type('method', 'as_of')
+        """
+        valid_types = (
+                DataFrameTypes.TRANSACTION_TIME_VIEW.name,
+                DataFrameTypes.TRANSACTION_TIME.name,
+                DataFrameTypes.TRANSACTION_TIME_VOLATILE_TABLE.name
+        )
+        table_type = 'transaction time dimension'
+
+        if argument_name == 'valid_time':
+            valid_types = (DataFrameTypes.VALID_TIME_VIEW.name,
+                           DataFrameTypes.VALID_TIME.name,
+                           DataFrameTypes.VALID_TIME_VOLATILE_TABLE.name
+                           )
+            table_type = 'valid time dimension'
+
+        bi_temporal_types = (
+                DataFrameTypes.BI_TEMPORAL_VIEW.name,
+                DataFrameTypes.BI_TEMPORAL.name,
+                DataFrameTypes.BI_TEMPORAL_VOLATILE_TABLE.name
+        )
+
+        # Raise error only if it is not a bitemporal table.
+        if (df_type not in bi_temporal_types) and (df_type not in valid_types):
+            raise TeradataMlException(Messages.get_message(MessageCodes.INVALID_USAGE,
+                                                           'argument',
+                                                           "'{}'".format(argument_name),
+                                                           "when underlying table or view is in {}".format(table_type)),
+                                      MessageCodes.INVALID_USAGE)
+
+    @staticmethod
+    def _validate_period_column_type(column_type):
+        """
+        DESCRIPTION:
+            Function to validate the type of a period column.
+
+        PARAMETERS:
+            column_type:
+                Required Argument.
+                Specifies the type of the column to be validated.
+                Types: Any
+
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            _Validators._validate_period_column_type(PERIOD_DATE)
+        """
+        if not isinstance(column_type, (PERIOD_DATE, PERIOD_TIMESTAMP)):
+            raise TeradataMlException(
+                Messages.get_message(
+                    MessageCodes.INVALID_COLUMN_TYPE
+                ).format(
+                    "period column",
+                    type(column_type).__name__,
+                    "PERIOD_DATE or PERIOD_TIMESTAMP"
+                ),
+                MessageCodes.INVALID_COLUMN_TYPE
+            )
+    @staticmethod
+    @skip_validation()
+    def _validate_features_not_in_efs_dataset(df,
+                                              feature_names,
+                                              action):
+        """
+        DESCRIPTION:
+            Function to validate whether the feature names provided
+            are not present in the EFS dataset.
+
+        PARAMETERS:
+            df:
+                Required Argument.
+                Specifies the EFS dataset dataframe.
+                Types: teradataml.dataframe.dataframe.DataFrame
+
+            feature_names:
+                Required Argument.
+                Specifies the feature names to be validated.
+                Types: str or list of str
+
+            action:
+                Required Argument.
+                Specifies the action to be performed.
+                Permitted Values: 'archived', 'deleted'
+                Types: str
+
+        RETURNS:
+            True, if the feature names are not present in the EFS dataset.
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> _Validators._validate_features_not_in_efs_dataset(df, ["feature1", "feature2"], "delete")
+        """
+        if isinstance(feature_names, str):
+            feature_names = [feature_names]
+
+        invalid_df = df[(df['feature_name'].isin(feature_names))]
+
+        if invalid_df.shape[0] > 0:
+            names = set()
+            datasets = set()
+            for feature in invalid_df.itertuples():
+                names.add(feature.feature_name)
+                datasets.add(feature.dataset_id)
+            datasets_str = ", ".join(f"'{dataset}'" for dataset in datasets)
+            name_str = ", ".join(f"'{name}'" for name in names)
+
+            error_code = MessageCodes.EFS_FEATURE_IN_DATASET
+            error_msg = Messages.get_message(error_code,
+                                             name_str,
+                                             datasets_str,
+                                             action)
+            raise TeradataMlException(error_msg, error_code)
+
+        return True
+
+    @staticmethod
+    def _validate_dataset_ids_not_in_efs(df, ids, data_domain, repo):
+        """
+        DESCRIPTION:
+            Function to validate whether the dataset ids provided
+            are not present in the EFS.
+
+        PARAMETERS:
+            df:
+                Required Argument.
+                Specifies the EFS dataset dataframe.
+                Types: teradataml.dataframe.dataframe.DataFrame
+
+            ids:
+                Required Argument.
+                Specifies the dataset ids to be validated.
+                Types: str or list of str
+
+            data_domain:
+                Required Argument.
+                Specifies the data domain for the feature process.
+                Types: str
+
+            repo:
+                Required Argument.
+                Specifies the repository to be used for validation.
+                Types: str
+
+        RETURNS:
+            True, if the dataset ids are not present in the EFS.
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> _Validators._validate_features_not_in_efs_dataset(df, ["12-dek-3e3-dek"], "d1")
+        """
+        from teradataml.common.utils import UtilFuncs
+        id_list_flag = False if isinstance(ids, str) else True
+        list_ids = UtilFuncs._as_list(ids)
+
+        # Check if the dataset ids are present in the domain.
+        df = df[(df['id'].isin(list_ids)) &
+                (df['data_domain'] == data_domain)]
+        matched_ids = [i.id for i in df.select("id").itertuples()]
+        # Get the list of dataset ids that are not present in the domain.
+        missing_ids = [i for i in list_ids if i not in matched_ids] 
+
+        # If there are ids that are not present in the domain,
+        # raise an exception with appropriate error message.
+        if len(missing_ids) > 0:
+            if id_list_flag:
+                msg_code = MessageCodes.EFS_OBJECT_NOT_EXIST
+                error_msg = Messages.get_message(msg_code, "Dataset", "id(s): {}".format(missing_ids),
+                                                 data_domain) + " Use DatasetCatalog.list_datasets() to list valid dataset ids."
+            else:
+                # Check if the dataset id is present in any other domain.
+                from teradataml.store.feature_store.utils import _FSUtils
+                res = _FSUtils._get_data_domains(repo, ids, 'dataset')
+                if res:
+                    msg_code = MessageCodes.EFS_OBJECT_IN_OTHER_DOMAIN
+                    error_msg = Messages.get_message(msg_code, "Dataset", "id '{}'".format(ids),
+                                                    data_domain, res)
+                else:
+                    msg_code = MessageCodes.EFS_OBJECT_NOT_EXIST
+                    error_msg = Messages.get_message(msg_code, "Dataset", "id '{}'".format(ids),
+                                                    data_domain)
+            raise TeradataMlException(error_msg, msg_code)
+
+        return True
+
+
+    @staticmethod
+    @skip_validation()
+    def _validate_duplicate_objects(objects, type_="features", arg_name='features'):
+        """
+        DESCRIPTION:
+            Function to validate that there are no duplicate objects in the provided list.
+
+        PARAMETERS:
+            objects:
+                Required Argument.
+                Specifies the objects to validate for duplicates.
+                Types: list or tuple
+
+            type_:
+                Optional Argument.
+                Specifies the type of objects being validated.
+                Default Value: "features"
+                Types: str
+
+            arg_name:
+                Optional Argument.
+                Specifies the name of the argument being validated.
+                Default Value: "features"
+                Types: str
+
+        RAISES:
+            TeradataMlException
+
+        Returns:
+            bool
+
+        EXAMPLES:
+            >>> load_examples_data('dataframe', 'sales')
+            >>> df = DataFrame('sales')
+
+            # Example 1: Validate duplicate features in the list.
+            >>> feature1 = Feature("Jan", df.Jan)
+            >>> _Validators._validate_duplicate_objects([feature1, 'Jan', 'Feb'])
+
+            # Example 2: Validate duplicate datetime.datetime objects in tuple.
+            >>> t = datetime.datetime(2025, 1, 1, 0, 0, 1)
+            >>> td = datetime.date(2025, 1, 1)
+            >>> _Validators._validate_duplicate_objects((td, td.strftime('%Y-%m-%d %H:%M:%S'), t))
+        """
+        from teradataml.common.utils import UtilFuncs
+        from teradataml.store.feature_store.models import Feature
+        seen = set()
+        duplicates = set()
+
+        if isinstance(objects, (list, tuple)):
+            for obj in objects:
+                if isinstance(obj, Feature):
+                    name = obj.column_name
+                elif isinstance(obj, (datetime.datetime, datetime.date)):
+                    name = obj.strftime('%Y-%m-%d %H:%M:%S')
+                else:
+                    name = obj
+
+                if name in seen:
+                    duplicates.add(name)
+                else:
+                    seen.add(name)
+
+            if len(duplicates) > 0:
+                msg = "{} in {}".format(
+                    ", ".join(["'{}'".format(duplicate) for duplicate in sorted(duplicates)]),
+                    "'{}' argument".format(arg_name)
+                )
+                raise TeradataMlException(
+                    Messages.get_message(
+                        MessageCodes.DF_DUPLICATE_VALUES,
+                        type_,
+                        msg
+                    ),
+                    MessageCodes.DF_DUPLICATE_VALUES)
+
+        return True
+
+    @staticmethod
+    @skip_validation()
+    def _validate_duplicate_values(df, columns, arg_name, columns_arg='entity column(s)'):
+        """
+        DESCRIPTION:
+            Function to validate that there are no duplicate records in the DataFrame
+            based on the specified columns.
+
+        PARAMETERS:
+            df:
+                Required Argument.
+                Specifies the DataFrame to validate for duplicates.
+                Types: teradataml DataFrame
+
+            columns:
+                Required Argument.
+                Specifies the columns to check for duplicates.
+                Types: str or list of str
+
+            arg_name:
+                Required Argument.
+                Specifies the name of the argument being validated.
+                Types: str
+                
+            columns_arg:
+                Optional Argument.
+                Specifies the name of the columns argument.
+                Default Value: 'entity column(s)'
+                Types: str
+
+        RAISES:
+            TeradataMlException
+
+        Returns:
+            bool
+
+        EXAMPLES:
+            >>> _Validators._validate_duplicate_records(df, ['col1', 'col2'], 'columns')
+        """
+        columns = [columns] if isinstance(columns, str) else columns
+        df_ = df.groupby(columns).assign(total_rows_=func.count('*'))
+        duplicate_recs = df_[df_.total_rows_ > 1].shape[0]
+
+        if duplicate_recs > 0:
+            msg = "in {} {} provided in argument {}".format(
+                columns_arg,
+                ", ".join(["'{}'".format(col) for col in columns]),
+                "'{}'".format(arg_name)
+            )
+            raise TeradataMlException(
+                Messages.get_message(
+                    MessageCodes.DF_DUPLICATE_VALUES,
+                    "values in {}".format(columns_arg),
+                    msg
+                ),
+                MessageCodes.DF_DUPLICATE_VALUES)
+
+        return True
+
+    @staticmethod
+    @skip_validation()
+    def _validate_null_values(df, 
+                              columns, 
+                              arg_name, 
+                              columns_arg='entity column(s)', 
+                              operation='ingesting the features'):
+        """
+        DESCRIPTION:
+            Function to validate that there are no null values in the specified columns
+            of the DataFrame.
+
+        PARAMETERS:
+            df:
+                Required Argument.
+                Specifies the DataFrame to validate for null values.
+                Types: teradataml DataFrame
+
+            columns:
+                Required Argument.
+                Specifies the columns to check for null values.
+                Types: str or list of str
+
+            arg_name:
+                Required Argument.
+                Specifies the name of the argument being validated.
+                Types: str
+                
+            columns_arg:
+                Optional Argument.
+                Specifies the name of the columns argument.
+                Default Value: 'entity column(s)'
+                Types: str
+                
+            operation:
+                Optional Argument.
+                Specifies the operation being performed.
+                Default Value: 'ingesting the features'
+                Types: str
+
+        RAISES:
+            TeradataMlException
+
+        Returns:
+            bool
+
+        EXAMPLES:
+            >>> _Validators._validate_null_values(df, ['col1', 'col2'], 'columns')
+        """
+        columns = [columns] if isinstance(columns, str) else columns
+        col_expr = (df[columns[0]] == None)
+        for column in columns[1:]:
+            col_expr = col_expr | (df[column] == None)
+
+        null_count = df[col_expr].shape[0]
+
+        if null_count > 0:
+            msg = "in {} {} provided in argument {}".format(
+                columns_arg,
+                ", ".join(["'{}'".format(col) for col in columns]),
+                "'{}'".format(arg_name)
+            )
+            raise TeradataMlException(
+                Messages.get_message(
+                    MessageCodes.DF_NULL_VALUES,
+                    columns_arg,
+                    operation,
+                    msg
+                ),
+                MessageCodes.DF_NULL_VALUES)
+
+        return True
+
+    @staticmethod
+    @skip_validation()
+    def _validate_archived_features(features_to_validate, archived_features, msg=""):
+        """
+        DESCRIPTION:
+            Function to validate that the features are already archived or not.
+            If archived, it raises an exception.
+
+        PARAMETERS:
+            features_to_validate:
+                Required Argument.
+                Specifies the features to be validated for archiving.
+                Types: list of str
+
+            archived_features:
+                Required Argument.
+                Specifies the set of already archived features.
+                Types: set of str
+
+            msg:
+                Optional Argument.
+                Specifies the additional message to be displayed in the exception.
+                Default Value: ""
+                Types: str
+
+        RAISES:
+            TeradataMlException
+
+        Returns:
+            bool
+
+        EXAMPLES:
+            >>> _Validators._validate_archived_features(['feature1', 'feature2'], {'feature1'})
+        """
+        features_to_validate = [features_to_validate] if isinstance(features_to_validate, str) \
+            else features_to_validate
+        archived_features = [f for f in features_to_validate if f in archived_features]
+
+        if archived_features:
+            raise TeradataMlException(
+                Messages.get_message(MessageCodes.FEATURES_ARCHIVED,
+                                     ", ".join("'{}'".format(f) for f in archived_features),
+                                     msg
+                                     ),
+                MessageCodes.FEATURES_ARCHIVED)
+
+        return True
+
+    @staticmethod
+    @skip_validation()
+    def _validate_any_argument_passed(args_dict):
+        """
+        DESCRIPTION:
+            Check if any value in the argument dictionary is not None.
+            If all values are None, raise an exception.
+
+        PARAMETERS:
+            args_dict:
+                Required Argument.
+                Specifies the argument to value dictionary to check.
+                Types: dict
+
+        RAISES:
+            TeradataMlException
+
+        Returns:
+            bool
+
+        EXAMPLES:
+            >>> _Validators._validate_any_argument_passed({"arg1": None, "arg2": "abc"})
+        """
+        if all(value is None for value in args_dict.values()):
+            msg_code = MessageCodes.EITHER_ANY_ARGUMENT
+            argument_description = " or ".join(["'{}'".format(key) for key in args_dict.keys()])
+            error_msg = Messages.get_message(msg_code, argument_description)
+            raise TeradataMlException(error_msg, msg_code)
+
+        return True