teradataml 20.0.0.4__py3-none-any.whl → 20.0.0.5__py3-none-any.whl

teradataml/automl/model_training.py

@@ -775,7 +775,7 @@ class _ModelTraining:
 
         # Defining training data
         data_types = ['lasso', 'rfe', 'pca']
-        trainng_datas = tuple(DataFrame(self.table_name_mapping[f'{data_type}_train']) for data_type in data_types)
+        trainng_datas = tuple(DataFrame(self.data_mapping[f'{data_type}_train']) for data_type in data_types)
 
         if self.task_type == "Classification":
             response_values = trainng_datas[0].get(self.target_column).drop_duplicate().get_values().flatten().tolist()

teradataml/clients/auth_client.py

@@ -1,6 +1,6 @@
 """
 Unpublished work.
-Copyright (c) 2024 by Teradata Corporation. All rights reserved.
+Copyright (c) 2025 by Teradata Corporation. All rights reserved.
 TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
 Primary Owner: gouri.patwardhan@teradata.com
 Secondary Owner: Pradeep.Garre@teradata.com
@@ -67,7 +67,7 @@ class _AuthWorkflow:
             dict
         """
         # Extract the pem file name without extension.
-        kid = pathlib.Path(self.state.get('pem_file')).stem
+        kid = pathlib.Path(self.state.get('pem_file')).stem if not self.state.get('kid') else self.state['kid']
         header = {
             "alg": "RS256",
             "kid": kid,

teradataml/common/constants.py

@@ -20,7 +20,7 @@ from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
 from teradatasqlalchemy import (CHAR, CLOB)
 from teradatasqlalchemy import (PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP)
 from teradatasqlalchemy import (INTERVAL_YEAR, INTERVAL_YEAR_TO_MONTH, INTERVAL_MONTH,
-                                INTERVAL_DAY,INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
+                                INTERVAL_DAY, INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
                                 INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
                                 INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
                                 INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND,
@@ -82,7 +82,7 @@ class TeradataConstants(Enum):
     # Order of operators
     # shouldn't be changed. This is the order in which join condition is tested - first, operators
     # with two characters and then the operators with single character.
-    SUPPORTED_ENGINES = {"ENGINE_SQL" : {"name" : "sqle", "file" : "sqlengine_alias_definitions"}}
+    SUPPORTED_ENGINES = {"ENGINE_SQL": {"name": "sqle", "file": "sqlengine_alias_definitions"}}
     SUPPORTED_VANTAGE_VERSIONS = {"vantage1.0": "v1.0", "vantage1.1": "v1.1",
                                   "vantage1.3": "v1.3", "vantage2.0": "v1.1"}
     RANGE_SEPARATORS = [":"]
@@ -90,7 +90,7 @@ class TeradataConstants(Enum):
 
 class AEDConstants(Enum):
     AED_NODE_NOT_EXECUTED = 0
-    AED_NODE_EXECUTED     = 1
+    AED_NODE_EXECUTED = 1
     AED_DB_OBJECT_NAME_BUFFER_SIZE = 128
     AED_NODE_TYPE_BUFFER_SIZE = 32
     AED_ASSIGN_DROP_EXISITING_COLUMNS = "Y"
@@ -148,7 +148,7 @@ class TeradataTableKindConstants(Enum):
     TABLE = "table"
     VIEW = "view"
     TEMP = "temp"
-    ALL  = "all"
+    ALL = "all"
     ML_PATTERN = "ml_%"
     VOLATILE_TABLE_NAME = 'Table Name'
     REGULAR_TABLE_NAME = 'TableName'
@@ -220,7 +220,7 @@ class ModelCatalogingConstants(Enum):
 
 
 class CopyToConstants(Enum):
-    DBAPI_BATCHSIZE                      = 16383
+    DBAPI_BATCHSIZE = 16383
 
 
 class PTITableConstants(Enum):
@@ -377,34 +377,34 @@ class GeospatialConstants(Enum):
         "buffer": lambda x: "ST_Buffer",
         "contains": lambda x: "ST_Contains",
         "crosses": lambda x: "ST_Crosses",
-        "difference": lambda x: "ST_Difference", # M
+        "difference": lambda x: "ST_Difference",  # M
         "disjoint": lambda x: "ST_Disjoint",
-        "distance": lambda x: "ST_Distance", # M
-        "distance_3D": lambda x: "ST_3DDistance", # M
+        "distance": lambda x: "ST_Distance",  # M
+        "distance_3D": lambda x: "ST_3DDistance",  # M
         "geom_equals": lambda x: "ST_Equals",
         "intersection": lambda x: "ST_Intersection",
-        #"intersect": lambda x: "ST_Intersect", # M
+        # "intersect": lambda x: "ST_Intersect", # M
         "make_2D": lambda x: "Make_2D",
         "overlaps": lambda x: "ST_Overlaps",
         "relates": lambda x: "ST_Relate",
         "simplify": lambda x: "SimplifyPreserveTopology",
-        "sym_difference": lambda x: "ST_SymDifference", # M
+        "sym_difference": lambda x: "ST_SymDifference",  # M
         "touches": lambda x: "ST_Touches",
         "transform": lambda x: "ST_Transform",
         "union": lambda x: "ST_Union",
         "within": lambda x: "ST_Within",
-        "wkb_geom_to_sql": lambda x: "ST_WKBToSQL", # M
-        "wkt_geom_to_sql": lambda x: "ST_WKTToSQL", # M
+        "wkb_geom_to_sql": lambda x: "ST_WKBToSQL",  # M
+        "wkt_geom_to_sql": lambda x: "ST_WKTToSQL",  # M
         "set_srid": lambda x: "ST_SRID",
 
         ## *** Geometry Type ST_Point Methods *** ##
         "set_x": lambda x: "ST_X",
         "set_y": lambda x: "ST_Y",
         "set_z": lambda x: "ST_Z",
-        "spherical_buffer": lambda x: "ST_SphericalBufferMBR", # M
-        "spherical_distance": lambda x: "ST_SphericalDistance", # M
-        "spheroidal_buffer": lambda x: "ST_SpheroidalBufferMBR", # M
-        "spheroidal_distance": lambda x: "ST_SpheroidalDistance", # M
+        "spherical_buffer": lambda x: "ST_SphericalBufferMBR",  # M
+        "spherical_distance": lambda x: "ST_SphericalDistance",  # M
+        "spheroidal_buffer": lambda x: "ST_SpheroidalBufferMBR",  # M
+        "spheroidal_distance": lambda x: "ST_SpheroidalDistance",  # M
 
         ## *** Geometry Type ST_LineString Methods *** ##
         "line_interpolate_point": lambda x: "ST_Line_Interpolate_Point",
@@ -509,9 +509,18 @@ class TableOperatorConstants(Enum):
                                                     "delimiter(' ') " \
                                                     "returns('package VARCHAR({2}), " \
                                                     "version VARCHAR({2})'))"
-    
+
     SCRIPT_LIST_FILES_QUERY = "SELECT DISTINCT * FROM SCRIPT (SCRIPT_COMMAND " \
-                       "('ls ./{}') RETURNS ('Files VARCHAR({})'))"
+                              "('ls ./{}') RETURNS ('Files VARCHAR({})'))"
+
+
+    # OpenBlas by default is multi-threaded, needs to be set to single-threaded.
+    OPENBLAS_NUM_THREADS = "OPENBLAS_NUM_THREADS=1"
+
+    # Query to create a DataFrame with a range of numbers.
+    RANGE_QUERY = "WITH RECURSIVE NumberSeries (id) AS (SELECT id AS id from {0} "\
+                  "UNION ALL SELECT id {3} {1} FROM NumberSeries WHERE id {3} {1} {4} {2}) "\
+                  "SELECT id FROM NumberSeries;"
 
 class ValibConstants(Enum):
     # A dictionary that maps teradataml name of the exposed VALIB function name
@@ -1355,7 +1364,7 @@ class SQLFunctionConstants(Enum):
         "regexp_replace": "REGEXP_REPLACE",
         "regexp_similar": "REGEXP_SIMILAR",
         "regexp_substr": "REGEXP_SUBSTR",
-        
+
         # DateTime Functions
         'week_begin': 'td_week_begin',
         'week_start': 'td_week_begin',
@@ -1426,6 +1435,7 @@ class TeradataReservedKeywords(Enum):
                                "TYPE"
                                ]
 
+
 class TeradataAnalyticFunctionTypes(Enum):
     SQLE = "FASTPATH"
     UAF = "UAF"
@@ -1435,15 +1445,15 @@ class TeradataAnalyticFunctionTypes(Enum):
 
 
 class TeradataAnalyticFunctionInfo(Enum):
-
-    FASTPATH = {"func_type": "sqle", "lowest_version": "16.20", "display_function_type_name" :"SQLE"}
+    FASTPATH = {"func_type": "sqle", "lowest_version": "16.20", "display_function_type_name": "SQLE"}
     UAF = {"func_type": "uaf", "lowest_version": "17.20", "display_function_type_name": "UAF",
-           "metadata_class" : "_AnlyFuncMetadataUAF"}
+           "metadata_class": "_AnlyFuncMetadataUAF"}
     TABLE_OPERATOR = {"func_type": "tableoperator", "lowest_version": "17.00 ",
-                      "display_function_type_name" :"TABLE OPERATOR"}
+                      "display_function_type_name": "TABLE OPERATOR"}
     BYOM = {"func_type": "byom", "lowest_version": None, "display_function_type_name": "BYOM"}
     STORED_PROCEDURE = {"func_type": "storedprocedure", "lowest_version": "17.20", "display_function_type_name": "UAF",
-           "metadata_class" : "_AnlyFuncMetadataUAF"}
+                        "metadata_class": "_AnlyFuncMetadataUAF"}
+
 
 class TeradataUAFSpecificArgs(Enum):
     INPUT_MODE = "input_mode"
