teradataml 20.0.0.0__py3-none-any.whl → 20.0.0.2__py3-none-any.whl

teradataml/analytics/analytic_function_executor.py

@@ -14,11 +14,11 @@ File implements classes for following:
     * _TableOperatorExecutor
     * _BYOMFunctionExecutor
 """
-
+from collections import OrderedDict
 from teradataml.options.configure import configure
 from teradataml.common.constants import TeradataConstants, TeradataAnalyticFunctionTypes
 from teradataml.analytics.json_parser import PartitionKind
-from teradataml.analytics.analytic_query_generator import AnalyticQueryGenerator, UAFQueryGenerator
+from teradataml.analytics.analytic_query_generator import AnalyticQueryGenerator, UAFQueryGenerator, StoredProcedureQueryGenerator
 from teradataml.analytics.json_parser.json_store import _JsonStore
 from teradataml.analytics.utils import FuncSpecialCaseHandler
 from teradataml.options.display import display
@@ -28,8 +28,11 @@ from teradataml.common.messages import Messages, MessageCodes
 from teradataml.common.wrapper_utils import AnalyticsWrapperUtils
 from teradataml.common.utils import UtilFuncs
 from teradataml.context.context import _get_context_temp_databasename
+from teradataml.dataframe.dataframe import in_schema
+from teradataml.dbutils.dbutils import _create_table, db_drop_table
+from teradatasqlalchemy.types import *
 from teradataml.table_operators.table_operator_query_generator import TableOperatorQueryGenerator
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 from teradataml.utils.dtypes import _ListOf
 from teradataml.utils.validators import _Validators
 
@@ -86,6 +89,9 @@ class _AnlyticFunctionExecutor:
         # Initialize FuncSpecialCaseHandler.
         self._spl_func_obj = FuncSpecialCaseHandler(self.func_name)
 
+        # Initialize database object type.
+        self.db_object_type = TeradataConstants.TERADATA_VIEW
+
     @staticmethod
     def _validate_analytic_function_argument(func_arg_name, func_arg_value, argument, additional_valid_types=None):
         """
@@ -152,7 +158,7 @@ class _AnlyticFunctionExecutor:
         _Validators._validate_function_arguments([argument_info])
 
     @collect_queryband(attr="func_name")
-    def _execute_query(self, persist=False, volatile=False):
+    def _execute_query(self, persist=False, volatile=False, display_table_name=True):
         """
         DESCRIPTION:
             Function to execute query on Vantage.
@@ -169,6 +175,13 @@ class _AnlyticFunctionExecutor:
                 Specifies whether to create a volatile table or not.
                 Default Value: False
                 Type: bool
+            
+            display_table_name:
+                Optional Argument.
+                Specifies whether to display the table names or not when 
+                persist is set to True.
+                Default Value: True
+                Type: bool
 
         RETURNS:
             None
@@ -178,7 +191,7 @@ class _AnlyticFunctionExecutor:
 
         EXAMPLES:
             self._execute_query()
-        """
+        """        
         # Generate STDOUT table name and add it to the output table list.
         func_params = self._get_generate_temp_table_params(persist=persist, volatile=volatile)
         sqlmr_stdout_temp_tablename = UtilFuncs._generate_temp_table_name(**func_params)
@@ -203,7 +216,8 @@ class _AnlyticFunctionExecutor:
             else:
                 self._function_output_table_map["result"] = sqlmr_stdout_temp_tablename
 
-            if persist:
+            # Print the table/view names if display_table_name is set to True.
+            if persist and display_table_name:
                 # SQL is executed. So, print the table/view names.
                 for output_attribute, table_name in self._function_output_table_map.items():
                     print("{} data stored in table '{}'".format(output_attribute, table_name))
@@ -248,25 +262,18 @@ class _AnlyticFunctionExecutor:
             self._get_generate_temp_table_params(True, True)
         """
         use_default_database = True
-        db_object_type = TeradataConstants.TERADATA_VIEW
         prefix = "td_sqlmr_out_"
         gc_on_quit = True
 
