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

teradataml/README.md

@@ -16,6 +16,118 @@ Copyright 2024, Teradata. All Rights Reserved.
 * [License](#license)
 
 ## Release Notes:
+#### teradataml 20.00.00.02
+
+* teradataml will no longer be supported with SQLAlchemy < 2.0.
+* teradataml no longer shows the warnings from Vantage by default. 
+  * Users should set `display.suppress_vantage_runtime_warnings` to `False` to display warnings.
+
+* ##### New Features/Functionality
+  * ##### teradataml: SQLE Engine Analytic Functions
+    * New Analytics Database Analytic Functions:
+      * `TFIDF()`
+      * `Pivoting()`
+      * `UnPivoting()`
+    * New Unbounded Array Framework(UAF) Functions:
+      * `AutoArima()`
+      * `DWT()`
+      * `DWT2D()`
+      * `FilterFactory1d()`  
+      * `IDWT()`
+      * `IDWT2D()`
+      * `IQR()`
+      * `Matrix2Image()`
+      * `SAX()`
+      * `WindowDFFT()`
+  * ###### teradataml: Functions
+      * `udf()` - Creates a user defined function (UDF) and returns ColumnExpression.
+      * `set_session_param()` is added to set the database session parameters. 
+      * `unset_session_param()` is added to unset database session parameters.
+  
+  * ###### teradataml: DataFrame
+      * `materialize()` - Persists DataFrame into database for current session.
+      * `create_temp_view()` - Creates a temporary view for session on the DataFrame.
+
+  * ###### teradataml DataFrameColumn a.k.a. ColumnExpression
+      * _Date Time Functions_
+        * `DataFrameColumn.to_timestamp()` - Converts string or integer value to a TIMESTAMP data type or TIMESTAMP WITH TIME ZONE data type.
+        * `DataFrameColumn.extract()` - Extracts date component to a numeric value.
+        * `DataFrameColumn.to_interval()` - Converts a numeric value or string value into an INTERVAL_DAY_TO_SECOND or INTERVAL_YEAR_TO_MONTH value.
+      * _String Functions_
+        * `DataFrameColumn.parse_url()` - Extracts a part from a URL.
+      * _Arithmetic Functions_
+        * `DataFrameColumn.log` - Returns the logarithm value of the column with respect to 'base'.
+
+  * ##### teradataml: AutoML
+      * New methods added for `AutoML()`, `AutoRegressor()` and `AutoClassifier()`:
+        * `evaluate()` - Performs evaluation on the data using the best model or the model of users choice
+          from the leaderboard.
+        * `load()`: Loads the saved model from database.
+        * `deploy()`: Saves the trained model inside database.
+        * `remove_saved_model()`: Removes the saved model in database.
+        * `model_hyperparameters()`: Returns the hyperparameter of fitted or loaded models.
+
+* ##### Updates
+  * ##### teradataml: AutoML
+    * `AutoML()`, `AutoRegressor()`
+      * New performance metrics added for task type regression i.e., "MAPE", "MPE", "ME", "EV", "MPD" and "MGD".
+    * `AutoML()`, `AutoRegressor()` and `AutoClassifier`
+      * New arguments added: `volatile`, `persist`.
+      * `predict()` - Data input is now mandatory for generating predictions. Default model 
+      evaluation is now removed.
+  * `DataFrameColumn.cast()`: Accepts 2 new arguments `format` and `timezone`.
+  * `DataFrame.assign()`: Accepts ColumnExpressions returned by `udf()`.
+
+  * ##### teradataml: Options
+    * `set_config_params()`
+      * Following arguments will be deprecated in the future:
+        * `ues_url`
+        * `auth_token`
+
+  * ###### Database Utility
+      * `list_td_reserved_keywords()` - Accepts a list of strings as argument.
+
+  * ##### Updates to existing UAF Functions:
+    * `ACF()` - `round_results` parameter removed as it was used for internal testing.
+    * `BreuschGodfrey()` - Added default_value 0.05 for parameter `significance_level`.
+    * `GoldfeldQuandt()` - 
+      * Removed parameters  `weights` and `formula`.
+        Replaced parameter `orig_regr_paramcnt` with `const_term`.
+        Changed description for parameter `algorithm`. Please refer document for more details.
+      * Note: This will break backward compatibility.
+    * `HoltWintersForecaster()` - Default value of parameter `seasonal_periods` removed.
+    * `IDFFT2()` - Removed parameter `output_fmt_row_major` as it is used for internal testing.
+    * `Resample()` - Added parameter `output_fmt_index_style`.
+
+* ##### Bug Fixes
+  * KNN `predict()` function can now predict on test data which does not contain target column.
+  * Metrics functions are supported on the Lake system.
+  * The following OpensourceML functions from different sklearn modules are fixed.
+    * `sklearn.ensemble`:
+      * ExtraTreesClassifier - `apply()`
+      * ExtraTreesRegressor - `apply()`
+      * RandomForestClassifier - `apply()`
+      * RandomForestRegressor - `apply()`
+    * `sklearn.impute`:
+      * SimpleImputer - `transform()`, `fit_transform()`, `inverse_transform()`
+      * MissingIndicator - `transform()`, `fit_transform()`
+    * `sklearn.kernel_approximations`:
+      * Nystroem - `transform()`, `fit_transform()`
+      * PolynomialCountSketch - `transform()`, `fit_transform()`
+      * RBFSampler - `transform()`, `fit_transform()`
+    * `sklearn.neighbours`:
+      * KNeighborsTransformer - `transform()`, `fit_transform()`
+      * RadiusNeighborsTransformer - `transform()`, `fit_transform()`
+    * `sklearn.preprocessing`:
+      * KernelCenterer - `transform()`
+      * OneHotEncoder - `transform()`, `inverse_transform()`
+  * OpensourceML returns teradataml objects for model attributes and functions instead of sklearn
+    objects so that the user can perform further operations like `score()`, `predict()` etc on top
+    of the returned objects.
+  * AutoML `predict()` function now generates correct ROC-AUC value for positive class.
+  * `deploy()` method of `Script` and `Apply` classes retries model deployment if there is any 
+    intermittent network issues.
+
 #### teradataml 20.00.00.01
 * teradataml no longer supports Python versions less than 3.8.
 

teradataml/__init__.py

@@ -64,7 +64,10 @@ from teradataml.opensource import *
 # Import AutoML
 from teradataml.automl import AutoML, AutoRegressor, AutoClassifier
 
-
-# Configure app name and app version for querybands
-from teradatasqlalchemy.telemetry.queryband import session_queryband
+# Import global variable representing session_queryband.
+from teradataml.telemetry_utils.queryband import session_queryband
+# Configure app name and app version for teradataml querybands.
 session_queryband.configure_queryband_parameters(app_name="TDML", app_version=__version__)
+
+# Import functions.
+from teradataml.dataframe.functions import *

teradataml/_version.py

@@ -8,4 +8,4 @@
 # 
 # ################################################################## 
 
-version = "20.00.00.01"
+version = "20.00.00.02"

teradataml/analytics/__init__.py

@@ -22,7 +22,7 @@ from .Transformations import Binning, Derive, OneHotEncoder, FillNa, LabelEncode
     Retain, Sigmoid, ZScore
 from teradataml.analytics.json_parser.utils import _get_json_data_from_tdml_repo, _process_paired_functions
 from teradataml.analytics.analytic_function_executor import _SQLEFunctionExecutor, _TableOperatorExecutor,\
-    _UAFFunctionExecutor, _BYOMFunctionExecutor
+    _UAFFunctionExecutor, _BYOMFunctionExecutor, _StoredProcedureExecutor
 from teradataml.common.constants import TeradataAnalyticFunctionTypes
 
 
@@ -76,6 +76,7 @@ def _get_executor_class_name(function_type):
         TeradataAnalyticFunctionTypes.SQLE.value: _SQLEFunctionExecutor,
         TeradataAnalyticFunctionTypes.TABLEOPERATOR.value: _TableOperatorExecutor,
         TeradataAnalyticFunctionTypes.UAF.value: _UAFFunctionExecutor,
-        TeradataAnalyticFunctionTypes.BYOM.value: _BYOMFunctionExecutor
+        TeradataAnalyticFunctionTypes.BYOM.value: _BYOMFunctionExecutor,
+        TeradataAnalyticFunctionTypes.STORED_PROCEDURE.value: _StoredProcedureExecutor
     }
     return func_type_to_executor.get(function_type.upper(), _SQLEFunctionExecutor).__name__

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
 
