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

teradataml/common/messages.py

@@ -168,6 +168,8 @@ class Messages():
             [ErrorInfoCodes.UNSUPPORTED_FILE_EXTENSION, MessageCodes.UNSUPPORTED_FILE_EXTENSION],
             [ErrorInfoCodes.FILE_EMPTY, MessageCodes.FILE_EMPTY],
             [ErrorInfoCodes.PYTHON_NOT_INSTALLED, MessageCodes.PYTHON_NOT_INSTALLED],
+            [ErrorInfoCodes.PYTHON_VERSION_MISMATCH, MessageCodes.PYTHON_VERSION_MISMATCH],
+            [ErrorInfoCodes.PYTHON_VERSION_MISMATCH_OAF, MessageCodes.PYTHON_VERSION_MISMATCH_OAF],
             [ErrorInfoCodes.INT_ARGUMENT_COMPARISON, MessageCodes.INT_ARGUMENT_COMPARISON],
             [ErrorInfoCodes.EXECUTION_FAILED, MessageCodes.EXECUTION_FAILED],
             [ErrorInfoCodes.INVALID_COLUMN_DATATYPE, MessageCodes.INVALID_COLUMN_DATATYPE],
@@ -192,7 +194,8 @@ class Messages():
             [ErrorInfoCodes.INVALID_PARTITIONING_COLS, MessageCodes.INVALID_PARTITIONING_COLS],
             [ErrorInfoCodes.PATH_NOT_FOUND, MessageCodes.PATH_NOT_FOUND],
             [ErrorInfoCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE, MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE],
-            [ErrorInfoCodes.AUTH_TOKEN_REQUIRED, MessageCodes.AUTH_TOKEN_REQUIRED],
+            [ErrorInfoCodes.SET_REQUIRED_PARAMS, MessageCodes.SET_REQUIRED_PARAMS],
+            [ErrorInfoCodes.MISSING_ARGS, MessageCodes.CONNECTION_PARAMS]
     ]
 
     @staticmethod

teradataml/common/sqlbundle.py

@@ -40,9 +40,9 @@ class SQLBundle:
                 [SQLConstants.SQL_BASE_QUERY, "SELECT * FROM {0}"],
                 [SQLConstants.SQL_SAMPLE_QUERY, " {0} SAMPLE {1}"],
                 [SQLConstants.SQL_SAMPLE_WITH_WHERE_QUERY, " {0} WHERE {1} SAMPLE {2}"],
-                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_FROM_QUERY_WITH_DATA, "CREATE MULTISET VOLATILE TABLE {0} AS ({1}) WITH DATA ON COMMIT PRESERVE ROWS"],
-                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_FROM_QUERY_WITHOUT_DATA, "CREATE MULTISET VOLATILE TABLE {0} AS ({1}) WITH NO DATA"],
-                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_USING_COLUMNS, "CREATE MULTISET VOLATILE TABLE {0}( {1} )"],
+                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_FROM_QUERY_WITH_DATA, "CREATE MULTISET VOLATILE TABLE {0} AS ({1}) WITH DATA NO PRIMARY INDEX ON COMMIT PRESERVE ROWS"],
+                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_FROM_QUERY_WITHOUT_DATA, "CREATE MULTISET VOLATILE TABLE {0} AS ({1}) WITH NO DATA NO PRIMARY INDEX"],
+                [SQLConstants.SQL_CREATE_VOLATILE_TABLE_USING_COLUMNS, "CREATE MULTISET VOLATILE TABLE {0}( {1} ) NO PRIMARY INDEX"],
                 [SQLConstants.SQL_CREATE_TABLE_FROM_QUERY_WITH_DATA, "CREATE MULTISET TABLE {0} AS ({1}) WITH DATA"],
                 [SQLConstants.SQL_HELP_COLUMNS, "help column {0}.*"],
                 [SQLConstants.SQL_DROP_TABLE, "DROP TABLE {0}"],