-        # If function produces output tables, i.e., function has output table arguments,
-        # the 'db_object_type' should be "table" or if analytic function does not support
-        # reading from a view created on output, then 'db_object_type' should be "table".
-        if len(self._metadata.output_tables) > 0 or not self._metadata._is_view_supported:
-            db_object_type = TeradataConstants.TERADATA_TABLE
-
-        # If result is to be persisted or if the table is a volaile table then, db_object_type
-        # should be "table" and it must not be Garbage collected.
+        # If result is to be persisted or if the table is a volaile table then,
+        # it must not be Garbage collected.
         if persist or volatile:
             gc_on_quit = False
-            db_object_type = TeradataConstants.TERADATA_TABLE
             prefix = "td_sqlmr_{}_out_".format("persist" if persist else "volatile")
+            use_default_database = False if volatile else True
 
         return {"use_default_database": use_default_database,
-                "table_type": db_object_type,
+                "table_type": self.db_object_type,
                 "prefix": prefix,
                 "gc_on_quit": gc_on_quit}
 
@@ -682,6 +689,7 @@ class _AnlyticFunctionExecutor:
         start_time = time.time()
         persist = kwargs.get("persist", False)
         volatile = kwargs.get("volatile", False)
+        display_table_name = kwargs.get("display_table_name", True)
 
         # Validate local_order_column argument type and values.
         arg_info_matrix = [["persist", persist, True, bool], ["volatile", volatile, True, bool]]
@@ -694,23 +702,53 @@ class _AnlyticFunctionExecutor:
                 MessageCodes.CANNOT_USE_TOGETHER_WITH)
 
         self._dyn_cls_data_members.update(kwargs)
-
+        
+        # If function produces output tables, i.e., function has output table arguments,
+        # then 'db_object_type' should be "table" or if analytic function does not support
+        # reading from a view created on output, then 'db_object_type' should be "table".
+        # If result is to be persisted or if the table is a volaile table then, db_object_type
+        # should be "table" else it should be "view".
+        self.db_object_type = (
+            TeradataConstants.TERADATA_VOLATILE_TABLE if volatile
+            else TeradataConstants.TERADATA_TABLE if len(self._metadata.output_tables) > 0 \
+                or not self._metadata._is_view_supported or persist 
+            else TeradataConstants.TERADATA_VIEW
+        )
         if not skip_input_arg_processing:
             self._process_input_argument(**kwargs)
 
+        # check func_name is GLM  and data_partition_column, data_hash_column, local_order_data are passed
+        if self.func_name in ['GLM', 'TDGLMPredict'] and \
+            any(key in kwargs for key in ['data_partition_column', 'data_hash_column', 'local_order_data']):
+            skip_output_arg_processing = True
+
         if not skip_output_arg_processing:
             self._process_output_argument(**kwargs)
 
         if not skip_other_arg_processing:
             self._process_other_argument(**kwargs)
 
-        self._generate_query(volatile=volatile)
+        # When Analytic function is executed it stores the result in _function_output_table_map['result'].
+        # If we want to skip the query execution of the function then we need to pass result table in '_result_data'.
 
-        # Print SQL-MR query if requested to do so.
-        if display.print_sqlmr_query:
-            print(self.sqlmr_query)
+        # Execute the query only if the '_result_data' is not passed as an argument in kwargs.
+        # Otherwise, store the result table in _function_output_table_map.
+        if kwargs.get("_result_data", None) is None:
+            self._generate_query(volatile=volatile)
 
-        self._execute_query(persist, volatile)
+            # Print SQL-MR query if requested to do so.
+            if display.print_sqlmr_query:
+                print(self.sqlmr_query)
+
+            self._execute_query(persist, volatile, display_table_name)
+        else:
+            # This is useful when we already have the result table and 
+            # need to pass function result as an object to another function 
+            # without executing the function again.
+
+            # Store the result table in map.
+            self._function_output_table_map["result"] = kwargs.pop("_result_data")
+            self._dyn_cls_data_members['result'] = self._dyn_cls_data_members.pop('_result_data')
 
         if not skip_func_output_processing:
             self._process_function_output(**kwargs)
