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

teradataml/context/context.py

@@ -19,17 +19,15 @@ import os
 import socket
 import sys
 import threading
-import urllib.parse
 import warnings
 from pathlib import Path
-from dotenv import dotenv_values
 
+from dotenv import dotenv_values
 from sqlalchemy import create_engine
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.engine.url import URL
 
 from teradataml.common.constants import Query, SQLConstants, TeradataConstants
-from teradataml.common.deprecations import argument_deprecation
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.garbagecollector import GarbageCollector
 from teradataml.common.messagecodes import MessageCodes
@@ -138,7 +136,7 @@ def __cleanup_garbage_collection():
     GarbageCollector._cleanup_garbage_collector()
 
 
-def _get_other_connection_parameters(logmech = None, logdata = None, database = None, **kwargs):
+def _get_other_connection_parameters(logmech=None, logdata=None, database=None, **kwargs):
     """
     DESCRIPTION:
         Internal function to return the connection parameters.
@@ -199,24 +197,27 @@ def _get_other_connection_parameters(logmech = None, logdata = None, database =
 
     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):
+def create_context(host=None, username=None, password=None, tdsqlengine=None, temp_database_name=None,
+                   logmech=None, logdata=None, database=None, **kwargs):
     """
     DESCRIPTION:
         Creates a connection to the Teradata Vantage using the teradatasql + teradatasqlalchemy DBAPI and dialect
         combination.
-        Users can create a connection by passing the connection parameters using any of the following methods:
-            1. Pass all required parameters (host, username, password) directly to the function, OR
+        Users can create a connection by passing the connection parameters using any one of the following methods:
+            1. Pass all required parameters (host, username, password) directly to the function.
             2. Set the connection parameters in a configuration file (.cfg or .env) and
-               pass the configuration file OR
+               pass the configuration file.
             3. Set the connection parameters in environment variables and create_context() reads from
                environment variables.
 
-        Alternatively, users can pass a SQLAlchemy engine to the `tdsqlengine` parameter to override the default DBAPI
+        Alternatively, users can pass a SQLAlchemy engine object to the `tdsqlengine` parameter to override the default DBAPI
         and dialect combination.
 
+        Function also enables user to set the authentication token which is required to access services running
+        on Teradata Vantage.
+
         Note:
             1. teradataml requires that the user has certain permissions on the user's default database or the initial
                default database specified using the database argument, or the temporary database when specified using
@@ -264,6 +265,28 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
                                 os.environ['TD_PASSWORD'] = 'tdpassword'
                 3. A configuration file if provided (such as a .env file).
 
+            4. Points to note when user sets authentication token with create_context():
+                * The username provided in create_context() is not case-sensitive. For example,
+                  if a user is created with the username xyz, create_context() still establishes
+                  a connection if user passes the username as XyZ. However, authentication token
+                  generation requires the username to be in the same case as when it was created.
+                  Therefore, Teradata recommends to pass the username with the same case as when
+                  it was created.
+                * User must have a privilege to login with a NULL password to use set_auth_token().
+                  Refer to GRANT LOGON section in Teradata Documentation for more details.
+                * When "auth_mech" is not specified, arguments are used in the following combination
+                  to derive authentication mechanism.
+                    * If "base_url" and "client_id" are specified then token generation is done through OAuth.
+                    * If "base_url", "pat_token", "pem_file" are specified then token generation is done using PAT.
+                    * If "base_url" and "auth_token" are specified then value provided for "auth_token" is used.
+                    * If only "base_url" is specified then token generation is done through OAuth.
+                * If Basic authentication mechanism is to be used then user must specify argument
+                  "auth_mech" as "BASIC" along with "username" and "password".
+                * Refresh token works only for OAuth authentication.
+                * Use the argument "kid" only when key used during the pem file generation is different
+                  from pem file name. For example, if you use the key as 'key1' while generating pem file
+                  and the name of the pem file is `key1(1).pem`, then pass value 'key1' to the argument "kid".
+
     PARAMETERS:
         host:
             Optional Argument.
@@ -277,39 +300,15 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         
         password:
             Optional Argument.
-            Specifies the password required for the username.
+            Specifies the password required for the "username".
             Types: str
             Note:
                 * Encrypted passwords can also be passed to this argument, using Stored Password Protection feature.
                   Examples section below demonstrates passing encrypted password to 'create_context'.
                   More details on Stored Password Protection and how to generate key and encrypted password file
                   can be found at https://pypi.org/project/teradatasql/#StoredPasswordProtection
