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

teradataml/table_operators/Script.py

@@ -431,8 +431,8 @@ class Script(TableOperator):
             from teradataml import list_td_reserved_keywords
             if get_connection():
                 # Checking for reserved keywords and raising error if present.
-                for column_name in self.returns:
-                    list_td_reserved_keywords(key=column_name, raise_error=True)
+                columns = self.returns
+                list_td_reserved_keywords(key=columns, raise_error=True)
 
     def __validate(self):
         """

teradataml/table_operators/TableOperator.py

@@ -16,7 +16,7 @@ import os
 import time
 import uuid
 from math import floor
-import tarfile
+import warnings
 import subprocess
 from pathlib import Path
 import teradataml.dataframe as tdmldf
@@ -1012,18 +1012,24 @@ class TableOperator:
             repr_string = "{}\n\n{}".format(repr_string, self.result)
         return repr_string
 
-    def deploy(self, model_column, partition_columns=None, model_file_prefix=None):
+    def deploy(self, model_column, partition_columns=None, model_file_prefix=None, retry=3,
+               retry_timeout=30):
         """
         DESCRIPTION:
-            Function deploys the model generated after running `execute_script()` in database in
+            Function deploys the models generated after running `execute_script()` in database in
             VantageCloud Enterprise or in user environment in VantageCloud Lake.
             If deployed files are not needed, these files can be removed using `remove_file()` in
-            database or `<user_env>.remove_file()` in lake.
+            database or `UserEnv.remove_file()` in lake.
+
+            Note:
+                If the models (one or many) fail to get deployed in Vantage even after retries,
+                try deploying them again using `install_file()` function or remove installed
+                files using `remove_file()` function.
 
         PARAMETERS:
             model_column:
                 Required Argument.
-                Specifies the column name in which model is present.
+                Specifies the column name in which models are present.
                 Supported types of model in this column are CLOB and BLOB.
                 Note:
                     The column mentioned in this argument should be present in
@@ -1051,11 +1057,27 @@ class TableOperator:
                       with underscore(_) to generate model file names.
                 Types: str
 
+            retry:
+                Optional Argument.
+                Specifies the maximum number of retries to be made to deploy the models.
+                This argument helps in retrying the deployment of models in case of network issues.
+                This argument should be a positive integer.
+                Default Value: 3
+                Types: int
+
+            retry_timeout:
+                Optional Argument. Used along with retry argument. Ignored otherwise.
+                Specifies the time interval in seconds between each retry.
+                This argument should be a positive integer.
+                Default Value: 30
+                Types: int
+
         RETURNS:
             List of generated file identifiers in database or file names in lake.
 
         RAISES:
-            TeradatamlException
+            - TeradatamlException
+            - Throws warning when models failed to deploy even after retries.
 
         EXAMPLES:
             >>> import teradataml
@@ -1139,7 +1161,24 @@ class TableOperator:
              'my_prefix_new__0_11',
              'my_prefix_new__1_10',
              'my_prefix_new__1_11']
-             
+
+            # Example 5: Assuming that 2 model files fail to get installed due to network issues,
+            #            the function retries installing the failed files twice with timeout between
+            #            retries of 10 secs.
+            >>> opt = obj.deploy(model_column="model", model_file_prefix="my_prefix_",
+                                 partition_columns=["partition_column_1", "partition_column_2"],
+                                 retry=2, retry_timeout=10)
+            RuntimeWarning: The following model files failed to get installed in Vantage:
+            ['my_prefix__1_10', 'my_prefix__1_11'].
+            Try manually deploying them from the path '<temp_path>' using:
+                - `install_file()` when connected to Enterprise/On-Prem system or
+                - `UserEnv.install_file()` when connected to Lake system.
+            OR
+            Remove the returned installed files manually using `remove_file()` or `UserEnv.remove_file()`.
+            >>> opt
+            ['my_prefix__0_10',
+             'my_prefix__0_11']
+
             ## Run in VantageCloud Lake using Apply object.
             # Let's assume an user environment named "user_env" already exists in VantageCloud Lake,
             # which will be used for the examples below.