@@ -69,6 +69,8 @@ class SQLBundle:
                 [SQLConstants.SQL_CREATE_TABLE_USING_COLUMNS, "CREATE MULTISET TABLE {0}( {1} )"],
                 [SQLConstants.SQL_EXEC_STORED_PROCEDURE, "call {0}"],
                 [SQLConstants.SQL_SELECT_COLUMNNAMES_WITH_WHERE, "sel {0} from {1} where {2}"],
+                [SQLConstants.SQL_HELP_DATABASE, "HELP DATABASE {0}"],
+                [SQLConstants.SQL_HELP_DATALAKE, "HELP DATALAKE {0}"]
 
         ]
         self._add_sql_version()
@@ -257,14 +259,15 @@ class SQLBundle:
         return query.format(tablename, select_query)
 
     @staticmethod
-    def _build_drop_table(tablename):
+    def _build_drop_table(tablename, purge_clause=None):
         """
         Returns a drop table DDL statement for a table.
         Example:
             drop table mytab
 
         PARAMETERS:
-            tablename - The table to drop
+            tablename - The table to drop.
+            purge_clause - String representing purge clause.
 
         RETURNS:
             Returns a drop table DDL statement for the table.
@@ -273,12 +276,17 @@ class SQLBundle:
             None
 
         EXAMPLES:
-            dropstmt = SQLBundle._build_drop_table('mytab')
-
+            drop_stmt = SQLBundle._build_drop_table('my_tab')
+            drop_stmt = SQLBundle._build_drop_table("my_lake"."my_db"."my_tab",
+                                                    purge_clause='PURGE ALL')
+            drop_stmt = SQLBundle._build_drop_table("my_lake"."my_db"."my_tab",
+                                                    purge_clause='NO PURGE')
         """
         sqlbundle = SQLBundle()
-        dropstmt = sqlbundle._get_sql_query(SQLConstants.SQL_DROP_TABLE)
-        return dropstmt.format(tablename)
+        drop_stmt = sqlbundle._get_sql_query(SQLConstants.SQL_DROP_TABLE).format(tablename)
+        if purge_clause:
+            drop_stmt = "{} {}".format(drop_stmt, purge_clause)
+        return drop_stmt
 
     @staticmethod
     def _build_drop_view(viewname):
@@ -400,6 +408,28 @@ class SQLBundle:
         return sqlbundle._get_sql_query(SQLConstants.SQL_HELP_VOLATILE_TABLE)
 
     @staticmethod
+    def _build_help_datalake(datalake_name):
+        """
+        Builds a query to get help on datalake.
+
+        Example:
+            "HELP DATALAKE datalake_name;"
+
+        PARAMETERS:
+
+        RETURNS:
+            returns a HELP DATALAKE <datalake_name> command.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            query = SQLBundle._build_help_datalake(datalake_name)
+        """
+        sqlbundle = SQLBundle()
+        help_datalake_sql = sqlbundle._get_sql_query(SQLConstants.SQL_HELP_DATALAKE)
+        return help_datalake_sql.format(datalake_name)
+
     def _build_select_table_name(tab_name):
         """
         Builds a query to get table name from DBC.TABLESV
@@ -463,7 +493,7 @@ class SQLBundle:
                     # Extracting table name without '%' character
                     table_name_str = table_name.replace('%', '')
 
-                    # Adding condition to check if table name contains the string using POSITION function
+                    # Adding condition to check if table name contains the string using POSITION function.
                     # POSITION function returns the position index of the substring in the string if found,
                     # else returns 0
                     query = "{0}{1}{2}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME_LIKE).format(table_name), \

teradataml/common/utils.py

@@ -311,6 +311,10 @@ class UtilFuncs():
             tabname = "\"{}\".\"{}\"".format(_get_user(), tabname)
             return tabname
 
+        if configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
+            from teradataml.context.context import _get_user
+            return "\"{}\".\"{}_{}\"".format(_get_user(), "vt", tabname)
+
         if use_default_database and databasename is None:
             tabname = "\"{}\".\"{}\"".format(tdmlctx._get_context_temp_databasename(
                 table_type=table_type), tabname)
@@ -694,6 +698,7 @@ class UtilFuncs():
         EXAMPLES:
             UtilFuncs._create_table('"dbname"."table_name"', "select * from table_name")
         """