@@ -856,22 +894,34 @@ class _SQLEFunctionExecutor(_AnlyticFunctionExecutor):
         EXAMPLES:
             self._get_input_args()
         """
+        sort_order = list(kwargs.keys())
+        input_table_dict = {}
+
         for _inp_attribute in self._metadata.input_tables:
             input_table_arg = _inp_attribute.get_lang_name()
-            yield input_table_arg, _inp_attribute
 
-            # Check if SQLE function allows multiple values as input.
+            # Store the first argument directly into the dictionary
+            input_table_dict[input_table_arg] = _inp_attribute
+
+            # Check if SQL function allows multiple values as input.
             if _inp_attribute.allows_lists():
                 _index = 1
                 while True:
                     _input_table_arg = "{}{}".format(input_table_arg, _index)
-                    # If the corresponding object is available in kwargs, then extract it.
-                    # Otherwise, stop looking for multiple arguments and proceed for next attribute.
                     if _input_table_arg in kwargs:
-                        yield _input_table_arg, _inp_attribute
-                        _index = _index + 1
+                        input_table_dict[_input_table_arg] = _inp_attribute
+                        _index += 1
                     else:
                         break
+        
+        # For ColumnTransformer, yield the input arguments in the order they are passed.
+        if self.func_name == "ColumnTransformer":
+            for key in sort_order:
+                if key in input_table_dict:
+                    yield key, input_table_dict[key]
+        else:
+            for key in input_table_dict:
+                yield key, input_table_dict[key]
 
     def _process_input_argument(self, **kwargs):
         """
@@ -1465,7 +1515,7 @@ class _TableOperatorExecutor(_SQLEFunctionExecutor):
 
 class _UAFFunctionExecutor(_SQLEFunctionExecutor):
     """ Class to hold the attributes and provide methods to enable execution for UAF Functions. """
-    def __init__(self, func_name):
+    def __init__(self, func_name, func_type = TeradataAnalyticFunctionTypes.UAF.value):
         """
         DESCRIPTION:
             Constructor for the class.
@@ -1482,7 +1532,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
         EXAMPLES:
              _UAFFunctionExecutor("ArimaEstimate")
         """
-        super().__init__(func_name, TeradataAnalyticFunctionTypes.UAF.value)
+        super().__init__(func_name, func_type)
         self._func_other_args = {}
         self._func_input_fmt_arguments = {}
         self._func_output_fmt_arguments = {}
@@ -1510,6 +1560,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
         EXAMPLES:
             self._generate_query()
         """
+
         query_generator = UAFQueryGenerator(function_name=self._metadata.sql_function_name,
                                             func_input_args=self._func_input_args,
                                             func_input_filter_expr_args=self._func_input_filter_expr_args,
@@ -1707,14 +1758,17 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
             self._get_generate_temp_table_params(True, True)
         """
         prefix = "td_uaf_out_"
-
+        gc_on_quit = True
         # If result is to be persisted then, it must not be Garbage collected.
-        gc_on_quit = False if persist or volatile else True
+        if persist or volatile:
+            gc_on_quit = False
+            prefix = "td_uaf_{}_out_".format("persist" if persist else "volatile")
 
-        return {"table_type": TeradataConstants.TERADATA_TABLE,
+        return {"table_type": self.db_object_type,
                 "prefix": prefix,
                 "gc_on_quit": gc_on_quit,
-                "databasename": output_db if output_db else _get_context_temp_databasename()}
+                "databasename": output_db if output_db else _get_context_temp_databasename(
+                    table_type=self.db_object_type)}
 
     def _process_output_argument(self, **kwargs):
         """
@@ -1762,7 +1816,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
             # If database name is not provided by user, get the default database name
             # else use user provided database name.
             db_name = output_db_name if output_db_name is not None else \
-                _get_context_temp_databasename()
+                _get_context_temp_databasename(table_type=self.db_object_type)
 
             # Get the fully qualified table name.
             table_name = "{}.{}".format(UtilFuncs._teradata_quote_arg(db_name,
@@ -1909,7 +1963,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
                                                   **kwargs))
 
     @collect_queryband(attr="func_name")
-    def _execute_query(self, persist=False, volatile=None):
+    def _execute_query(self, persist=False, volatile=None, display_table_name=True):
         """
         DESCRIPTION:
             Function to execute query on Vantage.
@@ -1920,6 +1974,13 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
                 Specifies whether to persist a table or not.
                 Default Value: False
                 Type: bool