-                * Special characters that may be used in the password are encoded by default, except '~'.
-                  The encoding is done using urllib.parse library and can be
-                  disabled by setting "url_encode" = False.
-                  For example, if the password is: "kx%jj5/g", then this password is encoded as below:
-                  "kx%25jj5%2Fg"
-                   where,
-                      %25 represents the '%' character and
-                      %2F represents the '/' character
-                  The details of how the special characters are replaced can be found in the below link:
-                  "https://docs.microfocus.com/OMi/10.62/Content/OMi/ExtGuide/ExtApps/URL_encoding.htm".
-                  Note:
-                      When password contains a space:
-                        * "url_encode" must be set to False.
-                        * In addition to space, other special characters in this password should be manually encoded,
-                          following the link: https://docs.microfocus.com/OMi/10.62/Content/OMi/ExtGuide/ExtApps/URL_encoding.htm
-                          Refer Example 16 in examples section for a detailed demonstration.
-                      
-                      When password contains unreserved characters like tilde("~"), dot("."), underscore("_"), hyphen("-"):
-                        * Character is not URL encoded by default.
-                        * If unreserved character in passed needs to be encoded then,
-                          it must be encoded manually and encoded password must be passed, along with "url_encode" set to False.
-                        * The unreserved characters differ from one Python version to another Python version.
-                          For example, The encoding standards for Python version 3.7 found in the below link:
-                          "https://docs.python.org/3/library/urllib.parse.html#url-quoting".
-                      
-            
+                * Special characters used in the password are encoded by default.
+
         tdsqlengine:
             Optional Argument.
             Specifies Teradata Vantage sqlalchemy engine object that should be used to establish a Teradata Vantage
@@ -347,18 +346,23 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
             Types: str
 
         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
-            on connection parameters of the driver.
-            Note: When the type of a connection parameter is integer or boolean (eg: log, lob_support etc,.), pass
-                  integer or boolean value, instead of quoted integer or quoted boolean as suggested in the
-                  documentation. Please check the examples for usage.
+            Specifies optional keyword arguments accepted by create_context().
+            Below are the supported keyword arguments:
+
+            Connection parameters for Teradata SQL Driver:
+                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
+                on connection parameters of the driver.
+                Note:
+                    * When type of a connection parameter is integer or boolean (eg: log, lob_support etc,.), pass
+                      integer or boolean value, instead of quoted integer or quoted boolean as suggested in the
+                      documentation. Please check the examples for usage.
+                    * "sql_timeout" represents "request_timeout" connection parameter.
 
             config_file:
-                Optional Argument.
                 Specifies the name of the configuration file to read the connection parameters.
                 Notes:
-                    * If user do not specify full path of file,then file look up is done at current working directory.
+                    * If user does not specify full path of file, then file look up is done at current working directory.
                     * The content of the file must be in '.env' format.
                     * Use parameters of create_context() as key in the configuration file.
                       Example:
@@ -373,6 +377,73 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
                 Default Value : td_properties.cfg
                 Types: str
 
