teradataml 20.0.0.3__py3-none-any.whl → 20.0.0.5__py3-none-any.whl

teradataml/utils/validators.py

@@ -28,13 +28,16 @@ def skip_validation():
         def validation_func(): ...
 
     """
+
     def decorator(func):
         def wrapper(*args, **kwargs):
             # If "skip_all" flag is set to False,
             # skip all validation execution.
             if not _Validators.skip_all:
                 return func(*args, **kwargs)
+
         return wraps(func)(wrapper)
+
     return decorator
 
 
@@ -286,7 +289,8 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_dataframe_has_argument_columns(columns, column_arg, data, data_arg, is_partition_arg=False):
+    def _validate_dataframe_has_argument_columns(columns, column_arg, data, data_arg, is_partition_arg=False,
+                                                 case_insensitive=False):
         """
         Function to check whether column names in columns are present in given dataframe or not.
         This function is used currently only for Analytics wrappers.
@@ -312,12 +316,19 @@ class _Validators:
                 Specifies the name of the dataframe argument.
                 Types: str
 
-            isPartitionArg:
+            is_partition_arg:
                 Optional Argument.
                 Specifies a bool argument notifying, whether argument being validate is
                 Partition argument or not.
                 Types: bool
 
+            case_insensitive:
+                Optional Argument.
+                Specifies a bool argument notifying, whether to check column names
+                in case-insensitive manner or not.
+                Default Value: False
+                Types: bool
+
         RAISES:
             TeradataMlException - TDMLDF_COLUMN_IN_ARG_NOT_FOUND column(s) does not exist in a dataframe.
 
@@ -338,7 +349,7 @@ class _Validators:
             columns = [columns]
 
         total_columns = []
-                
+
         for column in columns:
             for separator in TeradataConstants.RANGE_SEPARATORS.value:
                 if column is None:
@@ -357,32 +368,33 @@ class _Validators:
                     # ':' specifies all columns in the table.
 
                     try:
-                        # Check if its a sinlge column with one separator. For e.g. column:A.
+                        # Check if it's a single column with one separator. For e.g. column:A.
                         # If yes, just continue.
-                        _Validators._validate_column_exists_in_dataframe(column, data._metaexpr)
+                        _Validators._validate_column_exists_in_dataframe(column, data._metaexpr,
+                                                                         case_insensitive=case_insensitive)
                         continue
                     except:
                         # User has provided range value.
                         column_names = column.split(separator)
                         if (len(column_names) == 2 and
-                          any([column_names[0].isdigit(), column_names[1].isdigit()]) and
-                          not all([column_names[0].isdigit(), column_names[1].isdigit()]) and 
-                          not "" in column_names):
-                          # Raises Exception if column range has mixed types. For e.g. "4:XYZ".
-                          err_msg = Messages.get_message(MessageCodes.MIXED_TYPES_IN_COLUMN_RANGE)
-                          raise ValueError(err_msg.format(column_arg))
-                        
+                                any([column_names[0].isdigit(), column_names[1].isdigit()]) and
+                                not all([column_names[0].isdigit(), column_names[1].isdigit()]) and
+                                not "" in column_names):
+                            # Raises Exception if column range has mixed types. For e.g. "4:XYZ".
+                            err_msg = Messages.get_message(MessageCodes.MIXED_TYPES_IN_COLUMN_RANGE)
+                            raise ValueError(err_msg.format(column_arg))
+
                         for col in column_names:
                             if not col.isdigit() and col != "":
                                 total_columns.append(col)
 
                 elif column.count(separator) > 1:
-                    continue                     
+                    continue
                 else:
                     total_columns.append(column)
 
         return _Validators._validate_column_exists_in_dataframe(total_columns, data._metaexpr, column_arg=column_arg,
-                                                                data_arg=data_arg)
+                                                                data_arg=data_arg, case_insensitive=case_insensitive)
 
     @staticmethod
     @skip_validation()
@@ -446,9 +458,9 @@ class _Validators:
         if isinstance(columns, str):
             columns = [columns]
 
-        # Constructing New unquotted column names for selected columns ONLY using Parent _metaexpr
+        # Constructing New unquoted column names for selected columns ONLY using Parent _metaexpr
         if case_insensitive:
-            # If lookup has to be a case insensitive then convert the
+            # If lookup has to be a case-insensitive then convert the
             # metaexpr columns name to lower case.
             unquoted_df_columns = [c.name.replace('"', "").lower() for c in metaexpr.c]
         else:
@@ -459,13 +471,10 @@ class _Validators:
             if column_name is None:
                 column_name = str(column_name)
 
-            if case_insensitive:
-                # If lookup has to be a case insensitive then convert the
-                # column name to lower case.
-                column_name = column_name.lower()
+            case_based_column_name = column_name.lower() if case_insensitive else column_name
 
             # If column name does not exist in metaexpr, raise the exception
-            if not column_name.replace('"', "") in unquoted_df_columns:
+            if not case_based_column_name.replace('"', "") in unquoted_df_columns:
                 if column_arg and data_arg:
                     raise ValueError(Messages.get_message(MessageCodes.TDMLDF_COLUMN_IN_ARG_NOT_FOUND,
                                                           column_name,
@@ -474,7 +483,8 @@ class _Validators:
                                                           "Table" if for_table else "DataFrame"))
                 else:
                     raise ValueError(Messages.get_message(MessageCodes.TDMLDF_DROP_INVALID_COL,
-                                                          column_name, sorted(unquoted_df_columns)))
+                                                          column_name,
+                                                          sorted([c.name.replace('"', "") for c in metaexpr.c])))
 
         return True
 
@@ -509,7 +519,7 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_function_arguments(arg_list, skip_empty_check = None):
+    def _validate_function_arguments(arg_list, skip_empty_check=None):
         """
         Method to verify that the input arguments are of valid data type except for
         argument of DataFrameType.
@@ -534,10 +544,29 @@ class _Validators:
         EXAMPLES:
             _Validators._validate_function_arguments(arg_list)
         """
+        # arg_list is list of list, where each inner list can have maximum 6 elements
+        # and must have minimum (first) 4 elements:
+        # Consider following inner list.
+        #   [element1, element2, element3, element4, element5, element6]
+        #   Corresponds to:
+        #   [<1_arg_name>, <2_arg_value>, <3_is_optional>, <4_tuple_of_accepted_types>,
+        #    <5_empty_not_allowed>, <6_list_of_permitted_values>]
+        #   e.g.
+        #       arg_list = [["join", join, True, (str), True, concat_join_permitted_values]]
+        #   1. element1 --> Argument Name, a string. ["join" in above example.]
+        #   2. element2 --> Argument itself. [join]
+        #   3. element3 --> Specifies a flag that mentions if argument is optional or not.
+        #                   False means required argument and True means optional argument.
+        #   4. element4 --> Tuple of accepted types. (str) in above example.
+        #   5. element5 --> True, means validate for empty value. Error will be raised, if empty values are passed.
+        #                   If not specified, argument value will not be validated for empty value.
+        #   6. element6 --> A list of permitted values, an argument can accept.
+        #                   If not specified, argument value will not be validated against any permitted values.
+        #                   If a list is passed, validation will be performed for permitted values.
         invalid_arg_names = []
         invalid_arg_types = []
 
-        typeCheckFailed = False
+        type_check_failed = False
 
         for args in arg_list:
             num_args = len(args)
@@ -560,7 +589,7 @@ class _Validators:
             # Let's validate argument types.
             #
             # Verify datatypes for arguments which are required or the optional arguments are not None
-            if ((args[2] == True and args[1] is not None) or (args[2] == False)):
+            if (args[2] == True and args[1] is not None) or (args[2] == False):
                 # Validate the types of argument, if expected types are instance of tuple or type
                 dtype_list = _Validators.__getTypeAsStr(args[3])
 
@@ -577,13 +606,13 @@ class _Validators:
                             if not _Validators._check_isinstance(value, args[3]):
                                 invalid_arg_names.append(args[0])
                                 invalid_arg_types.append(valid_types_str)
-                                typeCheckFailed = True
+                                type_check_failed = True
                                 break
                     elif not _Validators._check_isinstance(args[1], args[3]):
                         # Argument is not of type list.
                         invalid_arg_names.append(args[0])
                         invalid_arg_types.append(valid_types_str)