@@ -1451,9 +1461,11 @@ class TeradataUAFSpecificArgs(Enum):
     OUTPUT_FMT_INDEX = "output_fmt_index"
     OUTPUT_FMT_INDEX_STYLE = "output_fmt_index_style"
 
+
 class Query(Enum):
     VANTAGE_VERSION = "SELECT InfoData FROM DBC.DBCInfoV where InfoKey = 'VERSION'"
 
+
 class DriverEscapeFunctions(Enum):
     # Holds variables for the teradatasql driver escape functions to be used
     NATIVE_SQL = "{fn teradata_nativesql}"
@@ -1494,6 +1506,13 @@ class AsyncStatusColumns(Enum):
     ADDITIONAL_DETAILS = "Additional Details"
 
 
+class AsyncOpStatus(Enum):
+    # Holds valid status for asynchronous operatiosns in UES.
+    FILE_INSTALLED = "File Installed"
+    ERRED = "Errored"
+    FINISHED = "Finished"
+
+
 class CloudProvider(Enum):
     # Holds variable names for Cloud Providers.
     AWS = "AWS"
@@ -1503,7 +1522,8 @@ class CloudProvider(Enum):
     X_MS_VERSION = "2019-12-12"
     X_MS_BLOB_TYPE = "BlockBlob"
 