+            base_url:
+                Specifies the endpoint URL for a given environment on Teradata Vantage.
+                Types: str
+
+            client_id:
+                Specifies the id of the application that requests the access token from
+                VantageCloud Lake.
+                Types: str
+
+            pat_token:
+                Specifies the PAT token generated from VantageCloud Lake Console.
+                Types: str
+
+            pem_file:
+                Specifies the path to private key file which is generated from VantageCloud Lake Console.
+                Types: str
+
+            auth_token:
+                Specifies the authentication token required to access services running
+                on Teradata Vantage.
+
+            expiration_time:
+                Specifies the expiration time of the token in seconds. After expiry time JWT token expires and
+                UserEnv methods does not work, user should regenerate the token.
+                Note:
+                    This option is used only for PAT and not for OAuth.
+                Default Value: 31536000
+                Types: int
+
+            kid:
+                Specifies the name of the key which is used while generating 'pem_file'.
+                Note:
+                    * Use the argument "kid" only when key used during the pem file generation is different
+                      from pem file name. For example, if you use the key as 'key1' while generating pem file
+                      and the name of the pem file is `key1(1).pem`, then pass value 'key1' to the argument "kid".
+                Types: str
+
+            auth_url:
+                Optional Argument.
+                Specifies the endpoint URL for a keycloak server.
+                Types: str
+
+            rest_client:
+                Optional Argument.
+                Specifies the service for which keycloak token is to be generated.
+                Permitted values: "VECTORSTORE"
+                Default value: "VECTORSTORE"
+                Types: str
+
+            auth_mech:
+                Specifies the mechanism to be used for generating authentication token.
+                Notes:
+                    * User must use this argument if Basic authentication is to be used.
+                    * When "auth_mech" is provided, other arguments are used in the following
+                      combination as per value of "auth_mech":
+                        * OAuth: Token generation is done through OAuth by using client id
+                                 which can be sepcified by user in "client_id" argument or
+                                 can be derived internally from "base_url".
+                        * PAT  : Token generation is done using "pat_token" and "pem_file".
+                        * BASIC: Authentication is done via Basic authentication mechanism
+                                 using user credentials passed in "username" and "password"
+                                 arguments.
+                        * JWT  : Readily available token in "auth_token" argument is used.
+                        * KEYCLOAK: Token generation is done using keycloak.
+                Permitted Values: "OAuth", "PAT", "BASIC", "JWT", "KEYCLOAK".
+                Types: str
+
     RETURNS:
         A Teradata sqlalchemy engine object.
 
@@ -383,7 +454,7 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         >>> from teradataml.context.context import *
 
         # Example 1: Create context using hostname, username and password
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword')
 
         # Example 2: Create context using already created sqlalchemy engine
         >>> from sqlalchemy import create_engine
@@ -391,56 +462,56 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         >>> td_context = create_context(tdsqlengine = sqlalchemy_engine)
 
         # Example 3: Creating context for Vantage with default logmech 'TD2'
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', logmech='TD2')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', logmech = 'TD2')
 
        # Example 4: Creating context for Vantage with logmech as 'TDNEGO'
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', logmech='TDNEGO')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', logmech = 'TDNEGO')
 
         # Example 5: Creating context for Vantage with logmech as 'LDAP'
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', logmech='LDAP')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', logmech = 'LDAP')
 
         # Example 6: Creating context for Vantage with logmech as 'KRB5'
-        >>> td_context = create_context(host = 'tdhost', logmech='KRB5')
+        >>> td_context = create_context(host = 'tdhost', logmech = 'KRB5')
 
         # Example 7: Creating context for Vantage with logmech as 'JWT'
-        >>> td_context = create_context(host = 'tdhost', logmech='JWT', logdata='token=eyJpc...h8dA')
+        >>> td_context = create_context(host = 'tdhost', logmech = 'JWT', logdata = 'token=eyJpc...h8dA')
 
         # Example 8: Create context using encrypted password and key passed to 'password' parameter.
-        # The password should be specified in the format mentioned below:
-        # ENCRYPTED_PASSWORD(file:<PasswordEncryptionKeyFileName>, file:<EncryptedPasswordFileName>)
-        # The PasswordEncryptionKeyFileName specifies the name of a file that contains the password encryption key
-        # and associated information.
-        # The EncryptedPasswordFileName specifies the name of a file that contains the encrypted password and
-        # associated information.
-        # Each filename must be preceded by the 'file:' prefix. The PasswordEncryptionKeyFileName must be separated
-        # from the EncryptedPasswordFileName by a single comma.
+        #            The password should be specified in the format mentioned below:
+        #            ENCRYPTED_PASSWORD(file:<PasswordEncryptionKeyFileName>, file:<EncryptedPasswordFileName>)
+        #            The PasswordEncryptionKeyFileName specifies the name of a file that contains the password encryption key
+        #            and associated information.
+        #            The EncryptedPasswordFileName specifies the name of a file that contains the encrypted password and
+        #            associated information.
+        #            Each filename must be preceded by the 'file:' prefix. The PasswordEncryptionKeyFileName must be separated
+        #            from the EncryptedPasswordFileName by a single comma.
         >>> encrypted_password = "ENCRYPTED_PASSWORD(file:PassKey.properties, file:EncPass.properties)"
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = encrypted_password)
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = encrypted_password)
 
         # Example 9: Create context using encrypted password in LDAP logon mechanism.
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = encrypted_password,
-                                        logmech='LDAP')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = encrypted_password,
+        ...                             logmech = 'LDAP')
 
        # Example 10: Create context using hostname, username, password and database parameters, and connect to a
        # different initial database by setting the database parameter.
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', database =
-                                        'database_name')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', database =
+        ...                            'database_name')
 
         # Example 11: Create context using already created sqlalchemy engine, and connect to a different initial
         # database by setting the database parameter.
         >>> from sqlalchemy import create_engine
         >>> sqlalchemy_engine = create_engine('teradatasql://'+ tduser +':' + tdpassword + '@'+tdhost +
-                                               '/?DATABASE=database_name')
+        ...                                   '/?DATABASE=database_name')
         >>> td_context = create_context(tdsqlengine = sqlalchemy_engine)
 
         # Example 12: Create context for Vantage with logmech as 'LDAP', and connect to a different initial
         # database by setting the database parameter.
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', logmech='LDAP',
-                                        database = 'database_name')
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', logmech = 'LDAP',
+        ...                             database = 'database_name')
 
         # Example 13: Create context using 'tera' mode with log value set to 8 and lob_support disabled.
