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

teradataml/common/garbagecollector.py

@@ -22,6 +22,7 @@ from teradataml.common.messages import Messages
 from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.constants import TeradataConstants
 from teradataml.options.configure import configure
+from teradataml.utils.internal_buffer import _InternalBuffer
 from teradatasql import OperationalError
 import psutil
 import getpass
@@ -36,15 +37,22 @@ class GarbageCollector():
     garbage collection, so that they can be dropped when connection is disconnected/lost.
     Writes to a output file where the database name & table/view/script names are persisted.
     """
-    __garbage_persistent_file_name = getpass.getuser() + "_garbagecollect.info"
+    # Adding old garbage collector file name to support backward compatibility.
+    __old_garbage_persistent_file_name = getpass.getuser() + "_garbagecollect.info"
     __garbagecollector_folder_name = '.teradataml'
     __contentseperator = ","
+    __filenameseperator = "_"
     __version = "ver1.0"
     __gc_tables = []
     __gc_views = []
     __gc_scripts = []
     __gc_container = []
     __gc_apply = []
+    # Function to get the garbage collector file name specific to host and process.
+    _get_gc_file_name = lambda: "{}_{}_{}_garbagecollect.info".format(
+        getpass.getuser(),
+        tdmlctx.context._get_host_ip(),
+        str(os.getpid()))
 
     @staticmethod
     def _get_temp_dir_name():
@@ -64,8 +72,13 @@ class GarbageCollector():
         EXAMPLES:
             GarbageCollector._get_temp_dir_name()
         """
+        # Default location for .teradataml is user's home directory if configure.local_storage is not set.
         tempdir = expanduser("~")
         tempdir = os.path.join(tempdir, GarbageCollector.__garbagecollector_folder_name)
+
+        # set the .teradataml location to the location specified by the user.
+        if configure.local_storage:
+            tempdir = os.path.join(configure.local_storage, GarbageCollector.__garbagecollector_folder_name)
         return tempdir
 
     @staticmethod
@@ -88,7 +101,7 @@ class GarbageCollector():
         """
         tempdir = GarbageCollector._get_temp_dir_name()
         os.makedirs(tempdir, exist_ok=True)
-        tempfile = os.path.join(os.path.sep, tempdir, GarbageCollector.__garbage_persistent_file_name)
+        tempfile = os.path.join(os.path.sep, tempdir, GarbageCollector._get_gc_file_name())
         return tempfile
 
     @staticmethod
@@ -200,29 +213,31 @@ class GarbageCollector():
         EXAMPLES:
             GarbageCollector._add_to_garbagecollector(object_name = "temp"."temp_table1")
         """
-        if object_name and object_type:
-            try:
-                tempfilename = GarbageCollector.__make_temp_file_name()
-                writecontent = str(GarbageCollector.__version) + "," + str(os.getpid())
-                writecontent += "," + str(object_type.value)
-                writecontent += "," + object_name + "\n"
-                with open(tempfilename, 'a+') as fgc:
-                    fgc.write(writecontent)
-                if configure._validate_gc:
-                    GarbageCollector.__validate_gc_add_object(object_name, object_type)
-            except TeradataMlException:
-                raise
-            except Exception as err:
-                logger.error(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) + str(err))
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR),
-                                          MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) from err
-            finally:
-                if fgc is not None:
-                    fgc.close()
+        # Use global lock while writing to the garbage collector file.
+        with _InternalBuffer.get("global_lock"):
+            if object_name and object_type:
+                try:
+                    tempfilename = GarbageCollector.__make_temp_file_name()
+                    writecontent = str(GarbageCollector.__version) + "," + str(os.getpid())
+                    writecontent += "," + str(object_type.value)
+                    writecontent += "," + object_name + "\n"
+                    with open(tempfilename, 'a+') as fgc:
+                        fgc.write(writecontent)
+                    if configure._validate_gc:
+                        GarbageCollector.__validate_gc_add_object(object_name, object_type)
+                except TeradataMlException:
+                    raise
+                except Exception as err:
+                    logger.error(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) + str(err))
+                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR),
+                                                MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) from err
+                finally:
+                    if fgc is not None:
+                        fgc.close()
         return True
 
     @staticmethod
