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

teradataml/common/wrapper_utils.py

@@ -27,87 +27,6 @@ import teradataml.dataframe as tdmldf
 from teradatasqlalchemy.types import INTEGER, SMALLINT, BIGINT, BYTEINT, FLOAT, NUMBER, VARCHAR, BYTE
 
 FUNCTION_PREDICTION_TYPE_MAPPER = {
-    # MLE functions
-    'teradataml.analytics.mle.AdaBoost.AdaBoost':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.AdaBoostPredict.AdaBoostPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.Arima.Arima':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.ArimaPredict.ArimaPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.CoxHazardRatio.CoxHazardRatio':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.CoxPH.CoxPH':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.CoxSurvival.CoxSurvival':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.DecisionTree.DecisionTree':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.DecisionTreePredict.DecisionTreePredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.GLM.GLM':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.GLML1L2.GLML1L2':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.GLML1L2Predict.GLML1L2Predict':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.GLMPredict.GLMPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.KMeans.KMeans':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLUSTERING.value,
-    'teradataml.analytics.mle.KNN.KNN':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.LAR.LAR':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.LARPredict.LARPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.LDA.LDA':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.LDAInference.LDAInference':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.LDATopicSummary.LDATopicSummary':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.LinReg.LinReg':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.LinRegPredict.LinRegPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.MinHash.MinHash':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLUSTERING.value,
-    'teradataml.analytics.mle.NaiveBayes.NaiveBayes':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.NaiveBayesPredict.NaiveBayesPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.NaiveBayesTextClassifier.NaiveBayesTextClassifier':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.NaiveBayesTextClassifier2.NaiveBayesTextClassifier2':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.NaiveBayesTextClassifierPredict.NaiveBayesTextClassifierPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMDense.SVMDense':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMDensePredict.SVMDensePredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMDenseSummary.SVMDenseSummary':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMSparse.SVMSparse':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMSparsePredict.SVMSparsePredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.SVMSparseSummary.SVMSparseSummary':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.TextClassifierTrainer.TextClassifierTrainer':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.TextClassifier.TextClassifier':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.TextClassifierTrainerEvaluator.TextClassifierTrainerEvaluator':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.VarMax.VarMax':
-        ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value,
-    'teradataml.analytics.mle.XGBoost.XGBoost':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
-    'teradataml.analytics.mle.XGBoostPredict.XGBoostPredict':
-        ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
     # SQLE functions
     'teradataml.analytics.sqle.DecisionTreePredict.DecisionTreePredict':
         ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value,
@@ -121,11 +40,6 @@ FUNCTION_PREDICTION_TYPE_MAPPER = {
         ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value
 }
 
-# List of functions having the prediction dependent on the inputs
-INPUT_DEPENDENT_PREDICTION_TYPE_FUNCTION_LIST = [
-    'teradataml.analytics.mle.DecisionForest.DecisionForest'
-]
-
 
 class AnalyticsWrapperUtils:
 
@@ -673,24 +587,6 @@ class AnalyticsWrapperUtils:
         # This list serves as a quick lookup.
         function_name_with_module = '{}.{}'.format(function_obj.__class__.__module__, function_obj.__class__.__name__)
 
-        if function_name_with_module == 'teradataml.analytics.mle.DecisionForest.DecisionForest':
-            # Check the tree_type argument to the function
-            if function_obj.tree_type is not None:
-                # The tree_type argument can be either 'regression' or 'classification'.
-                # We can return it as is.
-                return function_obj.tree_type.upper()
-            else:
-                # Since tree_type was not used, we will have to check the type of the response column used with formula
-                formula_object = self._validate_formula_notation(function_obj.formula, input_data, "formula")
-                # response variable
-                response = formula_object._get_dependent_vars()
-
-                common_util = UtilFuncs()
-                if response in formula_object.get_all_columns(common_util._get_numeric_datatypes()):
-                    # The response column is numeric, so the prediction type is REGRESSION
-                    return ModelCatalogingConstants.PREDICTION_TYPE_REGRESSION.value
-                else:
-                    return ModelCatalogingConstants.PREDICTION_TYPE_CLASSIFICATION.value
 
     def _get_function_prediction_type(self, function_obj, input_data=None):
         """
@@ -726,9 +622,4 @@ class AnalyticsWrapperUtils:
         try:
             return FUNCTION_PREDICTION_TYPE_MAPPER[function_name_with_module]
         except KeyError:
-            # If we are here, it means that the functions prediction type is either dependent
-            # in its input, or must default to OTHER
-            if function_name_with_module not in INPUT_DEPENDENT_PREDICTION_TYPE_FUNCTION_LIST:
-                return ModelCatalogingConstants.PREDICTION_TYPE_OTHER.value
-            else:
-                return self.__get_input_dependent_prediction_type(function_obj, input_data)
+            return self.__get_input_dependent_prediction_type(function_obj, input_data)

teradataml/context/context.py

@@ -13,7 +13,10 @@ A teradataml context functions provide interface to Teradata Vantage. Provides f
 context which can be used by other analytical functions to get the Teradata Vantage connection.
 
 """
+from pathlib import Path
 from sqlalchemy import create_engine
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.common.deprecations import argument_deprecation
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.warnings import TeradataMlRuntimeWarning
 from teradataml.common.messages import Messages
@@ -23,12 +26,12 @@ from teradataml.common.constants import SQLConstants
 from teradataml.common.garbagecollector import GarbageCollector
 from teradataml.context.aed_context import AEDContext
 from teradataml.common.constants import TeradataConstants, Query
-from teradataml.common.utils import UtilFuncs
 from teradataml.options.configure import configure
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
 from teradataml.utils.internal_buffer import _InternalBuffer
 from sqlalchemy.engine.base import Engine
+from sqlalchemy.engine.url import URL
 import os
 import warnings
 import atexit
@@ -122,7 +125,7 @@ def __cleanup_garbage_collection():
 def _get_other_connection_parameters(logmech = None, logdata = None, database = None, **kwargs):
     """
     DESCRIPTION:
-        Function to generate and return the string for connection parameters.
+        Internal function to return the connection parameters.
 
     PARAMETERS:
         logmech:
@@ -145,7 +148,7 @@ def _get_other_connection_parameters(logmech = None, logdata = None, database =
             Specifies the keyword value pairs of other connection parameters to create the connection string.
 
     RETURNS:
-        String containing connection parameters, needed to generate engine URL.
+        dict, needed to generate engine URL.
 
     EXAMPLES:
         __get_other_connection_parameters(logmech = "JWT", logdata = "<jwt_token>", database = "<database_name>",
@@ -155,12 +158,14 @@ def _get_other_connection_parameters(logmech = None, logdata = None, database =
     if not logmech and not logdata and not database and len(kwargs) == 0:
         return ""
 
+    result = {}
+
     if logmech:
-        kwargs['LOGMECH'] = logmech.upper()
+        result['LOGMECH'] = logmech.upper()
     if logdata:
-        kwargs['LOGDATA'] = logdata
+        result['LOGDATA'] = logdata
     if database:
-        kwargs['DATABASE'] = database
+        result['DATABASE'] = database
 
     # Create connection parameters string.
     other_params = []
@@ -174,11 +179,12 @@ def _get_other_connection_parameters(logmech = None, logdata = None, database =
             # Other type values like integer, boolean etc, are converted to string.
             # For boolean values, the connection string should contain lower case values i.e., True -> true
             val = str(val).lower()
-        other_params.append("{}={}".format(key.upper(), val))
-
-    return "/?{}".format("&".join(other_params))
+        result[key] = val
 
+    return result
 
+@argument_deprecation("future", ["url_encode"], False, None)
+@collect_queryband(queryband='CrtCxt')
 def create_context(host = None, username = None, password = None, tdsqlengine = None, temp_database_name = None,
                    logmech = None, logdata = None, database = None, url_encode = True, **kwargs):
     """
@@ -284,36 +290,17 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         logmech:
             Optional Argument.
             Specifies the type of logon mechanism to establish a connection to Teradata Vantage. 
-            Permitted Values: 'TD2', 'TDNEGO', 'LDAP', 'KRB5' & 'JWT'.
-                TD2: 
-                    The Teradata 2 (TD2) mechanism provides authentication using a 
-                    Vantage username and password. This is the default logon mechanism
-                    using which the connection is established to Vantage.
-                TDNEGO:
-                    A security mechanism that automatically determines the actual 
-                    mechanism required, based on policy, without user's involvement.
-                    The actual mechanism is determined by the TDGSS server configuration
-                    and by the security policy's mechanism restrictions.
-                LDAP:
-                    A directory-based user logon to Vantage with a directory username
-                    and password and is authenticated by the directory.
-                KRB5 (Kerberos):
-                    A directory-based user logon to Vantage with a domain username
-                    and password and is authenticated by Kerberos (KRB5 mechanism).
-                    Note: User must have a valid ticket-granting ticket in order to use this logon mechanism.
-                JWT: 
-                    The JSON Web Token (JWT) authentication mechanism enables single 
-                    sign-on (SSO) to the Vantage after the user successfully authenticates
-                    to Teradata UDA User Service.
-                    Note: User must use logdata parameter when using 'JWT' as the logon mechanism.
-            Types: str
-
-            Note:
-                teradataml expects the client environments are already setup with appropriate
-                security mechanisms and are in working conditions.
+            Permitted Values: As supported by the teradata driver.
+            Notes:
+                1. teradataml expects the client environments are already setup with appropriate
+                   security mechanisms and are in working conditions.
+                2. User must have a valid ticket-granting ticket in order to use KRB5 (Kerberos) logon mechanism.
+                3. User must use logdata parameter when using 'JWT' as the logon mechanism.
+                4. Browser Authentication is supported for Windows and macOS.
                 For more information please refer Teradata Vantage™ - Advanced SQL Engine
                 Security Administration at https://www.info.teradata.com/
-        
+            Types: str
+
         logdata:
             Optional Argument.
             Specifies parameters to the LOGMECH command beyond those needed by the logon mechanism, such as 
@@ -325,13 +312,6 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
             Specifies the initial database to use after logon, instead of the user's default database.
             Types: str
 
-        url_encode:
-            Optional Argument.
-            Specifies whether the password should be URL encoded or not.
-            When set to True, passwords are URL encoded, otherwise not.
-            Default Value: True
-            Types: bool
-
         kwargs:
             Specifies the keyword-value pairs of connection parameters that are passed to Teradata SQL Driver for
             Python. Please refer to https://github.com/Teradata/python-driver#ConnectionParameters to get information
@@ -409,22 +389,6 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', tmode = 'tera',
                                         log = 8, lob_support = False)
 
