teradataml 17.20.0.7__py3-none-any.whl → 20.0.0.1__py3-none-any.whl

teradataml/analytics/json_parser/analytic_functions_argument.py

@@ -1,1708 +1,1708 @@
-"""
-Unpublished work.
-Copyright (c) 2021 by Teradata Corporation. All rights reserved.
-TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
-
-Primary Owner: pradeep.garre@teradata.com
-Secondary Owner: PankajVinod.Purandare@teradata.com
-
-This file implements several classes for representing the input, output and other
-arguments of analytic functions. These are used by IN-DB SQLE analytic framework
-for parsing and storing the JSON details of each argument of each function.
-File implements classes for following:
-    * Analytic Function Argument Base
-    * Analytic Function Input Argument
-    * Analytic Function Output Argument
-    * Analytic Function Other Argument
-"""
-from teradataml.analytics.json_parser import PartitionKind
-from teradataml.utils.dtypes import _Dtypes
-from teradataml.utils.validators import _Validators
-from teradataml.common.messages import Messages, MessageCodes
-from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.utils import UtilFuncs
-from teradataml.analytics.json_parser import UAFJsonFields as SJF
-from teradataml.dataframe.dataframe import TDSeries, TDMatrix, TDAnalyticResult, TDGenSeries
-
-
-class _DependentArgument:
-    """
-    Class to hold the information about dependent argument.
-    """
-    def __init__(self, sql_name, type, operator, right_operand):
-        """
-        DESCRIPTION:
-            Constructor for the class.
-
-        PARAMETERS:
-            sql_name:
-                Required Argument.
-                Specifies the name of the dependent argument in SQL.
-                Types: str
-
-            type:
-                Required Argument.
-                Specifies the type of the dependent argument. Dependent argument
-                type can be input_tables or arguments or output_tables.
-                Types: str
-
-            operator:
-                Required Argument.
-                Specifies the comparision operators for dependent argument.
-                Types: str
-
-            right_operand:
-                Required Argument.
-                Specifies the value to be used for comparing the dependent argument
-                using 'operator'.
-                Types: str
-        """
-        self.sql_name = sql_name
-        self.operator = operator
-        self.right_operand = right_operand
-        self.type = type
-
-    def is_required(self, arg_value):
-        """
-        DESCRIPTION:
-            Check if argument is required or not based on the value of dependent argument.
-
-        PARAMETERS:
-            arg_value:
-                Required Argument.
-                Specifies the value of dependent argument passed by the user.
-                Types: str or int or bool or float or list
-
-        RETURNS:
-            bool
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            _DependentArgument("MethodType", "arguments", "=", "EQUAL-WIDTH").is_required("EQUAL-WIDTH")
-        """
-        if self.operator == "=":
-            return arg_value == self.right_operand
-        elif self.operator == ">=":
-            return arg_value >= self.right_operand
-        elif self.operator == ">":
-            return arg_value > self.right_operand
-        elif self.operator == "<=":
-            return arg_value <= self.right_operand
-        elif self.operator == "<":
-            return arg_value < self.right_operand
-        elif self.operator == "IN":
-            return arg_value in self.right_operand
-        elif self.operator == "NOT IN":
-            return arg_value not in self.right_operand
-        else:
-            msg_code = MessageCodes.EXECUTION_FAILED
-            raise TeradataMlException(
-                Messages.get_message(msg_code,
-                                     "parse the dependent argument '{}'".format(self.sql_name),
-                                     "Operator '{}' is not implemented".format(self.operator)),
-                msg_code)
-
-
-class _AnlyFuncArgumentBase(object):
-    """
-    Class to hold the basic/common information about all the arguments.
-    """
-    def __init__(self, sql_name, is_required, sql_description, lang_description, lang_name, use_in_r):
-        """
-        DESCRIPTION:
-            Constructor for the class.
-
-        PARAMETERS:
-            sql_name:
-                Required Argument.
-                Specifies the name of the argument in SQL.
-                Types: str
-
-            is_required:
-                Required Argument.
-                Specifies whether the argument is required or not.
-                Types: bool
-
-            sql_description:
-                Required Argument.
-                Specifies the description of argument in SQL.
-                Types: str
-
-            lang_description:
-                Required Argument.
-                Specifies the description of the argument, which needs to be exposed
-                to user.
-                Types: str
-
-            lang_name:
-                Required Argument.
-                Specifies the name of the argument to be exposed to user.
-                Types: str
-
-            use_in_r:
-                Required Argument.
-                Specifies whether argument should be used in client or not.
-                Types: bool
-        """
-        self.__sql_name = sql_name
-        self.__is_required = is_required
-        self.__sql_description = sql_description
-        self.__description = lang_description
-        self.__name = lang_name
-        self.__use_in_r = use_in_r
-
-        awu_matrix = []
-        awu_matrix.append(["sql_name", sql_name, False, (str,), True])
-        awu_matrix.append(["is_required", is_required, False, (bool,)])
-        awu_matrix.append(["sql_description", sql_description, False, (str,), True])
-        awu_matrix.append(["lang_description", lang_description, False, (str,), True])
-        awu_matrix.append(["lang_name", lang_name, False, (str,), True])
-        awu_matrix.append(["use_in_r", use_in_r, False, (bool,)])
-
-        # Validate argument types.
-        _Validators._validate_function_arguments(awu_matrix)
-        self.is_empty_value_allowed = lambda: True
-        self.is_output_column = lambda: False
-        self.get_r_default_value = lambda: None
-
-    # Getters
-    def get_sql_name(self):
-        """
-        DESCRIPTION:
-            Get SQL name of the argument.
-
-        RETURNS:
-            str
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Get the argument name used in SQL Query.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            argument_base.get_sql_name()
-        """
-        return self.__sql_name
-
-    def is_required(self):
-        """
-        DESCRIPTION:
-            Check if argument is required or not.
-
-        RETURNS:
-            bool
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Check whether the argument is a mandatory or not for Analytic function.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            if argument_base.is_required():
-                print("Required")
-        """
-        return self.__is_required
-
-    def get_sql_description(self):
-        """
-        DESCRIPTION:
-            Get SQL description of the argument.
-
-        RETURNS:
-            str
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Get the description of the argument with respect to SQL.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            argument_base.get_sql_description()
-        """
-        return self.__sql_description
-
-    def get_lang_description(self):
-        """
-        DESCRIPTION:
-            Get client specific description name of the argument.
-
-        RETURNS:
-            str
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Get the description of the argument with respect to Python.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            argument_base.get_lang_description()
-        """
-        return self.__description
-
-    def get_lang_name(self):
-        """
-        DESCRIPTION:
-            Get client specific name of the argument.
-
-        RETURNS:
-            str
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Get the argument name, which is exposed to user.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            argument_base.get_lang_name()
-        """
-        return self.__name
-
-    def use_in_r(self):
-        """
-        DESCRIPTION:
-            Check if argument should be used in client function or not.
-
-        RETURNS:
-            str
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            # Check whether argument is used in R or not.
-            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
-            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
-            if argument_base.use_in_r():
-                print("Yes")
-        """
-        return self.__use_in_r
-
-
-class _AnlyFuncInput(_AnlyFuncArgumentBase):
-    """
-    Class to hold the information about input argument.
-    """
-
-    def __init__(self,
-                 sql_name,
-                 is_required,
-                 sql_description,
-                 lang_description,
-                 lang_name,
-                 use_in_r,
-                 r_order_num,
-                 datatype="TABLE_NAME",
-                 required_input_kind=None,
-                 partition_by_one=False,
-                 partition_by_one_inclusive=False,
-                 is_ordered=False,
-                 is_local_ordered=False,
-                 hash_by_key=False,
-                 allows_lists=False,
-                 r_formula_usage=False,
-                 alternate_sql_name=None):
-        """
-        Constructor for generating an object of Analytic Function Argument from
-        JSON for arguments accepting input table.
-
-        PARAMETERS:
-            sql_name:
-                Required Argument.
-                Specifies the name of the argument in SQL.
-                Types: str
-
-            is_required:
-                Required Argument.
-                Specifies whether the argument is required or not.
-                Types: bool
-
-            sql_description:
-                Required Argument.
-                Specifies the description of argument in SQL.
-                Types: str
-
-            lang_description:
-                Required Argument.
-                Specifies the description of the argument, which needs to be exposed
-                to user.
-                Types: str
-
-            lang_name:
-                Required Argument.
-                Specifies the name of the argument to be exposed to user.
-                Types: str
-
-            use_in_r:
-                Required Argument.
-                Specifies whether argument should be used in client or not.
-                Types: bool
-
-            r_order_num:
-                Required Argument.
-                Specifies the ordering sequence of the argument for R function call.
-                Types: integer
-
-            datatype:
-                Optional Argument.
-                Specifies the datatype for output table.
-                Permitted Values: table_name, table_alias
-                Default Value: table_name
-                Types: str
-
-            required_input_kind:
-                Optional Argument.
-                Specifies the kind of input.
-                Permitted Values: partition_by_key, partition_by_any, or dimension
-                Default Value: None
-                Types: str or list of str
-
-            partition_by_one:
-                Optional Argument.
-                Specifies that for partition_by_key input kind, the key should be
-                "Partition by 1". If this argument is set to true and
-                "partition_by_one_inclusive" is set to False, the function only accepts
-                "Partition by 1" but not "Partition by key".
-                Default Value: False
-                Types: bool
-
-            partition_by_one_inclusive:
-                Optional Argument.
-                Specifies that for partition_by_key input kind, the function accepts both
-                "Partition by 1" and "Partition by key". This argument can be set to True
-                only if "required_input_kind" has partition_by_key, partition_by_any.
-                Default Value: False
-                Types: bool
-
-            is_ordered:
-                Optional Argument.
-                Specifies that the table must be input with an "Order by" clause.
-                Default Value: False
-                Types: bool
-
-            is_local_ordered:
-                Optional Argument.
-                Specifies whether the table supports LOCAL ORDER BY clause or not.
-                Default Value: False
-                Types: bool
-
-            hash_by_key:
-                Optional Argument.
-                Specifies whether data is grouped according to the HASH BY clause.
-                Default Value: False
-                Types: bool
-
-            allow_lists:
-                Optional Argument.
-                Specifies whether the argument accepts list of values. If false, the
-                argument can only accept a single value.
-                Default Value: False
-                Types: bool
-
-            r_formula_usage:
-                Optional Argument.
-                Specifies if the argument contains a formula.
-                Default Value: False
-                Types: bool
-
-            alternate_sql_name:
-                Optional Argument.
-                Specifies alternate names for the argument.
-                Default Value: None
-                Types: str or list of str
-        """
-
-        # Call Abstract class constructor
-        super().__init__(sql_name, is_required, sql_description, lang_description,
-                         lang_name,
-                         use_in_r)
-
-        # Process other parameters of input table argument.
-        self.__required_input_kind = required_input_kind
-        self.__partition_by_one = partition_by_one
-        self.__partition_by_one_inclusive = partition_by_one_inclusive
-        self.__is_ordered = is_ordered
-        self.__is_local_ordered = is_local_ordered
-        self.__hash_by_key = hash_by_key
-        self.__datatype = datatype
-        self.__allows_lists = allows_lists
-        self.__r_formula_usage = r_formula_usage
-        self.__r_order_num = r_order_num
-        self.__alternate_sql_name = alternate_sql_name
-
-        # Create argument information matrix to do parameter checking
-        self.__arg_info_matrix = []
-        required_input_kind_permitted_values = ["PartitionByKey", "PartitionByAny", "Dimension"]
-        self.__arg_info_matrix.append(
-            ["required_input_kind", self.__required_input_kind, True, (list, str), True,
-             required_input_kind_permitted_values])
-        self.__arg_info_matrix.append(
-            ["partition_by_one", self.__partition_by_one, True, (bool)])
-        self.__arg_info_matrix.append(
-            ["partition_by_one_inclusive", self.__partition_by_one_inclusive, True, (bool)])
-        self.__arg_info_matrix.append(["is_ordered", self.__is_ordered, True, (bool)])
-        self.__arg_info_matrix.append(["is_local_ordered", self.__is_local_ordered, True, (bool)])
-        self.__arg_info_matrix.append(["hash_by_key", self.__hash_by_key, True, (bool)])
-        self.__arg_info_matrix.append(
-            ["datatype", self.__datatype, False, (str), True, ["table_name", "table_alias"]])
-        self.__arg_info_matrix.append(["r_order_num", self.__r_order_num, False, (int), True])
-        self.__arg_info_matrix.append(["allows_lists", self.__allows_lists, True, (bool)])
-        self.__arg_info_matrix.append(["alternate_sql_name", self.__alternate_sql_name, True, (list, str)])
-        self.__arg_info_matrix.append(["r_formula_usage", self.__r_formula_usage, True, (bool)])
-        # Perform the function validations
-        self.__validate()
-        self.get_default_value = lambda: None
-        self.get_permitted_values = lambda: None
-        self._only_partition_by_one = lambda: \
-            self.__partition_by_one and not self.__partition_by_one_inclusive
-
-    def __validate(self):
-        """
-        DESCRIPTION:
-            Function to validate arguments, which verifies missing arguments,
-            input argument.
-        """
-        # Validate argument types.
-        _Validators._validate_function_arguments(self.__arg_info_matrix)
-
-    # Getters.
-    def get_required_input_kind(self):
-        """
-        DESCRIPTION:
-        Function to get the required_input_kind argument.
-        """
-        return self.__required_input_kind
-
-    def get_python_type(self):
-        """
-        DESCRIPTION:
-            Function to get the python type of argument.
-        """
-        from teradataml.dataframe.dataframe import DataFrame
-        return DataFrame
-
-    def is_reference_function_acceptable(self):
-        """
-        DESCRIPTION:
-            Function to check if argument accepts reference function name or not.
-        """
-        return self.get_lang_name().lower() in ("object", "modeldata")
-
-    def is_partition_by_one(self):
-        """
-        DESCRIPTION:
-            Function to check whether partition_by_one is True or False.
-        """
-        return self.__partition_by_one
-
-    def is_partition_by_one_inclusive(self):
-        """
-        DESCRIPTION:
-            Function to check whether partition_by_one_inclusive is True or False.
-        """
-        return self.__partition_by_one_inclusive
-
-    def is_ordered(self):
-        """
-        DESCRIPTION:
-            Function to check whether input table has an order by clause.
-        """
-        return self.__is_ordered
-
-    def is_local_ordered(self):
-        """
-        DESCRIPTION:
-            Check whether input supports LOCAL ORDER BY clause or not.
-        """
-        return self.__is_local_ordered
-
-    def hash_by_key(self):
-        """
-        DESCRIPTION:
-            Check whether input supports HASH BY KEY clause or not.
-        """
-        return self.__hash_by_key
-
-    def get_data_type(self):
-        """
-        DESCRIPTION:
-             Function to get the datatype of the argument.
-        """
-        return self.__datatype
-
-    def allows_lists(self):
-        """
-        DESCRIPTION:
-            Function to check if argument accepts lists or not.
-        """
-        return self.__allows_lists
-
-    def get_r_formula_usage(self):
-        """
-        DESCRIPTION:
-            Function to check if argument is part of a formula or not.
-        """
-        return self.__r_formula_usage
-
-    def get_r_order_number(self):
-        """
-        DESCRIPTION:
-            Function to get the order number of the argument.
-        """
-        return self.__r_order_num
-
-    def get_alternate_sql_name(self):
-        """
-        DESCRIPTION:
-            Function to get the alternate SQL name of the argument.
-        """
-        return self.__alternate_sql_name
-
-    def _get_partition_column_required_kind(self):
-        """
-        DESCRIPTION:
-            Function to determine if the input table is partitioned by a column or ANY or 1
-            or data distribution is DIMENSION. This function follows below steps and derives
-            partition column kind.
-                * The input_table is partitioned by a key, if requireInputKind == PartitionByKey
-                  and partitionByOne == False.
-                * The input_table is partitioned by 1/key, if requireInputKind == PartitionByKey,
-                  partitionByOneInclusive == True and partitionByOne == True.
-                * The input_table is partitioned by 1 only, if partitionByOneInclusive == False
-                  and partitionByOne=true.
-                * The input_table is partitioned by ANY/key, if requireInputKind == PartitionByKey
-                  and requireInputKind == PartitionByAny.
-                * The input_table is partitioned by ANY only, if requireInputKind == PartitionByAny.
-                * The input_table is distributed by either DIMENSION or partitioned by key, if
-                  requireInputKind == PartitionByKey and requireInputKind == DIMENSION.
-                * The input_table is distributed by either DIMENSION or partitioned by ANY/key, if
-                  requireInputKind == PartitionByKey and requireInputKind == PartitionByAny and
-                  requireInputKind == DIMENSION.
-
-        RAISES:
-            None
-
-        RETURNS:
-            enum of type teradataml.analytics.json_parser.PartitionKind
-
-        EXAMPLES:
-            self._get_partition_column_required_kind()
-        """
-        is_partition_by_key, is_partition_by_any, is_partition_by_one, is_dimension = [False]*4
-
-        # Input table is partitioned by 1 ONLY when partitionByOneInclusive is false and
-        # partitionByOne is true.
-        if self.__partition_by_one and not self.__partition_by_one_inclusive:
-            is_partition_by_one = True
-        else:
-            for input_kind in self.__required_input_kind:
-                if input_kind == "Dimension":
-                    is_dimension = True
-                # If requiredInputKind has PartitionByKey and partitionByOneInclusive and
-                # partitionByOne is True then input table is partitioned by 1 or Key.
-                # Else input table is partitioned by Key Only.
-                elif input_kind == "PartitionByKey":
-                    if self.__partition_by_one_inclusive and self.__partition_by_one:
-                        is_partition_by_one = True
-                        is_partition_by_key = True
-                    else:
-                        is_partition_by_key = True
-                elif input_kind == "PartitionByAny":
-                    is_partition_by_any = True
-
-        if is_dimension:
-            if is_partition_by_key and is_partition_by_any:
-                return PartitionKind.DIMENSIONKEYANY
-            elif is_partition_by_key and not is_partition_by_any:
-                return PartitionKind.DIMENSIONKEY
-            else:
-                return PartitionKind.DIMENSION
-        else:
-            if is_partition_by_key and not is_partition_by_any and not is_partition_by_one:
-                return PartitionKind.KEY
-            elif is_partition_by_key and is_partition_by_any:
-                return PartitionKind.ANY
-            elif not is_partition_by_key and is_partition_by_any:
-                return PartitionKind.ANYONLY
-            elif is_partition_by_one and is_partition_by_key:
-                return PartitionKind.ONE
-            elif is_partition_by_one and is_partition_by_key:
-                return PartitionKind.ONEONLY
-
-    def _get_default_partition_column_kind(self):
-        """ Returns the default Parition Type based on requiredInputKind parameter in json file. """
-        required_column_kind = UtilFuncs._as_list(self.__required_input_kind)[0]
-
-        if required_column_kind == "PartitionByAny":
-            return PartitionKind.ANY
-        elif required_column_kind == "Dimension":
-            return PartitionKind.DIMENSION
-        elif required_column_kind == "PartitionByOne":
-            return PartitionKind.ONE
-        else:
-            return None
-
-    '''
-    @staticmethod
-    def _get_default_partition_by_value(partition_kind):
-        """
-        DESCRIPTION:
-            Function to get the default value for partition column kind.
-
-        PARAMETERS:
-            partition_kind:
-                Required Argument.
-                Specifies input table partition type.
-
-        RAISES:
-            None
-
-        RETURNS:
-            str OR int
-
-        EXAMPLES:
-            self._get_default_partition_by_value(PartitionKind.KEY)
-        """
-        if partition_kind == PartitionKind.KEY or partition_kind == PartitionKind.DIMENSIONKEY:
-            return None
-        elif partition_kind == PartitionKind.ONE or partition_kind == PartitionKind.ONEONLY:
-            return 1
-        elif partition_kind == PartitionKind.ANY or partition_kind == PartitionKind.ANYONLY or \
-                partition_kind == PartitionKind.DIMENSIONKEYANY:
-            return "ANY"
-    '''
-
-    def _only_partition_by_any(self):
-        """
-        DESCRIPTION:
-            Check partition column supports only Partition By Any.
-
-        RAISES:
-            None
-
-        RETURNS:
-            bool
-
-        EXAMPLES:
-            self._only_partition_by_any()
-        """
-        if isinstance(self.__required_input_kind, str):
-            return self.__required_input_kind == "PartitionByAny"
-        return self.__required_input_kind == ["PartitionByAny"]
-
-
-class _AnlyFuncOutput(_AnlyFuncArgumentBase):
-    """
-    Class to hold the information about output argument.
-    """
-
-    def __init__(self,
-                 sql_name,
-                 is_required,
-                 sql_description,
-                 lang_description,
-                 lang_name,
-                 use_in_r,
-                 r_order_num,
-                 datatype="TABLE_NAME",
-                 is_output_table=True,
-                 allows_lists=False,
-                 output_schema=None,
-                 alternate_sql_name=None,
-                 support_volatility=False,
-                 is_required_dependent_argument=None):
-        """
-        Constructor for generating an object of Analytic Function Argument from
-        JSON for arguments accepting output table information.
-
-        PARAMETERS:
-            sql_name:
-                Required Argument.
-                Specifies the name of the argument in SQL.
-                Types: str
-
-            is_required:
-                Required Argument.
-                Specifies whether the argument is required or not.
-                Types: bool
-
-            sql_description:
-                Required Argument.
-                Specifies the description of argument in SQL.
-                Types: str
-
-            lang_description:
-                Required Argument.
-                Specifies the description of the argument, which needs to be exposed
-                to user.
-                Types: str
-
-            lang_name:
-                Required Argument.
-                Specifies the name of the argument to be exposed to user.
-                Types: str
-
-            use_in_r:
-                Required Argument.
-                Specifies whether argument should be used in client or not.
-                Types: bool
-
-            r_order_num:
-                Required Argument.
-                Specifies the ordering sequence of the argument for R function call.
-                Types: integer
-
-            datatype:
-                Optional Argument.
-                Specifies the datatype for output table.
-                Permitted Values: table_name, table_alias
-                Default Value: table_name
-                Types: str
-
-            is_output_table:
-                Optional Argument.
-                Specifies whether the argument clause has an output table name.
-                Default Value: True
-                Types: bool
-
-            allow_lists:
-                Optional Argument.
-                Specifies whether the argument accepts list of values. If false, the
-                argument can only accept a single value.
-                Default Value: False
-                Types: bool
-
-            output_schema:
-                Optional Argument.
-                Specifies the output schema of the function.
-                Default Value: None
-                Types: str
-
-            alternate_sql_name:
-                Optional Argument.
-                Specifies alternate names for the argument.
-                Default Value: None
-                Types: str or list of str
-
-            support_volatility:
-                Optional Argument.
-                Specifies whether the output table support VOLATILE table or not.
-                Default Value: False
-                Types: bool
-        """
-
-        # Call super class constructor to initialize basic parameters.
-        super().__init__(sql_name, is_required, sql_description, lang_description,
-                         lang_name,
-                         use_in_r)
-
-        self.__r_order_num = r_order_num
-        self.__allows_lists = allows_lists
-        self.__output_schema = output_schema
-        self.__alternate_sql_name = alternate_sql_name
-        self.__is_output_table = is_output_table
-        self.__datatype = datatype
-        self.__support_volatility = support_volatility
-        # Create argument information matrix to do parameter checking
-        self.__arg_info_matrix = []
-        self.__arg_info_matrix.append(["r_order_num", self.__r_order_num, False, int, True])
-        self.__arg_info_matrix.append(["allows_lists", self.__allows_lists, True, bool])
-        self.__arg_info_matrix.append(["output_schema", self.__output_schema, True, str, True])
-        self.__arg_info_matrix.append(["alternate_sql_name", self.__alternate_sql_name, True, (list, str)])
-        self.__arg_info_matrix.append(["is_output_table", self.__is_output_table, True, bool])
-        self.__arg_info_matrix.append(
-            ["datatype", self.__datatype, True, str, True, ["table_name", "table_alias"]])
-        self.__arg_info_matrix.append(["support_volatility", self.__support_volatility, True, bool])
-        self.__arg_info_matrix.append(
-            ["is_required_dependent_argument", is_required_dependent_argument, True, _DependentArgument])
-
-        # Perform the function validations
-        self.__validate()
-        self.is_volatility_supported = lambda : self.__support_volatility
-        self.get_is_required_dependent_argument = lambda : is_required_dependent_argument
-
-    def __validate(self):
-        """
-        DESCRIPTION:
-            Function to validate arguments, which verifies missing arguments,
-            input argument.
-        """
-        # Validate argument types.
-        _Validators._validate_function_arguments(self.__arg_info_matrix)
-
-    # Getters
-    def get_data_type(self):
-        """
-        DESCRIPTION:
-             Function to get the datatype of the argument.
-        """
-        return self.__datatype
-
-    def is_output_table(self):
-        """
-        DESCRIPTION:
-            Function to check if argument represents output table or not.
-        """
-        return self.__is_output_table
-
-    def get_r_order_number(self):
-        """
-        DESCRIPTION:
-            Function to get the order number of the argument.
-        """
-        return self.__r_order_num
-
-    def allows_lists(self):
-        """
-        DESCRIPTION:
-            Function to check if argument accepts lists or not.
-        """
-        return self.__allows_lists
-
-    def get_output_schema(self):
-        """
-        DESCRIPTION:
-            Function to get the output schema of the argument.
-        """
-        return self.__output_schema
-
-    def get_alternate_sql_name(self):
-        """
-        DESCRIPTION:
-            Function to get the alternate SQL name of the argument.
-        """
-        return self.__alternate_sql_name
-
-
-class _AnlyFuncArgument(_AnlyFuncArgumentBase):
-    """
-    Class to hold the information about analytic function argument.
-    """
-
-    def __init__(self,
-                 sql_name,
-                 is_required,
-                 sql_description,
-                 lang_description,
-                 lang_name,
-                 use_in_r,
-                 r_order_num,
-                 datatype,
-                 default_value=None,
-                 permitted_values=None,
-                 lower_bound=None,
-                 lower_bound_type=None,
-                 upper_bound=None,
-                 upper_bound_type=None,
-                 allow_nan=False,
-                 required_length=0,
-                 match_length_of_argument=None,
-                 allows_lists=False,
-                 allow_padding=False,
-                 r_formula_usage=False,
-                 r_default_value=None,
-                 target_table=None,
-                 target_table_lang_name=None,
-                 check_duplicate=False,
-                 allowed_types=None,
-                 allowed_type_groups=None,
-                 is_output_column=False,
-                 alternate_sql_name=None):
-        """
-        Constructor for generating an object of Analytic Function Argument from
-        JSON for other arguments.
-
-        PARAMETERS:
-            sql_name:
-                Required Argument.
-                Specifies the name of the argument in SQL.
-                Types: str
-
-            is_required:
-                Required Argument.
-                Specifies whether the argument is required or not.
-                Types: bool
-
-            sql_description:
-                Required Argument.
-                Specifies the description of argument in SQL.
-                Types: str
-
-            lang_description:
-                Required Argument.
-                Specifies the description of the argument, which needs to be exposed
-                to user.
-                Types: str
-
-            lang_name:
-                Required Argument.
-                Specifies the name of the argument to be exposed to user.
-                Types: str
-
-            use_in_r:
-                Required Argument.
-                Specifies whether argument should be used in client or not.
-                Types: bool
-
-            r_order_num:
-                Required Argument.
-                Specifies the ordering sequence of the argument.
-                Types: integer
-
-            datatype:
-                Required Argument.
-                Specifies the datatype for argument.
-                Types: str OR list of str
-
-            default_value:
-                Optional Argument.
-                Specifies the default value for argument.
-                Types: str OR int OR float OR bool
-
-            permitted_values:
-                Optional Argument.
-                Specified the permitted values for argument.
-                Types: list OR str OR float OR int
-
-            lower_bound:
-                Optional Argument.
-                Specifies the lower bound value for argument.
-                Types: int OR float
-
-            lower_bound_type:
-                Optional Argument.
-                Specifies whether "lower_bound" is inclusive or exclusive.
-                Permitted Values: INCLUSIVE, EXCLUSIVE
-                Types: str
-
-            upper_bound:
-                Optional Argument.
-                Specifies the upper bound value for argument.
-                Types: int OR float
-
-            upper_bound_type:
-                Optional Argument.
-                Specifies whether "upper_bound" is inclusive or exclusive.
-                Permitted Values: INCLUSIVE, EXCLUSIVE
-                Types: str
-
-            allow_nan:
-                Optional Argument.
-                Specifies whether argument accepts None or not.
-                Default Value: False
-                Types: bool
-
-            allows_lists:
-                Optional Argument.
-                Specifies whether argument accepts a list of values or not.
-                Default Value: False
-                Types: bool
-
-            match_length_of_argument:
-                Optional Argument.
-                Specifies whether length of "allow_lists" should be checked or not.
-                Default Value: False
-                Types: bool
-
-            required_length:
-                Optional Argument.
-                Specifies if the list must be the same length as the list specified
-                in argument clause.
-                Default Value: 0
-                Types: int
-
-            allow_padding:
-                Optional Argument.
-                Specifies whether to add padding to argument or not. When set to True,
-                user submitted value will be padded into a list equal to the required
-                length.
-                Default Value: False
-                Types: bool
-
-            r_formula_usage:
-                Optional Argument.
-                Specifies whether argument is part of formula.
-                Default Value: False
-                Types: bool
-
-            r_default_value:
-                Optional Argument.
-                Specifies the default value of the argument.
-                Types: str OR int OR float
-
-            target_table:
-                Optional Argument.
-                Specifies the name of the input table that the input column
-                should be found in (Only applicable for datatype COLUMNS or COLUMN_NAMES)
-                Types: str OR list of str
-
-            target_table_lang_name:
-                Optional Argument.
-                Specifies the lang name of the input table that the input column
-                should be found in (Only applicable for datatype COLUMNS or COLUMN_NAMES)
-                Types: str
-
-            check_duplicate:
-                Optional Argument.
-                Specifies whether duplicate columns should be checked in input
-                or not (Only applicable for datatype COLUMNS or COLUMN_NAMES).
-                Default Value: False
-                Types: bool
-
-            allowed_types:
-                Optional Argument.
-                Specifies SQL types that are allowed (Only applicable for datatype
-                COLUMNS or COLUMN_NAMES).
-                Types: str OR list of str
-
-            allowed_type_groups:
-                Optional Argument.
-                Species the group of SQL types that are allowed.
-                    * NUMERIC for all numeric types.
-                    * STRING for all char/varchar types.
-                    * GROUPTYPE for any type except double or float.
-                Types: list of str
-
-            is_output_column:
-                Optional Argument.
-                Specifies whether argument is output column or not.
-                Default Value: False
-                Types: bool
-
-            alternate_sql_name:
-                Optional Argument.
-                Specifies alternate names for the argument.
-                Types: str or list of str
-        """
-
-        # Call super class constructor to initialize basic parameters.
-        super().__init__(sql_name, is_required, sql_description, lang_description, lang_name, use_in_r)
-
-        # Initialize rest of the parameters for the Arguments class.
-        self.__default_value = default_value
-        self.__permitted_values = permitted_values
-        self.__lower_bound = lower_bound
-        self.__lower_bound_type = lower_bound_type
-        self.__upper_bound = upper_bound
-        self.__upper_bound_type = upper_bound_type
-        self.__allow_nan = allow_nan
-        self.__required_length = required_length
-        self.__match_length_of_argument = match_length_of_argument
-        self.__datatype = datatype
-        self.__allows_lists = allows_lists
-        self.__allow_padding = allow_padding
-        self.__r_formula_usage = r_formula_usage
-        self.__r_default_value = r_default_value
-        self.__target_table = target_table
-        self.__target_table_lang_name = target_table_lang_name
-        self.__check_duplicate = check_duplicate
-        self.__allowed_types = allowed_types
-        self.__allowed_type_groups = allowed_type_groups
-        self.__r_order_num = r_order_num
-        self.__is_output_column = is_output_column
-        self.__alternate_sql_name = alternate_sql_name
-
-        awu_matrix = []
-        awu_matrix.append(["r_order_num", r_order_num, False, int])
-        awu_matrix.append(["datatype", datatype, False, (list, str), True])
-        awu_matrix.append(["default_value", default_value, True, (int, str, bool, float)])
-        awu_matrix.append(["permitted_values", permitted_values, True, (list, str, int, float)])
-        awu_matrix.append(["lower_bound", lower_bound, True, (int, float)])
-        awu_matrix.append(["lower_bound_type", lower_bound_type, True, str, True, ["INCLUSIVE", "EXCLUSIVE"]])
-        awu_matrix.append(["upper_bound", upper_bound, True, (int, float)])
-        awu_matrix.append(["upper_bound_type", upper_bound_type, True, str, True, ["INCLUSIVE", "EXCLUSIVE"]])
-        awu_matrix.append(["allow_nan", allow_nan, True, bool])
-        awu_matrix.append(["allows_lists", allows_lists, True, bool])
-        awu_matrix.append(["match_length_of_argument", match_length_of_argument, True, bool])
-        awu_matrix.append(["required_length", required_length, True, int])
-        awu_matrix.append(["allow_padding", allow_padding, True, bool])
-        awu_matrix.append(["r_formula_usage", r_formula_usage, True, bool])
-        awu_matrix.append(["r_default_value", r_default_value, True, (int, float, str)])
-        awu_matrix.append(["target_table", target_table, True, (list, str)])
-        awu_matrix.append(["target_table_lang_name", target_table_lang_name, True, str])
-        awu_matrix.append(["check_duplicate", check_duplicate, True, bool])
-        awu_matrix.append(["allowed_types", allowed_types, True, (list, str)])
-        awu_matrix.append(["allowed_type_groups", allowed_type_groups, True, (list, str)])
-        awu_matrix.append(["is_output_column", is_output_column, True, bool])
-        awu_matrix.append(["alternate_sql_name", alternate_sql_name, True, (list, str)])
-
-        # Validate argument types.
-        _Validators._validate_function_arguments(awu_matrix)
-
-        # Validate lower bound is greater than upper bound.
-        # _validate_argument_range validates whether lower bound is less than upper bound
-        # or not if argument is None.
-        _Validators._validate_argument_range(
-            arg_name="dummy", arg=None, lbound=self.__lower_bound, ubound=self.__upper_bound)
-
-        # Getters.
-        self.get_r_order_number = lambda: self.__r_order_num
-        self.get_data_type = lambda: self.__datatype
-        self.get_default_value = lambda: self.__default_value
-        self.get_permitted_values = lambda: self.__permitted_values
-        self.get_lower_bound = lambda: self.__lower_bound
-        self.get_lower_bound_type = lambda: self.__lower_bound_type
-        self.get_upper_bound = lambda: self.__upper_bound
-        self.get_upper_bound_type = lambda: self.__upper_bound_type
-        self.is_nan_allowed = lambda: self.__allow_nan
-        self.get_required_length = lambda: self.__required_length
-        self.get_match_length_of_argument = lambda: self.__match_length_of_argument
-        self.is_lists_allowed = lambda: self.__allows_lists
-        self.is_padding_required = lambda: self.__allow_padding
-        self.is_argument_a_formula = lambda: self.__r_formula_usage
-        self.get_r_default_value = lambda: self.__r_default_value
-        self.get_target_table = lambda: self.__target_table
-        self.get_target_table_lang_name = lambda: self.__target_table_lang_name
-        self.check_duplicate = lambda: self.__check_duplicate
-        self.get_allowed_types = lambda: self.__allowed_types
-        self.get_allowed_type_groups = lambda: self.__allowed_type_groups
-        self.is_output_column = lambda: self.__is_output_column
-        self.get_alternate_sql_name = lambda: self.__alternate_sql_name
-        self.is_empty_value_allowed = lambda: not self.is_column_argument()
-
-    def get_python_type(self):
-        """
-        DESCRIPTION:
-            Get equivalent Python type for the JSON datatype for an argument.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            type.
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.get_python_type(arg1="string", arg2="db", arg3=2)
-        """
-        py_types = tuple()
-
-        # If multiple datatype's allowed, return the tuple of all allowed python types.
-        if isinstance(self.__datatype, list):
-            for td_type in self.__datatype:
-                py_type = _Dtypes._anly_json_type_to_python_type(td_type)
-
-                # If py_type is not a tuple, convert to a tuple.
-                py_types = py_types + ((py_type, ) if not isinstance(py_type, tuple) else py_type)
-        else:
-            py_type = _Dtypes._anly_json_type_to_python_type(self.__datatype)
-            py_types = py_type if isinstance(py_type, tuple) else (py_type, )
-
-        # If lists are allowed, add list type also.
-        if self.__allows_lists and (list not in py_types):
-            py_types = py_types + (list, )
-
-        return  py_types
-
-    def is_column_argument(self):
-        """
-        DESCRIPTION:
-            Function checks if the argument accepts column as input or not.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            bool
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.is_column_argument()
-        """
-        # __datatype can be either string or list.
-        if isinstance(self.__datatype, list):
-            datatype = (datatype.lower() for datatype in self.__datatype)
-        else:
-            datatype = self.__datatype.lower()
-        return "column" in datatype
-
-
-class _AnlyFuncArgumentBaseUAF(object):
-    """ Class to hold the basic/common information about all the arguments."""
-    def __init__(self, data_type, description, lang_name, is_required=False):
-        """
-        DESCRIPTION:
-            Constructor for the class.
-
-        PARAMETERS:
-             data_type:
-                 Required Argument.
-                 Specifies the data type an argument can accept.
-                 Type: str
-
-             description:
-                 Required Argument.
-                 Specifies the argument description.
-                 Type: str or List
-
-             lang_name:
-                 Required Argument.
-                 Specifies the name of the argument to be exposed to user.
-                 Type: str
-
-            is_required:
-                Optional Argument.
-                Specifies whether the argument is required or not.
-                Default Value: False
-                Types: bool
-
-        """
-        self.__data_type = data_type
-        self.__description = description
-        self.__lang_name = lang_name
-        self.__is_required = is_required
-
-        # Getters
-        self.get_data_type = lambda: self.__data_type
-        self.get_description = lambda: self.__description
-        self.get_lang_name = lambda: self.__lang_name
-        self.is_required = lambda: self.__is_required
-        self.is_empty_value_allowed = lambda: True
-        self.is_output_column = lambda: False
-        self.get_r_default_value = lambda: None
-
-        # Validation
-        self.__arg_info_matrix = []
-        self.__arg_info_matrix.append(["type", self.__data_type, False, (list, str), True])
-        self.__arg_info_matrix.append(["description", self.__description, False, (list, str)])
-        self.__arg_info_matrix.append(["lang_name", self.__lang_name, False, str])
-        self.__arg_info_matrix.append(["optional", self.__is_required, True, bool])
-
-        _Validators._validate_function_arguments(self.__arg_info_matrix)
-        self.is_empty_value_allowed = lambda: True
-        self.is_output_column = lambda: False
-        self.get_permitted_values = lambda: None
-
-        # Combining list to string.
-        self.__description = ''.join(description)
-
-    def is_column_argument(self):
-        """
-        DESCRIPTION:
-            Function checks if the argument accepts column as input or not.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            bool
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.is_column_argument()
-        """
-        # __datatype can be either string or list.
-        if isinstance(self.__data_type, list):
-            datatype = (datatype.lower() for datatype in self.__data_type)
-        else:
-            datatype = self.__data_type.lower()
-        return "column" in datatype
-
-    def get_python_type(self):
-        """
-        DESCRIPTION:
-            Get equivalent Python type for the JSON datatype for an argument.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            type.
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.get_python_type(arg1="string", arg2="db", arg3=2)
-        """
-        py_types = tuple()
-        supp_data_types = UtilFuncs._as_list(self.__data_type)
-        # If multiple datatype's allowed, return the tuple of all allowed Python types.
-        for td_type in supp_data_types:
-            py_type = _Dtypes._anly_json_type_to_python_type(td_type)
-
-            # If py_type is not a tuple, convert to a tuple.
-            py_types = py_types + ((py_type,) if not isinstance(py_type, tuple) else py_type)
-
-        # If lists are allowed, add list type also.
-        if self.is_lists_allowed() and (list not in py_types):
-            py_types = py_types + (list,)
-        return py_types
-    
-    def set_is_required(self, value):
-        """
-        DESCRIPTION:
-            Setter function to set if argument is required or not.
-
-        RETURNS:
-            None
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.set_is_required(True)
-        """
-        self.__is_required = value
-
-
-class _AnlyFuncInputUAF(_AnlyFuncArgumentBaseUAF):
-    """ Class to hold the information about input argument of UAF."""
-    def __init__(self, data_type, description, lang_name, is_required=False):
-       """
-        DESCRIPTION:
-           Constructor for the class.
-
-        PARAMETERS:
-            data_type:
-                Required Argument.
-                Specifies the data type an input argument can accept.
-                Type: str
-
-            description:
-                Required Argument.
-                Specifies the input argument description.
-                Type: Str or List
-
-            lang_name:
-                Required Argument.
-                Specifies the name of the argument to be exposed to user.
-                Type: str
-
-            is_required:
-                Optional Argument.
-                Specifies whether the argument is required or not.
-                Default Value: False
-                Type: bool
-       """
-
-       # Call Abstract class constructor
-       super().__init__(data_type, description, lang_name, is_required)
-       self.get_default_value = lambda: None
-       self.is_lists_allowed = lambda: False
-
-
-class _AnlyFuncOutputUAF(_AnlyFuncArgumentBaseUAF):
-    """ Class to hold the information about output argument of UAF."""
-    def __init__(self, data_type, description, lang_name, layer_name,
-                 primary_layer=False, result_table_column_types=None, is_required=False):
-        """
-         DESCRIPTION:
-            Constructor for the class.
-
-         PARAMETERS:
-             description:
-                 Required Argument.
-                 Specifies the output argument description.
-                 Type: str or List
-
-             data_type:
-                 Required Argument.
-                 Specifies data type an output argument can accept.
-                 Type: str
-
-             lang_name:
-                 Required Argument.
-                 Specifies the name of the argument to be exposed to user.
-                 Type: str
-
-            primary_layer:
-                 Optional Argument.
-                 Specifies whether the layer is primary or not.
-                 Default Value: False
-                 Type: bool
-
-            layer_name:
-                 Required Argument.
-                 Specifies the name of the output layer.
-                 Type:str
-
-            result_table_column_types:
-                Optional Argument
-                Specifies the column types for the result table.
-                Type: List or str
-
-            is_required:
-                 Optional Argument.
-                 Specifies whether the argument is required or not.
-                 Default Value: False
-                 Type: bool
-        """
-
-        # Call Abstract class constructor
-        super().__init__(data_type, description, lang_name, is_required)
-        # Process other parameters of output table argument.
-        self.__result_table_column_types = result_table_column_types
-        self.__primary_layer = primary_layer
-        self.__layer_name = layer_name
-
-        # Getters
-        self.get_result_table_column_types = lambda: self.__result_table_column_types
-        self.get_primary_layer = lambda : self.__primary_layer
-        self.get_layer_name = lambda : self.__layer_name
-
-        # Validation
-        self.__arg_info_matrix = []
-        self.__arg_info_matrix.append(["result_table_column_types", self.__result_table_column_types, True, (list, str)])
-        self.__arg_info_matrix.append(["primary_layer", self.__primary_layer, True, bool])
-        self.__arg_info_matrix.append(["layer_name", self.__layer_name, False, str])
-        _Validators._validate_function_arguments(self.__arg_info_matrix)
-
-
-class _AnlyFuncArgumentUAF(_AnlyFuncArgumentBaseUAF):
-    """Class to hold the information about the other function parameters."""
-
-    def __init__(self, data_type, description, name, is_required=False, permitted_values=None,
-                 lower_bound=None, upper_bound=None, lower_bound_type=None, upper_bound_type=None,
-                 check_duplicates=False, list_type=None, allow_nan=None, lang_name=None,
-                 default_value=None, required_length=0, nested_param_list=None,
-                 is_nested=False, parent=None, has_nested=False):
-        """
-         DESCRIPTION:
-            Constructor for the class.
-
-         PARAMETERS:
-             description:
-                 Required Argument.
-                 Specifies the argument description.
-                 Type: str or List
-
-             name:
-                 Required Argument.
-                 Specifies the SQL name of the argument.
-                 Type: str
-
-             data_type:
-                 Required Argument.
-                 Specifies the data type for the argument.
-                 Type: str
-
-             is_required:
-                 Optional Argument.
-                 Specifies whether the argument is required or not.
-                 Default Value: False
-                 Types: bool
-
-             permitted_values:
-                Optional Argument.
-                 Specifies the permitted values for the particular argument.
-                 Type: List
-
-             lower_bound:
-                 Optional Argument.
-                 Specifies the lower bound for the particular argument.
-                 Type: int or float
-
-             upper_bound:
-                 Optional Argument.
-                 Specifies the upper bound for the particular argument.
-                 Type: int or float
-
-             lower_bound_type:
-                 Optional Argument.
-                 Specifies whether the lower bound is inclusive or not.
-                 Type: str
-
-             upper_bound_type:
-                 Optional Argument.
-                 Specifies whether the upper bound is inclusive or not.
-                 Type: str
-
-             check_duplicates:
-                 Optional Argument
-                 Specifies if the argument checks for duplicate values.
-                 Type: bool
-
-             list_type:
-                 Optional Argument.
-                 Specifies the type of the list in the argument.
-                 Type: str
-
-            allow_nan:
-                Required Argument.
-                Specifies whether nan values are allowed or not.
-                Type: bool
-
-            is_required:
-                Optional Argument.
-                Specifies whether the argument is required or not .
-                Type: bool
-
-            lang_name:
-                Optional Argument.
-                Specifies the name of the argument to be exposed to user.
-                Type: str
-
-            default_value:
-                Optional Argument.
-                Specifies the default value of the particular argument.
-                Type: int or str or float
-
-            required_length:
-                Optional Argument.
-                Specifies if the list must be the same length as the list specified
-                in argument clause.
-                Types: int
-
-            nested_params_json:
-                Optional Argument.
-                Specifies the json object for nested_params argument.
-                Type: List
-
-            is_nested:
-                Optional Argument.
-                Specifies whether the argument is a nested argument or not.
-                Default Value: False
-                Type: bool
-
-            parent:
-                Optional Argument.
-                Specifies the name of the parent incase of nested argument.
-                Default Value: None
-                Type: str or None
-
-            has_nested:
-                Optional Argument.
-                Specifies whether the argument has nested_params or not.
-                Default Value:False
-                Type: bool
-
-        """
-        # Call Abstract class constructor
-        super().__init__(data_type, description, lang_name, is_required)
-
-        # Process other parameters of arguments.
-        self.__name = name
-        self.__data_type = self.get_data_type()
-        self.__permitted_values = permitted_values
-        self.__default_value = default_value
-        self.__r_default_value = None
-        self.__allow_nan = allow_nan
-        self.__lower_bound = lower_bound
-        self.__upper_bound = upper_bound
-        self.__lower_bound_type = lower_bound_type
-        self.__upper_bound_type = upper_bound_type
-        self.__check_duplicates = check_duplicates
-        self.__required_length = required_length
-        self.__parent = parent
-        self.__is_nested = is_nested
-        self.__has_nested = has_nested
-        self.__allows_lists = False
-        self.__match_length_of_arguments = False
-
-        # Creating a list for nested params
-        self.__nested_param_list = nested_param_list
-
-        # Getters
-        self.get_name = lambda: self.__name
-        self.get_data_type = lambda: self.__data_type
-        self.get_permitted_values = lambda: self.__permitted_values
-        self.get_default_value = lambda: self.__default_value
-        self.get_r_default_value = lambda: self.__r_default_value
-        self.is_nan_allowed = lambda: self.__allow_nan
-        self.get_parent = lambda: self.__parent
-        self.get_lower_bound = lambda: self.__lower_bound
-        self.get_upper_bound = lambda: self.__upper_bound
-        self.get_lower_bound_type = lambda: self.__lower_bound_type
-        self.get_upper_bound_type = lambda: self.__upper_bound_type
-        self.get_check_duplicates = lambda: self.__check_duplicates
-        self.get_required_length = lambda: self.__required_length
-        self.get_nested_param_list = lambda: self.__nested_param_list
-        self.get_is_nested = lambda: self.__is_nested
-        self.get_has_nested = lambda: self.__has_nested
-        self.is_lists_allowed = lambda: self.__allows_lists
-        self.get_match_length_of_arguments = lambda: self.__match_length_of_arguments
-
-        # In order to make it similar to variables of SQLE functions if the data_type is list
-        # we are setting allows_list=True and data_type to the data_type of the list elements.
-        if self.get_data_type() == "list":
-            self.__allows_lists = True
-            self.__data_type = list_type
-
-        # Validation
-        self.__arg_info_matrix = []
-        self.__arg_info_matrix.append(["name", self.__name, True, str])
-        self.__arg_info_matrix.append(["permitted_values", self.__permitted_values, True, list])
-        self.__arg_info_matrix.append(["default_value", self.__default_value, True, (int, str, float, bool, list)])
-        self.__arg_info_matrix.append(["r_default_value", self.__r_default_value, True, (int, str, float, bool, list)])
-        self.__arg_info_matrix.append(["allow_nan", self.__allow_nan, True, bool])
-        self.__arg_info_matrix.append(["lower_bound", self.__lower_bound, True, (int, float)])
-        self.__arg_info_matrix.append(["upper_bound", self.__upper_bound, True, (int, float)])
-        self.__arg_info_matrix.append(["lower_bound_type", self.__lower_bound_type, True, str])
-        self.__arg_info_matrix.append(["upper_bound_type", self.__upper_bound_type, True, str])
-        self.__arg_info_matrix.append(["check_duplicates", self.__check_duplicates, True, bool])
-        self.__arg_info_matrix.append(["list_size", self.__required_length, True, (int, str)])
-
-        _Validators._validate_function_arguments(self.__arg_info_matrix)
-
-        # Validate whether lower bound is less than upper bound.
-        _Validators._validate_argument_range(arg_name="dummy", arg=None, lbound=self.__lower_bound,
-                                             ubound=self.__upper_bound)
-        # Validate whether lower_bound and lower_bound_type are mutually inclusive.
-        _Validators._validate_mutually_inclusive_arguments(lower_bound, "lower_bound", lower_bound_type, "lower_bound_type")
-        # Validate whether upper_bound and upper_bound_type are mutually inclusive.
-        _Validators._validate_mutually_inclusive_arguments(upper_bound, "upper_bound", upper_bound_type, "upper_bound_type")
-
-        # In order to make it similar to variables of SQLE functions, if get_required_length specifies
-        # a value we set match_length_of_arguments which will validate the length of the arguments
-        if not isinstance(self.__required_length, str) and self.get_required_length() > 0:
-            self.__match_length_of_arguments = True
-
-        # If the argument is an int type and permitted values are 0 and 1, then we should consider it as boolean.
-        if "INTEGER" in self.__data_type.upper() and self.__permitted_values is not None\
-                and set(self.__permitted_values) == {0, 1}:
-            self.__data_type = "BOOLEAN"
-            self.__permitted_values = None
-            self.set_is_required(False)
-            if self.__default_value is not None:
-                self.__default_value = bool(self.__default_value)
-            else:
-                self.__r_default_value = False             
-
-    def get_python_type(self):
-        """
-        DESCRIPTION:
-            Get equivalent Python type for the JSON datatype for an argument.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            type.
-
-        RAISES:
-            None
-
-        EXAMPLES:
-            self.get_python_type(arg1="string", arg2="db", arg3=2)
-        """
-        py_types = tuple()
-
-        # If multiple datatype's allowed, return the tuple of all allowed python types.
-        if isinstance(self.__data_type, list):
-            for td_type in self.__data_type:
-                py_type = _Dtypes._anly_json_type_to_python_type(td_type)
-
-                # If py_type is not a tuple, convert to a tuple.
-                py_types = py_types + ((py_type,) if not isinstance(py_type, tuple) else py_type)
-        else:
-            py_type = _Dtypes._anly_json_type_to_python_type(self.__data_type)
-            py_types = py_type if isinstance(py_type, tuple) else (py_type,)
-
-        # If lists are allowed, add list type also.
-        if self.__allows_lists and (list not in py_types):
-            py_types = py_types + (list,)
-
+"""
+Unpublished work.
+Copyright (c) 2021 by Teradata Corporation. All rights reserved.
+TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
+
+Primary Owner: pradeep.garre@teradata.com
+Secondary Owner: PankajVinod.Purandare@teradata.com
+
+This file implements several classes for representing the input, output and other
+arguments of analytic functions. These are used by IN-DB SQLE analytic framework
+for parsing and storing the JSON details of each argument of each function.
+File implements classes for following:
+    * Analytic Function Argument Base
+    * Analytic Function Input Argument
+    * Analytic Function Output Argument
+    * Analytic Function Other Argument
+"""
+from teradataml.analytics.json_parser import PartitionKind
+from teradataml.utils.dtypes import _Dtypes
+from teradataml.utils.validators import _Validators
+from teradataml.common.messages import Messages, MessageCodes
+from teradataml.common.exceptions import TeradataMlException
+from teradataml.common.utils import UtilFuncs
+from teradataml.analytics.json_parser import UAFJsonFields as SJF
+from teradataml.dataframe.dataframe import TDSeries, TDMatrix, TDAnalyticResult, TDGenSeries
+
+
+class _DependentArgument:
+    """
+    Class to hold the information about dependent argument.
+    """
+    def __init__(self, sql_name, type, operator, right_operand):
+        """
+        DESCRIPTION:
+            Constructor for the class.
+
+        PARAMETERS:
+            sql_name:
+                Required Argument.
+                Specifies the name of the dependent argument in SQL.
+                Types: str
+
+            type:
+                Required Argument.
+                Specifies the type of the dependent argument. Dependent argument
+                type can be input_tables or arguments or output_tables.
+                Types: str
+
+            operator:
+                Required Argument.
+                Specifies the comparision operators for dependent argument.
+                Types: str
+
+            right_operand:
+                Required Argument.
+                Specifies the value to be used for comparing the dependent argument
+                using 'operator'.
+                Types: str
+        """
+        self.sql_name = sql_name
+        self.operator = operator
+        self.right_operand = right_operand
+        self.type = type
+
+    def is_required(self, arg_value):
+        """
+        DESCRIPTION:
+            Check if argument is required or not based on the value of dependent argument.
+
+        PARAMETERS:
+            arg_value:
+                Required Argument.
+                Specifies the value of dependent argument passed by the user.
+                Types: str or int or bool or float or list
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            _DependentArgument("MethodType", "arguments", "=", "EQUAL-WIDTH").is_required("EQUAL-WIDTH")
+        """
+        if self.operator == "=":
+            return arg_value == self.right_operand
+        elif self.operator == ">=":
+            return arg_value >= self.right_operand
+        elif self.operator == ">":
+            return arg_value > self.right_operand
+        elif self.operator == "<=":
+            return arg_value <= self.right_operand
+        elif self.operator == "<":
+            return arg_value < self.right_operand
+        elif self.operator == "IN":
+            return arg_value in self.right_operand
+        elif self.operator == "NOT IN":
+            return arg_value not in self.right_operand
+        else:
+            msg_code = MessageCodes.EXECUTION_FAILED
+            raise TeradataMlException(
+                Messages.get_message(msg_code,
+                                     "parse the dependent argument '{}'".format(self.sql_name),
+                                     "Operator '{}' is not implemented".format(self.operator)),
+                msg_code)
+
+
+class _AnlyFuncArgumentBase(object):
+    """
+    Class to hold the basic/common information about all the arguments.
+    """
+    def __init__(self, sql_name, is_required, sql_description, lang_description, lang_name, use_in_r):
+        """
+        DESCRIPTION:
+            Constructor for the class.
+
+        PARAMETERS:
+            sql_name:
+                Required Argument.
+                Specifies the name of the argument in SQL.
+                Types: str
+
+            is_required:
+                Required Argument.
+                Specifies whether the argument is required or not.
+                Types: bool
+
+            sql_description:
+                Required Argument.
+                Specifies the description of argument in SQL.
+                Types: str
+
+            lang_description:
+                Required Argument.
+                Specifies the description of the argument, which needs to be exposed
+                to user.
+                Types: str
+
+            lang_name:
+                Required Argument.
+                Specifies the name of the argument to be exposed to user.
+                Types: str
+
+            use_in_r:
+                Required Argument.
+                Specifies whether argument should be used in client or not.
+                Types: bool
+        """
+        self.__sql_name = sql_name
+        self.__is_required = is_required
+        self.__sql_description = sql_description
+        self.__description = lang_description
+        self.__name = lang_name
+        self.__use_in_r = use_in_r
+
+        awu_matrix = []
+        awu_matrix.append(["sql_name", sql_name, False, (str,), True])
+        awu_matrix.append(["is_required", is_required, False, (bool,)])
+        awu_matrix.append(["sql_description", sql_description, False, (str,), True])
+        awu_matrix.append(["lang_description", lang_description, False, (str,), True])
+        awu_matrix.append(["lang_name", lang_name, False, (str,), True])
+        awu_matrix.append(["use_in_r", use_in_r, False, (bool,)])
+
+        # Validate argument types.
+        _Validators._validate_function_arguments(awu_matrix)
+        self.is_empty_value_allowed = lambda: True
+        self.is_output_column = lambda: False
+        self.get_r_default_value = lambda: None
+
+    # Getters
+    def get_sql_name(self):
+        """
+        DESCRIPTION:
+            Get SQL name of the argument.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Get the argument name used in SQL Query.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            argument_base.get_sql_name()
+        """
+        return self.__sql_name
+
+    def is_required(self):
+        """
+        DESCRIPTION:
+            Check if argument is required or not.
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Check whether the argument is a mandatory or not for Analytic function.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            if argument_base.is_required():
+                print("Required")
+        """
+        return self.__is_required
+
+    def get_sql_description(self):
+        """
+        DESCRIPTION:
+            Get SQL description of the argument.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Get the description of the argument with respect to SQL.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            argument_base.get_sql_description()
+        """
+        return self.__sql_description
+
+    def get_lang_description(self):
+        """
+        DESCRIPTION:
+            Get client specific description name of the argument.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Get the description of the argument with respect to Python.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            argument_base.get_lang_description()
+        """
+        return self.__description
+
+    def get_lang_name(self):
+        """
+        DESCRIPTION:
+            Get client specific name of the argument.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Get the argument name, which is exposed to user.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            argument_base.get_lang_name()
+        """
+        return self.__name
+
+    def use_in_r(self):
+        """
+        DESCRIPTION:
+            Check if argument should be used in client function or not.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Check whether argument is used in R or not.
+            from teradataml.analytics.json_parser.argument import _AnlyFuncArgumentBase
+            argument_base = _AnlyFuncArgumentBase("sql_name", True, "SQL Description", "Python Description", "name", True)
+            if argument_base.use_in_r():
+                print("Yes")
+        """
+        return self.__use_in_r
+
+
+class _AnlyFuncInput(_AnlyFuncArgumentBase):
+    """
+    Class to hold the information about input argument.
+    """
+
+    def __init__(self,
+                 sql_name,
+                 is_required,
+                 sql_description,
+                 lang_description,
+                 lang_name,
+                 use_in_r,
+                 r_order_num,
+                 datatype="TABLE_NAME",
+                 required_input_kind=None,
+                 partition_by_one=False,
+                 partition_by_one_inclusive=False,
+                 is_ordered=False,
+                 is_local_ordered=False,
+                 hash_by_key=False,
+                 allows_lists=False,
+                 r_formula_usage=False,
+                 alternate_sql_name=None):
+        """
+        Constructor for generating an object of Analytic Function Argument from
+        JSON for arguments accepting input table.
+
+        PARAMETERS:
+            sql_name:
+                Required Argument.
+                Specifies the name of the argument in SQL.
+                Types: str
+
+            is_required:
+                Required Argument.
+                Specifies whether the argument is required or not.
+                Types: bool
+
+            sql_description:
+                Required Argument.
+                Specifies the description of argument in SQL.
+                Types: str
+
+            lang_description:
+                Required Argument.
+                Specifies the description of the argument, which needs to be exposed
+                to user.
+                Types: str
+
+            lang_name:
+                Required Argument.
+                Specifies the name of the argument to be exposed to user.
+                Types: str
+
+            use_in_r:
+                Required Argument.
+                Specifies whether argument should be used in client or not.
+                Types: bool
+
+            r_order_num:
+                Required Argument.
+                Specifies the ordering sequence of the argument for R function call.
+                Types: integer
+
+            datatype:
+                Optional Argument.
+                Specifies the datatype for output table.
+                Permitted Values: table_name, table_alias
+                Default Value: table_name
+                Types: str
+
+            required_input_kind:
+                Optional Argument.
+                Specifies the kind of input.
+                Permitted Values: partition_by_key, partition_by_any, or dimension
+                Default Value: None
+                Types: str or list of str
+
+            partition_by_one:
+                Optional Argument.
+                Specifies that for partition_by_key input kind, the key should be
+                "Partition by 1". If this argument is set to true and
+                "partition_by_one_inclusive" is set to False, the function only accepts
+                "Partition by 1" but not "Partition by key".
+                Default Value: False
+                Types: bool
+
+            partition_by_one_inclusive:
+                Optional Argument.
+                Specifies that for partition_by_key input kind, the function accepts both
+                "Partition by 1" and "Partition by key". This argument can be set to True
+                only if "required_input_kind" has partition_by_key, partition_by_any.
+                Default Value: False
+                Types: bool
+
+            is_ordered:
+                Optional Argument.
+                Specifies that the table must be input with an "Order by" clause.
+                Default Value: False
+                Types: bool
+
+            is_local_ordered:
+                Optional Argument.
+                Specifies whether the table supports LOCAL ORDER BY clause or not.
+                Default Value: False
+                Types: bool
+
+            hash_by_key:
+                Optional Argument.
+                Specifies whether data is grouped according to the HASH BY clause.
+                Default Value: False
+                Types: bool
+
+            allow_lists:
+                Optional Argument.
+                Specifies whether the argument accepts list of values. If false, the
+                argument can only accept a single value.
+                Default Value: False
+                Types: bool
+
+            r_formula_usage:
+                Optional Argument.
+                Specifies if the argument contains a formula.
+                Default Value: False
+                Types: bool
+
+            alternate_sql_name:
+                Optional Argument.
+                Specifies alternate names for the argument.
+                Default Value: None
+                Types: str or list of str
+        """
+
+        # Call Abstract class constructor
+        super().__init__(sql_name, is_required, sql_description, lang_description,
+                         lang_name,
+                         use_in_r)
+
+        # Process other parameters of input table argument.
+        self.__required_input_kind = required_input_kind
+        self.__partition_by_one = partition_by_one
+        self.__partition_by_one_inclusive = partition_by_one_inclusive
+        self.__is_ordered = is_ordered
+        self.__is_local_ordered = is_local_ordered
+        self.__hash_by_key = hash_by_key
+        self.__datatype = datatype
+        self.__allows_lists = allows_lists
+        self.__r_formula_usage = r_formula_usage
+        self.__r_order_num = r_order_num
+        self.__alternate_sql_name = alternate_sql_name
+
+        # Create argument information matrix to do parameter checking
+        self.__arg_info_matrix = []
+        required_input_kind_permitted_values = ["PartitionByKey", "PartitionByAny", "Dimension"]
+        self.__arg_info_matrix.append(
+            ["required_input_kind", self.__required_input_kind, True, (list, str), True,
+             required_input_kind_permitted_values])
+        self.__arg_info_matrix.append(
+            ["partition_by_one", self.__partition_by_one, True, (bool)])
+        self.__arg_info_matrix.append(
+            ["partition_by_one_inclusive", self.__partition_by_one_inclusive, True, (bool)])
+        self.__arg_info_matrix.append(["is_ordered", self.__is_ordered, True, (bool)])
+        self.__arg_info_matrix.append(["is_local_ordered", self.__is_local_ordered, True, (bool)])
+        self.__arg_info_matrix.append(["hash_by_key", self.__hash_by_key, True, (bool)])
+        self.__arg_info_matrix.append(
+            ["datatype", self.__datatype, False, (str), True, ["table_name", "table_alias"]])
+        self.__arg_info_matrix.append(["r_order_num", self.__r_order_num, False, (int), True])
+        self.__arg_info_matrix.append(["allows_lists", self.__allows_lists, True, (bool)])
+        self.__arg_info_matrix.append(["alternate_sql_name", self.__alternate_sql_name, True, (list, str)])
+        self.__arg_info_matrix.append(["r_formula_usage", self.__r_formula_usage, True, (bool)])
+        # Perform the function validations
+        self.__validate()
+        self.get_default_value = lambda: None
+        self.get_permitted_values = lambda: None
+        self._only_partition_by_one = lambda: \
+            self.__partition_by_one and not self.__partition_by_one_inclusive
+
+    def __validate(self):
+        """
+        DESCRIPTION:
+            Function to validate arguments, which verifies missing arguments,
+            input argument.
+        """
+        # Validate argument types.
+        _Validators._validate_function_arguments(self.__arg_info_matrix)
+
+    # Getters.
+    def get_required_input_kind(self):
+        """
+        DESCRIPTION:
+        Function to get the required_input_kind argument.
+        """
+        return self.__required_input_kind
+
+    def get_python_type(self):
+        """
+        DESCRIPTION:
+            Function to get the python type of argument.
+        """
+        from teradataml.dataframe.dataframe import DataFrame
+        return DataFrame
+
+    def is_reference_function_acceptable(self):
+        """
+        DESCRIPTION:
+            Function to check if argument accepts reference function name or not.
+        """
+        return self.get_lang_name().lower() in ("object", "modeldata")
+
+    def is_partition_by_one(self):
+        """
+        DESCRIPTION:
+            Function to check whether partition_by_one is True or False.
+        """
+        return self.__partition_by_one
+
+    def is_partition_by_one_inclusive(self):
+        """
+        DESCRIPTION:
+            Function to check whether partition_by_one_inclusive is True or False.
+        """
+        return self.__partition_by_one_inclusive
+
+    def is_ordered(self):
+        """
+        DESCRIPTION:
+            Function to check whether input table has an order by clause.
+        """
+        return self.__is_ordered
+
+    def is_local_ordered(self):
+        """
+        DESCRIPTION:
+            Check whether input supports LOCAL ORDER BY clause or not.
+        """
+        return self.__is_local_ordered
+
+    def hash_by_key(self):
+        """
+        DESCRIPTION:
+            Check whether input supports HASH BY KEY clause or not.
+        """
+        return self.__hash_by_key
+
+    def get_data_type(self):
+        """
+        DESCRIPTION:
+             Function to get the datatype of the argument.
+        """
+        return self.__datatype
+
+    def allows_lists(self):
+        """
+        DESCRIPTION:
+            Function to check if argument accepts lists or not.
+        """
+        return self.__allows_lists
+
+    def get_r_formula_usage(self):
+        """
+        DESCRIPTION:
+            Function to check if argument is part of a formula or not.
+        """
+        return self.__r_formula_usage
+
+    def get_r_order_number(self):
+        """
+        DESCRIPTION:
+            Function to get the order number of the argument.
+        """
+        return self.__r_order_num
+
+    def get_alternate_sql_name(self):
+        """
+        DESCRIPTION:
+            Function to get the alternate SQL name of the argument.
+        """
+        return self.__alternate_sql_name
+
+    def _get_partition_column_required_kind(self):
+        """
+        DESCRIPTION:
+            Function to determine if the input table is partitioned by a column or ANY or 1
+            or data distribution is DIMENSION. This function follows below steps and derives
+            partition column kind.
+                * The input_table is partitioned by a key, if requireInputKind == PartitionByKey
+                  and partitionByOne == False.
+                * The input_table is partitioned by 1/key, if requireInputKind == PartitionByKey,
+                  partitionByOneInclusive == True and partitionByOne == True.
+                * The input_table is partitioned by 1 only, if partitionByOneInclusive == False
+                  and partitionByOne=true.
+                * The input_table is partitioned by ANY/key, if requireInputKind == PartitionByKey
+                  and requireInputKind == PartitionByAny.
+                * The input_table is partitioned by ANY only, if requireInputKind == PartitionByAny.
+                * The input_table is distributed by either DIMENSION or partitioned by key, if
+                  requireInputKind == PartitionByKey and requireInputKind == DIMENSION.
+                * The input_table is distributed by either DIMENSION or partitioned by ANY/key, if
+                  requireInputKind == PartitionByKey and requireInputKind == PartitionByAny and
+                  requireInputKind == DIMENSION.
+
+        RAISES:
+            None
+
+        RETURNS:
+            enum of type teradataml.analytics.json_parser.PartitionKind
+
+        EXAMPLES:
+            self._get_partition_column_required_kind()
+        """
+        is_partition_by_key, is_partition_by_any, is_partition_by_one, is_dimension = [False]*4
+
+        # Input table is partitioned by 1 ONLY when partitionByOneInclusive is false and
+        # partitionByOne is true.
+        if self.__partition_by_one and not self.__partition_by_one_inclusive:
+            is_partition_by_one = True
+        else:
+            for input_kind in self.__required_input_kind:
+                if input_kind == "Dimension":
+                    is_dimension = True
+                # If requiredInputKind has PartitionByKey and partitionByOneInclusive and
+                # partitionByOne is True then input table is partitioned by 1 or Key.
+                # Else input table is partitioned by Key Only.
+                elif input_kind == "PartitionByKey":
+                    if self.__partition_by_one_inclusive and self.__partition_by_one:
+                        is_partition_by_one = True
+                        is_partition_by_key = True
+                    else:
+                        is_partition_by_key = True
+                elif input_kind == "PartitionByAny":
+                    is_partition_by_any = True
+
+        if is_dimension:
+            if is_partition_by_key and is_partition_by_any:
+                return PartitionKind.DIMENSIONKEYANY
+            elif is_partition_by_key and not is_partition_by_any:
+                return PartitionKind.DIMENSIONKEY
+            else:
+                return PartitionKind.DIMENSION
+        else:
+            if is_partition_by_key and not is_partition_by_any and not is_partition_by_one:
+                return PartitionKind.KEY
+            elif is_partition_by_key and is_partition_by_any:
+                return PartitionKind.ANY
+            elif not is_partition_by_key and is_partition_by_any:
+                return PartitionKind.ANYONLY
+            elif is_partition_by_one and is_partition_by_key:
+                return PartitionKind.ONE
+            elif is_partition_by_one and is_partition_by_key:
+                return PartitionKind.ONEONLY
+
+    def _get_default_partition_column_kind(self):
+        """ Returns the default Parition Type based on requiredInputKind parameter in json file. """
+        required_column_kind = UtilFuncs._as_list(self.__required_input_kind)[0]
+
+        if required_column_kind == "PartitionByAny":
+            return PartitionKind.ANY
+        elif required_column_kind == "Dimension":
+            return PartitionKind.DIMENSION
+        elif required_column_kind == "PartitionByOne":
+            return PartitionKind.ONE
+        else:
+            return None
+
+    '''
+    @staticmethod
+    def _get_default_partition_by_value(partition_kind):
+        """
+        DESCRIPTION:
+            Function to get the default value for partition column kind.
+
+        PARAMETERS:
+            partition_kind:
+                Required Argument.
+                Specifies input table partition type.
+
+        RAISES:
+            None
+
+        RETURNS:
+            str OR int
+
+        EXAMPLES:
+            self._get_default_partition_by_value(PartitionKind.KEY)
+        """
+        if partition_kind == PartitionKind.KEY or partition_kind == PartitionKind.DIMENSIONKEY:
+            return None
+        elif partition_kind == PartitionKind.ONE or partition_kind == PartitionKind.ONEONLY:
+            return 1
+        elif partition_kind == PartitionKind.ANY or partition_kind == PartitionKind.ANYONLY or \
+                partition_kind == PartitionKind.DIMENSIONKEYANY:
+            return "ANY"
+    '''
+
+    def _only_partition_by_any(self):
+        """
+        DESCRIPTION:
+            Check partition column supports only Partition By Any.
+
+        RAISES:
+            None
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            self._only_partition_by_any()
+        """
+        if isinstance(self.__required_input_kind, str):
+            return self.__required_input_kind == "PartitionByAny"
+        return self.__required_input_kind == ["PartitionByAny"]
+
+
+class _AnlyFuncOutput(_AnlyFuncArgumentBase):
+    """
+    Class to hold the information about output argument.
+    """
+
+    def __init__(self,
+                 sql_name,
+                 is_required,
+                 sql_description,
+                 lang_description,
+                 lang_name,
+                 use_in_r,
+                 r_order_num,
+                 datatype="TABLE_NAME",
+                 is_output_table=True,
+                 allows_lists=False,
+                 output_schema=None,
+                 alternate_sql_name=None,
+                 support_volatility=False,
+                 is_required_dependent_argument=None):
+        """
+        Constructor for generating an object of Analytic Function Argument from
+        JSON for arguments accepting output table information.
+
+        PARAMETERS:
+            sql_name:
+                Required Argument.
+                Specifies the name of the argument in SQL.
+                Types: str
+
+            is_required:
+                Required Argument.
+                Specifies whether the argument is required or not.
+                Types: bool
+
+            sql_description:
+                Required Argument.
+                Specifies the description of argument in SQL.
+                Types: str
+
+            lang_description:
+                Required Argument.
+                Specifies the description of the argument, which needs to be exposed
+                to user.
+                Types: str
+
+            lang_name:
+                Required Argument.
+                Specifies the name of the argument to be exposed to user.
+                Types: str
+
+            use_in_r:
+                Required Argument.
+                Specifies whether argument should be used in client or not.
+                Types: bool
+
+            r_order_num:
+                Required Argument.
+                Specifies the ordering sequence of the argument for R function call.
+                Types: integer
+
+            datatype:
+                Optional Argument.
+                Specifies the datatype for output table.
+                Permitted Values: table_name, table_alias
+                Default Value: table_name
+                Types: str
+
+            is_output_table:
+                Optional Argument.
+                Specifies whether the argument clause has an output table name.
+                Default Value: True
+                Types: bool
+
+            allow_lists:
+                Optional Argument.
+                Specifies whether the argument accepts list of values. If false, the
+                argument can only accept a single value.
+                Default Value: False
+                Types: bool
+
+            output_schema:
+                Optional Argument.
+                Specifies the output schema of the function.
+                Default Value: None
+                Types: str
+
+            alternate_sql_name:
+                Optional Argument.
+                Specifies alternate names for the argument.
+                Default Value: None
+                Types: str or list of str
+
+            support_volatility:
+                Optional Argument.
+                Specifies whether the output table support VOLATILE table or not.
+                Default Value: False
+                Types: bool
+        """
+
+        # Call super class constructor to initialize basic parameters.
+        super().__init__(sql_name, is_required, sql_description, lang_description,
+                         lang_name,
+                         use_in_r)
+
+        self.__r_order_num = r_order_num
+        self.__allows_lists = allows_lists
+        self.__output_schema = output_schema
+        self.__alternate_sql_name = alternate_sql_name
+        self.__is_output_table = is_output_table
+        self.__datatype = datatype
+        self.__support_volatility = support_volatility
+        # Create argument information matrix to do parameter checking
+        self.__arg_info_matrix = []
+        self.__arg_info_matrix.append(["r_order_num", self.__r_order_num, False, int, True])
+        self.__arg_info_matrix.append(["allows_lists", self.__allows_lists, True, bool])
+        self.__arg_info_matrix.append(["output_schema", self.__output_schema, True, str, True])
+        self.__arg_info_matrix.append(["alternate_sql_name", self.__alternate_sql_name, True, (list, str)])
+        self.__arg_info_matrix.append(["is_output_table", self.__is_output_table, True, bool])
+        self.__arg_info_matrix.append(
+            ["datatype", self.__datatype, True, str, True, ["table_name", "table_alias"]])
+        self.__arg_info_matrix.append(["support_volatility", self.__support_volatility, True, bool])
+        self.__arg_info_matrix.append(
+            ["is_required_dependent_argument", is_required_dependent_argument, True, _DependentArgument])
+
+        # Perform the function validations
+        self.__validate()
+        self.is_volatility_supported = lambda : self.__support_volatility
+        self.get_is_required_dependent_argument = lambda : is_required_dependent_argument
+
+    def __validate(self):
+        """
+        DESCRIPTION:
+            Function to validate arguments, which verifies missing arguments,
+            input argument.
+        """
+        # Validate argument types.
+        _Validators._validate_function_arguments(self.__arg_info_matrix)
+
+    # Getters
+    def get_data_type(self):
+        """
+        DESCRIPTION:
+             Function to get the datatype of the argument.
+        """
+        return self.__datatype
+
+    def is_output_table(self):
+        """
+        DESCRIPTION:
+            Function to check if argument represents output table or not.
+        """
+        return self.__is_output_table
+
+    def get_r_order_number(self):
+        """
+        DESCRIPTION:
+            Function to get the order number of the argument.
+        """
+        return self.__r_order_num
+
+    def allows_lists(self):
+        """
+        DESCRIPTION:
+            Function to check if argument accepts lists or not.
+        """
+        return self.__allows_lists
+
+    def get_output_schema(self):
+        """
+        DESCRIPTION:
+            Function to get the output schema of the argument.
+        """
+        return self.__output_schema
+
+    def get_alternate_sql_name(self):
+        """
+        DESCRIPTION:
+            Function to get the alternate SQL name of the argument.
+        """
+        return self.__alternate_sql_name
+
+
+class _AnlyFuncArgument(_AnlyFuncArgumentBase):
+    """
+    Class to hold the information about analytic function argument.
+    """
+
+    def __init__(self,
+                 sql_name,
+                 is_required,
+                 sql_description,
+                 lang_description,
+                 lang_name,
+                 use_in_r,
+                 r_order_num,
+                 datatype,
+                 default_value=None,
+                 permitted_values=None,
+                 lower_bound=None,
+                 lower_bound_type=None,
+                 upper_bound=None,
+                 upper_bound_type=None,
+                 allow_nan=False,
+                 required_length=0,
+                 match_length_of_argument=None,
+                 allows_lists=False,
+                 allow_padding=False,
+                 r_formula_usage=False,
+                 r_default_value=None,
+                 target_table=None,
+                 target_table_lang_name=None,
+                 check_duplicate=False,
+                 allowed_types=None,
+                 allowed_type_groups=None,
+                 is_output_column=False,
+                 alternate_sql_name=None):
+        """
+        Constructor for generating an object of Analytic Function Argument from
+        JSON for other arguments.
+
+        PARAMETERS:
+            sql_name:
+                Required Argument.
+                Specifies the name of the argument in SQL.
+                Types: str
+
+            is_required:
+                Required Argument.
+                Specifies whether the argument is required or not.
+                Types: bool
+
+            sql_description:
+                Required Argument.
+                Specifies the description of argument in SQL.
+                Types: str
+
+            lang_description:
+                Required Argument.
+                Specifies the description of the argument, which needs to be exposed
+                to user.
+                Types: str
+
+            lang_name:
+                Required Argument.
+                Specifies the name of the argument to be exposed to user.
+                Types: str
+
+            use_in_r:
+                Required Argument.
+                Specifies whether argument should be used in client or not.
+                Types: bool
+
+            r_order_num:
+                Required Argument.
+                Specifies the ordering sequence of the argument.
+                Types: integer
+
+            datatype:
+                Required Argument.
+                Specifies the datatype for argument.
+                Types: str OR list of str
+
+            default_value:
+                Optional Argument.
+                Specifies the default value for argument.
+                Types: str OR int OR float OR bool
+
+            permitted_values:
+                Optional Argument.
+                Specified the permitted values for argument.
+                Types: list OR str OR float OR int
+
+            lower_bound:
+                Optional Argument.
+                Specifies the lower bound value for argument.
+                Types: int OR float
+
+            lower_bound_type:
+                Optional Argument.
+                Specifies whether "lower_bound" is inclusive or exclusive.
+                Permitted Values: INCLUSIVE, EXCLUSIVE
+                Types: str
+
+            upper_bound:
+                Optional Argument.
+                Specifies the upper bound value for argument.
+                Types: int OR float
+
+            upper_bound_type:
+                Optional Argument.
+                Specifies whether "upper_bound" is inclusive or exclusive.
+                Permitted Values: INCLUSIVE, EXCLUSIVE
+                Types: str
+
+            allow_nan:
+                Optional Argument.
+                Specifies whether argument accepts None or not.
+                Default Value: False
+                Types: bool
+
+            allows_lists:
+                Optional Argument.
+                Specifies whether argument accepts a list of values or not.
+                Default Value: False
+                Types: bool
+
+            match_length_of_argument:
+                Optional Argument.
+                Specifies whether length of "allow_lists" should be checked or not.
+                Default Value: False
+                Types: bool
+
+            required_length:
+                Optional Argument.
+                Specifies if the list must be the same length as the list specified
+                in argument clause.
+                Default Value: 0
+                Types: int
+
+            allow_padding:
+                Optional Argument.
+                Specifies whether to add padding to argument or not. When set to True,
+                user submitted value will be padded into a list equal to the required
+                length.
+                Default Value: False
+                Types: bool
+
+            r_formula_usage:
+                Optional Argument.
+                Specifies whether argument is part of formula.
+                Default Value: False
+                Types: bool
+
+            r_default_value:
+                Optional Argument.
+                Specifies the default value of the argument.
+                Types: str OR int OR float
+
+            target_table:
+                Optional Argument.
+                Specifies the name of the input table that the input column
+                should be found in (Only applicable for datatype COLUMNS or COLUMN_NAMES)
+                Types: str OR list of str
+
+            target_table_lang_name:
+                Optional Argument.
+                Specifies the lang name of the input table that the input column
+                should be found in (Only applicable for datatype COLUMNS or COLUMN_NAMES)
+                Types: str
+
+            check_duplicate:
+                Optional Argument.
+                Specifies whether duplicate columns should be checked in input
+                or not (Only applicable for datatype COLUMNS or COLUMN_NAMES).
+                Default Value: False
+                Types: bool
+
+            allowed_types:
+                Optional Argument.
+                Specifies SQL types that are allowed (Only applicable for datatype
+                COLUMNS or COLUMN_NAMES).
+                Types: str OR list of str
+
+            allowed_type_groups:
+                Optional Argument.
+                Species the group of SQL types that are allowed.
+                    * NUMERIC for all numeric types.
+                    * STRING for all char/varchar types.
+                    * GROUPTYPE for any type except double or float.
+                Types: list of str
+
+            is_output_column:
+                Optional Argument.
+                Specifies whether argument is output column or not.
+                Default Value: False
+                Types: bool
+
+            alternate_sql_name:
+                Optional Argument.
+                Specifies alternate names for the argument.
+                Types: str or list of str
+        """
+
+        # Call super class constructor to initialize basic parameters.
+        super().__init__(sql_name, is_required, sql_description, lang_description, lang_name, use_in_r)
+
+        # Initialize rest of the parameters for the Arguments class.
+        self.__default_value = default_value
+        self.__permitted_values = permitted_values
+        self.__lower_bound = lower_bound
+        self.__lower_bound_type = lower_bound_type
+        self.__upper_bound = upper_bound
+        self.__upper_bound_type = upper_bound_type
+        self.__allow_nan = allow_nan
+        self.__required_length = required_length
+        self.__match_length_of_argument = match_length_of_argument
+        self.__datatype = datatype
+        self.__allows_lists = allows_lists
+        self.__allow_padding = allow_padding
+        self.__r_formula_usage = r_formula_usage
+        self.__r_default_value = r_default_value
+        self.__target_table = target_table
+        self.__target_table_lang_name = target_table_lang_name
+        self.__check_duplicate = check_duplicate
+        self.__allowed_types = allowed_types
+        self.__allowed_type_groups = allowed_type_groups
+        self.__r_order_num = r_order_num
+        self.__is_output_column = is_output_column
+        self.__alternate_sql_name = alternate_sql_name
+
+        awu_matrix = []
+        awu_matrix.append(["r_order_num", r_order_num, False, int])
+        awu_matrix.append(["datatype", datatype, False, (list, str), True])
+        awu_matrix.append(["default_value", default_value, True, (int, str, bool, float)])
+        awu_matrix.append(["permitted_values", permitted_values, True, (list, str, int, float)])
+        awu_matrix.append(["lower_bound", lower_bound, True, (int, float)])
+        awu_matrix.append(["lower_bound_type", lower_bound_type, True, str, True, ["INCLUSIVE", "EXCLUSIVE"]])
+        awu_matrix.append(["upper_bound", upper_bound, True, (int, float)])
+        awu_matrix.append(["upper_bound_type", upper_bound_type, True, str, True, ["INCLUSIVE", "EXCLUSIVE"]])
+        awu_matrix.append(["allow_nan", allow_nan, True, bool])
+        awu_matrix.append(["allows_lists", allows_lists, True, bool])
+        awu_matrix.append(["match_length_of_argument", match_length_of_argument, True, bool])
+        awu_matrix.append(["required_length", required_length, True, int])
+        awu_matrix.append(["allow_padding", allow_padding, True, bool])
+        awu_matrix.append(["r_formula_usage", r_formula_usage, True, bool])
+        awu_matrix.append(["r_default_value", r_default_value, True, (int, float, str)])
+        awu_matrix.append(["target_table", target_table, True, (list, str)])
+        awu_matrix.append(["target_table_lang_name", target_table_lang_name, True, str])
+        awu_matrix.append(["check_duplicate", check_duplicate, True, bool])
+        awu_matrix.append(["allowed_types", allowed_types, True, (list, str)])
+        awu_matrix.append(["allowed_type_groups", allowed_type_groups, True, (list, str)])
+        awu_matrix.append(["is_output_column", is_output_column, True, bool])
+        awu_matrix.append(["alternate_sql_name", alternate_sql_name, True, (list, str)])
+
+        # Validate argument types.
+        _Validators._validate_function_arguments(awu_matrix)
+
+        # Validate lower bound is greater than upper bound.
+        # _validate_argument_range validates whether lower bound is less than upper bound
+        # or not if argument is None.
+        _Validators._validate_argument_range(
+            arg_name="dummy", arg=None, lbound=self.__lower_bound, ubound=self.__upper_bound)
+
+        # Getters.
+        self.get_r_order_number = lambda: self.__r_order_num
+        self.get_data_type = lambda: self.__datatype
+        self.get_default_value = lambda: self.__default_value
+        self.get_permitted_values = lambda: self.__permitted_values
+        self.get_lower_bound = lambda: self.__lower_bound
+        self.get_lower_bound_type = lambda: self.__lower_bound_type
+        self.get_upper_bound = lambda: self.__upper_bound
+        self.get_upper_bound_type = lambda: self.__upper_bound_type
+        self.is_nan_allowed = lambda: self.__allow_nan
+        self.get_required_length = lambda: self.__required_length
+        self.get_match_length_of_argument = lambda: self.__match_length_of_argument
+        self.is_lists_allowed = lambda: self.__allows_lists
+        self.is_padding_required = lambda: self.__allow_padding
+        self.is_argument_a_formula = lambda: self.__r_formula_usage
+        self.get_r_default_value = lambda: self.__r_default_value
+        self.get_target_table = lambda: self.__target_table
+        self.get_target_table_lang_name = lambda: self.__target_table_lang_name
+        self.check_duplicate = lambda: self.__check_duplicate
+        self.get_allowed_types = lambda: self.__allowed_types
+        self.get_allowed_type_groups = lambda: self.__allowed_type_groups
+        self.is_output_column = lambda: self.__is_output_column
+        self.get_alternate_sql_name = lambda: self.__alternate_sql_name
+        self.is_empty_value_allowed = lambda: not self.is_column_argument()
+
+    def get_python_type(self):
+        """
+        DESCRIPTION:
+            Get equivalent Python type for the JSON datatype for an argument.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            type.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.get_python_type(arg1="string", arg2="db", arg3=2)
+        """
+        py_types = tuple()
+
+        # If multiple datatype's allowed, return the tuple of all allowed python types.
+        if isinstance(self.__datatype, list):
+            for td_type in self.__datatype:
+                py_type = _Dtypes._anly_json_type_to_python_type(td_type)
+
+                # If py_type is not a tuple, convert to a tuple.
+                py_types = py_types + ((py_type, ) if not isinstance(py_type, tuple) else py_type)
+        else:
+            py_type = _Dtypes._anly_json_type_to_python_type(self.__datatype)
+            py_types = py_type if isinstance(py_type, tuple) else (py_type, )
+
+        # If lists are allowed, add list type also.
+        if self.__allows_lists and (list not in py_types):
+            py_types = py_types + (list, )
+
+        return  py_types
+
+    def is_column_argument(self):
+        """
+        DESCRIPTION:
+            Function checks if the argument accepts column as input or not.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.is_column_argument()
+        """
+        # __datatype can be either string or list.
+        if isinstance(self.__datatype, list):
+            datatype = (datatype.lower() for datatype in self.__datatype)
+        else:
+            datatype = self.__datatype.lower()
+        return "column" in datatype
+
+
+class _AnlyFuncArgumentBaseUAF(object):
+    """ Class to hold the basic/common information about all the arguments."""
+    def __init__(self, data_type, description, lang_name, is_required=False):
+        """
+        DESCRIPTION:
+            Constructor for the class.
+
+        PARAMETERS:
+             data_type:
+                 Required Argument.
+                 Specifies the data type an argument can accept.
+                 Type: str
+
+             description:
+                 Required Argument.
+                 Specifies the argument description.
+                 Type: str or List
+
+             lang_name:
+                 Required Argument.
+                 Specifies the name of the argument to be exposed to user.
+                 Type: str
+
+            is_required:
+                Optional Argument.
+                Specifies whether the argument is required or not.
+                Default Value: False
+                Types: bool
+
+        """
+        self.__data_type = data_type
+        self.__description = description
+        self.__lang_name = lang_name
+        self.__is_required = is_required
+
+        # Getters
+        self.get_data_type = lambda: self.__data_type
+        self.get_description = lambda: self.__description
+        self.get_lang_name = lambda: self.__lang_name
+        self.is_required = lambda: self.__is_required
+        self.is_empty_value_allowed = lambda: True
+        self.is_output_column = lambda: False
+        self.get_r_default_value = lambda: None
+
+        # Validation
+        self.__arg_info_matrix = []
+        self.__arg_info_matrix.append(["type", self.__data_type, False, (list, str), True])
+        self.__arg_info_matrix.append(["description", self.__description, False, (list, str)])
+        self.__arg_info_matrix.append(["lang_name", self.__lang_name, False, str])
+        self.__arg_info_matrix.append(["optional", self.__is_required, True, bool])
+
+        _Validators._validate_function_arguments(self.__arg_info_matrix)
+        self.is_empty_value_allowed = lambda: True
+        self.is_output_column = lambda: False
+        self.get_permitted_values = lambda: None
+
+        # Combining list to string.
+        self.__description = ''.join(description)
+
+    def is_column_argument(self):
+        """
+        DESCRIPTION:
+            Function checks if the argument accepts column as input or not.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.is_column_argument()
+        """
+        # __datatype can be either string or list.
+        if isinstance(self.__data_type, list):
+            datatype = (datatype.lower() for datatype in self.__data_type)
+        else:
+            datatype = self.__data_type.lower()
+        return "column" in datatype
+
+    def get_python_type(self):
+        """
+        DESCRIPTION:
+            Get equivalent Python type for the JSON datatype for an argument.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            type.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.get_python_type(arg1="string", arg2="db", arg3=2)
+        """
+        py_types = tuple()
+        supp_data_types = UtilFuncs._as_list(self.__data_type)
+        # If multiple datatype's allowed, return the tuple of all allowed Python types.
+        for td_type in supp_data_types:
+            py_type = _Dtypes._anly_json_type_to_python_type(td_type)
+
+            # If py_type is not a tuple, convert to a tuple.
+            py_types = py_types + ((py_type,) if not isinstance(py_type, tuple) else py_type)
+
+        # If lists are allowed, add list type also.
+        if self.is_lists_allowed() and (list not in py_types):
+            py_types = py_types + (list,)
+        return py_types
+    
+    def set_is_required(self, value):
+        """
+        DESCRIPTION:
+            Setter function to set if argument is required or not.
+
+        RETURNS:
+            None
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.set_is_required(True)
+        """
+        self.__is_required = value
+
+
+class _AnlyFuncInputUAF(_AnlyFuncArgumentBaseUAF):
+    """ Class to hold the information about input argument of UAF."""
+    def __init__(self, data_type, description, lang_name, is_required=False):
+       """
+        DESCRIPTION:
+           Constructor for the class.
+
+        PARAMETERS:
+            data_type:
+                Required Argument.
+                Specifies the data type an input argument can accept.
+                Type: str
+
+            description:
+                Required Argument.
+                Specifies the input argument description.
+                Type: Str or List
+
+            lang_name:
+                Required Argument.
+                Specifies the name of the argument to be exposed to user.
+                Type: str
+
+            is_required:
+                Optional Argument.
+                Specifies whether the argument is required or not.
+                Default Value: False
+                Type: bool
+       """
+
+       # Call Abstract class constructor
+       super().__init__(data_type, description, lang_name, is_required)
+       self.get_default_value = lambda: None
+       self.is_lists_allowed = lambda: False
+
+
+class _AnlyFuncOutputUAF(_AnlyFuncArgumentBaseUAF):
+    """ Class to hold the information about output argument of UAF."""
+    def __init__(self, data_type, description, lang_name, layer_name,
+                 primary_layer=False, result_table_column_types=None, is_required=False):
+        """
+         DESCRIPTION:
+            Constructor for the class.
+
+         PARAMETERS:
+             description:
+                 Required Argument.
+                 Specifies the output argument description.
+                 Type: str or List
+
+             data_type:
+                 Required Argument.
+                 Specifies data type an output argument can accept.
+                 Type: str
+
+             lang_name:
+                 Required Argument.
+                 Specifies the name of the argument to be exposed to user.
+                 Type: str
+
+            primary_layer:
+                 Optional Argument.
+                 Specifies whether the layer is primary or not.
+                 Default Value: False
+                 Type: bool
+
+            layer_name:
+                 Required Argument.
+                 Specifies the name of the output layer.
+                 Type:str
+
+            result_table_column_types:
+                Optional Argument
+                Specifies the column types for the result table.
+                Type: List or str
+
+            is_required:
+                 Optional Argument.
+                 Specifies whether the argument is required or not.
+                 Default Value: False
+                 Type: bool
+        """
+
+        # Call Abstract class constructor
+        super().__init__(data_type, description, lang_name, is_required)
+        # Process other parameters of output table argument.
+        self.__result_table_column_types = result_table_column_types
+        self.__primary_layer = primary_layer
+        self.__layer_name = layer_name
+
+        # Getters
+        self.get_result_table_column_types = lambda: self.__result_table_column_types
+        self.get_primary_layer = lambda : self.__primary_layer
+        self.get_layer_name = lambda : self.__layer_name
+
+        # Validation
+        self.__arg_info_matrix = []
+        self.__arg_info_matrix.append(["result_table_column_types", self.__result_table_column_types, True, (list, str)])
+        self.__arg_info_matrix.append(["primary_layer", self.__primary_layer, True, bool])
+        self.__arg_info_matrix.append(["layer_name", self.__layer_name, False, str])
+        _Validators._validate_function_arguments(self.__arg_info_matrix)
+
+
+class _AnlyFuncArgumentUAF(_AnlyFuncArgumentBaseUAF):
+    """Class to hold the information about the other function parameters."""
+
+    def __init__(self, data_type, description, name, is_required=False, permitted_values=None,
+                 lower_bound=None, upper_bound=None, lower_bound_type=None, upper_bound_type=None,
+                 check_duplicates=False, list_type=None, allow_nan=None, lang_name=None,
+                 default_value=None, required_length=0, nested_param_list=None,
+                 is_nested=False, parent=None, has_nested=False):
+        """
+         DESCRIPTION:
+            Constructor for the class.
+
+         PARAMETERS:
+             description:
+                 Required Argument.
+                 Specifies the argument description.
+                 Type: str or List
+
+             name:
+                 Required Argument.
+                 Specifies the SQL name of the argument.
+                 Type: str
+
+             data_type:
+                 Required Argument.
+                 Specifies the data type for the argument.
+                 Type: str
+
+             is_required:
+                 Optional Argument.
+                 Specifies whether the argument is required or not.
+                 Default Value: False
+                 Types: bool
+
+             permitted_values:
+                Optional Argument.
+                 Specifies the permitted values for the particular argument.
+                 Type: List
+
+             lower_bound:
+                 Optional Argument.
+                 Specifies the lower bound for the particular argument.
+                 Type: int or float
+
+             upper_bound:
+                 Optional Argument.
+                 Specifies the upper bound for the particular argument.
+                 Type: int or float
+
+             lower_bound_type:
+                 Optional Argument.
+                 Specifies whether the lower bound is inclusive or not.
+                 Type: str
+
+             upper_bound_type:
+                 Optional Argument.
+                 Specifies whether the upper bound is inclusive or not.
+                 Type: str
+
+             check_duplicates:
+                 Optional Argument
+                 Specifies if the argument checks for duplicate values.
+                 Type: bool
+
+             list_type:
+                 Optional Argument.
+                 Specifies the type of the list in the argument.
+                 Type: str
+
+            allow_nan:
+                Required Argument.
+                Specifies whether nan values are allowed or not.
+                Type: bool
+
+            is_required:
+                Optional Argument.
+                Specifies whether the argument is required or not .
+                Type: bool
+
+            lang_name:
+                Optional Argument.
+                Specifies the name of the argument to be exposed to user.
+                Type: str
+
+            default_value:
+                Optional Argument.
+                Specifies the default value of the particular argument.
+                Type: int or str or float
+
+            required_length:
+                Optional Argument.
+                Specifies if the list must be the same length as the list specified
+                in argument clause.
+                Types: int
+
+            nested_params_json:
+                Optional Argument.
+                Specifies the json object for nested_params argument.
+                Type: List
+
+            is_nested:
+                Optional Argument.
+                Specifies whether the argument is a nested argument or not.
+                Default Value: False
+                Type: bool
+
+            parent:
+                Optional Argument.
+                Specifies the name of the parent incase of nested argument.
+                Default Value: None
+                Type: str or None
+
+            has_nested:
+                Optional Argument.
+                Specifies whether the argument has nested_params or not.
+                Default Value:False
+                Type: bool
+
+        """
+        # Call Abstract class constructor
+        super().__init__(data_type, description, lang_name, is_required)
+
+        # Process other parameters of arguments.
+        self.__name = name
+        self.__data_type = self.get_data_type()
+        self.__permitted_values = permitted_values
+        self.__default_value = default_value
+        self.__r_default_value = None
+        self.__allow_nan = allow_nan
+        self.__lower_bound = lower_bound
+        self.__upper_bound = upper_bound
+        self.__lower_bound_type = lower_bound_type
+        self.__upper_bound_type = upper_bound_type
+        self.__check_duplicates = check_duplicates
+        self.__required_length = required_length
+        self.__parent = parent
+        self.__is_nested = is_nested
+        self.__has_nested = has_nested
+        self.__allows_lists = False
+        self.__match_length_of_arguments = False
+
+        # Creating a list for nested params
+        self.__nested_param_list = nested_param_list
+
+        # Getters
+        self.get_name = lambda: self.__name
+        self.get_data_type = lambda: self.__data_type
+        self.get_permitted_values = lambda: self.__permitted_values
+        self.get_default_value = lambda: self.__default_value
+        self.get_r_default_value = lambda: self.__r_default_value
+        self.is_nan_allowed = lambda: self.__allow_nan
+        self.get_parent = lambda: self.__parent
+        self.get_lower_bound = lambda: self.__lower_bound
+        self.get_upper_bound = lambda: self.__upper_bound
+        self.get_lower_bound_type = lambda: self.__lower_bound_type
+        self.get_upper_bound_type = lambda: self.__upper_bound_type
+        self.get_check_duplicates = lambda: self.__check_duplicates
+        self.get_required_length = lambda: self.__required_length
+        self.get_nested_param_list = lambda: self.__nested_param_list
+        self.get_is_nested = lambda: self.__is_nested
+        self.get_has_nested = lambda: self.__has_nested
+        self.is_lists_allowed = lambda: self.__allows_lists
+        self.get_match_length_of_arguments = lambda: self.__match_length_of_arguments
+
+        # In order to make it similar to variables of SQLE functions if the data_type is list
+        # we are setting allows_list=True and data_type to the data_type of the list elements.
+        if self.get_data_type() == "list":
+            self.__allows_lists = True
+            self.__data_type = list_type
+
+        # Validation
+        self.__arg_info_matrix = []
+        self.__arg_info_matrix.append(["name", self.__name, True, str])
+        self.__arg_info_matrix.append(["permitted_values", self.__permitted_values, True, list])
+        self.__arg_info_matrix.append(["default_value", self.__default_value, True, (int, str, float, bool, list)])
+        self.__arg_info_matrix.append(["r_default_value", self.__r_default_value, True, (int, str, float, bool, list)])
+        self.__arg_info_matrix.append(["allow_nan", self.__allow_nan, True, bool])
+        self.__arg_info_matrix.append(["lower_bound", self.__lower_bound, True, (int, float)])
+        self.__arg_info_matrix.append(["upper_bound", self.__upper_bound, True, (int, float)])
+        self.__arg_info_matrix.append(["lower_bound_type", self.__lower_bound_type, True, str])
+        self.__arg_info_matrix.append(["upper_bound_type", self.__upper_bound_type, True, str])
+        self.__arg_info_matrix.append(["check_duplicates", self.__check_duplicates, True, bool])
+        self.__arg_info_matrix.append(["list_size", self.__required_length, True, (int, str)])
+
+        _Validators._validate_function_arguments(self.__arg_info_matrix)
+
+        # Validate whether lower bound is less than upper bound.
+        _Validators._validate_argument_range(arg_name="dummy", arg=None, lbound=self.__lower_bound,
+                                             ubound=self.__upper_bound)
+        # Validate whether lower_bound and lower_bound_type are mutually inclusive.
+        _Validators._validate_mutually_inclusive_arguments(lower_bound, "lower_bound", lower_bound_type, "lower_bound_type")
+        # Validate whether upper_bound and upper_bound_type are mutually inclusive.
+        _Validators._validate_mutually_inclusive_arguments(upper_bound, "upper_bound", upper_bound_type, "upper_bound_type")
+
+        # In order to make it similar to variables of SQLE functions, if get_required_length specifies
+        # a value we set match_length_of_arguments which will validate the length of the arguments
+        if not isinstance(self.__required_length, str) and self.get_required_length() > 0:
+            self.__match_length_of_arguments = True
+
+        # If the argument is an int type and permitted values are 0 and 1, then we should consider it as boolean.
+        if "INTEGER" in self.__data_type.upper() and self.__permitted_values is not None\
+                and set(self.__permitted_values) == {0, 1}:
+            self.__data_type = "BOOLEAN"
+            self.__permitted_values = None
+            self.set_is_required(False)
+            if self.__default_value is not None:
+                self.__default_value = bool(self.__default_value)
+            else:
+                self.__r_default_value = False             
+
+    def get_python_type(self):
+        """
+        DESCRIPTION:
+            Get equivalent Python type for the JSON datatype for an argument.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            type.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            self.get_python_type(arg1="string", arg2="db", arg3=2)
+        """
+        py_types = tuple()
+
+        # If multiple datatype's allowed, return the tuple of all allowed python types.
+        if isinstance(self.__data_type, list):
+            for td_type in self.__data_type:
+                py_type = _Dtypes._anly_json_type_to_python_type(td_type)
+
+                # If py_type is not a tuple, convert to a tuple.
+                py_types = py_types + ((py_type,) if not isinstance(py_type, tuple) else py_type)
+        else:
+            py_type = _Dtypes._anly_json_type_to_python_type(self.__data_type)
+            py_types = py_type if isinstance(py_type, tuple) else (py_type,)
+
+        # If lists are allowed, add list type also.
+        if self.__allows_lists and (list not in py_types):
+            py_types = py_types + (list,)
+
         return py_types