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

teradataml/catalog/byom.py

@@ -26,7 +26,7 @@ from teradataml.options.display import display
 from teradataml.common.constants import ModelCatalogingConstants as mac
 from teradataml.options.configure import configure
 from teradataml.utils.utils import execute_sql
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 
 validator = _Validators()
 
@@ -541,13 +541,12 @@ def save_byom(model_id,
         # If exists, extract required information about table columns types
         # else extract from additional_columns_types.
         # Also validate model_id against allowed length.
-        table_exists = connection.dialect.has_table(connection, table_name=table_name, schema=schema_name)
+        table_exists = connection.dialect.has_table(connection, table_name=table_name,
+                                                    schema=schema_name, table_only=True)
         if table_exists:
             # Check if model exists or not. If exists, raise error.
             __check_if_model_exists(
                 model_id, table_name, schema_name, raise_error_if_model_found=True)
-            if len(additional_columns_types) != 0:
-                warnings.warn("Argument additional_columns_types is ignored since table already exists.", stacklevel=2)
 
             # Gather column name and type information from existing table
             existing_table_df = DataFrame(in_schema(schema_name, table_name))
@@ -807,7 +806,7 @@ def delete_byom(model_id, table_name=None, schema_name=None):
 
     # Before proceed further, check whether table exists or not.
     conn = get_connection()
-    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name):
+    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name, table_only=True):
         error_code = MessageCodes.MODEL_CATALOGING_OPERATION_FAILED
         error_msg = Messages.get_message(
             error_code, "delete", 'Table "{}.{}" does not exist.'.format(schema_name, table_name))
@@ -1472,7 +1471,7 @@ def retrieve_byom(model_id,
 
     # Before proceeding further, check whether table exists or not.
     conn = get_connection()
-    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name):
+    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name, table_only=True):
         error_code = MessageCodes.MODEL_CATALOGING_OPERATION_FAILED
         error_msg = Messages.get_message(
             error_code, "retrieve", 'Table "{}.{}" does not exist.'.format(schema_name, table_name))
@@ -1535,7 +1534,8 @@ def retrieve_byom(model_id,
     license_table = in_schema(license_schema_name, license_table_name)
 
     # Check whether license table exists or not before proceed further.
-    if not conn.dialect.has_table(conn, table_name=license_table_name, schema=license_schema_name):
+    if not conn.dialect.has_table(conn, table_name=license_table_name, schema=license_schema_name,
+                                  table_only=True):
         error_code = MessageCodes.EXECUTION_FAILED
         error_msg = Messages.get_message(
             error_code, "retrieve the model", 'Table "{}" does not exist.'.format(license_table))
@@ -1723,7 +1723,7 @@ def list_byom(table_name=None, schema_name=None, model_id=None):
 
     # Before proceeding further, check whether table exists or not.
     conn = get_connection()
-    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name):
+    if not conn.dialect.has_table(conn, table_name=table_name, schema=schema_name, table_only=True):
         error_code = MessageCodes.MODEL_CATALOGING_OPERATION_FAILED
         error_msg = Messages.get_message(
             error_code, "list", 'Table "{}.{}" does not exist.'.format(schema_name, table_name))

teradataml/catalog/model_cataloging_utils.py

@@ -179,7 +179,7 @@ def __get_model_inputs_outputs(model, function_arg_map):
                     tdp = preparer(td_dialect)
                     nrows, ncols = member.shape
                     db_schema = UtilFuncs._extract_db_name(member._table_name)
-                    # Add quotes around the DB name in case we are getting it using _get_current_databasename()
+                    # Add quotes around the DB name in case we are getting it using _get_current_databasename().
                     db_schema = tdp.quote(_get_current_databasename()) if db_schema is None else db_schema
                     db_table_name = UtilFuncs._extract_table_name(member._table_name)
 

teradataml/clients/auth_client.py

