teradataml 20.0.0.1__py3-none-any.whl → 20.0.0.3__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, DataFrame
+from teradataml.dbutils.dbutils import _create_table, db_drop_table, list_td_reserved_keywords
+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))
@@ -332,6 +343,17 @@ class _AnlyticFunctionExecutor:
                 self._func_output_args.append(temp_table_name)
                 self._function_output_table_map[lang_name] = temp_table_name
 
+    def _get_column_name_from_feature(self, obj):
+        # Extract the associated column name from Feature.
+        from teradataml.store.feature_store.feature_store import Feature
+        if isinstance(obj, Feature):
+            return obj.column_name
+
+        if isinstance(obj, list):
+            return [self._get_column_name_from_feature(col) for col in obj]
+
+        return obj
+
     def _process_other_argument(self, **kwargs):
         """
         DESCRIPTION:
@@ -428,6 +450,9 @@ class _AnlyticFunctionExecutor:
 
             self._validate_analytic_function_argument(arg_name, arg_value, argument)
 
+            # Extract column names if it is a Feature.
+            arg_value = self._get_column_name_from_feature(arg_value)
+
             # Perform the checks which are specific to argument(_AnlyFuncArgument) type.
             # Check lower bound and upper bound for number type of arguments.
             if isinstance(arg_value, (int, float)):
@@ -463,6 +488,12 @@ class _AnlyticFunctionExecutor:
                 # does not require special case handler.
                 arg_value = self._spl_func_obj._add_square_bracket(arg_value)
 
+                # Handling special case for Teradata reserved keywords or column names with spaces.
+                # If argument is a string or list of strings, then add quotes to the string.
+                if arg_name not in ["partition_columns"] and (\
+                    UtilFuncs._contains_space(arg_value) or list_td_reserved_keywords(arg_value)):
+                    arg_value = UtilFuncs._teradata_quote_arg(arg_value, "\"", False)          
+
             # SequenceInputBy arguments require special processing.
             if 500 <= argument.get_r_order_number() <= 510:
                 quoted_value = UtilFuncs._teradata_collapse_arglist(arg_value, "")
@@ -524,6 +555,17 @@ class _AnlyticFunctionExecutor:
             return repr_string
         self._dyn_cls_data_members["__repr__"] = print_result
 
+        def copy(self, **args):
+            """ Function to copy the ART to another table."""
+            from teradataml import CopyArt
+            params = {
+                "data": self.result,
+                "database_name": args.get("database_name", None),
+                "table_name": args.get("table_name", None),
+                "map_name": args.get("map_name", None),
+                "persist": args.get("persist", False)}
+            return CopyArt(**params)
+
         query = self.sqlmr_query
         build_time = None if self.__build_time is None else round(self.__build_time, 2)
 
@@ -533,6 +575,7 @@ class _AnlyticFunctionExecutor:
         # To list attributes using dict()
         self._dyn_cls_data_members["__dict__"] = self._dyn_cls_data_members
         self._dyn_cls_data_members["_mlresults"] = self._mlresults
+        self._dyn_cls_data_members["copy"] = copy
 
         # Dynamic class creation with In-DB function name.
         indb_class = type(self.func_name, (object,), self._dyn_cls_data_members)
@@ -678,6 +721,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]]
@@ -688,6 +732,14 @@ class _AnlyticFunctionExecutor:
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.CANNOT_USE_TOGETHER_WITH, "persist", "volatile"),
                 MessageCodes.CANNOT_USE_TOGETHER_WITH)
+        
+        # If function is VectorDistance and largereference_input is set to True,
+        # then set data_partition_column to PartitionKind.DIMENSION and
+        # reference_data_partition_column to PartitionKind.ANY .
+        if self.func_name == "VectorDistance" and \
+            kwargs.get("largereference_input", False):
+            kwargs['target_data_partition_column'] = PartitionKind.DIMENSION
+            kwargs['reference_data_partition_column'] = PartitionKind.ANY
 
         self._dyn_cls_data_members.update(kwargs)
         
@@ -709,6 +761,11 @@ class _AnlyticFunctionExecutor:
         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
+        elif self.func_name in ['CopyArt']:
+            # CopyArt function take care of persisting the result table internally
+            # through 'permanent_table' argument.
+            persist = False
+            volatile = False
 
         if not skip_output_arg_processing:
             self._process_output_argument(**kwargs)
@@ -716,13 +773,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 +1560,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 +1577,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 +1605,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 +2008,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 +2019,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 +2039,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 +2118,206 @@ 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)
+
+        # 'CopyArt' function requires 'SRC_DATABASENMAE' and 'SRC_TABLENAME' as input arguments.
+        # Extract the database and table name from the 'data' argument and add them to the
+        # '_func_other_args' dictionary.
+        if self.func_name == "CopyArt":
+            data = kwargs.get('data', None)
+            argument_info = ["data", data, False, (DataFrame), True]
+            # 'data' is a required argument for 'CopyArt' function to get the source table name and database name.
+            _Validators._validate_missing_required_arguments([argument_info])
+            # 'data' should be a DataFrame.
+            _Validators._validate_function_arguments([argument_info])
+
+            # Add the 'SRC_DATABASENMAE' and 'SRC_TABLENAME' to the '_func_other_args' dictionary.
+            self._func_other_args["SRC_DATABASENMAE"] = "'{0}'".format(UtilFuncs._extract_db_name(data._table_name))
+            self._func_other_args["SRC_TABLENAME"] = "'{0}'".format(UtilFuncs._extract_table_name(data._table_name))
+
+            # Setting permanent_table to True if 'persist' is set to True, else False.
+            kwargs['permanent_table'] = 'True' if kwargs.get('persist', False) else 'False'
+
+            # Setting 'map_name' to empty string if not provided.
+            if kwargs.get('map_name', None) is None:
+                kwargs['map_name'] = ""
+
+            # CopyArt does not take 'data' as input argument.
+            kwargs.pop('data')
+
+        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():
+            # For 'CopyArt' function, the result should be the destination table name and database name provided as input.
+            if self.func_name == "CopyArt":
+                out_table_name = kwargs.get('table_name')
+                out_db_name = kwargs.get('database_name')
+            else:
+                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)
@@ -1178,10 +1179,19 @@ class _AnlyFuncMetadata:
             # from teradataml.data.docs.<function_type>.<doc_dir_with_version_info>.<func_name>
             # import <func_name>
             func_module = __import__(("teradataml.data.docs.{}.{}.{}".
-                                      format(function_type, doc_dir, self.func_name)),
-                                     fromlist=[self.func_name])
-            return getattr(func_module, self.func_name).__doc__
+                                    format(function_type, doc_dir, self.func_name)),
+                                    fromlist=[self.func_name])
+            return getattr(func_module, self.func_name).__doc__   
         except:
+            # For db_version 20.00, if function type is sqle, then check for docs_17_20 directory.
+            if version_dir == '20.00' and function_type == 'sqle':
+                try:
+                    func_module = __import__(("teradataml.data.docs.{}.{}.{}".
+                                             format(function_type, "docs_17_20", self.func_name)),
+                                             fromlist=[self.func_name])
+                    return getattr(func_module, self.func_name).__doc__
+                except:
+                    pass
             return ("Refer to Teradata Package for Python Function Reference guide for "
                     "Documentation. Reference guide can be found at: https://docs.teradata.com ."
                     "Refer to the section with Database version: {}".format(self.__database_version))

teradataml/analytics/json_parser/utils.py

@@ -54,7 +54,6 @@ def _get_json_data_from_tdml_repo():
     # both versions are matched, then the json store has data available so no need
     # to parse again.
     if configure.database_version != _JsonStore.version:
-
         # Json store version is different from database version. So, json's should
         # be parsed again. Before parsing the json, first clean the json store.
         _JsonStore.clean()
@@ -171,9 +170,15 @@ def __get_json_files_directory():
         if func_info.value["lowest_version"]:
             # 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():
+                # If function type is SQLE and db_version is 20.00, then add 17.20 JSON directory.
+                if func_type_json_version[func_info.value["func_type"]] == '20.00' and  \
+                   func_info.value["func_type"] == 'sqle':
+                    yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
+                                                         version='17.20'),
+                                                         func_info.name]
                 yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
-                                                    version=func_type_json_version[func_info.value["func_type"]]),
-                       func_info.name]
+                                                     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 +242,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 +561,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