-class SessionParamsSQL:
+
+class SessionParamsSQL(Enum):
     # Holds the SQL Statements for Session params.
     TIMEZONE = "SET TIME ZONE {}"
     ACCOUNT = "SET SESSION ACCOUNT = '{}' FOR {}"
@@ -1523,7 +1543,8 @@ class SessionParamsSQL:
     QUERY_BAND = "SET QUERY_BAND = {} FOR {}"
     UDFSEARCHPATH = "SET SESSION UDFSEARCHPATH = {} FOR FUNCTION = {}"
 
-class SessionParamsPythonNames:
+
+class SessionParamsPythonNames(Enum):
     # Holds the SQL Statements for Session params.
     TIMEZONE = "Session Time Zone"
     ACCOUNT = "Account Name"
@@ -1532,3 +1553,17 @@ class SessionParamsPythonNames:
     DATABASE = "Current DataBase"
     DATEFORM = 'Current DateForm'
 
+
+class AutoMLConstants(Enum):
+    # List stores feature selection methods
+    FEATURE_SELECTION_MTDS = ["lasso", "rfe", "pca"]
+
+
+class AuthMechs(Enum):
+    """
+    Enum to hold permitted values for authentication mechanism.
+    """
+    OAUTH = "OAuth"
+    JWT = "JWT"
+    PAT = "PAT"
+    BASIC = "BASIC"