+
         crt_table = SQLBundle._build_create_table_with_data(table_name, query)
         if volatile:
             crt_table = SQLBundle._build_create_volatile_table_with_data(table_name, query)
@@ -757,13 +762,14 @@ class UtilFuncs():
         return vtab_name
 
     @staticmethod
-    def _drop_table(table_name, check_table_exist=True):
+    def _drop_table(table_name, check_table_exist=True, purge_clause=None):
         """
         Drops a table.
 
         PARAMETERS:
             table_name - The table to drop.
             check_table_exist - Checks if the table exist before dropping the table.
+            purge_clause - Specifies string representing purge clause to be appended to drop table query.
 
         RETURNS:
             True - if the table is dropped.
@@ -776,9 +782,11 @@ class UtilFuncs():
             UtilFuncs._drop_table('mytab', check_table_exist = False)
             UtilFuncs._drop_table('mydb.mytab', check_table_exist = False)
             UtilFuncs._drop_table("mydb"."mytab", check_table_exist = True)
+            UtilFuncs._drop_table("my_lake"."my_db"."my_tab", purge_clause='PURGE ALL')
+            UtilFuncs._drop_table("my_lake"."my_db"."my_tab", purge_clause='NO PURGE')
 
         """
-        drop_tab = SQLBundle._build_drop_table(table_name)
+        drop_tab = SQLBundle._build_drop_table(table_name, purge_clause)
         if check_table_exist is True:
             helptable = UtilFuncs._get_help_tablename(table_name)
             if helptable:
@@ -958,6 +966,22 @@ class UtilFuncs():
         """
         return UtilFuncs._execute_query(SQLBundle._build_help_table(table_name))
 
+    @staticmethod
+    def _get_help_datalakename(datalake_name):
+        """
+        Function to get help of the datalake.
+
+        PARAMETERS:
+            datalake_name - The name of the datalake.
+
+        RETURNS:
+            The help information of the datalake specified by datalake_name.
+
+        EXAMPLES:
+            UtilFuncs._get_help_datalakename(mydatalake)
+        """
+        return UtilFuncs._execute_query(SQLBundle._build_help_datalake(datalake_name))
+
     @staticmethod
     def _get_select_table(table_name):
         """
@@ -1286,43 +1310,71 @@ class UtilFuncs():
             return any(UtilFuncs._contains_space(col) for col in item)  
 
         return False  
-
-    @staticmethod
-    def _in_schema(schema_name, table_name):
+    
+    def _is_ascii(col_lst):
         """
-        Function takes a schema name and a table name and creates a database
-        object name in the format "schema"."table_name".
-        Note:
-            teradataml recommends to use this function to access table(s)/view(s),
-            from the database other than the default database.
+        Description:
+            Check if the specified string in col_lst has non-ASCII characters in it.
 
         PARAMETERS:
-            schema_name:
-                Required Argument
-                Specifies the schema where the table resides in.
-                Types: str
+            col_lst:
+                Required Argument.
+                Specifies a list of strings to check for non-ASCII characters.
+                Types: list
 
-            table_name:
-                Required Argument
-                Specifies the table name or view name in Vantage.
-                Types: str
+        RETURNS:
+            True, if the specified string has non-ASCII characters in it, else False.
 
+        RAISES:
+            None.
+        
         EXAMPLES:
-            from teradataml.dataframe.dataframe import in_schema, DataFrame
+            # Passing column name with non-ASCII characters returns True.
+            >>> is_non_ascii = UtilFuncs._is_ascii(["col name", "がく片の長さ@name"])
+            >>> print(is_non_ascii)
+            >>> True
+            # Passing column name without non-ASCII characters returns False.
+            >>> is_non_ascii = UtilFuncs._is_ascii(["colname", "col_name"])
+            >>> print(is_non_ascii)
+            >>> False
+        """
+        if isinstance(col_lst, str):
+            # Check if the input is a string and look for non-ASCII characters
+            return not col_lst.isascii()
+
+        if isinstance(col_lst, list):
+            for item in col_lst:
+                if isinstance(item, str) and not item.isascii():
+                    return True
+        return False
+
+    @staticmethod
+    def __get_dot_separated_names(full_qualified_name):
+        """
+        Takes in fully qualified name of the table/view (db.table), and returns
+        a dot separated name from the same.
+
+        PARAMETERS:
+            full_qualified_name - Name of the table/view
 
-            # Example 1: The following example creates a DataFrame from the
-            #            existing Vantage table "dbcinfo" in the non-default
-            #            database "dbc" using the in_schema() function.
-            df = DataFrame(in_schema("dbc", "dbcinfo"))
+        EXAMPLES:
+            UtilFuncs._extract_db_name('"db1"."tablename"')
+            UtilFuncs._extract_db_name('"Icebergs"."db1"."tablename"')
 
-            # Example 2: The following example uses from_table() function, existing
-            #            Vantage table "dbcinfo" and non-default database "dbc" to
-            #            create a teradataml DataFrame.
-            df = DataFrame.from_table(in_schema("dbc","dbcinfo"))
+        RETURNS:
+            List of dot separated name from the provided name.
 
         """