-        >>> td_context = create_context(host = 'tdhost', username='tduser', password = 'tdpassword', tmode = 'tera',
-                                        log = 8, lob_support = False)
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', tmode = 'tera',
+        ...                             log = 8, lob_support = False)
 
         # Example 14: Create context from config file with name 'td_properties.cfg'
         #             available under current working directory.
@@ -464,7 +535,7 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         #                 logmech=tdlogmech
         #                 logdata=tdlogdata
         #                 database=tddatabase
-        >>> td_context = create_context(config_file="user_td_properties.cfg")
+        >>> td_context = create_context(config_file = "user_td_properties.cfg")
 
         # Example 16: Create context using environment variables.
         #             Set these using os.environ and then run the example:
@@ -476,6 +547,66 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
         #                  os.environ['TD_LOGDATA'] = 'tdlogdata'
         #                  os.environ['TD_DATABASE'] = 'tddatabase'
         >>> td_context = create_context()
+
+        # Example 17: Create a context by providing username and password. Along with it,
+        #             set authentication token by providing the pem file and pat token.
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword',
+        ...                             base_url = 'base_url', pat_token = 'pat_token', pem_file = 'pem_file')
+
+        # Example 18: Create a context by providing username and password. Along with it,
+        #             generate authentication token by providing the client id.
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword',
+        ...                             base_url = 'base_url', client_id = 'client_id')
+
+        # Example 19: Create context and set authentication token by providing all the details in a config file.
+        #             td_properties.cfg content:
+        #                 host=tdhost
+        #                 username=tduser
+        #                 password=tdpassword
+        #                 base_url=base_url
+        #                 pat_token=pat_token
+        #                 pem_file=pem_file
+        >>> td_context = create_context()
+
+        # Example 20: Create context and set authentication token by providing all the details in environment variables.
+        #             Set these using os.environ and then run the example:
+        #                  os.environ['TD_HOST'] = 'tdhost'
+        #                  os.environ['TD_USERNAME'] = 'tduser'
+        #                  os.environ['TD_PASSWORD'] = 'tdpassword'
+        #                  os.environ['TD_BASE_URL'] = 'base_url'
+        #                  os.environ['TD_PAT_TOKEN'] = 'pat_token'
+        #                  os.environ['TD_PEM_FILE'] = 'pem_file'
+        >>> td_context = create_context()
+
+        # Example 21: Create context with sql_timeout set to 3.
+        >>> td_context = create_context(host = 'tdhost', username = 'tduser', password = 'tdpassword', sql_timeout = 3)
+
+        # Example 22: Create context and set authentication token via Basic authentication mechanism
+        #             using username and password.
+        >>> import getpass
+        >>> create_context(host="host",
+        ...                username=getpass.getpass("username : "),
+        ...                password=getpass.getpass("password : "),
+        ...                base_url=getpass.getpass("base_url : "),
+        ...                auth_mech="BASIC")
+
+        # Example 23: Create context and set authentication token by providing auth_mech argument.
+        >>> import getpass
+        >>> create_context(host="vcl_host",
+        ...                username=getpass.getpass("username : "),
+        ...                password=getpass.getpass("password : "),
+        ...                base_url=getpass.getpass("base_url : "),
+        ...                auth_mech="OAuth")
+
+        # Example 24: Create context and set authentication token by providing auth_url and
+        #             rest_client arguments.
+        >>> import getpass
+        >>> create_context(host="host",
+        ...                username=getpass.getpass("username : "),
+        ...                password=getpass.getpass("password : "),
+        ...                base_url=getpass.getpass("base_url : "),
+        ...                auth_url=getpass.getpass("auth_url : "),
+        ...                rest_client=getpass.getpass("rest_client : "))
     """
     global td_connection
     global td_sqlalchemy_engine
@@ -489,7 +620,7 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     # Check if the user has provided the connection parameters or tdsqlengine.
     # If not, check if the user has provided the connection parameters in the environment variables.
     # If not, check if the user has provided the connection parameters in the config file.
-    if not (host or tdsqlengine) and host!="":
+    if not (host or tdsqlengine) and host != "":
         return _load_context_from_env_config(kwargs.pop('config_file', 'td_properties.cfg'))
 
     awu_matrix = []
@@ -500,13 +631,24 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     awu_matrix.append(["logmech", logmech, True, (str), True])
     awu_matrix.append(["logdata", logdata, True, (str), True])
     awu_matrix.append(["database", database, True, (str), True])
+    # set_auth_token parameters
+    _set_auth_token_params = {}
+    auth_mech = kwargs.get('auth_mech', None)
+    for param in ['base_url', 'pat_token', 'pem_file', 'client_id', 'auth_token', 'expiration_time',
+                  'kid', 'auth_mech', 'auth_url', 'rest_client']:
+        if kwargs.get(param):
+            _set_auth_token_params[param] = kwargs.pop(param)
+
+    # Set the "sql_timeout" parameter to "request_timeout" which is consumed by teradatasql.
+    if kwargs.get('sql_timeout'):
+        awu_matrix.append(["sql_timeout", kwargs.get('sql_timeout'), True, (int), True])
+        kwargs['request_timeout'] = kwargs.pop('sql_timeout')
 
     awu = _Validators()
     awu._validate_function_arguments(awu_matrix)
 
     # Clearing the internal buffer.
     _InternalBuffer.clean()
-
     if logmech == "JWT" and not logdata:
         raise TeradataMlException(Messages.get_message(MessageCodes.DEPENDENT_ARG_MISSING,
                                                        'logdata',
@@ -541,7 +683,6 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
             host_value = '{}:@{}'.format(username, host)
         else:
             host_value = '{}:{}@{}'.format(username, password, host)
-
         url_object = URL.create(
             "teradatasql",
             username=username,
@@ -555,7 +696,7 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
             td_connection = td_sqlalchemy_engine.connect()
             td_user = username.upper()
 
-            # Masking senstive information - password, logmech and logdata.
+            # Masking sensitive information - password, logmech and logdata.
             if password:
                 try:
                     # Below statement raises an AttributeError with SQLAlchemy
@@ -578,9 +719,6 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
             raise TeradataMlException(Messages.get_message(MessageCodes.CONNECTION_FAILURE),
                                       MessageCodes.CONNECTION_FAILURE) from err
 
-    # Load function aliases from config.
-    _load_function_aliases()
-
     python_packages_installed = False
     python_version_vantage = None
     python_version_local = sys.version.split(" ")[0].strip()
@@ -607,21 +745,42 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     # Process Analytic functions.
     from teradataml.analytics import _process_analytic_functions
     _process_analytic_functions()
-    
+
+    if _set_auth_token_params.get('base_url'):
+        from teradataml.scriptmgmt.lls_utils import set_auth_token
+        try:
+            # password needs to be passed to set_auth_token only when any of the following is True:
+            # 1. auth_mech is set to either 'basic' or 'keycloak'
+            # 2. 'auth_url' argument is passed which represents 'keycloak' authentication mechanism.
+            if ((auth_mech and auth_mech.lower() in ['basic', 'keycloak']) or
+                _set_auth_token_params.get('auth_url'))\
+                    and password:
+                _set_auth_token_params['password'] = password
+            set_auth_token(**_set_auth_token_params)
+        except Exception as err:
+            print("Connection to Vantage established successfully.")
+            mssg = f"Failed to set authentication token. Rerun \"set_auth_token()\" again to set the authentication token." \
+                   f" Reason for failure: {err.args[0]}"
+            warnings.warn(mssg, stacklevel=2)
+
     # Add global lock to internal buffer
     _InternalBuffer.add(global_lock=threading.Lock())
 
+    # Set _check_py_version to True to check the python version between local and Vantage.
+    _InternalBuffer.add(_check_py_version=True)
+
     # Return the connection by default
     return td_sqlalchemy_engine
 
-def _load_context_from_env_config(config_file):
+
+def _load_context_from_env_config(config_file=None):
     """
     DESCRIPTION:
         Reads the connection parameters from the configuration file or environment variables.
 
     PARAMETERS:
         config_file:
-            Required Argument.
+            Optional Argument.
             Specifies the name of the configuration file to read the connection parameters.
             Types: str
 
@@ -632,16 +791,17 @@ def _load_context_from_env_config(config_file):
         TeradataMlException
     """
     host = os.environ.get('TD_HOST')
-    connection_params_from_file = dotenv_values(config_file)
     if host:
         connection_params_from_env = {key[3:].lower(): value for key, value in os.environ.items()
                                       if key.startswith('TD_')}
         return create_context(**connection_params_from_env)
-    elif connection_params_from_file.get('host'):
-        return create_context(**connection_params_from_file)
-    else:
-        raise TeradataMlException(Messages.get_message(MessageCodes.CONNECTION_PARAMS),
-                                  MessageCodes.MISSING_ARGS)
+    elif config_file is not None:
+        connection_params_from_file = dotenv_values(config_file)
+        if connection_params_from_file.get('host'):
+            return create_context(**connection_params_from_file)
+    raise TeradataMlException(Messages.get_message(MessageCodes.CONNECTION_PARAMS),
+                              MessageCodes.MISSING_ARGS)
+
 
 def _mask_logmech_logdata():
     """
@@ -767,19 +927,19 @@ def set_context(tdsqlengine, temp_database_name=None):
     else:
         return None
 