-    def __deleterow(content_row):
+    def __deleterow(content_row, file_name):
         """
         DESCRIPTION:
             Deletes an entry from persisted file.
@@ -232,6 +247,11 @@ class GarbageCollector():
                 Required Argument.
                 Specifies the text of row to delete from the persisted file.
                 Types: str
+            
+            file_name:
+                Required Argument.
+                Specifies the name of the file to delete the row.
+                Types: str
 
         RETURNS:
             None.
@@ -243,10 +263,9 @@ class GarbageCollector():
             GarbageCollector._deleterow(content_row = 'ver1.0,72136,3,"alice"."temp_table_gbview1"')
         """
         try:
-            tempfilename = GarbageCollector.__make_temp_file_name()
-            if not os.path.isfile(tempfilename):
+            if not os.path.isfile(file_name):
                 return True
-            with open(tempfilename, 'r+') as fgc:
+            with open(file_name, 'r+') as fgc:
                 output = fgc.readlines()
                 fgc.seek(0)
                 for dbtablename in output:
@@ -486,104 +505,121 @@ class GarbageCollector():
         """
         try:
             td_connection = tdmlctx.context.get_connection()
-            tempfilename = GarbageCollector.__make_temp_file_name()
-            if not os.path.isfile(tempfilename):
+            # Get the temp directory where garbage collector file is persisted.
+            tempdir = GarbageCollector._get_temp_dir_name()
+            # Garbage collect file that is created by the current host and current process.
+            # Also check if file is not of current process and associated process is
+            # currently running in the system or not.
+            # Walk through the temp directory and filter garbage collector files.
+            tempfiles = []
+            for root, _, files in os.walk(tempdir):
+                for file in files:
+                    if file.endswith('_garbagecollect.info'):
+                        try:
+                            filepath = os.path.join(root, file)
+                            fileparts = file.split(GarbageCollector.__filenameseperator)
+                            hostname = fileparts[1]
+                            filepid = int(fileparts[2])
+                            if hostname == tdmlctx.context._get_host_ip():
+                                if filepid == os.getpid() or not psutil.pid_exists(filepid):
+                                    tempfiles.append(filepath)
+                        except (IndexError, ValueError):
+                            # Handle the case where the filename format is not as expected
+                            # check if old garbage collector file is present.
+                            if file == GarbageCollector.__old_garbage_persistent_file_name:
+                                tempfiles.append(filepath)
+
+            # Process each garbage collector file.
+            if len(tempfiles) == 0:
                 return True
-            with open(tempfilename, 'r+') as fgc:
-                content = fgc.readlines()
-
-            for contentrecord in content:
-                contentrecord = contentrecord.strip()
-
-                if (td_connection is not None) and (len(contentrecord) > 0):
-                    try:
-                        recordparts = contentrecord.split(GarbageCollector.__contentseperator)
-                        version = recordparts[0]
-                        contentpid = int(recordparts[1].strip())
-                        # Check and garbage collect even currrent running process at exit.
-                        # Check if contentpid is not of current process as well as any
-                        # currently running process in the system
-                        proceed_to_cleanup = False
-                        if contentpid != int(os.getpid()):
-                            if not psutil.pid_exists(contentpid):
-                                proceed_to_cleanup = True
-                        else:
-                            proceed_to_cleanup = True
-                        if proceed_to_cleanup == True:
-                            object_type = int(recordparts[2].strip())
-                            database_object = recordparts[3].strip()
-
-                            # Create the TeradataConstant to use with __delete_object_from_gc_list().
-                            object_type_enum = TeradataConstants(object_type)
-
+            else:
+                for tempfilename in tempfiles:
+                    if not os.path.isfile(tempfilename):
+                        return True
+                    with open(tempfilename, 'r+') as fgc:
+                        content = fgc.readlines()
+
+                    for contentrecord in content:
+                        contentrecord = contentrecord.strip()
+                        if (td_connection is not None) and (len(contentrecord) > 0):
                             try:
-                                # Drop the table/view/script/container based on database object type retrieved from the collector file.
-                                # # Drop table.
-                                if TeradataConstants.TERADATA_TABLE.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._drop_table(database_object,
-                                                                         check_table_exist=False)
-
-                                # # Drop view.
-                                elif TeradataConstants.TERADATA_VIEW.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._drop_view(database_object,
-                                                                        check_view_exist=False)
-
-                                elif object_type in [TeradataConstants.TERADATA_LOCAL_SCRIPT.value,
-                                                    TeradataConstants.TERADATA_TEXT_FILE.value]:
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # # Drop Apply script.
-                                elif TeradataConstants.TERADATA_APPLY.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._delete_script(database_object,
-                                                                            file_type=object_type_enum)
-                                    # Delete the script locally
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # # Drop STO script.
-                                else:
-                                    tdmlutil.utils.UtilFuncs._delete_script(database_object,
-                                                                            file_type=object_type_enum,
-                                                                            check_script_exist=False)
-                                    # Delete the script locally
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # Finally, delete the entry from gc lists if required.
-                                GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                              object_type_enum)
-
-                                # Remove the entry for a table/view from GC, after it has been dropped.
-                                GarbageCollector.__deleterow(contentrecord)
-                            except OperationalError as operr:
-                                # Remove the entry for a table/view/script even after drop has failed,
-                                # if that object does not exist.
-                                # Also added additional check for error when the database containing
-                                # the object doesn't exist anymore.
-                                if "[Teradata Database] [Error 3802] Database" in str(operr) or \
-                                        "[Teradata Database] [Error 3807] Object" in str(operr) or \
-                                        "[Teradata Database] [Error 9852] The file" in str(operr):
-                                    GarbageCollector.__deleterow(contentrecord)
-                                    # Delete entry from gc lists of required.
-                                    GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                                  object_type_enum)
-                            except (TeradataMlException, RuntimeError) as err:
-                                if "Failed to execute get_env" in str(err) or \
-                                    "Failed to execute remove_file" in str(err):
-                                    # For removing files in OpenAF environment.
-                                    GarbageCollector.__deleterow(contentrecord)
-                                    # Delete entry from gc lists of required.
+                                recordparts = contentrecord.split(GarbageCollector.__contentseperator)
+                                object_type = int(recordparts[2].strip())
+                                database_object = recordparts[3].strip()
+
+                                # Create the TeradataConstant to use with __delete_object_from_gc_list().
+                                object_type_enum = TeradataConstants(object_type)
+
+                                try:
+                                    # Drop the table/view/script/container based on database object type retrieved from the collector file.
+                                    # # Drop table.
+                                    if TeradataConstants.TERADATA_TABLE.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._drop_table(database_object,
+                                                                            check_table_exist=False)
+
+                                    # # Drop view.
+                                    elif TeradataConstants.TERADATA_VIEW.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._drop_view(database_object,
+                                                                            check_view_exist=False)
+
+                                    elif object_type in [TeradataConstants.TERADATA_LOCAL_SCRIPT.value,
+                                                        TeradataConstants.TERADATA_TEXT_FILE.value]:
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # # Drop Apply script.
+                                    elif TeradataConstants.TERADATA_APPLY.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                                file_type=object_type_enum)
+                                        # Delete the script locally
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # # Drop STO script.
+                                    else:
+                                        tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                                file_type=object_type_enum,
+                                                                                check_script_exist=False)
+                                        # Delete the script locally
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # Remove the entry for a table/view from GC, after it has been dropped.
+                                    GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                    
+                                    # Finally, delete the entry from gc lists if required.
                                     GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                                  object_type_enum)
-                            except FileNotFoundError:
-                                # This will occur only when the item being deleted is a file,
-                                # and it's local copy is not found.
-                                GarbageCollector.__deleterow(contentrecord)
-                                if object_type == TeradataConstants.TERADATA_APPLY:
-                                    GarbageCollector.__gc_apply.remove(database_object)
-                                elif object_type == TeradataConstants.TERADATA_SCRIPT:
-                                    GarbageCollector.__gc_scripts.remove(database_object)
-                    except Exception as err:
-                        pass
-                        # logger.error(Messages.get_message(MessageCodes.TDMLDF_DELETE_GARBAGE_COLLECTOR) + str(err))
+                                                                                object_type_enum)
+                                except OperationalError as operr:
+                                    # Remove the entry for a table/view/script even after drop has failed,
+                                    # if that object does not exist.
+                                    # Also added additional check for error when the database containing
+                                    # the object doesn't exist anymore.
+                                    if "[Teradata Database] [Error 3802] Database" in str(operr) or \
+                                            "[Teradata Database] [Error 3807] Object" in str(operr) or \
+                                            "[Teradata Database] [Error 9852] The file" in str(operr):
+                                        GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                        # Delete entry from gc lists of required.
+                                        GarbageCollector.__delete_object_from_gc_list(database_object,
+                                                                                    object_type_enum)
+                                except (TeradataMlException, RuntimeError) as err:
+                                    if "Failed to execute get_env" in str(err) or \
+                                        "Failed to execute remove_file" in str(err):
+                                        # For removing files in OpenAF environment.
+                                        GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                        # Delete entry from gc lists of required.
+                                        GarbageCollector.__delete_object_from_gc_list(database_object,
+                                                                                    object_type_enum)
+                                except FileNotFoundError:
+                                    # This will occur only when the item being deleted is a file,
+                                    # and it's local copy is not found.
+                                    GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                    if object_type == TeradataConstants.TERADATA_APPLY:
+                                        GarbageCollector.__gc_apply.remove(database_object)
+                                    elif object_type == TeradataConstants.TERADATA_SCRIPT:
+                                        GarbageCollector.__gc_scripts.remove(database_object)
+                            except Exception as err:
+                                pass
+                    # delete empty file itself after deleting the entry from the file
+                    if os.path.getsize(tempfilename) == 0:
+                        GarbageCollector._delete_local_file(tempfilename)
         except Exception as e:
             logger.error(Messages.get_message(MessageCodes.TDMLDF_DELETE_GARBAGE_COLLECTOR) + str(e))
         finally:

teradataml/common/messagecodes.py

@@ -180,6 +180,7 @@ class ErrorInfoCodes(Enum):
     INVALID_LIST_LENGTH = 'TDML_2314'
 
     IMPORT_PYTHON_PACKAGE = 'TDML_2414'
+    PATH_NOT_FOUND = 'TDML_2415'
 
     # Script local run Error codes
     SCRIPT_LOCAL_RUN_ERROR = 'TDML_2410'
@@ -218,6 +219,7 @@ class ErrorInfoCodes(Enum):
     PARTITION_VALUES_NOT_MATCHING = 'TDML_2538'
     PARTITION_IN_BOTH_FIT_AND_PREDICT = 'TDML_2539'
     INVALID_PARTITIONING_COLS = 'TDML_2540'
+    TARGET_COL_NOT_FOUND_FOR_EVALUATE = 'TDML_2541'
 
 class MessageCodes(Enum):
     """