+            
+            display_table_name:
+                Optional Argument.
+                Specifies whether to display the table names or not when 
+                persist is set to True.
+                Default Value: True
+                Type: bool
 
         RETURNS:
             None
@@ -1933,9 +1994,10 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
         try:
             # Execute already generated query.
             UtilFuncs._execute_query(query=self.sqlmr_query)
-
-            if persist:
-                # SQL is already executed. So, print the table names.
+            
+            # Print the table/view names if display_table_name is set to True.
+            if persist and display_table_name:
+                # SQL is executed. So, print the table/view names.
                 for output_attribute, table_name in self._function_output_table_map.items():
                     print("{} data stored in table '{}'".format(output_attribute, table_name))
 
@@ -2011,3 +2073,176 @@ class _BYOMFunctionExecutor(_SQLEFunctionExecutor):
 
         # Invoke call to SQL-MR generation.
         self.sqlmr_query = self.__aqg_obj._gen_sqlmr_select_stmt_sql()
+
+class _StoredProcedureExecutor(_UAFFunctionExecutor):
+    """
+    Class to hold the attributes and provide methods to enable execution for Stored Procedures.
+    As the stored procedure JSONs are written like UAF Functions we will use
+    _UAFFunctionExecutor as the base class.
+    """
+    def __init__(self, func_name):
+        """
+        DESCRIPTION:
+            Constructor for the class.
+
+        PARAMETERS:
+            func_name:
+                Required Argument.
+                Specifies the name of the analytic function, which is exposed to the user.
+                Types: str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            _StoredProcedureExecutor("FilterFactory1d")
+        """
+        super().__init__(func_name, TeradataAnalyticFunctionTypes.STORED_PROCEDURE.value)
+        self._func_other_args = OrderedDict()
+
+    def _generate_query(self, volatile=False):
+        """
+        DESCRIPTION:
+            Function to generate the SQL query for Stored Procedures.
+
+        PARAMETERS:
+            volatile:
+                Optional Argument.
+                Specifies whether to create a volatile table or not.
+                Default Value: False
+                Type: bool
+
+        RETURNS:
+            None.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self._generate_query()
+        """
+        # update the db_name.
+        db_name = None
+        if configure.stored_procedure_install_location is not None:
+            db_name = configure.stored_procedure_install_location
+
+        self.__aqg_obj = StoredProcedureQueryGenerator(function_name=self._metadata.sql_function_name,
+                                                       func_other_args_values=self._func_other_args,
+                                                       db_name=db_name)
+
+        # Invoke call to SQL-MR generation.
+        self.sqlmr_query = self.__aqg_obj._gen_call_stmt()
+
+    def _process_other_argument(self, **kwargs):
+        """
+        DESCRIPTION:
+           Internal function to process the arguments.
+           1. The function does the following:
+              * Checks the required arguments are passed or not.
+              * Checks the type of the arguments are expected or not.
+              * Checks for permitted values.
+              * Checks for empty string.
+              * If validations run fine,
+                then returns a dict with the SQL name of the argument as key
+                and user provided value as the value {arg_sql_name : value}
+
+        PARAMETERS:
+
+            kwargs:
+                Specifies the keyword arguments passed to a function.
+
+        RETURNS:
+            None.
+
+        RAISES:
+            ValueError OR TypeError OR TeradataMlException.
+
+        EXAMPLES:
+            self._process_other_arguments(argument, arg1="string", arg2="db", arg3=2)
+
+        """
+        ## As the function 'FilterFactory1d' requries the output table to be created before the stored procedure call,
+        ## creating it and adding them as parameters as stored procedure requires them
+
+        if self.func_name == "FilterFactory1d":
+            columns_to_create = {"ID": INTEGER,
+                                 "row_i": INTEGER,
+                                 "FilterMag": FLOAT,
+                                 "description": VARCHAR}
+
+            schema_name = UtilFuncs._extract_db_name(self._func_output_args)
+            table_name = UtilFuncs._extract_table_name(self._func_output_args)
+
+            _create_table(table_name=table_name,
+                          columns=columns_to_create,
+                          schema_name=schema_name,
+                          primary_index=["ID", "row_i"])
+            self._func_other_args['database_name'] = UtilFuncs._teradata_quote_arg(schema_name, "\'", False)
+            self._func_other_args['table_name'] = UtilFuncs._teradata_quote_arg(table_name, "\'", False)
+
+        for argument in self._metadata.arguments:
+            sql_name = argument.get_name()
+            lang_name = argument.get_lang_name()
+            arg_value = kwargs.get(lang_name)
+            # Set the "argument".
+            self._spl_func_obj.set_arg_name(argument)
+            # Let's get spl handler if function requires.
+            special_case_handler = self._spl_func_obj._get_handle()
+
+            self._validate_analytic_function_argument(lang_name, arg_value, argument)
+            # As stored procedures require the argument to passed in positional order and
+            # NULL is required for arguments which are not present
+            if arg_value is None:
+                self._func_other_args[sql_name] = 'NULL'
+
+            # If argument is not None add the sql_name and arg_value to the dict.
+            else:
+                # If get_match_length_of_arguments is True, check if the arg_value is
+                # a list and of the required size.
+                if argument.get_match_length_of_arguments():
+                    required_length = argument.get_required_length()
+                    if (isinstance(arg_value, list) and len(arg_value) != required_length) or\
+                       (not isinstance(arg_value, list)):
+                        raise TeradataMlException(Messages.get_message(
+                                                  MessageCodes.INVALID_LIST_LENGTH).format(lang_name,
+                                                                                           required_length),
+                                                  MessageCodes.INVALID_LIST_LENGTH)
+
+                # Perform the checks which are specific to argument(_AnlyFuncArgument) type.
+                # Check lower bound and upper bound for numeric arguments.
+                if isinstance(arg_value, (int, float)):
+                    lower_bound_inclusive = argument.get_lower_bound_type() == "INCLUSIVE"
+                    upper_bound_inclusive = argument.get_upper_bound_type() == "INCLUSIVE"
+                    _Validators._validate_argument_range(arg_value,
+                                                         lang_name,
+                                                         lbound=argument.get_lower_bound(),
+                                                         ubound=argument.get_upper_bound(),
+                                                         lbound_inclusive=lower_bound_inclusive,
+                                                         ubound_inclusive=upper_bound_inclusive)
+
+                # If the argument is a bool type, convert it to integer since SQL do
+                # not know boolean processing.
+                if bool in argument.get_python_type() and isinstance(arg_value, bool):
+                    arg_value = int(arg_value)
+
+                # Handle special cases for "arg_values" based on handling method.
+                arg_value = special_case_handler(arg_value) if special_case_handler is not None else arg_value
+                self._func_other_args[sql_name] = arg_value
+
+
+    def _process_function_output(self, **kwargs):
+        """
+        DESCRIPTION:
+          Internal function to process the function output.
+        """
+        for lang_name, table_name in self._function_output_table_map.items():
+            out_table_name = UtilFuncs._extract_table_name(table_name)
+            out_db_name = UtilFuncs._extract_db_name(table_name)
+            df = self._awu._create_data_set_object(
+                df_input=out_table_name, database_name=out_db_name, source_type="table")
+            self._dyn_cls_data_members[lang_name] = df
+            # Condition make sure that the first element always be result or output in _mlresults.
+            if lang_name in ["output", "result"]:
+                self._mlresults.insert(0, df)
+            else:
+                self._mlresults.append(df)