@@ -155,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.
@@ -172,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
@@ -206,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))
@@ -678,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]]
@@ -716,13 +728,27 @@ class _AnlyticFunctionExecutor:
         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'.
+
+        # 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)
 
-        # Print SQL-MR query if requested to do so.
-        if display.print_sqlmr_query:
-            print(self.sqlmr_query)
+            # Print SQL-MR query if requested to do so.
+            if display.print_sqlmr_query:
+                print(self.sqlmr_query)
 
-        self._execute_query(persist, volatile)
+            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)
@@ -1489,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.
@@ -1506,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 = {}
@@ -1534,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,
@@ -1936,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.
@@ -1947,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
@@ -1960,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))
 
@@ -2038,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)

teradataml/analytics/json_parser/utils.py

@@ -172,7 +172,7 @@ def __get_json_files_directory():
             # Check if current function type is allowed on connected Vantage version or not.
             if func_info.value["func_type"] in func_type_json_version.keys():
                 yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
-                                                    version=func_type_json_version[func_info.value["func_type"]]),
+                                                     version=func_type_json_version[func_info.value["func_type"]]),
                        func_info.name]
         else:
             yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info), func_info.name]
@@ -237,7 +237,7 @@ def _process_paired_functions():
     """
 
     json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
-    with open(json_path) as fp:
+    with open(json_path, encoding="utf8") as fp:
         _json = json.load(fp)
 
     _available_functions, _ = _JsonStore._get_function_list()
@@ -556,8 +556,10 @@ class _KNNPredict:
                   "train_data": self.train_data,
                   "input_columns": self.input_columns,
                   "response_column": kwargs.get("response_column", self.response_column),
-                  "accumulate": kwargs.get("accumulate", kwargs.get("response_column", self.response_column)
-                                if getattr(self.obj, "accumulate") is None else self.accumulate)}
+                  # Retrieve the accumulate value from kwargs if available.
+                  # otherwise, no accumulation will occur.
+                  "accumulate": kwargs.get("accumulate")
+                  }
 
         # KNN works in a different way. predict calls the same function with test data along with
         # the arguments passed to the actual function. The above parameters are required