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

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,16 +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 `execute_script()` in database or user
-            environment in lake.
+            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 `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
@@ -1049,13 +1057,31 @@ 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 names.
+            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
+            >>> from teradataml import load_example_data
             >>> load_example_data("openml", "multi_model_classification")
 
             >>> df = DataFrame("multi_model_classification")
@@ -1073,12 +1099,16 @@ class TableOperator:
             -0.615226 -0.546472  0.017496 -0.488720      0            12                   0                  10
              0.579671 -0.573365  0.160603  0.014404      0             9                   1                  10
 
+            ## Run in VantageCloud Enterprise using Script object.
             # Install Script file.
             >>> file_location = os.path.join(os.path.dirname(teradataml.__file__), "data", "scripts", "deploy_script.py")
             >>> install_file("deploy_script", file_location, replace=True)
 
+            >>> execute_sql("SET SESSION SEARCHUIFDBPATH = <db_name>;")
+
             # Variables needed for Script execution.
-            >>> script_command = '/opt/teradata/languages/Python/bin/python3 ./ALICE/deploy_script.py'
+            >>> from teradataml import configure
+            >>> script_command = f'{configure.indb_install_location} ./<db_name>/deploy_script.py enterprise'
             >>> partition_columns = ["partition_column_1", "partition_column_2"]
             >>> columns = ["col1", "col2", "col3", "col4", "label",
                            "partition_column_1", "partition_column_2"]
@@ -1104,10 +1134,10 @@ class TableOperator:
             #            is auto generated.
             >>> obj.deploy(model_column="model",
                            partition_columns=["partition_column_1", "partition_column_2"])
-            >>> ['model_file_1710436227163427__0_10',
-                 'model_file_1710436227163427__1_10',
-                 'model_file_1710436227163427__0_11',
-                 'model_file_1710436227163427__1_11']
+            ['model_file_1710436227163427__0_10',
+             'model_file_1710436227163427__1_10',
+             'model_file_1710436227163427__0_11',
+             'model_file_1710436227163427__1_11']
             
             # Example 2: Provide only "model_file_prefix" argument. Here, filenames are suffixed 
             #            with 1, 2, 3, ... for multiple models.
@@ -1131,15 +1161,74 @@ 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.
+
+            # ApplyTableOperator returns BLOB type for model column as per deploy_script.py.
+            >>> returns = OrderedDict([("partition_column_1", INTEGER()),
+                                       ("partition_column_2", INTEGER()),
+                                       ("model", BLOB())])
+
+            # Install the script file which returns model and partition columns.
+            >>> user_env.install_file(file_location)
+
+            >>> script_command = 'python3 deploy_script.py lake'
+            >>> obj = Apply(data=df.select(columns),
+                            script_command=script_command,
+                            data_partition_column=partition_columns,
+                            returns=returns,
+                            env_name="user_env"
+                            )
+
+            >>> opt = obj.execute_script()
+            >>> opt
+            partition_column_1  partition_column_2               model                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    model
+                            0                  10   b'gAejc1.....drIr'
+                            0                  11   b'gANjcw.....qWIu'
+                            1                  10   b'abdwcd.....dWIz'
+                            1                  11   b'gA4jc4.....agfu'
+
+            # 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',
+             'my_prefix__0_11',
+             'my_prefix__1_10',
+             'my_prefix__1_11']
+
+            # Other examples are similar to the examples provided for VantageCloud Enterprise.
         """
 
         arg_info_matrix = []
         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."
 
@@ -1167,7 +1256,28 @@ 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]
@@ -1178,7 +1288,7 @@ class TableOperator:
                 partition_values = str(i+1)
 
             model_file = f"{model_file_prefix}_{partition_values}"
-            model_file_path = os.path.join(os.path.expanduser("~"), ".teradataml", model_file)
+            model_file_path = os.path.join(tempdir, model_file)
 
             if model_column_type == "CLOB":
                 import base64
@@ -1193,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_name=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/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,7 @@ 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
 
 
 class _TableOperatorUtils:
@@ -281,12 +280,19 @@ 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 == TableOperatorConstants.UDF_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 = []
@@ -349,37 +355,73 @@ 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}
+        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:
+
+                        # Function can have udf as decorator. Remove that.
+                        # The below notation
+                            # @udf
+                            # def to_upper(s):
+                            #     return s.upper()
+                            # Then source code will be as it is.
+                        # But if below notation is used,
+                            # f = udf(to_upper)
+                            # Then source code will not have udf.
+                        # So, remove first line if it comes with first notation.
+                        # For both notations if in starting function defination have any extra space. Remove that.
+                        # If multiple UDF's are there append them as a single string.
+                        
+                        user_function_code = ""
+                        for udf_code in self.user_function:
+                            udf_code = getsource(udf_code)
+                            udf_code = udf_code.lstrip()
+                            if udf_code.startswith("@"):
+                                udf_code = udf_code[udf_code.find("\n")+1: ].lstrip()
+                            user_function_code += udf_code + '\n'
+
+                        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)
+                        ))
+                    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
@@ -572,8 +616,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 +662,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_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

teradataml/utils/validators.py

@@ -170,7 +170,7 @@ class _Validators:
                 Required Argument.
                 Specifies the name or list of names of columns to be validated
                 for existence.
-                Types: str or List of strings
+                Types: str or List of strings or ColumnExpression or list of ColumnExpression
 
             arg_name:
                 Required Argument.
@@ -204,7 +204,15 @@ class _Validators:
         df_columns = UtilFuncs._all_df_columns(column_expression)
 
         # Let's validate existence of each column one by one.
-        for column_name in columns:
+        columns_ = []
+        for column in columns:
+            if isinstance(column, str):
+                columns_.append(column)
+            else:
+                columns_ = columns_ + UtilFuncs._all_df_columns(column)
+
+        # Let's validate existence of each column one by one.
+        for column_name in columns_:
             # If column name does not exist in DataFrame of a column, raise the exception.
             if column_name not in df_columns:
                 message = "{}. Check the argument '{}'".format(sorted(df_columns), arg_name)
@@ -1652,7 +1660,7 @@ class _Validators:
 
         # Check whether table exists on the system or not.
         table_exists = conn.dialect.has_table(conn, table_name=table_name,
-                                              schema=schema_name)
+                                              schema=schema_name, table_only=True)
 
         # If tables exists, return True.
         if table_exists:
@@ -2237,3 +2245,33 @@ class _Validators:
             raise TeradataMlException(message,
                                       MessageCodes.IMPORT_PYTHON_PACKAGE)
         return True
+
+
+    @staticmethod
+    @skip_validation()
+    def _validate_ipaddress(ip_address):
+        """
+        DESCRIPTION:
+            Check if ipaddress is valid.
+        PARAMETERS:
+            ip_address:
+                Required Argument.
+                Specifies the ip address to be validated.
+                Types: str
+        RETURNS:
+            None.
+        RAISES:
+            TeradataMlException
+        EXAMPLES:
+            _Validators._validate_ipaddress("190.132.12.15")
+        """
+        import ipaddress
+
+        try:
+            ipaddress.ip_address(ip_address)
+        except Exception as err:
+            raise ValueError(Messages.get_message(
+                MessageCodes.INVALID_ARG_VALUE).format(ip_address, "ip_address",
+                                                       'of four numbers (each between 0 and 255) separated by periods'))
+
+        return True