@@ -1168,7 +1207,7 @@ class TableOperator:
                             1                  10   b'abdwcd.....dWIz'
                             1                  11   b'gA4jc4.....agfu'
 
-            # Example 5: Provide both "partition_columns" and "model_file_prefix" arguments.
+            # Example 6: Provide both "partition_columns" and "model_file_prefix" arguments.
             >>> obj.deploy(model_column="model", model_file_prefix="my_prefix_",
                            partition_columns=["partition_column_1", "partition_column_2"])
             ['my_prefix__0_10',
@@ -1183,8 +1222,13 @@ class TableOperator:
         arg_info_matrix.append(["model_column", model_column, False, (str)])
         arg_info_matrix.append(["partition_columns", partition_columns, True, (str, list)])
         arg_info_matrix.append(["model_file_prefix", model_file_prefix, True, (str)])
+        arg_info_matrix.append(["retry", retry, True, (int)])
+        arg_info_matrix.append(["retry_timeout", retry_timeout, True, (int)])
         _Validators._validate_function_arguments(arg_info_matrix)
 
+        _Validators._validate_positive_int(retry, "retry", lbound_inclusive=True)
+        _Validators._validate_positive_int(retry_timeout, "retry_timeout", lbound_inclusive=True)
+
         if self.result is None:
             return "Result is empty. Please run execute_script first."
 
@@ -1212,11 +1256,29 @@ class TableOperator:
         model_column_type = data._td_column_names_and_sqlalchemy_types[model_column.lower()].__class__.__name__
 
         n_models = len(vals)
-        all_files = []
 
         # Default location for .teradataml is user's home directory if configure.local_storage is not set.
         tempdir =  GarbageCollector._get_temp_dir_name()
 
+        def __install_file(model_file, model_file_path):
+            """
+            Function to install the model file in Vantage and return the status.
+            """
+            file_installed = True
+            try:
+                if self.__class__.__name__ == "Script":
+                    from teradataml.dbutils.filemgr import install_file
+                    install_file(file_identifier=model_file, file_path=model_file_path,
+                                is_binary=True, suppress_output=True, replace=True)
+                elif self.__class__.__name__ == "Apply":
+                    self.env.install_file(file_path=model_file_path, suppress_output=True, replace=True)
+            except Exception as e:
+                file_installed = False
+            return file_installed
+
+        installed_files = []
+        failed_files = []
+
         for i, row in enumerate(vals):
             model = row[0]
             partition_values = ""
@@ -1241,15 +1303,39 @@ class TableOperator:
             with open(model_file_path, "wb") as f:
                 f.write(model)
 
-            if self.__class__.__name__ == "Script":
-                from teradataml import install_file
-                install_file(file_identifier=model_file, file_path=model_file_path,
-                             is_binary=True, suppress_output=True)
-            elif self.__class__.__name__ == "Apply":
-                self.env.install_file(file_path=model_file_path)
-
-            all_files.append(model_file)
+            file_installed = __install_file(model_file, model_file_path)
 
-            os.remove(model_file_path)
-
-        return all_files
+            if file_installed:
+                installed_files.append(model_file)
+                os.remove(model_file_path)
+            else:
+                # File failed to get installed in Vantage. Hence, keeping the file in tempdir.
+                failed_files.append(model_file)
+
+        while retry and failed_files:
+            # If there are any failed files and retry is not zero, retry installing the failed files.
+            time.sleep(retry_timeout)
+            retry_failed_files = []
+            for model_file in failed_files:
+                model_file_path = os.path.join(tempdir, model_file)
+                file_installed = __install_file(model_file, model_file_path)
+
+                if file_installed:
+                    installed_files.append(model_file)
+                    os.remove(model_file_path)
+                else:
+                    # File failed to get installed in Vantage. Hence, keeping the file in tempdir.
+                    retry_failed_files.append(model_file)
+            failed_files = retry_failed_files
+            retry -= 1
+
+        if failed_files:
+            failed_files.sort()
+            warning_message = "The following model files failed to get installed in Vantage:\n" + str(failed_files) + ".\n"
+            warning_message += "Try manually deploying them from the path '" + tempdir + "' using:\n"
+            warning_message += "    - `install_file()` when connected to Enterprise/On-Prem system or\n"
+            warning_message += "    - `UserEnv.install_file()` when connected to Lake system.\n"
+            warning_message += "OR\nRemove the returned installed files manually using `remove_file()` or `UserEnv.remove_file()`."
+            warnings.warn(RuntimeWarning(warning_message))
+
+        return installed_files

teradataml/table_operators/query_generator.py

@@ -481,6 +481,9 @@ class QueryGenerator:
             return configure.read_nos_function_mapping.upper()
         elif "WriteNOS".lower() == function_name.lower():
             return configure.write_nos_function_mapping.upper()
+        # If Table Operator function is IMAGE2MATRIX, then return alias name as TD_IMAGE2MATRIX.
+        elif "IMAGE2MATRIX".lower() == function_name.lower():
+            return "TD_IMAGE2MATRIX"
             
         engine_name = UtilFuncs._get_engine_name(self._engine)
 

teradataml/table_operators/table_operator_query_generator.py

@@ -231,7 +231,9 @@ class TableOperatorQueryGenerator(QueryGenerator):
             using_clause = ""
             # If the function is a NOS function, then USING clause is needed.
             if self._function_name.lower() in [configure.write_nos_function_mapping.lower(),
-                                               configure.read_nos_function_mapping.lower()]: 
+                                               configure.read_nos_function_mapping.lower(),
+                                               "td_image2matrix"
+                                               ]: 
                 using_clause = "USING"
             invocation_sql = "{0}\n\t{1}{2}".format(invocation_sql, using_clause, self.__OTHER_ARG_CLAUSE)
 