teradataml/common/messagecodes.py

@@ -125,6 +125,7 @@ class ErrorInfoCodes(Enum):
     SPECIFY_AT_LEAST_ONE_ARG = 'TDML_2037'
     CANNOT_USE_TOGETHER_WITH = 'TDML_2042'
     TABLE_DOES_NOT_EXIST = 'TDML_2046'
+    DEPENDENT_METHOD = 'TDML_2113'
 
     # Reserved for Generic Error Messages: 2121 - 2199
     RESERVED_KEYWORD = 'TDML_2121'
@@ -440,4 +441,4 @@ class MessageCodes(Enum):
     CONNECTION_PARAMS = "Required connection parameters are missing. Connection parameters should either be " \
                         "explicitly passed to function or specified using a configuration file, or setting up " \
                         "the environment variables."
-
+    DEPENDENT_METHOD = "Method(s) {} must be called before calling '{}'."

teradataml/common/messages.py

@@ -195,7 +195,8 @@ class Messages():
             [ErrorInfoCodes.PATH_NOT_FOUND, MessageCodes.PATH_NOT_FOUND],
             [ErrorInfoCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE, MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE],
             [ErrorInfoCodes.SET_REQUIRED_PARAMS, MessageCodes.SET_REQUIRED_PARAMS],
-            [ErrorInfoCodes.MISSING_ARGS, MessageCodes.CONNECTION_PARAMS]
+            [ErrorInfoCodes.MISSING_ARGS, MessageCodes.CONNECTION_PARAMS],
+            [ErrorInfoCodes.DEPENDENT_METHOD, MessageCodes.DEPENDENT_METHOD]
     ]
 
     @staticmethod
@@ -224,11 +225,11 @@ class Messages():
 
         """
         for msg in Messages.__messages:
-            if msg[1] == messagecode :
+            if msg[1] == messagecode:
                 message = "{}({}) {}".format(Messages.__standard_message, msg[0].value, msg[1].value)
                 if len(variables) != 0:
                     message = message.format(*variables)
-                if len(kwargs) != 0 :
+                if len(kwargs) != 0:
                     message = "{} {}".format(message, kwargs)
-
+                break
         return message

teradataml/common/utils.py

@@ -13,50 +13,48 @@ by other classes which can be reused according to the need.
 Add all the common functions in this class like creating temporary table names, getting
 the datatypes etc.
 """
-from inspect import getsource
 import json
+import os
+import re
+import time
 import uuid
+import warnings
+from functools import reduce
+from inspect import getsource
 from math import floor
-import os, itertools
-import time
-import re, requests
+
+import requests
 import sqlalchemy
-from pathlib import Path
 from numpy import number
 from sqlalchemy import Column, MetaData, Table
-
-from teradataml.context.context import get_connection
+from sqlalchemy.exc import OperationalError as sqlachemyOperationalError
+from teradatasql import OperationalError
+from teradatasqlalchemy.dialect import dialect as td_dialect
+from teradatasqlalchemy.dialect import preparer
+from teradatasqlalchemy.types import (BIGINT, BLOB, BYTE, BYTEINT, CHAR, CLOB,
+                                      DATE, DECIMAL, FLOAT, INTEGER, NUMBER,
+                                      SMALLINT, TIME, TIMESTAMP, VARBYTE,
+                                      VARCHAR, _TDType)
 
 from teradataml import _version
-from teradataml.context import context as tdmlctx
+from teradataml.common import td_coltype_code_to_tdtype
+from teradataml.common.constants import (HTTPRequest, PTITableConstants,
+                                         PythonTypes, TeradataConstants,
+                                         TeradataReservedKeywords,
+                                         TeradataTypes)
 from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.messages import Messages
+from teradataml.common.garbagecollector import GarbageCollector
 from teradataml.common.messagecodes import MessageCodes
+from teradataml.common.messages import Messages
 from teradataml.common.sqlbundle import SQLBundle
