teradataml 20.0.0.1__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,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/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

@@ -1660,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:

{teradataml-20.0.0.1.dist-info → teradataml-20.0.0.2.dist-info}/METADATA

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