@@ -419,4 +421,7 @@ class MessageCodes(Enum):
                                         " feature columns."
     PARTITION_VALUES_NOT_MATCHING = "Values in training and test data partition columns should be same."
     PARTITION_IN_BOTH_FIT_AND_PREDICT = "Use \"partition_columns\" only if model is fitted with partition_column(s)."
-    INVALID_PARTITIONING_COLS = "Provided partition_column(s) '{}' is/are not present in parent of '{}' DataFrame(s)."
+    INVALID_PARTITIONING_COLS = "Provided partition_column(s) '{}' is/are not present in parent of '{}' DataFrame(s)."
+    PATH_NOT_FOUND = "Specified local path '{}' not found. Please check the path."
+    TARGET_COL_NOT_FOUND_FOR_EVALUATE = "Target column '{}' not found in the passed dataFrame. "\
+                                        "evaluate() requires target column to be present in the dataFrame."

teradataml/common/messages.py

@@ -188,7 +188,9 @@ class Messages():
             [ErrorInfoCodes.PARTITIONING_COLS_IN_FEATURE_COLS, MessageCodes.PARTITIONING_COLS_IN_FEATURE_COLS],
             [ErrorInfoCodes.PARTITION_VALUES_NOT_MATCHING, MessageCodes.PARTITION_VALUES_NOT_MATCHING],
             [ErrorInfoCodes.PARTITION_IN_BOTH_FIT_AND_PREDICT, MessageCodes.PARTITION_IN_BOTH_FIT_AND_PREDICT],