-                        typeCheckFailed = True
+                        type_check_failed = True
 
                 elif isinstance(args[3], tuple):
                     # Argument can accept values of multiple types, but not list.
@@ -591,30 +620,30 @@ class _Validators:
                     if not _Validators._check_isinstance(args[1], args[3]):
                         invalid_arg_names.append(args[0])
                         invalid_arg_types.append(valid_types_str)
-                        typeCheckFailed = True
+                        type_check_failed = True
                 else:
                     # Argument can accept values of single type.
                     valid_types_str = " or ".join(dtype_list)
                     if not _Validators._check_isinstance(args[1], args[3]):
                         invalid_arg_names.append(args[0])
                         invalid_arg_types.append(valid_types_str)
-                        typeCheckFailed = True
+                        type_check_failed = True
 
                 #
                 # Validate the arguments for empty value
                 #
-                if not typeCheckFailed and len(args) >= 5:
+                if not type_check_failed and len(args) >= 5:
                     if args[4]:
                         _Validators._validate_input_columns_not_empty(args[1], args[0], skip_empty_check)
 
                 #
                 # Validate the arguments for permitted values
                 #
-                if not typeCheckFailed and len(args) >= 6:
+                if not type_check_failed and len(args) >= 6:
                     if args[5] is not None:
                         _Validators._validate_permitted_values(args[1], args[5], args[0], supported_types=args[3])
 
-        if typeCheckFailed:
+        if type_check_failed:
             if len(invalid_arg_names) != 0:
                 raise TypeError(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE,
                                                      invalid_arg_names, invalid_arg_types))
@@ -623,7 +652,7 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_input_columns_not_empty(arg, arg_name, skip_empty_check = None):
+    def _validate_input_columns_not_empty(arg, arg_name, skip_empty_check=None):
         """
         Function to check whether argument is empty string or not.
 
@@ -655,7 +684,7 @@ class _Validators:
             for col in arg:
                 if not (skip_empty_check and arg_name in skip_empty_check.keys() and col in skip_empty_check[arg_name]):
                     if isinstance(col, str):
-                        if (not (col is None) and ((len(col.strip()) == 0))):
+                        if (not (col is None)) and (len(col.strip()) == 0):
                             raise ValueError(Messages.get_message(MessageCodes.ARG_EMPTY, arg_name))
         return True
 
@@ -695,8 +724,8 @@ class _Validators:
             if args[2] == False and args[1] is None:
                 miss_args.append(args[0])
 
-        if (len(miss_args)>0):
-            raise TeradataMlException(Messages.get_message(MessageCodes.MISSING_ARGS,miss_args),
+        if len(miss_args) > 0:
+            raise TeradataMlException(Messages.get_message(MessageCodes.MISSING_ARGS, miss_args),
                                       MessageCodes.MISSING_ARGS)
         return True
 
@@ -804,7 +833,7 @@ class _Validators:
                 invalid_values.sort()
 
                 # Concatenate the message for datatypes not present in datatypes of permitted_values.
-                if len(add_types) > 0 :
+                if len(add_types) > 0:
                     add_types = _Validators.__getTypeAsStr(add_types)
                     add_types = " or ".join(add_types)
                     permitted_values = "{} {}".format(permitted_values, "or any values of type {}".format(add_types))
@@ -969,7 +998,7 @@ class _Validators:
             return True
 
         is_arg_in_lower_bound, is_arg_in_upper_bound = True, True
-        lbound_msg,  ubound_msg = "", ""
+        lbound_msg, ubound_msg = "", ""
 
         # Check for lower bound.
         if lbound is not None:
@@ -1062,7 +1091,7 @@ class _Validators:
         if timebucket_duration is None:
             return True
 
-        # Check if notation if formal or shorthand (beginning with a digit)
+        # Check if notation is formal or shorthand (beginning with a digit)
         if timebucket_duration[0].isdigit():
             valid_timebucket_durations = PTITableConstants.VALID_TIMEBUCKET_DURATIONS_SHORTHAND.value
             pattern_to_use = PTITableConstants.PATTERN_TIMEBUCKET_DURATION_SHORT.value
@@ -1090,7 +1119,7 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_column_type(df, col, col_arg, expected_types, raiseError = True):
+    def _validate_column_type(df, col, col_arg, expected_types, raiseError=True):
         """
         Internal function to validate the type of an input DataFrame column against
         a list of expected types.