teradataml/analytics/analytic_query_generator.py

@@ -956,3 +956,95 @@ class UAFQueryGenerator:
                                                                 sql,
                                                                 on_preserve_clause)
         return sql
+
+
+class StoredProcedureQueryGenerator:
+    """
+    This class creates a SQL-MR object, which can be used to generate
+    Stored Procedure Query Generator in FFE syntax for Teradata.
+    """
+
+    def __init__(self, function_name,
+                 func_other_args_values,
+                 db_name="SYSLIB"):
+        """
+        StoredProcedureQueryGenerator constructor, to create query for Stored Procedures.
+
+        PARAMETERS:
+            function_name:
+                Required Argument.
+                Specifies the name of the function.
+
+            func_other_args_values:
+                Required Argument.
+                Specifies a dict in the format: {'sql_name':'value'}.
+
+            db_name:
+                Optional Argument.
+                Specifies the install location of Stored Procedures.
+                Default Value: SYSLIB
+
+        RETURNS:
+            StoredProcedureQueryGenerator object.
+
+        EXAMPLES:
+            aqg_obj = StoredProcedureQueryGenerator(function_name, other_sql_args, db_name="mldb")
+        """
+        self.__function_name = function_name
+
+        # If the db_name is provided, append it to the stored
+        # procedure function name.
+        self.__db_name = db_name
+        if self.__db_name:
+            self.__function_name = "\"{}\".{}".format(self.__db_name,
+                                                      self.__function_name)
+
+        self.__func_other_args_values = func_other_args_values
+        self.__CALL_STMT_FMT = "Call {}({})"
+        self.__QUERY_SIZE = self.__get_string_size(self.__CALL_STMT_FMT) + 20
+
+
+    def __generate_sqlmr_func_other_arg_sql(self):
+        """
+        Private function to generate a SQL clause for other function arguments.
+        For Example, two paramater values of {a:False, b:"BINOMIAL"} are
+        appened like: False, "BINOMIAL", in the same order.
+
+        RETURNS:
+            SQL string for other function arguments, as shown in example here.
+
+        EXAMPLES:
+            __func_other_args_values = {"a":False, "b":"BINOMIAL"}
+            other_arg_sql = self.__generate_sqlmr_func_other_arg_sql()
+            # Output is as shown in example in description.
+
+        """
+        args_sql_str = ','.join(map(str, self.__func_other_args_values.values()))
+        self.__QUERY_SIZE = self.__QUERY_SIZE + self.__get_string_size(args_sql_str)
+        return args_sql_str
+
+    def _gen_call_stmt(self):
+        """
+        Protected function to generate complete  query.
+        For Example,
+            CALL SYSLIB.TD_FILTERFACTORY1D ('test', 'filters', 33, 'lowpass', 'blackman', NULL, 20.0, 40.0, NULL, 200, NULL);
+
+        PARAMETERS:
+
+        RETURNS:
+            A SQL-MR/Analytical query, as shown in example here.
+
+        RAISES:
+
+        EXAMPLES:
+            aqg_obj = StoredProcedureQueryGenerator(function_name=self._metadata.sql_function_name,
+                                                    func_other_args_values=self._func_other_args,
+                                                    db_name=db_name)
+            anly_query = aqg_obj._gen_sqlmr_select_stmt_sql()
+            # Output is as shown in example in description.
+
+        """
+        return self.__CALL_STMT_FMT.format(self.__function_name, self.__generate_sqlmr_func_other_arg_sql())
+
+    def __get_string_size(self, string):
+        return len(string.encode("utf8"))