-from teradataml.common import td_coltype_code_to_tdtype
-from teradataml.common.constants import PythonTypes
-from teradataml.common.constants import TeradataTypes
-from teradataml.common.garbagecollector import GarbageCollector
-from teradataml.common.constants import TeradataConstants, PTITableConstants, \
-    TableOperatorConstants, HTTPRequest
-from teradataml.common.warnings import VantageRuntimeWarning
+from teradataml.common.warnings import (OneTimeUserWarning,
+                                        VantageRuntimeWarning)
+from teradataml.context import context as tdmlctx
 from teradataml.options.configure import configure
 from teradataml.options.display import display
-from teradataml.common.constants import TeradataReservedKeywords, TeradataConstants
-
-from teradataml.utils.internal_buffer import _InternalBuffer
-from teradatasqlalchemy.types import _TDType
-from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT,
-                                      DECIMAL, FLOAT, NUMBER)
-from teradatasqlalchemy.types import (DATE, TIME, TIMESTAMP)
-from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
-from teradatasqlalchemy.types import (CHAR, VARCHAR, CLOB)
-from functools import reduce
-import warnings
 from teradataml.telemetry_utils.queryband import collect_queryband
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
-from sqlalchemy.exc import OperationalError as sqlachemyOperationalError
 
 
 class UtilFuncs():
@@ -304,7 +302,7 @@ class UtilFuncs():
             tabname = "{}_{}".format(tabname, prefix)
 
         tabname = "{}_{}".format(tabname, random_string)
-        
+
         # ELE-6710 - Use database user associated with the current context for volatile tables.
         if table_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
             from teradataml.context.context import _get_user
@@ -454,9 +452,10 @@ class UtilFuncs():
             >>> def udf(a, b): return a + b
             >>> func = UtilFuncs._serialize_and_encode(udf)
         """
-        from dill import dumps as dill_dumps
         from base64 import b64encode as base64_b64encode
 
+        from dill import dumps as dill_dumps
+
         return base64_b64encode(dill_dumps(obj, recurse=True))
 
     @staticmethod
@@ -1275,7 +1274,7 @@ class UtilFuncs():
             return UtilFuncs._teradata_quote_arg(keyword, "\"", False)
 
         return keyword
-    
+
     def _contains_space(item):
         """
         Check if the specified string in item has spaces or tabs in it.
@@ -1307,10 +1306,10 @@ class UtilFuncs():
         # If the input is a list, check each element
         if isinstance(item, list):
             # Check each item in the list
-            return any(UtilFuncs._contains_space(col) for col in item)  
+            return any(UtilFuncs._contains_space(col) for col in item)
+
+        return False
 
-        return False  
-    
     def _is_ascii(col_lst):
         """
         Description:
@@ -2476,7 +2475,14 @@ class UtilFuncs():
         # and determine the system type accordingly.
         if tbl_operator is None:
             from teradataml.context.context import _get_database_version
-            return int(_get_database_version().split(".")[0]) >= 20
+            if int(_get_database_version().split(".")[0]) < 20:
+                return False
+            # If the database version is 20 or higher, check if the system is VCL or not.
+            try:
+                res = UtilFuncs._execute_query("SELECT 1 WHERE TD_GetSystemType('PRODUCT') = 'VCL';")
+                return True if res else False
+            except OperationalError:
+                return True
 
         return tbl_operator == "apply"
 
@@ -2503,7 +2509,6 @@ class UtilFuncs():
         return "python" if UtilFuncs._is_lake() else \
             '{}/bin/python3'.format(configure.indb_install_location)
 
-
     def _is_view(tablename):
         """
         DESCRIPTION:
@@ -2589,7 +2594,7 @@ class UtilFuncs():
                 raise tdml_e
         except Exception as exc:
             raise exc
-        
+
     def _get_env_name(col=None):
         """
         DESCRIPTION:
@@ -2704,6 +2709,219 @@ class UtilFuncs():
         """
         return '"{}"."{}"'.format(schema_name, table_name)
 
