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

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.
 """
+from inspect import getsource
 import json
 import uuid
 from math import floor
@@ -43,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)
@@ -309,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)
@@ -692,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)
@@ -755,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.
@@ -774,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:
@@ -956,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):
         """
@@ -1249,43 +1275,106 @@ 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
 
-    @staticmethod
-    def _in_schema(schema_name, table_name):
+        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  
+    
+    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.
 
-            # 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"))
+        PARAMETERS:
+            full_qualified_name - Name of the table/view
 
-            # 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"))
+        EXAMPLES:
+            UtilFuncs._extract_db_name('"db1"."tablename"')
+            UtilFuncs._extract_db_name('"Icebergs"."db1"."tablename"')
+
+        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):
@@ -1297,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
 
@@ -1323,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):
         """
@@ -2358,8 +2469,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():
@@ -2379,8 +2498,8 @@ class UtilFuncs():
          EXAMPLES:
              >>> self._get_python_execution_path()
          """
-        # 'indb_install_location' expects python installation directory path. 
-        # Hence, postfixing python binary 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)
 
@@ -2403,7 +2522,7 @@ 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:
@@ -2471,7 +2590,7 @@ class UtilFuncs():
         except Exception as exc:
             raise exc
         
-    def _get_env_name(col):
+    def _get_env_name(col=None):
         """
         DESCRIPTION:
             Internal function to get the env name if passed with ColumnExpression
@@ -2479,9 +2598,10 @@ class UtilFuncs():
 
         PARAMETERS:
             col:
-                Required Argument.
+                Optional Argument.
                 Specifies teradataml DataFrame ColumnExpression.
                 Types: teradataml DataFrame ColumnExpression
+                Default Value: None
 
         RAISES:
             None.
@@ -2493,10 +2613,10 @@ class UtilFuncs():
             >>> self._get_env_name(col)
         """
 
-        # If env_name is passed with ColumnExpression fetch the env name,
+        # 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._env_name is not None:
+        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
@@ -2506,5 +2626,84 @@ class UtilFuncs():
             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/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