teradataml/table_operators/table_operator_util.py

@@ -9,8 +9,7 @@
 # Description: Utilities for Table Operators.                      #
 #                                                                  #
 # ##################################################################
-
-import os
+import os, json
 import teradataml.dataframe as tdmldf
 from teradataml.common.constants import TableOperatorConstants, \
     TeradataConstants, OutputStyle
@@ -24,7 +23,8 @@ from teradataml.scriptmgmt.lls_utils import get_env
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
 from functools import partial
-from inspect import isfunction
+from inspect import isfunction, getsource
+from pathlib import Path
 
 
 class _TableOperatorUtils:
@@ -281,12 +281,20 @@ class _TableOperatorUtils:
             self.__validate()
         """
         # Validate the user defined function.
-        if not (isfunction(self.user_function) or
-                isinstance(self.user_function, partial)):
-            raise TypeError(Messages.get_message(
-                MessageCodes.UNSUPPORTED_DATATYPE, 'user_function',
-                "'function' or 'functools.partial'")
-            )
+
+        if self.operation in [TableOperatorConstants.UDF_OP.value,\
+                              TableOperatorConstants.REGISTER_OP.value]:
+            for udf_function in self.user_function:
+                if not isfunction(udf_function):
+                    raise TypeError(Messages.get_message(
+                        MessageCodes.UNSUPPORTED_DATATYPE, 'user_function', "'function'"))
+        else:
+            if not (isfunction(self.user_function) or
+                    isinstance(self.user_function, partial)):
+                raise TypeError(Messages.get_message(
+                    MessageCodes.UNSUPPORTED_DATATYPE, 'user_function',
+                    "'function' or 'functools.partial'")
+                )
 
         if arg_info_matrix is None:
             arg_info_matrix = []
@@ -324,20 +332,30 @@ class _TableOperatorUtils:
         EXAMPLES:
             self.__create_user_script()
         """