+    def _check_python_version_diff(env = None):
+        """
+        DESCRIPTION:
+            Internal function to check the python version difference between Vantage and local.
+            
+        PARAMETERS:
+            env:
+                Optional Argument.
+                Specifies the user environment for Vantage Cloud Lake.
+                Types: str, object of class UserEnv
+                Default Value: None
+
+        RAISES:
+            TeradataMlException
+
+        RETURNS:
+            None.
+
+        EXAMPLES:
+            >>> self._check_python_version_diff(env)
+        """
+        if env:
+            # Get the Python interpreter version of the user environment.
+            from teradataml.scriptmgmt.lls_utils import list_user_envs
+            from teradataml.scriptmgmt.UserEnv import UserEnv
+            env_list = list_user_envs()
+            user_env_name = env.env_name if isinstance(env, UserEnv) else env
+            env_base_version = env_list[env_list['env_name'] == user_env_name].base_env_name.values
+            # Check if the user environment is not found, then return.
+            if len(env_base_version) == 0:
+                return
+            python_env = env_base_version[0].split("_")[1]
+
+            # Get the Python interpreter version of the local environment.
+            from teradataml.context import context as tdmlctx
+            python_local = tdmlctx.python_version_local.rsplit(".", 1)[0]
+            # Check if the Python interpreter major versions are consistent between Lake user environment and local.
+            # If not, raise an exception.
+            if python_env != python_local:
+                raise TeradataMlException(Messages.get_message(MessageCodes.PYTHON_VERSION_MISMATCH_OAF,
+                                                                python_env, python_local),
+                                            MessageCodes.PYTHON_VERSION_MISMATCH_OAF)
+        else:
+            from teradataml.context import context as tdmlctx
+            from teradataml.dbutils.dbutils import (db_python_version_diff, set_session_param)
+            set_session_param("searchuifdbpath",
+                              UtilFuncs._get_dialect_quoted_name(tdmlctx._get_current_databasename()))
+            if len(db_python_version_diff()) > 0:
+                # Raise exception when python versions don't match between Vantage and local.
+                py_major_vantage_version = tdmlctx.python_version_vantage.rsplit(".", 1)[0]
+                raise TeradataMlException(Messages.get_message(MessageCodes.PYTHON_VERSION_MISMATCH,
+                                                                tdmlctx.python_version_vantage, py_major_vantage_version),
+                                            MessageCodes.PYTHON_VERSION_MISMATCH)
+
+    def _check_package_version_diff(func, packages, env=None):
+        """
+        DESCRIPTION:
+            Internal function to process packages differences between Vantage and local.
+            Note:
+                * Raises a warning if the versions of certain Python packages are not consistent between Vantage and local.
+
+        PARAMETERS:
+            func:
+                Required Argument.
+                Specifies the function name.
+                Types: str
+
+            packages:
+                Required Argument.
+                Specifies the list of package names.
+                Types: list of str
+
+            env:
+                Optional Argument.
+                Specifies the user environment for Vantage Cloud Lake.
+                Types: str, object of class UserEnv
+                Default Value: None
+
+        RETURNS:
+            None
+
+        RAISES:
+            OneTimeUserWarning
+
+        EXAMPLES:
+            self._process_package_differences("apply", ["dill"], env)
+        """
+
+        # Check if OSML required packages are verified or not.
+        from teradataml.opensource._constants import _packages_verified_in_vantage
+        _is_packages_verfied_in_vantage = _packages_verified_in_vantage.get(
+            func, None)
+        if _is_packages_verfied_in_vantage:
+            return
+
+        if env:
+            from teradataml.scriptmgmt.lls_utils import get_env
+            from teradataml.scriptmgmt.UserEnv import UserEnv
+            env = env if isinstance(env, UserEnv) else get_env(env)
+            env_pkg_df = env.libs
+            pkgs_dict = dict(zip(env_pkg_df['name'], env_pkg_df['version']))
+
+            from importlib.metadata import version
+            warning_raised = False
+            strr = []
+            for pkg in packages:
+                env_version = pkgs_dict.get(pkg)
+                local_version = version(pkg)
+                # Write the requirements file listing all the related packages and their versions
+                # if the versions Python packages are not consistent between Vantage and local.
+                if env_version != local_version:
+                    warning_raised = True
+                    strr.append(f"{pkg}=={local_version}")
+
+            # If there are differences in package versions, display a warning message to the user.
+            # about the package differences and the requirements file created for the user to install the packages
+            if warning_raised:
+                file_name = f"requirements_{func}.txt"
+                req_file = os.path.join(GarbageCollector._get_temp_dir_name(), file_name)
+                with open(req_file, "w") as f:
+                    f.write("\n".join(strr))
+
+                packages = "{}".format(packages[0]) if len(packages) == 1 else\
+                           "', '".join(packages[:-1]) + "' and '" + packages[-1]
+
+                if func == "apply":
+                    warning_msg = f"The version of certain Python packages are not consistent between Lake "\
+                        f"user environment and local. Teradata recommends to maintain same version of '{packages}' "\
+                        f"between Lake user environment and local for '{func}'."
+                else:
+                    _packages_verified_in_vantage[func] = True
+                    warning_msg = "The versions of certain Python packages are not consistent between "\
+                        "Lake user environment and local. OpenSourceML compares the versions of '{}' "\
+                        f"(and also matches the patterns of these packages) used by 'td_{func}'. "\
+                        "Teradata recommends same versions for all the Python packages between Lake "\
+                        "user environment and local."
+
+                req = f"\nA requirements file listing all '{func}' " + \
+                    f"related packages and their versions has been written to '{req_file}'. "+ \
+                    "Update the Lake user environment with the required packages.\n"
+
+                warning_msg += req
+                warnings.warn(warning_msg.format(packages), category=OneTimeUserWarning)
+
+        else:
+            # Check if the versions of Python packages are consistent between Vantage and local.
+            from teradataml.dbutils.dbutils import _db_python_package_version_diff
+            all_package_versions = _db_python_package_version_diff(packages, only_diff=False)
+            package_difference = \
+                all_package_versions[all_package_versions.vantage != all_package_versions.local]
+            # If there are differences in package versions, raise a warning.
+            if package_difference.shape[0] > 0:
+                strr = []
+                # Write the requirements file listing all the related packages and their versions.
+                for rec in all_package_versions.to_records():
+                    strr.append(f"{rec[1]}=={rec[2]}")
+                file_name = f"requirements_{func}.txt"
+                req_file = os.path.join(GarbageCollector._get_temp_dir_name(), file_name)
+                with open(req_file, "w") as f:
+                    f.write("\n".join(strr))
+
+                packages = "{}".format(packages[0]) if len(packages) == 1 else\
+                           "', '".join(packages[:-1]) + "' and '" + packages[-1]
+
+                if func in ["map_row", "map_partition"]:
+                    warning_msg = f"The version of certain Python packages are not consistent between "\
+                        "Vantage and local. User can identify them using db_python_package_version_diff() "\
+                        f"function. Teradata recommends to maintain same version of '{packages}' "\
+                        f"between Vantage and local for '{func}'."
+                else:
+                    _packages_verified_in_vantage[func] = True
+                    warning_msg = "The versions of certain Python packages are not consistent between "\
+                        "Vantage and local. User can identify them using db_python_package_version_diff() "\
+                        "function. OpenSourceML compares the versions of '{}' (and also matches the "\
+                        f"patterns of these packages) used by 'td_{func}'. Teradata "\
+                        "recommends to maintain same versions for all the Python packages between Vantage "\
+                        "and local."
+
+                # Display a warning message to the user about the package differences
+                # and the requirements file created for the user to install the packages.
+                req = f"\nA requirements file listing all '{func}' " + \
+                    f"related packages and their versions has been written to '{req_file}'.\n"
+
+                warning_msg += req
+                warnings.warn(warning_msg.format(packages), category=OneTimeUserWarning)
+
+    @staticmethod
+    def _get_dialect_quoted_name(object_name):
+        """
+        DESCRIPTION:
+            Function to quote the SQL identifiers as per teradatasqlalchemy's quoting rules.
+
+        PARAMETERS:
+            object_name
+                Required Argument.
+                Specifies the name of the SQL identifier to be quoted.
+                Type: str
+
+        RAISES:
+            None
+
+        RETURNS:
+            Quoted object name.
+
+        EXAMPLES:
+            _get_dialect_quoted_name(object_name = "tdml.alice")
+
+        OUTPUT:
+            '"tdml.alice"'
+        """
+        tdp = preparer(td_dialect)
+        return tdp.quote(object_name)
+
 
 from teradataml.common.aed_utils import AedUtils
 from teradataml.dbutils.filemgr import remove_file