-        return "{0}.{1}".format(UtilFuncs._teradata_quote_arg(schema_name, "\"", False),
-                                UtilFuncs._teradata_quote_arg(table_name, "\"", False))
+        # If condition to handle the quoted name.
+        if '"' in full_qualified_name:
+            # Extract the double quoted strings.
+            names = re.findall(r'["](.*?)["]', full_qualified_name)
+            # Remove quotes around the string.
+            names = [i.replace('"', '') for i in names]
+        # Handle non-quoted string with dot separated name.
+        else:
+            names = full_qualified_name.split(".")
+        return names
 
     @staticmethod
     def _extract_db_name(full_qualified_name):
@@ -1334,19 +1386,19 @@ class UtilFuncs():
             full_qualified_name - Name of the table/view
 
         EXAMPLES:
-            UtilFuncs._extract_db_name("db1"."tablename")
+            UtilFuncs._extract_db_name('"db1"."tablename"')
+            UtilFuncs._extract_db_name('"Icebergs"."db1"."tablename"')
 
         RETURNS:
             Database name from the provided name.
 
         """
-        # Extract the double quoted strings.
-        names = re.findall(r'["](.*?)["]', full_qualified_name)
-        # Remove quotes around the string.
-        names = [i.replace('"', '') for i in names]
+        names = UtilFuncs.__get_dot_separated_names(full_qualified_name)
         if names:
             if len(names) == 2:
                 return names[0]
+            elif len(names) == 3:
+                return names[1]
         else:
             return None
 
@@ -1360,23 +1412,45 @@ class UtilFuncs():
             full_qualified_name - Name of the table/view
 
         EXAMPLES:
-            UtilFuncs._extract_db_name("db1"."tablename")
+            UtilFuncs._extract_table_name('"db1"."tablename"')
+            UtilFuncs._extract_table_name('"Icebergs"."db1"."tablename"')
 
         RETURNS:
             Table/View name from the provided name.
 
         """
-        # Extract the double quoted strings.
-        names = re.findall(r'["](.*?)["]', full_qualified_name)
-        # Remove quotes around the string.
-        names = [i.replace('"', '') for i in names]
+        names = UtilFuncs.__get_dot_separated_names(full_qualified_name)
         if names:
             if len(names) == 2:
                 return names[1]
+            elif len(names) == 3:
+                return names[2]
             else:
                 return names[0]
         return full_qualified_name
 
+    @staticmethod
+    def _extract_datalake_name(full_qualified_name):
+        """
+        Takes in fully qualified name of the table/view (db.table), and returns
+        a datalake name from the same.
+
+        PARAMETERS:
+            full_qualified_name - Name of the table/view
+
+        EXAMPLES:
+            UtilFuncs._extract_datalake_name('"db1"."tablename"')
+            UtilFuncs._extract_datalake_name('"Icebergs"."db1"."tablename"')
+
+        RETURNS:
+            Database name from the provided name.
+
+        """
+        names = UtilFuncs.__get_dot_separated_names(full_qualified_name)
+        if names and len(names) == 3:
+            return names[0]
+        return None
+
     @staticmethod
     def _teradata_quote_arg(args, quote="'", call_from_wrapper=True):
         """

teradataml/common/warnings.py

@@ -17,9 +17,20 @@ class VantageRuntimeWarning(RuntimeWarning):
     """
     pass
 