teradataml/analytics/byom/__init__.py

@@ -2,7 +2,7 @@ from teradataml.analytics.byom.H2OPredict import H2OPredict
 from teradataml.analytics.byom.PMMLPredict import PMMLPredict
 
 from teradataml.analytics.meta_class import _AnalyticFunction
-from teradataml.analytics.meta_class import _common_init
+from teradataml.analytics.meta_class import _common_init, _common_dir
 
 _byom_functions = ['H2OPredict', 'PMMLPredict', 'ONNXPredict', 'DataikuPredict', 'DataRobotPredict']
 
@@ -12,4 +12,5 @@ for func in _byom_functions:
                                                **kwargs: _common_init(self,
                                                                       'byom',
                                                                       **kwargs),
-                            "__doc__": _AnalyticFunction.__doc__})
+                            "__doc__": _AnalyticFunction.__doc__,
+                            "__dir__": _common_dir})

teradataml/analytics/json_parser/metadata.py

@@ -111,6 +111,7 @@ class _AnlyFuncMetadata:
                                        TeradataAnalyticFunctionTypes.TABLEOPERATOR.value,
                                        TeradataAnalyticFunctionTypes.UAF.value,
                                        TeradataAnalyticFunctionTypes.BYOM.value,
+                                       TeradataAnalyticFunctionTypes.STORED_PROCEDURE.value,
                                        None]])
         arg_info_matrix.append(["json_file", json_file, False, str, True])
         _Validators._validate_function_arguments(arg_info_matrix)