-            [ErrorInfoCodes.INVALID_PARTITIONING_COLS, MessageCodes.INVALID_PARTITIONING_COLS]
+            [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]
     ]
 
     @staticmethod

teradataml/common/sqlbundle.py

@@ -47,7 +47,7 @@ class SQLBundle:
                 [SQLConstants.SQL_HELP_COLUMNS, "help column {0}.*"],
                 [SQLConstants.SQL_DROP_TABLE, "DROP TABLE {0}"],
                 [SQLConstants.SQL_DROP_VIEW, "DROP VIEW {0}"],
-                [SQLConstants.SQL_NROWS_FROM_QUERY, "SELECT COUNT(*) FROM {0}"],
+                [SQLConstants.SQL_NROWS_FROM_QUERY, "SELECT CAST(COUNT(*) AS BIGINT) FROM {0}"],
                 [SQLConstants.SQL_TOP_NROWS_FROM_TABLEORVIEW, "select top {0} * from {1}"],
                 [SQLConstants.SQL_INSERT_INTO_TABLE_VALUES, "insert into {0} values({1})"],
                 [SQLConstants.SQL_SELECT_COLUMNNAMES_FROM, "sel {0} from ({1}) as {2}"],

teradataml/common/utils.py

@@ -13,6 +13,7 @@ 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.
 """
+import json
 import uuid
 from math import floor
 import os, itertools
@@ -22,6 +23,7 @@ import sqlalchemy
 from pathlib import Path
 from numpy import number
 from sqlalchemy import Column, MetaData, Table
+
 from teradataml.context.context import get_connection
 
 from teradataml import _version
@@ -49,7 +51,7 @@ from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
 from teradatasqlalchemy.types import (CHAR, VARCHAR, CLOB)
 from functools import reduce
 import warnings
-from teradatasqlalchemy.telemetry.queryband import set_queryband, collect_queryband, get_qb_query
+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
@@ -300,6 +302,12 @@ 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
+            tabname = "\"{}\".\"{}\"".format(_get_user(), tabname)
+            return tabname
 
         if use_default_database and databasename is None:
             tabname = "\"{}\".\"{}\"".format(tdmlctx._get_context_temp_databasename(
@@ -1851,7 +1859,7 @@ class UtilFuncs():
         con = tdmlctx.get_connection()
 
         if check_table_exists:
-            table_exists = con.dialect.has_table(con, table_name, schema_name)
+            table_exists = con.dialect.has_table(con, table_name, schema_name, table_only=True)
 
             if not table_exists:
                 raise TeradataMlException(Messages.get_message(MessageCodes.TABLE_DOES_NOT_EXIST, table_name),
@@ -2371,14 +2379,11 @@ class UtilFuncs():
          EXAMPLES:
              >>> self._get_python_execution_path()
          """