-    # Load function aliases from config.
-    _load_function_aliases()
-
     python_packages_installed = False
     python_version_vantage = None
     python_version_local = sys.version.split(" ")[0].strip()
 
     # Initialise Dag
     __initalise_dag()
-    
+
     # Add global lock to internal buffer
     _InternalBuffer.add(global_lock=threading.Lock())
 
+    # Set _check_py_version to True to check the python version between local and Vantage.
+    _InternalBuffer.add(_check_py_version=True)
+
     return td_connection
 
 
@@ -813,6 +973,9 @@ def remove_context():
     # Initiate the garbage collection
     __cleanup_garbage_collection()
 
+    # Clearing the internal buffer.
+    _InternalBuffer.clean()
+
     # Check if connection is established or not.
     if user_specified_connection is not True:
         try:
@@ -1117,6 +1280,7 @@ def _get_user():
         td_user = _get_database_username()
     return td_user
 
+
 def _get_host():
     """
     DESCRIPTION:
@@ -1139,6 +1303,7 @@ def _get_host():
     else:
         return td_sqlalchemy_engine.url.host
 
+
 def _get_host_ip():
     """
     DESCRIPTION:
@@ -1159,7 +1324,7 @@ def _get_host_ip():
     # Return None if connection is not established.
     if td_connection is None:
         return None
-    
+
     host = _get_host()
     try:
         # Validate if host_ip is a valid IP address (IPv4 or IPv6)
@@ -1170,7 +1335,7 @@ def _get_host_ip():
         dns_host_ip = _InternalBuffer.get('dns_host_ip')
         if dns_host_ip:
             return dns_host_ip
-        
+
         # If DNS host ip not found, resolve the host name to get the IP address.
         # If there is issue in resolving the host name, it will proceed with DNS host as it is.
         try:
@@ -1185,6 +1350,7 @@ def _get_host_ip():
             host_ip = host
     return host_ip
 
+
 class ContextUtilFuncs():
     @staticmethod
     def _check_alias_config_file_exists(vantage_version, alias_config_file):

teradataml/data/apriori_example.json

@@ -0,0 +1,22 @@
+{
+    "trans_dense": {
+      "location": "varchar(100)",
+      "tranid": "int",
+      "period": "varchar(20)",
+      "storeid": "int",
+      "region": "varchar(20)",
+      "item": "varchar(200)",
+      "sku": "int",
+      "category": "varchar(20)"
+    },
+    "trans_sparse": {
+      "location": "varchar(20)",
+      "tranid": "int",
+      "period": "varchar(20)",
+      "storeid": "int",
+      "region": "varchar(20)",
+      "item": "varchar(20)",
+      "sku": "int",
+      "category": "varchar(20)"
+    }
+}