-        # Generate script name and alias, and add entry to a Garbage Collector.
-        # script_entry is the string that is added to Garbage collector.
-        # It has the format "<databasename>"."<file_id>".
-        self.script_entry, self.script_alias, self.script_name, self.script_base_name = self.__get_script_name()
-
-        # Get the converters to use with pandas.read_csv, and to correctly
-        # typecast the numeric data.
-        python_input_col_types = [UtilFuncs._teradata_type_to_python_type(col.type)
-                                  for col in self.data._metaexpr.c]
-        input_converters = UtilFuncs._get_pandas_converters(python_input_col_types)
-
-        python_output_col_types = [UtilFuncs._teradata_type_to_python_type(type_)
-                                   for type_ in list(self.returns.values())]
-        output_converters = UtilFuncs._get_pandas_converters(python_output_col_types)
+        # If operation is register, then generate script name based on the
+        # user function name and return type.
+        # It has the format "tdml_udf_name_<registered_name>_udf_type_<return_type>_register.py"
+        if self.operation == TableOperatorConstants.REGISTER_OP.value:
+            registered_name = list(self.returns.keys())[0]
+            return_type = self.returns[registered_name]
+            self.script_name = "tdml_udf_name_{}_udf_type_{}_register.py".format(registered_name, return_type)
+            self.script_base_name = Path(self.script_name).stem
+        else:
+            # Generate script name and alias, and add entry to a Garbage Collector.
+            # script_entry is the string that is added to Garbage collector.
+            # It has the format "<databasename>"."<file_id>".
+            self.script_entry, self.script_alias, self.script_name, self.script_base_name = self.__get_script_name()
+
+        if self.operation not in [TableOperatorConstants.UDF_OP.value, TableOperatorConstants.REGISTER_OP.value]:
+            # Get the converters to use with pandas.read_csv, and to correctly
+            # typecast the numeric data.
+            python_input_col_types = [UtilFuncs._teradata_type_to_python_type(col.type)
+                                    for col in self.data._metaexpr.c]
+            input_converters = UtilFuncs._get_pandas_converters(python_input_col_types)
+
+            python_output_col_types = [UtilFuncs._teradata_type_to_python_type(type_)
+                                    for type_ in list(self.returns.values())]
+            output_converters = UtilFuncs._get_pandas_converters(python_output_col_types)
 
         # Create script in .teradataml directory.
         script_dir = GarbageCollector._get_temp_dir_name()
@@ -349,37 +367,61 @@ class _TableOperatorUtils:
                             os.path.dirname(os.path.abspath(__file__))),
                                             "table_operators",
                                             "templates")
-
-        template_name = TableOperatorConstants.APPLY_TEMPLATE.value if \
-            self.operation == TableOperatorConstants.APPLY_OP.value else TableOperatorConstants.MAP_TEMPLATE.value
+        # Get the template.
+        template = {TableOperatorConstants.APPLY_OP.value: TableOperatorConstants.APPLY_TEMPLATE.value,
+                    TableOperatorConstants.UDF_OP.value: TableOperatorConstants.UDF_TEMPLATE.value,
+                    TableOperatorConstants.REGISTER_OP.value: TableOperatorConstants.REGISTER_TEMPLATE.value                    }
+        template_name = template.get(self.operation, TableOperatorConstants.MAP_TEMPLATE.value)
         # Write to the script based on the template.
         try:
             with open(os.path.join(template_dir, template_name), 'r') as input_file:
                 with open(self.script_path, 'w') as output_file:
-                    output_file.write(
-                        input_file.read().format(
-                            DELIMITER=UtilFuncs._serialize_and_encode(
-                                self.delimiter),
-                            STO_OPERATION=UtilFuncs._serialize_and_encode(
-                                self.operation),
-                            USER_DEF_FUNC=UtilFuncs._serialize_and_encode(
-                                self.user_function),
-                            DF_COL_NAMES_LIST=UtilFuncs._serialize_and_encode(
-                                self.data.columns),
-                            DF_COL_TYPES_LIST=UtilFuncs._serialize_and_encode(
-                                python_input_col_types),
-                            OUTPUT_COL_NAMES_LIST=UtilFuncs._serialize_and_encode(
-                                list(self.returns.keys())),
-                            OUTPUT_CONVERTERS=UtilFuncs._serialize_and_encode(
-                                output_converters),
-                            QUOTECHAR=UtilFuncs._serialize_and_encode(
-                                self.quotechar),
-                            INPUT_CONVERTERS=UtilFuncs._serialize_and_encode(
-                                input_converters),
-                            CHUNK_SIZE=UtilFuncs._serialize_and_encode(
-                                self.chunk_size)
+                    if self.operation == TableOperatorConstants.UDF_OP.value:
+                        
+                        user_function_code = UtilFuncs._func_to_string(self.user_function)
+                        output_file.write(input_file.read().format(
+                            DELIMITER=self.delimiter,
+                            QUOTECHAR=self.quotechar,
+                            FUNCTION_DEFINITION=user_function_code,
+                            FUNCTION_ARGS =str(self.function_args),
+                            INPUT_COLUMNS=json.dumps(self.data.columns),
+                            OUTPUT_COLUMNS=json.dumps(list(self.returns.keys())),
+                            COLUMNS_DEFINITIONS=json.dumps(self.columns_definitions),
+                            OUTPUT_TYPE_CONVERTERS=json.dumps(self.output_type_converters)
+                        ))
+                    elif self.operation == TableOperatorConstants.REGISTER_OP.value:
+                        # Get the source code of the user function.
+                        user_function_code = UtilFuncs._func_to_string(self.user_function)
+                        output_file.write(input_file.read().format(
+                            FUNCTION_DEFINITION=user_function_code,
+                            FUNCTION_NAME = self.user_function[0].__name__
+                        ))   
+                    else:
+                        # prepare script file from template file for maprow and mappartition.
+                        output_file.write(
+                            input_file.read().format(
+                                DELIMITER=UtilFuncs._serialize_and_encode(
+                                    self.delimiter),
+                                STO_OPERATION=UtilFuncs._serialize_and_encode(
+                                    self.operation),
+                                USER_DEF_FUNC=UtilFuncs._serialize_and_encode(
+                                    self.user_function),
+                                DF_COL_NAMES_LIST=UtilFuncs._serialize_and_encode(
+                                    self.data.columns),
+                                DF_COL_TYPES_LIST=UtilFuncs._serialize_and_encode(
+                                    python_input_col_types),
+                                OUTPUT_COL_NAMES_LIST=UtilFuncs._serialize_and_encode(
+                                    list(self.returns.keys())),
+                                OUTPUT_CONVERTERS=UtilFuncs._serialize_and_encode(
+                                    output_converters),
+                                QUOTECHAR=UtilFuncs._serialize_and_encode(
+                                    self.quotechar),
+                                INPUT_CONVERTERS=UtilFuncs._serialize_and_encode(
+                                    input_converters),
+                                CHUNK_SIZE=UtilFuncs._serialize_and_encode(
+                                    self.chunk_size)
+                            )
                         )
-                    )
         except Exception:
             # We may end up here if the formatting of the templating to create
             # the user script fails.
@@ -410,9 +452,11 @@ class _TableOperatorUtils:
         """
         try:
             if self.operation in [TableOperatorConstants.MAP_ROW_OP.value,
-                                  TableOperatorConstants.MAP_PARTITION_OP.value]:
+                                  TableOperatorConstants.MAP_PARTITION_OP.value] or \
+                                  (self.operation == TableOperatorConstants.UDF_OP.value and self.exec_mode == 'IN-DB'):
                 return self.__execute_script_table_operator()
-            elif self.operation == TableOperatorConstants.APPLY_OP.value:
+            elif self.operation == TableOperatorConstants.APPLY_OP.value or \
+                (self.operation == TableOperatorConstants.UDF_OP.value and self.exec_mode == 'REMOTE'):
                 return self.__execute_apply_table_operator()
         except Exception:
             raise
@@ -450,7 +494,6 @@ class _TableOperatorUtils:
         script_name = script_alias  # alias now contains extension also.
 
         # Extract the base name without extension.
-        from pathlib import Path
         script_base_name = Path(script_alias).stem
         return script_entry, script_alias, script_name, script_base_name
 
@@ -572,8 +615,9 @@ class _TableOperatorUtils:
         if self.exec_mode.upper() == TableOperatorConstants.REMOTE_EXEC.value:
             # If not test mode, execute the script using Apply table operator.
             try:
-                # If APPLY, get environment and use it for installing file.
-                if self.operation == TableOperatorConstants.APPLY_OP.value:
+                # If APPLY or UDF, get environment and use it for installing file.
+                if self.operation in [TableOperatorConstants.APPLY_OP.value,
+                                      TableOperatorConstants.UDF_OP.value]:
                     self.__env.install_file(self.script_path, suppress_output=True)
 
                 # Execute the script.
@@ -617,13 +661,15 @@ class _TableOperatorUtils:
                         suppress_output=True)
 
         # For apply, remove file from remote user environment.
-        if self.operation == TableOperatorConstants.APPLY_OP.value:
+        if self.operation == TableOperatorConstants.APPLY_OP.value or \
+            (self.operation == TableOperatorConstants.UDF_OP.value and self.exec_mode == 'REMOTE'):
             self.__env.remove_file(self.script_name, suppress_output=True)
 
         # Remove the entry from Garbage Collector
         if self.operation in [TableOperatorConstants.MAP_ROW_OP.value,
                               TableOperatorConstants.MAP_PARTITION_OP.value,
-                              TableOperatorConstants.APPLY_OP.value]:
+                              TableOperatorConstants.APPLY_OP.value,
+                              TableOperatorConstants.UDF_OP.value]:
             GarbageCollector._delete_object_entry(
                 object_to_delete=self.script_entry,
                 object_type=TeradataConstants.TERADATA_SCRIPT,

teradataml/table_operators/templates/dataframe_register.template

@@ -0,0 +1,69 @@
+import json
+import sys, csv
+import datetime
+import urllib.parse
+
+td_buffer = {{}}
+
+
+{FUNCTION_DEFINITION}
+
+# Decode the URL encoded string and store it back as dictionary.
+dec = urllib.parse.unquote_plus(sys.argv[1])
+script_data = json.loads(dec)
+
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+delimiter = script_data["delimiter"]
+#  The quotechar to use.
+quotechar = script_data["qoutechar"]
+#  The names of columns in the input teradataml DataFrame.
+_input_columns = script_data["input_cols"]
+#  The names of columns in the output teradataml DataFrame.
+_output_columns = script_data["output_cols"]
+#  The types of columns in the input/output teradataml DataFrame.
+# The mapper of output column name to function arguments
+function_args = script_data["function_args"]
+#  The definition for new columns in output.
+columns_definitions = {{_output_columns[-1]: "{FUNCTION_NAME}"}}
+output_type_converters = script_data["output_type_converters"]
+for k,v in output_type_converters.items():
+    if v == 'datetime.date' or v == 'datetime.time' or v == 'datetime.datetime':
+        output_type_converters[k] = 'str'
+output_type_converters = {{k:getattr(__builtins__, v) for k,v in output_type_converters.items()}}
+
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+
+    records = csv.reader(sys.stdin.readlines(), delimiter=delimiter, quotechar=quotechar)
+    for record in records:
+        record = dict(zip(_input_columns, record))
+        out_rec = []
+        for column in _output_columns:
+
+            # If it is a new column, get the value from definition.
+            if column in columns_definitions:
+                f_args = tuple()
+                # Convert the argument types first.
+                for v in function_args[column]:
+                    if v in _input_columns:
+                        c_type_ = output_type_converters.get(v)
+                        if record[v]:
+                            # If it is a float, replace the empty character.
+                            if c_type_.__name__ == 'float':
+                                arg = output_type_converters.get(v)(record[v].replace(' ', ''))
+                            else:
+                                arg = output_type_converters.get(v)(record[v])
+                        else:
+                            arg = record[v]
+                    else:
+                        arg = v
+                    f_args = f_args + (arg, )
+                func_ = globals()[columns_definitions[column]]
+                out_rec.append(output_type_converters[column](func_(*f_args)))
+            else:
+                out_rec.append(record[column])
+
+        print("{{}}".format(delimiter).join((str(i) for i in out_rec)))

teradataml/table_operators/templates/dataframe_udf.template

@@ -0,0 +1,63 @@
+import sys, csv
+import datetime
+
+td_buffer = {{}}
+
+
+{FUNCTION_DEFINITION}
+
+function_args = {FUNCTION_ARGS}
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+delimiter = "{DELIMITER}"
+#  The names of columns in the input teradataml DataFrame.
+_input_columns = {INPUT_COLUMNS}
+#  The names of columns in the output teradataml DataFrame.
+_output_columns = {OUTPUT_COLUMNS}
+#  The definition for new columns in output.
+columns_definitions = {COLUMNS_DEFINITIONS}
+#  The types of columns in the input/output teradataml DataFrame.
+output_type_converters = {OUTPUT_TYPE_CONVERTERS}
+for k,v in output_type_converters.items():
+    if v == 'datetime.date' or v == 'datetime.time' or v == 'datetime.datetime':
+        output_type_converters[k] = 'str'
+output_type_converters = {{k:getattr(__builtins__, v) for k,v in output_type_converters.items()}}
+#  The quotechar to use.
+quotechar = "{QUOTECHAR}"
+if quotechar == "None":
+    quotechar = None
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+
+    records = csv.reader(sys.stdin.readlines(), delimiter=delimiter, quotechar=quotechar)
+    for record in records:
+        record = dict(zip(_input_columns, record))
+        out_rec = []
+        for column in _output_columns:
+
+            # If it is a new column, get the value from definition.
+            if column in columns_definitions:
+                f_args = tuple()
+                # Convert the argument types first.
+                for v in function_args[column]:
+                    if v in _input_columns:
+                        c_type_ = output_type_converters.get(v)
+                        if record[v]:
+                            # If it is a float, replace the empty character.
+                            if c_type_.__name__ == 'float':
+                                arg = output_type_converters.get(v)(record[v].replace(' ', ''))
+                            else:
+                                arg = output_type_converters.get(v)(record[v])
+                        else:
+                            arg = record[v]
+                    else:
+                        arg = v
+                    f_args = f_args + (arg, )
+                func_ = globals()[columns_definitions[column]]
+                out_rec.append(output_type_converters[column](func_(*f_args)))
+            else:
+                out_rec.append(record[column])
+
+        print("{{}}".format(delimiter).join((str(i) for i in out_rec)))

teradataml/telemetry_utils/queryband.py

@@ -0,0 +1,52 @@
+from functools import wraps
+from teradatasqlalchemy.telemetry.queryband import QueryBand, collect_queryband as tdsqlalchemy_collect_queryband
+
+
+# Create a global variable to manage querybands for teradataml package.
+global session_queryband
+session_queryband = QueryBand()
+
+
+def collect_queryband(*qb_deco_pos_args, **qb_deco_kwargs):
+    """
+    DESCRIPTION:
+        Decorator for calling collect_queryband decorator in telemetry utility
+        in teradatasqlalchemy using session_queryband object and other positional
+        and keyword arguments expected by collect_queryband.
+
+    PARAMETERS:
+        qb_deco_pos_args:
+            Optional Argument.
+            Specifies the positional arguments accepted by collect_queryband
+            decorator in telemetry utility in teradatasqlalchemy.
+
+        qb_deco_kwargs:
+            Optional Argument.
+            Specifies the keyword arguments accepted by collect_queryband
+            decorator in telemetry utility in teradatasqlalchemy.
+
+    EXAMPLES:
+        >>> from teradataml.telemetry_utils.queryband import collect_queryband
+        # Example 1: Collect queryband for a standalone function.
+        @collect_queryband(queryband="CreateContext")
+        def create_context(host = None, username ...): ...
+
+        # Example 2: Collect queryband for a class method and use
+        #            class attribute to retrive queryband string.
+        @collect_queryband(attr="func_name")
+        def _execute_query(self, persist=False, volatile=False):...
+
+        # Example 3: Collect queryband for a class method and use
+        #            method of same class to retrive queryband string.
+        @collect_queryband(method="get_class_specific_queryband")
+        def _execute_query(self, persist=False, volatile=False):...
+    """
+    def outer_wrapper(func):
+        @wraps(func)
+        def inner_wrapper(*func_args, **func_kwargs):
+            # Pass the required argument 'session_queryband' along with other
+            # expected arguments to collect_queryband() decorator which is
+            # imported as tdsqlalchemy_collect_queryband.
+            return tdsqlalchemy_collect_queryband(session_queryband, *qb_deco_pos_args, **qb_deco_kwargs)(func)(*func_args, **func_kwargs)
+        return inner_wrapper
+    return outer_wrapper