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

teradataml/common/utils.py

@@ -13,6 +13,8 @@ by other classes which can be reused according to the need.
 Add all the common functions in this class like creating temporary table names, getting
 the datatypes etc.
 """
+from inspect import getsource
+import json
 import uuid
 from math import floor
 import os, itertools
@@ -22,6 +24,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
@@ -41,6 +44,7 @@ from teradataml.options.configure import configure
 from teradataml.options.display import display
 from teradataml.common.constants import TeradataReservedKeywords, TeradataConstants
 
+from teradataml.utils.internal_buffer import _InternalBuffer
 from teradatasqlalchemy.types import _TDType
 from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT,
                                       DECIMAL, FLOAT, NUMBER)
@@ -49,7 +53,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
@@ -1247,6 +1251,41 @@ class UtilFuncs():
             return UtilFuncs._teradata_quote_arg(keyword, "\"", False)
 
         return keyword
+    
+    def _contains_space(item):
+        """
+        Check if the specified string in item has spaces or tabs in it.
+        
+        PARAMETERS:
+            item:
+                Required Argument.
+                Specifies a string to check for spaces or tabs.
+                Types: str
+
+        RETURNS:
+            True, if the specified string has spaces or tabs in it, else False.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            # Passing column name with spaces returns True.
+            is_space = UtilFuncs._contains_space("col name")
+            print(is_space)
+            # Passing column name without spaces returns False.
+            is_space = UtilFuncs._contains_space("colname")
+            print(is_space)
+        """
+        # Check if the input is a string and look for spaces or tabs
+        if isinstance(item, str):
+            return any(char in {' ', '\t'} for char in item)
+
+        # If the input is a list, check each element
+        if isinstance(item, list):
+            # Check each item in the list
+            return any(UtilFuncs._contains_space(col) for col in item)  
+
+        return False  
 
     @staticmethod
     def _in_schema(schema_name, table_name):
@@ -1857,7 +1896,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),
@@ -2356,8 +2395,16 @@ class UtilFuncs():
             >>> self._is_lake()
         """
 
-        from teradataml.context.context import _get_database_version
-        return int(_get_database_version().split(".")[0]) >= 20
+        tbl_operator = configure.table_operator.lower() \
+            if configure.table_operator else None
+
+        # If the user does not provide a table_operator, check the database version
+        # and determine the system type accordingly.
+        if tbl_operator is None:
+            from teradataml.context.context import _get_database_version
+            return int(_get_database_version().split(".")[0]) >= 20
+
+        return tbl_operator == "apply"
 
     @staticmethod
     def _get_python_execution_path():
@@ -2377,14 +2424,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):
         """
@@ -2404,21 +2448,188 @@ class UtilFuncs():
         """
         db_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_db_name(tablename), "\"")
         table_view_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_table_name(tablename), "\"")
-        query = SQLBundle._build_select_table_kind(db_name, "{0}".format(table_view_name), "'V'")
+        query = SQLBundle._build_select_table_kind(db_name, "'{0}'".format(table_view_name), "'V'")
 
         df = UtilFuncs._execute_query(query)
         if len(df) > 0:
             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=None):