@@ -1114,7 +1143,7 @@ class _Validators:
 
             expected_types:
                 Required Argument.
-                Specifies a list of teradatasqlachemy datatypes that the column is
+                Specifies a list of teradatasqlalchemy datatypes that the column is
                 expected to be of type.
                 Types: list of teradatasqlalchemy types
 
@@ -1125,10 +1154,10 @@ class _Validators:
                 Types: bool
 
         RETURNS:
-            True, when the columns is of an expected type.
+            True, when the column is of an expected type.
 
         RAISES:
-            TeradataMlException, when the columns is not one of the expected types.
+            TeradataMlException, when the column is not one of the expected types.
 
         EXAMPLES:
             _Validators._validate_column_type(df, timecode_column, 'timecode_column', PTITableConstants.VALID_TIMECODE_DATATYPES)
@@ -1398,7 +1427,157 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_unexpected_column_type(df, col, col_arg, unexpected_types, check_exist=True, raise_error=True):
+    def _validate_mutually_exclusive_argument_groups(*arg_groups, all_falsy_check=False,
+                                                     return_all_falsy_status=False):
+        """
+        DESCRIPTION:
+            Function to validate mutual exclusiveness of group of arguments.
+
+        PARAMETERS:
+            *arg_groups:
+                Specifies variable length argument list where each argument in list is a dictionary
+                representing one group of arguments which should be mutually exclusive from
+                other groups of arguments. Each dictionary contains key-value pairs for argument
+                name and its value.
+
+            all_falsy_check:
+                Optional Argument.
+                Specifies whether to throw Teradataml Exception when all arguments in all argument
+                groups hold Falsy/null values.
+                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.
+                Types: bool
+
+        RETURNS:
+            * When "return_all_falsy_status" is True:
+                * True: If all arguments in all argument groups hold Falsy/null values.
+                * False: If all arguments in all argument groups do not hold Falsy/null values.
+            * When "return_all_falsy_status" is False:
+                None
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            # Example 1: When groups of arguments are not mutually exclusive.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": "arg1"},
+            ...                                                          {"arg2": "arg2"},
+            ...                                                          {"arg3": "arg3", "arg4": "arg4"})
+            [Teradata][teradataml](TDML_2061) Provide either '['arg1']' argument(s) or '['arg2']' argument(s) or '['arg3', 'arg4']' argument(s).
+
+            # Example 2: When groups of arguments are mutually exclusive.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": None},
+            ...                                                          {"arg2": ""},
+            ...                                                          {"arg3": "arg3", "arg4": "arg4"})
+
+            # Example 3: When all groups of arguments hold falsy values
+            #          and "all_falsy_check" is set to True.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": None},
+            ...                                                          {"arg2": None},
+            ...                                                          {"arg3": None, "arg4": None},
+            ...                                                          all_falsy_check=True)
+            [Teradata][teradataml](TDML_2061) Provide either '['arg1']' argument(s) or '['arg2']' argument(s) or '['arg3', 'arg4']' argument(s).
+
+            # Example 4: When all groups of arguments hold falsy values
+            #            and "all_falsy_check" is set to False.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": None},
+            ...                                                          {"arg2": None},
+            ...                                                          {"arg3": None, "arg4": None})
+
+            # Example 5: When all groups of arguments hold falsy values
+            #            and "all_falsy_check" is set to False and
+            #            "return_all_falsy_status" is set to True.
+            >>> _Validators._validate_mutually_exclusive_argument_groups({"arg1": None},
+            ...                                                          {"arg2": None},
+            ...                                                          {"arg3": None, "arg4": None},
+            ...                                                          return_all_falsy_status=True)
+            True
+        """
+        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 not is_group_falsy:
+                non_falsy_groups.append(arg_grp)
+
+                # Current group is having non-falsy values and already traversed
+                # group(s) also has(have) non-falsy values. So set "mutually_exclusive_groups" to False.
+                if not all_groups_falsy:
+                    mutually_exclusive_groups = False
+
+            all_groups_falsy = all_groups_falsy and is_group_falsy
+
+        # Raise error if any one of the below-mentioned conditions is True:
+        # More than one group has non-falsy values.
+        # All groups have all falsy values and "all_falsy_check" is True.
+        if not mutually_exclusive_groups or (all_falsy_check and all_groups_falsy):
+            if not non_falsy_groups:
+                non_falsy_groups = [str(list(arg_grp.keys())) for arg_grp in arg_groups]
+            else:
+                non_falsy_groups = [str(list(non_falsy_group.keys())) for non_falsy_group in non_falsy_groups]
+            error_msg = Messages.get_message(
+                MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT, str(non_falsy_groups[0]),
+                "' argument(s) or \'".join(non_falsy_groups[1:]))
+
+            raise TeradataMlException(error_msg, MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
+
+        if return_all_falsy_status:
+            return all_groups_falsy
+
+    @staticmethod
+    @skip_validation()
+    def _validate_mutually_inclusive_n_arguments(**kwargs):
+        """
+        DESCRIPTION:
+            Function to validate mutual inclusiveness of group of arguments.
+
+        PARAMETERS:
+            **kwargs:
+                Specifies variable number of keyword arguments which are to be
+                validated for mutual inclusiveness.
+
+        RETURNS:
+            True, if arguments are mutually inclusive.
+
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            Example 1: When all arguments have non-None values.
+            >>> _Validators._validate_mutually_inclusive_n_arguments(arg1="arg1", arg2="arg2",
+            ...                                                      arg3="arg3", arg4="arg4")
+            True
+
+            Example 2: When one of the arguments is empty string.
+            >>> _Validators._validate_mutually_inclusive_n_arguments(arg1="arg1", arg2="arg2",
+            ...                                                      arg3="arg3", arg4="")
+            TeradataMlException
+
+            Example 3: When one of the arguments is None.
+            >>> _Validators._validate_mutually_inclusive_n_arguments(arg1="arg1", arg2=None,
+            ...                                                      arg3="arg3", arg4="arg4")
+            TeradataMlException
+        """
+        # TODO: Handling of falsy values can be done in more appropriate way by
+        #  differentiating None/empty string/empty list.
+        if all(arg_value for arg, arg_value in kwargs.items()):
+            return True
+        else:
+            arg_list = list(kwargs.keys())
+            message = Messages.get_message(MessageCodes.MUST_PASS_ARGUMENT,
+                                           arg_list[0], " and ".join(arg_list[1:]))
+            raise TeradataMlException(message, MessageCodes.MUST_PASS_ARGUMENT)
+
+    @staticmethod
+    @skip_validation()
+    def _validate_unexpected_column_type(df, col, col_arg, unexpected_types, check_exist=True, raise_error=True,
+                                         case_insensitive=False):
         """
         Internal function to validate the column existence and type of an input DataFrame column against
         a list of unexpected types.
@@ -1464,7 +1643,7 @@ class _Validators:
 
             # Check for column existence.
             if check_exist:
-                _Validators._validate_column_exists_in_dataframe(col, df._metaexpr)
+                _Validators._validate_column_exists_in_dataframe(col, df._metaexpr, case_insensitive=case_insensitive)
 
             if isinstance(df[col].type, unexpected_types):
                 if raise_error:
@@ -1547,6 +1726,60 @@ class _Validators:
                 raise TeradataMlException(error_msg.replace("(not None)", "as '{}'".format(msg_arg_value)),
                                           MessageCodes.DEPENDENT_ARGUMENT)
         return True
+    
+    @staticmethod
+    @skip_validation()
+    def _validate_dependent_method(dependent_mtd, independent_mtd, independent_mtd_calls):
+        """
+        DESCRIPTION:
+            Function validates if an independent method has been called before a dependent method.
+            Raises an error if the independent method is not called before the dependent method is called,
+            otherwise, returns True.
+
+        PARAMETERS:
+            dependent_mtd:
+                Required Argument.
+                Specifies the name of dependent method.
+                Types: String
+
+            independent_mtd:
+                Required Argument.
+                Specifies the name of independent method.
+                Types: String or List of Strings
+
+            independent_mtd_calls:
+                Required Argument.
+                Specifies the flag to check whether independent method is called or not.
+                Types: bool or List of bool
+
+        RETURNS:
+            True, when the independent method is called before the dependent method.
+
+        RAISES:
+            TeradataMlException, when independent method is not called before the
+            dependent method.
+
+        EXAMPLES:
+            _Validators._validate_dependent_method("dependent_method", "independent_method", False)
+            _Validators._validate_dependent_method("dependent_method", "independent_method", True)
+            _Validators._validate_dependent_method("dependent_method", ["independent_method1", "independent_method2"], [False, False])
+        """
+        # Check if all independent method calls are False
+        independent_mtd_calls = [independent_mtd_calls] \
+        if not isinstance(independent_mtd_calls, list) else independent_mtd_calls
+        all_false = all(not value for value in independent_mtd_calls)
+
+        # Check if any of the independent method is called before dependent method
+        if dependent_mtd and all_false:
+            error_code = MessageCodes.DEPENDENT_METHOD
+
+            if isinstance(independent_mtd, str):
+                independent_mtd = [independent_mtd]
+            independent_mtd = ' or '.join(f"'{item}'" for item in independent_mtd)   
+
+            error_msg = Messages.get_message(error_code, independent_mtd, dependent_mtd)
+            raise TeradataMlException(error_msg, error_code)
+        return True
 
     @staticmethod
     @skip_validation()
@@ -1755,7 +1988,7 @@ class _Validators:
         arg2 = True if arg2 == 0 else bool(arg2)
 
         # Either both the arguments are specified or both are None.
-        if not(all([arg1, arg2]) or both_args_none):
+        if not (all([arg1, arg2]) or both_args_none):
             arg_order = [err_disp_arg1_name, err_disp_arg2_name] if arg1 \
                 else [err_disp_arg2_name, err_disp_arg1_name]
             raise TeradataMlException(Messages.get_message(
@@ -1792,7 +2025,7 @@ class _Validators:
                 _Validators._validate_file_extension("/data/mapper.py",".py")
                 _Validators._validate_file_extension("ml__demoenv_requirements_1605727131624097.txt",".txt")
         """
-        extension = extension if isinstance(extension, list) else[extension]
+        extension = extension if isinstance(extension, list) else [extension]
         file_extension = file_path.lower().split('.')[-1]
         if file_extension not in extension:
             raise TeradataMlException(
@@ -1801,7 +2034,6 @@ class _Validators:
 
         return True
 
-
     @staticmethod
     @skip_validation()
     def _validate_argument_is_not_None(arg, arg_name, additional_error="", reverse=False):
@@ -1857,7 +2089,6 @@ class _Validators:
                                                       "provided {}".format(additional_error), ""))
             return True
 