+        # 'indb_install_location' expects python installation directory path. 
+        # Hence, postfixing python binary path. 
+        return "python" if UtilFuncs._is_lake() else \
+            '{}/bin/python3'.format(configure.indb_install_location)
 
-        if UtilFuncs._is_lake():
-            return "python"
-        else:
-            if configure.indb_install_location == "/var/opt/teradata/languages/sles12sp3/Python/":
-                return '{}bin/python3'.format(configure.indb_install_location)
-            else:
-                return configure.indb_install_location
 
     def _is_view(tablename):
         """
@@ -2405,14 +2410,101 @@ class UtilFuncs():
             return True
         else:
             return False
+
     @staticmethod
     def _set_queryband():
+        from teradataml import session_queryband
         try:
-            qb_query = get_qb_query()
+            qb_query = session_queryband.generate_set_queryband_query()
             execute_sql(qb_query)
-        except Exception:
+        except Exception as _set_queryband_err:
             pass
 
+    def _create_or_get_env(template):
+        """
+        DESCRIPTION:
+            Internal function to return the environment if already exists else
+            creates the environment using template file and return the environment.
+
+        PARAMETERS:
+            template:
+                Required Argument.
+                Template json file name containing details of environment(s) to be created.
+                Types: str
+
+        RAISES:
+            TeradataMLException
+
+        RETURNS:
+            An object of class UserEnv representing the user environment.
+
+        EXAMPLES:
+            >>> self._create_or_get_env("open_source_ml.json")
+        """
+        # Get the template file path.
+        from teradataml import _TDML_DIRECTORY
+        from teradataml.scriptmgmt.lls_utils import create_env, get_env
+        template_dir_path = os.path.join(_TDML_DIRECTORY, "data", "templates", template)
+
+        # Read template file.
+        with open(template_dir_path, "r") as r_file:
+            data = json.load(r_file)
+
+        # Get env_name.
+        _env_name = data["env_specs"][0]["env_name"]
+
+        try:
+            # Call function to get env.
+            return get_env(_env_name)
+        except TeradataMlException as tdml_e:
+            # We will get here when error says, env does not exist otherwise raise the exception as is.
+            # Env does not exist so create one.
+
+            exc_msg = "Failed to execute get_env(). User environment '{}' not " \
+                      "found.".format(_env_name)
+            if exc_msg in tdml_e.args[0]:
+                print(f"No OpenAF environment with name '{_env_name}' found. Creating one with "\
+                      "latest supported python and required packages.")
+                return create_env(template=template_dir_path)
+            else:
+                raise tdml_e
+        except Exception as exc:
+            raise exc
+        
+    def _get_env_name(col):
+        """
+        DESCRIPTION:
+            Internal function to get the env name if passed with ColumnExpression
+            else the default "openml_env".
+
+        PARAMETERS:
+            col:
+                Required Argument.
+                Specifies teradataml DataFrame ColumnExpression.
+                Types: teradataml DataFrame ColumnExpression
+
+        RAISES:
+            None.
+
+        RETURNS:
+            string
+            
+        EXAMPLES:
+            >>> self._get_env_name(col)
+        """
+
+        # If env_name is passed with ColumnExpression fetch the env name,
+        # else check if default "openml_user_env" env is configured or not,
+        # else get the default "openml_env" env if exists or create new deafult env.
+        if col._env_name is not None:
+            from teradataml.scriptmgmt.UserEnv import UserEnv
+            env = col._env_name
+            env_name = env.env_name if isinstance(col._env_name, UserEnv) else env
+        elif configure.openml_user_env is not None:
+            env_name = configure.openml_user_env.env_name
+        else:
+            env_name = UtilFuncs._create_or_get_env("open_source_ml.json").env_name
+        return env_name
 
 from teradataml.common.aed_utils import AedUtils
 from teradataml.dbutils.filemgr import remove_file

teradataml/common/wrapper_utils.py

@@ -317,7 +317,7 @@ class AnalyticsWrapperUtils:
         #TODO: Add support for nested level query as in R.
         return table_ref
 
-    def _validate_input_table_datatype(self, data, arg_name, reference_function_name = None):
+    def _validate_input_table_datatype(self, data, arg_name, reference_function_name=None):
         """
         Method to verify that the input table parameters of type DataFrame.