-        # Example 14: Create context when password has special characters.
-        # In this example password "alice@pass" is encoded by default.
-        >>> td_context = create_context(host = 'tdhost', username='alice_pass', password = 'alice@pass')
-            UserWarning: Warning: Password is URL encoded.
-
-        # Example 15: Create context when password contains space and special characters.
-        # "url_encode" must be set to False and special characters should be manually encoded in the password.
-        # For example, let's say password is: "kx%jj5/ g"
-        # then password should be manually encoded as: "kx%25jj5%2F g"
-        # where,
-        #     %25 represents the '%' character and
-        #     %2F represents the '/' character
-        #     space is not encoded.
-        >>> td_context = create_context(host = 'tdhost', username='alice_pass', password = 'kx%25jj5%2F g',
-                                        url_encode=False)
-
     """
     global td_connection
     global td_sqlalchemy_engine
@@ -432,16 +396,14 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     global user_specified_connection
     global python_packages_installed
     global td_user
-    logmech_valid_values = ['TD2', 'TDNEGO', 'LDAP', 'KRB5', 'JWT']
     awu_matrix = []
     awu_matrix.append(["host", host, True, (str), True])
     awu_matrix.append(["username", username, True, (str), True])
     awu_matrix.append(["password", password, True, (str), True])
     awu_matrix.append(["tdsqlengine", tdsqlengine, True, (Engine)])
-    awu_matrix.append(["logmech", logmech, True, (str), True, logmech_valid_values])
+    awu_matrix.append(["logmech", logmech, True, (str), True])
     awu_matrix.append(["logdata", logdata, True, (str), True])
     awu_matrix.append(["database", database, True, (str), True])
-    awu_matrix.append(["url_encode", url_encode, True, (bool), True])
 
     awu = _Validators()
     awu._validate_function_arguments(awu_matrix)
@@ -459,7 +421,7 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     warnings.simplefilter("always", TeradataMlRuntimeWarning)
     # Throwing warning and removing context if any.
     if td_connection is not None:
-        warnings.warn(Messages.get_message(MessageCodes.OVERWRITE_CONTEXT))
+        warnings.warn(Messages.get_message(MessageCodes.OVERWRITE_CONTEXT), stacklevel=2)
         remove_context()
 
     # Check if teradata sqlalchemy engine is provided by the user    
@@ -477,25 +439,23 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     elif host:
         username = '' if username is None else username
 
-        # Encode the password if authentication is through username/password and url_encode is True.
-        if password and url_encode:
-            encoded_password = urllib.parse.quote_plus(password)
-            if encoded_password != password:
-                warnings.warn("Warning: Password is URL encoded.", category=TeradataMlRuntimeWarning)
-            password = encoded_password
-
-        if logmech and logmech.upper() == 'JWT':
+        if logmech and logmech.upper() in ['JWT', 'BROWSER']:
             host_value = host
         elif logmech and logmech.upper() == 'KRB5':
             host_value = '{}:@{}'.format(username, host)
         else:
             host_value = '{}:{}@{}'.format(username, password, host)
 
-        other_connection_parameters = _get_other_connection_parameters(logmech, logdata, database, **kwargs)
+        url_object = URL.create(
+            "teradatasql",
+            username=username,
+            password=password,  # plain (unescaped) text
+            host=host,
+            query=_get_other_connection_parameters(logmech, logdata, database, **kwargs)
+        )
 
         try:
-            engine_url = "teradatasql://{}{}"
-            td_sqlalchemy_engine = create_engine(engine_url.format(host_value, other_connection_parameters))
+            td_sqlalchemy_engine = create_engine(url_object)
             td_connection = td_sqlalchemy_engine.connect()
             td_user = username.upper()
 
@@ -614,6 +574,7 @@ def get_connection():
     return td_connection
 
 
+@collect_queryband(queryband='SetCxt')
 def set_context(tdsqlengine, temp_database_name=None):
     """
     DESCRIPTION:
@@ -647,7 +608,7 @@ def set_context(tdsqlengine, temp_database_name=None):
     global user_specified_connection
     global python_packages_installed
     if td_connection is not None:
-        warnings.warn(Messages.get_message(MessageCodes.OVERWRITE_CONTEXT))
+        warnings.warn(Messages.get_message(MessageCodes.OVERWRITE_CONTEXT), stacklevel=2)
         remove_context()
 
     if tdsqlengine:
@@ -680,6 +641,7 @@ def set_context(tdsqlengine, temp_database_name=None):
     return td_connection
 
 
+@collect_queryband(queryband='RmCxt')
 def remove_context():
     """
     DESCRIPTION:
@@ -837,9 +799,9 @@ def _load_function_aliases():
             alias_config_file = os.path.join(config_folder,
                                              "{}_{}".format(supported_engines[engine]["file"], vantage_versions[vv]))
             engine_name = supported_engines[engine]['name']
-            UtilFuncs._check_alias_config_file_exists(vv, alias_config_file)
+            ContextUtilFuncs._check_alias_config_file_exists(vv, alias_config_file)
             function_alias_mappings_by_engine[engine_name] = \
-                UtilFuncs._get_function_mappings_from_config_file(alias_config_file)
+                ContextUtilFuncs._get_function_mappings_from_config_file(alias_config_file)
             function_alias_mappings[vv] = function_alias_mappings_by_engine
 
 
@@ -997,3 +959,113 @@ def _get_user():
     if not td_user:
         td_user = _get_database_username()
     return td_user
+
+
+class ContextUtilFuncs():
+    @staticmethod
+    def _check_alias_config_file_exists(vantage_version, alias_config_file):
+        """
+        Function to validate whether alias_config_file exists for the current vantage version.
+
+        PARAMETERS:
+            vantage_version:
+                Required Argument.
+                Specifies the current vantage version.
+
+            alias_config_file:
+                Required Argument.
+                Specifies the location of configuration file to be read.
+
+        RETURNS:
+            True, if the file 'alias_config_file' is present in the
+            teradataml/config directory for the current vantage version.
+
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            ContextUtilFuncs._check_alias_config_file_exists("vantage1.0", "config_file_location")
+
+        """
+        # Raise exception if alias config file is not defined.
+        if not Path(alias_config_file).exists():
+            raise TeradataMlException(Messages.get_message(
+                MessageCodes.CONFIG_ALIAS_CONFIG_FILE_NOT_FOUND).format(alias_config_file,
+                                                                        vantage_version),
+                                      MessageCodes.CONFIG_ALIAS_CONFIG_FILE_NOT_FOUND)
+        return True
+
+    @staticmethod
+    def _get_function_mappings_from_config_file(alias_config_file):
+        """
+        Function to return the function mappings given the location of configuration file in
+        argument 'alias_config_file'.
+
+        PARAMETERS:
+            alias_config_file:
+                Required Argument.
+                Specifies the location of configuration file to be read.
+
+        RETURNS:
+            Function mappings as a dictionary of function_names to alias_names.
+
+        RAISES:
+            TeradataMLException
+
+        EXAMPLES:
+            ContextUtilFuncs._get_function_mappings_from_config_file("config_file_location")
+
+        """
+        repeated_function_names = []
+        function_mappings = {}
+        invalid_function_mappings = []
+        invalid_function_mappings_line_nos = []
+        # Reading configuration files
+        with open(alias_config_file, 'r') as fread:
+            for line_no, line in enumerate(fread.readlines()):
+                line = line.strip()
+
+                # Ignoring empty lines in the config files.
+                if line == "":
+                    continue
+
+                # If the separator ":" is not present.
+                if ':' not in line:
+                    invalid_function_mappings.append(line)
+                    invalid_function_mappings_line_nos.append(str(line_no + 1))
+                else:
+                    func_name, alias_name = line.split(":")
+                    func_name = func_name.strip()
+                    alias_name = alias_name.strip()
+
+                    # First line of 'alias_config_file' has header "functionName:aliasName".
+                    if line_no == 0 and func_name == "functionName" and alias_name == "aliasName":
+                        continue
+
+                    if func_name == "" or alias_name == "":
+                        invalid_function_mappings.append(line)
+                        invalid_function_mappings_line_nos.append(str(line_no + 1))
+                        continue
+
+                    if func_name.lower() in function_mappings:
+                        repeated_function_names.append(func_name.lower())
+
+                    # Loading function maps with lower values for key.
+                    function_mappings[func_name.lower()] = alias_name
+
+        # Presence of Invalid function mappings in the 'alias_config_file'.
+        if len(invalid_function_mappings) > 0:
+            err_ = Messages.get_message(MessageCodes.CONFIG_ALIAS_INVALID_FUNC_MAPPING)
+            err_ = err_.format("', '".join(invalid_function_mappings),
+                               ", ".join(invalid_function_mappings_line_nos),
+                               alias_config_file)
+            raise TeradataMlException(err_, MessageCodes.CONFIG_ALIAS_INVALID_FUNC_MAPPING)
+
+        # Raising teradataml exception if there are any duplicates in function names.
+        if len(repeated_function_names) > 0:
+            raise TeradataMlException(Messages.get_message(
+                MessageCodes.CONFIG_ALIAS_DUPLICATES).format(alias_config_file,
+                                                             ", ".join(repeated_function_names)),
+                                      MessageCodes.CONFIG_ALIAS_DUPLICATES)
+
+        return function_mappings