+
 class TeradataMlRuntimeWarning(RuntimeWarning):
     """
     The TeradataMlRuntimeWarning is thrown whenever there are Warnings in runtime execution of objects in teradataml.
     """
     # For future purpose
     pass
+
+
+
+class OneTimeUserWarning(UserWarning):
+    """
+    The OneTimeUserWarning is thrown when the warning should only be displayed once to the user.
+    This can be useful for deprecation warnings, configuration issues, or other
+    non-critical warnings that do not need to be repeated multiple times.
+    """
+    pass

teradataml/context/context.py

@@ -13,32 +13,35 @@ 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.
 
 """
+import atexit
 import ipaddress
+import os
+import socket
+import sys
+import threading
+import urllib.parse
+import warnings
 from pathlib import Path
+from dotenv import dotenv_values
+
 from sqlalchemy import create_engine
-from teradataml.telemetry_utils.queryband import collect_queryband
+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.warnings import TeradataMlRuntimeWarning
-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.constants import SQLConstants
-from teradataml.common.garbagecollector import GarbageCollector
+from teradataml.common.warnings import TeradataMlRuntimeWarning
 from teradataml.context.aed_context import AEDContext
-from teradataml.common.constants import TeradataConstants, Query
 from teradataml.options.configure import configure
+from teradataml.telemetry_utils.queryband import collect_queryband
+from teradataml.utils.internal_buffer import _InternalBuffer
 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
-import socket
-import threading
-import urllib.parse
 
 # Store a global Teradata Vantage Connection.
 # Right now user can only provide a single Vantage connection at any point of time.
@@ -47,6 +50,8 @@ td_sqlalchemy_engine = None
 temporary_database_name = None
 user_specified_connection = False
 python_packages_installed = False
+python_version_vantage = None
+python_version_local = None
 td_user = None
 
 function_alias_mappings = {}
@@ -201,9 +206,16 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     """
     DESCRIPTION:
         Creates a connection to the Teradata Vantage using the teradatasql + teradatasqlalchemy DBAPI and dialect
-        combination. Users can pass all required parameters (host, username, password) for establishing a connection to
-        Vantage, or pass a sqlalchemy engine to the tdsqlengine parameter to override the default 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
+            2. Set the connection parameters in a configuration file (.cfg or .env) and
+               pass the configuration file OR
+            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
+        and dialect combination.
 
         Note:
             1. teradataml requires that the user has certain permissions on the user's default database or the initial
@@ -241,6 +253,17 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
                |                                                      | default database.                           |
                +------------------------------------------------------+---------------------------------------------+
 
+            3. The function prioritizes parameters in the following order:
+                1. Explicitly passed arguments (host, username, password).
+                2. Environment variables (TD_HOST, TD_USERNAME, TD_PASSWORD, etc.).
+                   Note:
+                       * The environment variables should start with 'TD_' and all must be in upper case.
+                         Example:
+                                os.environ['TD_HOST'] = 'tdhost'
+                                os.environ['TD_USERNAME'] = 'tduser'
+                                os.environ['TD_PASSWORD'] = 'tdpassword'
+                3. A configuration file if provided (such as a .env file).
+
     PARAMETERS:
         host:
             Optional Argument.
@@ -331,6 +354,25 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
                   integer or boolean value, instead of quoted integer or quoted boolean as suggested in the
                   documentation. Please check the examples for usage.
 
+            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.
+                    * The content of the file must be in '.env' format.
+                    * Use parameters of create_context() as key in the configuration file.
+                      Example:
+                          host=tdhost
+                          username=tduser
+                          password=tdpassword
+                          temp_database_name=tdtemp_database_name
+                          logmech=tdlogmech
+                          logdata=tdlogdata
+                          database=tddatabase
+                    * For more information please refer examples section.
+                Default Value : td_properties.cfg
+                Types: str
+
     RETURNS:
         A Teradata sqlalchemy engine object.
 