-
     @staticmethod
     @skip_validation()
     def _validate_dataframe(df, raise_error=True):
@@ -1902,7 +2133,6 @@ class _Validators:
             raise TeradataMlException(Messages.get_message(MessageCodes.IS_NOT_VALID_DF),
                                       MessageCodes.IS_NOT_VALID_DF)
 
-
     @staticmethod
     @skip_validation()
     def _validate_column_value_length(argument_name, argument_value, allowed_length,
@@ -1951,11 +2181,10 @@ class _Validators:
             error_msg = Messages.get_message(
                 error_code, operation,
                 'Length of argument {0} ({1}) is more than the allowed length ({2}).'
-                    .format(argument_name, len(argument_value), allowed_length))
+                .format(argument_name, len(argument_value), allowed_length))
             raise TeradataMlException(error_msg, error_code)
         return True
 
-
     @staticmethod
     @skip_validation()
     def _validate_list_lengths_equal(list1, arg_name1, list2, arg_name2):
@@ -2139,15 +2368,15 @@ class _Validators:
                     err_val = key
                 raise ValueError(
                     Messages.get_message(MessageCodes.INVALID_DICT_ARG_VALUE, err_val,
-                                        err_str, arg_name, permitted_values))
-            
+                                         err_str, arg_name, permitted_values))
+
             # Catch ValueError raised by '_validate_function_arguments'
             # for empty string value.
             elif "TDML_2004" in str(ve):
                 err_str = "Key" if "<dict_key>" in str(ve) else "Value"
                 raise ValueError(
                     Messages.get_message(MessageCodes.DICT_ARG_KEY_VALUE_EMPTY,
-                                        err_str, arg_name))
+                                         err_str, arg_name))
 
         except TypeError as te:
             # Catch TypeError raised by '_validate_function_arguments' to