@@ -0,0 +1,133 @@
+"""
+Unpublished work.
+Copyright (c) 2024 by Teradata Corporation. All rights reserved.
+TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
+Primary Owner: gouri.patwardhan@teradata.com
+Secondary Owner: Pradeep.Garre@teradata.com
+This file implements workflow for generating JWT token.
+"""
+import base64
+import jwt
+import time
+from pathlib import Path
+import pathlib
+from teradataml import configure
+
+class _AuthWorkflow:
+    """
+    Get the JWT token for requested user.
+    """
+    def __init__(self, state):
+        """
+        DESCRIPTION:
+            Constructor to initiate Authentication work flow.
+
+        PARAMETERS:
+            state:
+                Required Argument.
+                Specifies the dictionary containing following:
+                    1. "base_url" which is extracted from "ues_url".
+                    2. "org_id" which is also extracted from "ues_url".
+                    3. "pat_token" which is obtained from VantageCloud Lake Console, and it is specific to the user.
+                    4. "pem_file" which is obtained from VantageCloud Lake Console, and it is specific to the user.
+                    5. "username" which is the DB user.
+                    5. "expiration_time" which is the expiration time for the token and has a default value of
+                       31536000 seconds.
+                Types: dict
+
+        RETURNS:
+            Instance of _AuthWorkflow.
+
+        RAISES:
+            None
+
+        EXAMPLES :
+            >>> _AuthWorkflow(state)
+        """
+        self.state = state
+
+    def _get_epoch_time(self):
+        """
+        DESCRIPTION:
+            Generate expiry epoch time.
+
+        RETURNS:
+            float
+        """
+        current_epoch_time = int(time.time())
+        expiry_epoch_time = current_epoch_time + self.state.get('expiration_time')
+        return current_epoch_time, expiry_epoch_time
+
+    def _generate_header(self):
+        """
+        DESCRIPTION:
+            Generate JWT header.
+
+        RETURNS:
+            dict
+        """
+        # Extract the pem file name without extension.
+        kid = pathlib.Path(self.state.get('pem_file')).stem
+        header = {
+            "alg": "RS256",
+            "kid": kid,
+            "typ": "JWT"
+        }
+        return header
+
+    def _generate_payload(self):
+        """
+        DESCRIPTION:
+            Generate JWT payload.
+
+        RETURNS:
+            A dictionary with the JWT payload.
+        """
+        iat, exp= self._get_epoch_time()
+        payload = {
+            "aud": [
+                "td:service:authentication"
+            ],
+            "iat": iat,
+            "exp": exp,
+            "iss": "teradataml",
+            "multi-use": True,
+            "org_id": self.state['org_id'],
+            "pat": self.state['pat_token'],
+            "sub": self.state['username']
+        }
+        return payload
+
+    def _sign_jwt(self, payload, header):
+        """
+        DESCRIPTION:
+            Encode JWT using private key.
+
+        PARAMETERS:
+            payload:
+                Required Argument.
+                Specifies the payload required for encoding the JWT token.
+                Types: dict
+            header:
+                Required Argument.
+                Specified the header required for encoding the JWT token.
+                Types: dict
+
+        RETURNS:
+            str
+        """
+        with open(self.state['pem_file'], "r") as f:
+            private_key = f.read()
+        return jwt.encode(payload=payload, key=private_key, algorithm=header["alg"], headers=header)
+
+    def _proxy_jwt(self):
+        """
+        DESCRIPTION:
+            Generate JWT token and add the value in dictionary.
+
+        RETURNS:
+            str
+        """
+        jwt = self._sign_jwt(self._generate_payload(), self._generate_header())
+        self.state['jwt'] = jwt
+        return(jwt)

teradataml/clients/pkce_client.py