@@ -400,13 +442,56 @@ 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 from config file with name 'td_properties.cfg'
+        #             available under current working directory.
+        #             td_properties.cfg content:
+        #                 host=tdhost
+        #                 username=tduser
+        #                 password=tdpassword
+        #                 temp_database_name=tdtemp_database_name
+        #                 logmech=tdlogmech
+        #                 logdata=tdlogdata
+        #                 database=tddatabase
+        >>> td_context = create_context()
+
+        # Example 15: Create context using the file specified in user's home directory
+        #             with name user_td_properties.cfg.
+        #             user_td_properties.cfg content:
+        #                 host=tdhost
+        #                 username=tduser
+        #                 password=tdpassword
+        #                 temp_database_name=tdtemp_database_name
+        #                 logmech=tdlogmech
+        #                 logdata=tdlogdata
+        #                 database=tddatabase
+        >>> 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:
+        #                  os.environ['TD_HOST'] = 'tdhost'
+        #                  os.environ['TD_USERNAME'] = 'tduser'
+        #                  os.environ['TD_PASSWORD'] = 'tdpassword'
+        #                  os.environ['TD_TEMP_DATABASE_NAME'] = 'tdtemp_database_name'
+        #                  os.environ['TD_LOGMECH'] = 'tdlogmech'
+        #                  os.environ['TD_LOGDATA'] = 'tdlogdata'
+        #                  os.environ['TD_DATABASE'] = 'tddatabase'
+        >>> td_context = create_context()
     """
     global td_connection
     global td_sqlalchemy_engine
     global temporary_database_name
     global user_specified_connection
     global python_packages_installed
+    global python_version_vantage
+    global python_version_local
     global td_user
+
+    # 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!="":
+        return _load_context_from_env_config(kwargs.pop('config_file', 'td_properties.cfg'))
+
     awu_matrix = []
     awu_matrix.append(["host", host, True, (str), True])
     awu_matrix.append(["username", username, True, (str), True])
@@ -497,6 +582,8 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     _load_function_aliases()
 
     python_packages_installed = False
+    python_version_vantage = None
+    python_version_local = sys.version.split(" ")[0].strip()
 
     # Assign the tempdatabase name to global
     if temp_database_name is None:
@@ -527,6 +614,34 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     # Return the connection by default
     return td_sqlalchemy_engine
 
+def _load_context_from_env_config(config_file):
+    """
+    DESCRIPTION:
+        Reads the connection parameters from the configuration file or environment variables.
+
+    PARAMETERS:
+        config_file:
+            Required Argument.
+            Specifies the name of the configuration file to read the connection parameters.
+            Types: str
+
+    RETURNS:
+        A Teradata sqlalchemy engine object.
+
+    RAISES:
+        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)
 
 def _mask_logmech_logdata():
     """
@@ -625,6 +740,8 @@ def set_context(tdsqlengine, temp_database_name=None):
     global temporary_database_name
     global user_specified_connection
     global python_packages_installed
+    global python_version_local
+    global python_version_vantage
     if td_connection is not None:
         # Clearing the internal buffer.
         _InternalBuffer.clean()
@@ -654,6 +771,8 @@ def set_context(tdsqlengine, temp_database_name=None):
     _load_function_aliases()
 
     python_packages_installed = False
+    python_version_vantage = None
+    python_version_local = sys.version.split(" ")[0].strip()
 
     # Initialise Dag
     __initalise_dag()
@@ -687,6 +806,8 @@ def remove_context():
     global td_sqlalchemy_engine
     global user_specified_connection
     global python_packages_installed
+    global python_version_vantage
+    global python_version_local
     global td_user
 
     # Initiate the garbage collection
@@ -706,10 +827,13 @@ def remove_context():
     td_connection = None
     td_sqlalchemy_engine = None
     python_packages_installed = False
+    python_version_local = None
+    python_version_vantage = None
     td_user = None
     configure._current_database_name = None
     configure._database_username = None
     configure.database_version = None
+    configure.indb_install_location = ''
 
     # Closing Dag
     __close_dag()