@@ -2163,7 +2392,7 @@ class _Validators:
                                kv_type.__name__ for kv_type in permitted_types]
 
             raise TypeError(
-                Messages.get_message(MessageCodes.UNSUPPORTED_DICT_KEY_VALUE_DTYPE, err_str, 
+                Messages.get_message(MessageCodes.UNSUPPORTED_DICT_KEY_VALUE_DTYPE, err_str,
                                      arg_name, permitted_types))
 
         return True
@@ -2249,7 +2478,6 @@ class _Validators:
                                       MessageCodes.IMPORT_PYTHON_PACKAGE)
         return True
 
-
     @staticmethod
     @skip_validation()
     def _validate_ipaddress(ip_address):
@@ -2278,7 +2506,6 @@ class _Validators:
                                                        'of four numbers (each between 0 and 255) separated by periods'))
 
         return True
-    
 
     @staticmethod
     @skip_validation()
@@ -2303,7 +2530,95 @@ class _Validators:
             >>> _Validators._check_auth_token("udf")
         """
         if _InternalBuffer.get("auth_token") is None:
-            raise TeradataMlException(Messages.get_message(MessageCodes.AUTH_TOKEN_REQUIRED,\
-                                                           func_name), MessageCodes.AUTH_TOKEN_REQUIRED)
-        
-        return True
+            raise TeradataMlException(Messages.get_message(MessageCodes.SET_REQUIRED_PARAMS, \
+                                                           'Auth Token', func_name,
+                                                           'set_auth_token'),
+                                      MessageCodes.SET_REQUIRED_PARAMS)
+
+        return True
+
+    @staticmethod
+    def _check_required_params(arg_value, arg_name, caller_func_name, target_func_name):
+        """
+        DESCRIPTION:
+            Check if the required argument is not None.
+
+        PARAMETERS:
+            arg_value:
+                Required Argument.
+                Specifies the argument value to be
+                checked for non None values.
+                Types: str, float, int, bool
+
+            arg_name:
+                Required Argument.
+                Specifies the argument name.
+                Types: str
+
+            caller_func_name:
+                Required Argument.
+                Specifies the function name which calls this function.
+                This is required for the error message.
+                Types: str
+
+            target_func_name:
+                Required Argument.
+                Specifies the function name which the user needs to call
+                so that the error is fixed.
+                This is required for the error message.
+                Types: str
+
+        RAISES:
+            TeradataMLException
+
+        RETURNS:
+            True.
+
+        EXAMPLES:
+            >>> _Validators._check_required_params("udf", "arg_name")
+        """
+        if arg_value is None:
+            raise TeradataMlException(Messages.get_message(MessageCodes.SET_REQUIRED_PARAMS, \
+                                                           arg_name, caller_func_name,
+                                                           target_func_name),
+                                      MessageCodes.SET_REQUIRED_PARAMS)
+        return True
+
+    @staticmethod
+    def _valid_list_length(arg_value, arg_name, required_length):
+        """
+        DESCRIPTION:
+            Check if the argument has length matching the required length.
+
+        PARAMETERS:
+            arg_value:
+                Required Argument.
+                Specifies the argument value.
+                Types: _ListOf
+
+            arg_name:
+                Required Argument.
+                Specifies the argument name.
+                Types: str
+
+            required_length:
+                Required Argument.
+                Specifies the required list length.
+                Types: int
+
+        RAISES:
+            TeradataMlException
+
+        RETURNS:
+            True.
+
+        EXAMPLES:
+            >>> _Validators._valid_list_length(["udf", "udf1"], "arg_name", 2)
+        """
+        if (isinstance(arg_value, list) and len(arg_value) != required_length) or \
+                (not isinstance(arg_value, list)):
+            raise TeradataMlException(Messages.get_message(
+                MessageCodes.INVALID_LIST_LENGTH).format(arg_name,
+                                                         required_length),
+                                      MessageCodes.INVALID_LIST_LENGTH)
+        return True