+        """
+        DESCRIPTION:
+            Internal function to get the env name if passed with ColumnExpression
+            else the default "openml_env".
+
+        PARAMETERS:
+            col:
+                Optional Argument.
+                Specifies teradataml DataFrame ColumnExpression.
+                Types: teradataml DataFrame ColumnExpression
+                Default Value: None
+
+        RAISES:
+            None.
+
+        RETURNS:
+            string
+            
+        EXAMPLES:
+            >>> self._get_env_name(col)
+        """
+
+        # If ColumnExpression is passed and env_name is passed with it 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 and 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
+
+    def _func_to_string(user_functions):
+        """
+        DESCRIPTION:
+            Internal function to get the user functions in a single string format.
+
+        PARAMETERS:
+            user_functions:
+                Required Argument.
+                List of user functions.
+                Types: list
+
+        RAISES:
+            None.
+
+        RETURNS:
+            string
+
+        EXAMPLES:
+            >>> from teradataml.dataframe.functions import udf
+            >>> @udf(returns=VARCHAR())
+            ... def sum(x, y):
+            ...     return x+y
+            >>>
+            >>> def to_upper(s):
+            ...    return s.upper()
+            >>> user_functions = [sum(1,2)._udf, to_upper]
+            >>> res = self._func_to_string(user_functions)
+            >>> print(res)
+            def sum(x, y):
+                return x+y
+
+            def to_upper(s):
+                return s.upper()
+
+            >>>
+        """
+        user_function_code = ""
+        for func in user_functions:
+            # Get the source code of the user function.
+            func = getsource(func)
+            # If the function have any extra space in the beginning remove it.
+            func = func.lstrip()
+            # Function can have decorator,e.g. udf as decorator, remove it.
+            if func.startswith("@"):
+                func = func[func.find("\n")+1: ].lstrip()
+            # If multiple functions are passed, separate them with new line.
+            user_function_code += func + '\n'
+        return user_function_code
+
+    @staticmethod
+    def _get_qualified_table_name(schema_name, table_name):
+        """
+        DESCRIPTION:
+            Internal function to get the fully qualified name of table.
+
+        PARAMETERS:
+            schema_name:
+                Required Argument.
+                Specifies the name of the schema.
+                Types: str
+
+            table_name:
+                Required Argument.
+                Specifies the name of the table.
+                Types: str
+
+        RAISES:
+            None.
+
+        RETURNS:
+            string
+
+        EXAMPLES:
+            >>> UtilFuncs._get_qualified_table_name("schema_name", "table_name")
+            '"schema_name"."table_name"'
+        """
+        return '"{}"."{}"'.format(schema_name, table_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.
 

teradataml/context/context.py

@@ -13,9 +13,10 @@ A teradataml context functions provide interface to Teradata Vantage. Provides f
 context which can be used by other analytical functions to get the Teradata Vantage connection.
 
 """
+import ipaddress
 from pathlib import Path
 from sqlalchemy import create_engine
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 from teradataml.common.deprecations import argument_deprecation
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.warnings import TeradataMlRuntimeWarning
@@ -35,6 +36,8 @@ 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.
@@ -517,6 +520,9 @@ def create_context(host = None, username = None, password = None, tdsqlengine =
     # Process Analytic functions.
     from teradataml.analytics import _process_analytic_functions
     _process_analytic_functions()
+    
+    # Add global lock to internal buffer
+    _InternalBuffer.add(global_lock=threading.Lock())
 
     # Return the connection by default
     return td_sqlalchemy_engine
@@ -620,6 +626,8 @@ def set_context(tdsqlengine, temp_database_name=None):
     global user_specified_connection
     global python_packages_installed
     if td_connection is not None:
+        # Clearing the internal buffer.
+        _InternalBuffer.clean()
         warnings.warn(Messages.get_message(MessageCodes.OVERWRITE_CONTEXT), stacklevel=2)
         remove_context()
 
@@ -649,6 +657,9 @@ def set_context(tdsqlengine, temp_database_name=None):
 
     # Initialise Dag
     __initalise_dag()
+    
+    # Add global lock to internal buffer
+    _InternalBuffer.add(global_lock=threading.Lock())
 
     return td_connection
 
@@ -681,6 +692,7 @@ def remove_context():
     # Initiate the garbage collection
     __cleanup_garbage_collection()
 
+    # Check if connection is established or not.
     if user_specified_connection is not True:
         try:
             # Close the connection if not user specified connection.
@@ -839,7 +851,8 @@ def _get_vantage_version():
     EXAMPLES:
         _get_vantage_version()
     """
-    if td_connection.dialect.has_table(td_connection, "versionInfo", schema="pm"):
+    if td_connection.dialect.has_table(td_connection, "versionInfo", schema="pm",
+                                       table_only=True):
 
         # BTEQ -- Enter your SQL request or BTEQ command:
         # select * from pm.versionInfo;
@@ -980,6 +993,73 @@ def _get_user():
         td_user = _get_database_username()
     return td_user
 
+def _get_host():
+    """
+    DESCRIPTION:
+        An internal function to get the host associated with the current context.
+    
+    PARAMETERS:
+        None.
+    
+    RETURNS:
+        Host associated with the current context.
+    
+    RAISES:
+        None.
+    
+    EXAMPLES:
+        _get_host()
+    """
+    if td_connection is None:
+        return None
+    else:
+        return td_sqlalchemy_engine.url.host
+
+def _get_host_ip():
+    """
+    DESCRIPTION:
+        Function to return the host IP address or host name associated with the current context.
+
+    PARAMETERS:
+        None.
+
+    RETURNS:
+        Host IP address or host name associated with the current context.
+
+    RAISES:
+        None.
+
+    EXAMPLES:
+        GarbageCollector._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)
+        ipaddress.ip_address(host)
+        return host
+    except ValueError:
+        # If host is not an IP address, get the IP address by DNS name from _InternalBuffer.
+        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:
+            # Get the list of addresses(compatible for both IPv4 and IPv6)
+            addr_info = socket.getaddrinfo(host, None)
+            # Pick the first address from the list
+            host_ip = addr_info[0][4][0]
+            # Add the DNS host IP to the _InternalBuffer.
+            _InternalBuffer.add(dns_host_ip=host_ip)
+        except socket.gaierror:
+            # Use dns host as it is
+            host_ip = host
+    return host_ip
 
 class ContextUtilFuncs():
     @staticmethod