@@ -425,7 +425,7 @@ class _DAWorkflow:
         """
         device_cfg = requests.post(
             url=self.device_auth_end_point,
-            data={'client_id': self.__client_id})
+            data={'client_id': self.__client_id, 'scope': 'openid'})
 
         # Check the status. If response is not 200, raise error.
         _Validators._validate_http_response(device_cfg, 200, "get the device metadata")

teradataml/common/aed_utils.py

@@ -1287,8 +1287,9 @@ class AedUtils:
         arg_name = ["group by"]
         # If option is passed, add prefix of the option to the groupby_expr,
         # else, add prefix as empty string.
-        arg_value = ["{} | {}".format(option, groupby_expr)] if option\
-            else ["{}| {}".format("", groupby_expr)]
+        if isinstance(groupby_expr, str):
+            arg_value = ["{} | {}".format(option, groupby_expr)] if option \
+               else ["{}| {}".format("", groupby_expr)]
         temp_table_name = UtilFuncs._generate_temp_table_name(prefix="groupby_", use_default_database=True, quote=False)
         output_table = [UtilFuncs._extract_table_name(temp_table_name)]
         output_schema = [UtilFuncs._extract_db_name(temp_table_name)]

teradataml/common/constants.py

@@ -65,6 +65,7 @@ class TeradataConstants(Enum):
     CONTAINER = 5
     TERADATA_TEXT_FILE = 6
     TERADATA_APPLY = 7
+    TERADATA_VOLATILE_TABLE = 8
     TABLE_COLUMN_LIMIT = 2048
     TERADATA_JOINS = ["inner", "left", "right", "full", "cross"]
     TERADATA_JOIN_OPERATORS = ['>=', '<=', '<>', '!=', '>', '<', '=']
@@ -424,6 +425,8 @@ class TableOperatorConstants(Enum):
     MAP_TEMPLATE = "dataframe_map.template"
     # Template of the intermediate script that will be generated.
     APPLY_TEMPLATE = "dataframe_apply.template"
+    # Template of the intermediate script that will be generated for UDF.
+    UDF_TEMPLATE = "dataframe_udf.template"
     # In-DB execution mode.
     INDB_EXEC = "IN-DB"
     # Local execution mode.
@@ -438,6 +441,8 @@ class TableOperatorConstants(Enum):
     MAP_PARTITION_OP = "map_partition"
     # apply operation.
     APPLY_OP = "apply"
+    # udf operation.
+    UDF_OP = "udf"
     # Template of the script_executor that will be used to generate the temporary script_executor file.
     SCRIPT_TEMPLATE = "script_executor.template"
     # Log Type.
@@ -463,18 +468,18 @@ class TableOperatorConstants(Enum):
                                 ON (select 1) PARTITION BY ANY
                                 SCRIPT_COMMAND('{}/bin/pip3 --version')
                                 returns('package VARCHAR(256)'))
-                             """.format(configure.indb_install_location)
+                             """
 
     # Script Query to get Python packages and corresponding versions.
     # Location of In-DB packages is indicated by configure.indb_install_location.
     partial_version_query = "SELECT distinct * FROM SCRIPT( ON (select 1) " \
-                            "PARTITION BY ANY SCRIPT_COMMAND('{}/bin/pip3 freeze | "\
-        .format(configure.indb_install_location)
-    PACKAGE_VERSION_QUERY = partial_version_query + "{0}awk -F ''=='' " \
+                            "PARTITION BY ANY SCRIPT_COMMAND('{0}/bin/pip3 freeze | "
+
+    PACKAGE_VERSION_QUERY = partial_version_query + "{1}awk -F ''=='' " \
                                                     "''{{print $1, $2}}''') " \
                                                     "delimiter(' ') " \
-                                                    "returns('package VARCHAR({1}), " \
-                                                    "version VARCHAR({1})'))"
+                                                    "returns('package VARCHAR({2}), " \
+                                                    "version VARCHAR({2})'))"
 
 class ValibConstants(Enum):
     # A dictionary that maps teradataml name of the exposed VALIB function name
@@ -1368,6 +1373,7 @@ class TeradataAnalyticFunctionTypes(Enum):
     UAF = "UAF"
     TABLEOPERATOR = "TABLE_OPERATOR"
     BYOM = "BYOM"
+    STORED_PROCEDURE = "STORED_PROCEDURE"
 
 
 class TeradataAnalyticFunctionInfo(Enum):
@@ -1378,6 +1384,8 @@ class TeradataAnalyticFunctionInfo(Enum):
     TABLE_OPERATOR = {"func_type": "tableoperator", "lowest_version": "17.00 ",
                       "display_function_type_name" :"TABLE OPERATOR"}
     BYOM = {"func_type": "byom", "lowest_version": None, "display_function_type_name": "BYOM"}
+    STORED_PROCEDURE = {"func_type": "storedprocedure", "lowest_version": "17.20", "display_function_type_name": "UAF",
+           "metadata_class" : "_AnlyFuncMetadataUAF"}
 
 class TeradataUAFSpecificArgs(Enum):
     INPUT_MODE = "input_mode"
@@ -1404,6 +1412,10 @@ class DriverEscapeFunctions(Enum):
     WRITE_TO_CSV = "{{fn teradata_write_csv({0})}}"
     FIELD_QUOTE = "{{fn teradata_field_quote({0})}}"
     FIELD_SEP = "{{fn teradata_field_sep({0})}}"
+    ERR_TBL_1 = "{{fn teradata_error_table_1_suffix({0})}}"
+    ERR_TBL_2 = "{{fn teradata_error_table_2_suffix({0})}}"
+    ERR_STAGING_DB = "{{fn teradata_error_table_database({0})}}"
+    ERR_TBL_MNG_FLAG = "{{fn teradata_manage_error_tables_{0}}}"
 
 
 class HTTPRequest(Enum):
@@ -1431,3 +1443,33 @@ class CloudProvider(Enum):
     # and '2018-03-28', using the latest one.
     X_MS_VERSION = "2019-12-12"
     X_MS_BLOB_TYPE = "BlockBlob"
+
+class SessionParamsSQL:
+    # Holds the SQL Statements for Session params.
+    TIMEZONE = "SET TIME ZONE {}"
+    ACCOUNT = "SET SESSION ACCOUNT = '{}' FOR {}"
+    CALENDAR = "SET SESSION CALENDAR = {}"
+    CHARACTER_SET_UNICODE = "SET SESSION CHARACTER SET UNICODE PASS THROUGH {}"
+    COLLATION = "SET SESSION COLLATION {}"
+    CONSTRAINT = "SET SESSION CONSTRAINT = {}"
+    DATABASE = "SET SESSION DATABASE {}"
+    DATEFORM = "SET SESSION DATEFORM = {}"
+    DEBUG_FUNCTION = "SET SESSION DEBUG FUNCTION {} {}"
+    DOT_NOTATION = "SET SESSION DOT NOTATION {} ON ERROR"
+    ISOLATED_LOADING = "SET SESSION FOR {} ISOLATED LOADING"
+    FUNCTION_TRACE = "SET SESSION FUNCTION TRACE USING {} FOR TABLE {}"
+    JSON_IGNORE_ERRORS = "SET SESSION JSON IGNORE ERRORS {}"
+    SEARCHUIFDBPATH = "SET SESSION SEARCHUIFDBPATH = {}"
+    TRANSACTION_ISOLATION_LEVEL = "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL {}"
+    QUERY_BAND = "SET QUERY_BAND = {} FOR {}"
+    UDFSEARCHPATH = "SET SESSION UDFSEARCHPATH = {} FOR FUNCTION = {}"
+
+class SessionParamsPythonNames:
+    # Holds the SQL Statements for Session params.
+    TIMEZONE = "Session Time Zone"
+    ACCOUNT = "Account Name"
+    CALENDAR = "Calendar"
+    COLLATION = "Collation"
+    DATABASE = "Current DataBase"
+    DATEFORM = 'Current DateForm'
+

teradataml/common/deprecations.py

@@ -87,13 +87,19 @@ def argument_deprecation(tdml_version, deprecated_arguments, behaviour=False, al
 
     def decorator(func):
         def wrapper(*args, **kwargs):
-            msg = "\nThe argument(s) \"{}\" will be deprecated in {}."
-            if behaviour:
-                msg = "\nBehaviour of the argument(s) \"{}\" will change in {}."
-            msg = msg.format(deprecated_arguments, tdml_version)
-            if alternatives is not None:
-                msg += "\nUse argument(s) \"{}\" instead.".format(alternatives)
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            # Check if deprecated arguments is a list, if not convert it to a list
+            deprecated_args_list = deprecated_arguments if isinstance(deprecated_arguments, list) \
+                else [deprecated_arguments]
+            # Check list of deprecated arguments are used in the function call
+            deprecated_arguments_used = [arg for arg in deprecated_args_list if arg in kwargs]
+            if deprecated_arguments_used:
+                msg = "\nThe argument(s) \"{}\" will be deprecated in {}."
+                if behaviour:
+                    msg = "\nBehaviour of the argument(s) \"{}\" will change in {}."
+                msg = msg.format(deprecated_arguments_used, tdml_version)
+                if alternatives is not None:
+                    msg += "\nUse argument(s) \"{}\" instead.".format(alternatives)
+                warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
             return func(*args, **kwargs)
 
         return wraps(func)(wrapper)