teradataml 20.0.0.5__py3-none-any.whl → 20.0.0.7__py3-none-any.whl

teradataml/clients/auth_client.py

@@ -33,6 +33,8 @@ class _AuthWorkflow:
                     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.
+                    6. "valid_from" which states epoch seconds representing time from which JWT token will be valid
+                        and same is used as iat claim in payload.
                 Types: dict
 
         RETURNS:
@@ -52,7 +54,7 @@ class _AuthWorkflow:
             Generate expiry epoch time.
 
         RETURNS:
-            float
+            tuple
         """
         current_epoch_time = int(time.time())
         expiry_epoch_time = current_epoch_time + self.state.get('expiration_time')
@@ -83,12 +85,11 @@ class _AuthWorkflow:
         RETURNS:
             A dictionary with the JWT payload.
         """
-        iat, exp= self._get_epoch_time()
+        _, exp = self._get_epoch_time()
         payload = {
             "aud": [
                 "td:service:authentication"
             ],
-            "iat": iat,
             "exp": exp,
             "iss": "teradataml",
             "multi-use": True,
@@ -96,6 +97,9 @@ class _AuthWorkflow:
             "pat": self.state['pat_token'],
             "sub": self.state['username']
         }
+        # Add iat if applicable.
+        if self.state['valid_from'] is not None:
+            payload.update({"iat": self.state['valid_from']})
         return payload
 
     def _sign_jwt(self, payload, header):
@@ -128,6 +132,6 @@ class _AuthWorkflow:
         RETURNS:
             str
         """
-        jwt = self._sign_jwt(self._generate_payload(), self._generate_header())
-        self.state['jwt'] = jwt
-        return(jwt)
+        jwt_token = self._sign_jwt(self._generate_payload(), self._generate_header())
+        self.state['jwt'] = jwt_token
+        return jwt_token

teradataml/clients/keycloak_client.py

@@ -0,0 +1,165 @@
+"""
+Unpublished work.
+Copyright (c) 2025 by Teradata Corporation. All rights reserved.
+TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
+Primary Owner: shivani.kondewar@teradata.com
+Secondary Owner: aanchal.kavedia@teradata.com
+This file implements _KeycloakManager class used to store data for keycloak token generation.
+"""
+
+import time
+from enum import Enum
+
+from teradataml import TeradataMlException, MessageCodes
+from teradataml.common.constants import HTTPRequest
+from teradataml.context.context import _get_user
+
+
+class GrantType(Enum):
+    PASS = "password"
+    REFRESH = "refresh_token"
+    CLIENT = "client_credentials"
+
+
+class _KeycloakManager():
+
+    def __init__(self, auth_url, client_id):
+        """
+        DESCRIPTION:
+            Constructor to initiate keycloak manager.
+
+        PARAMETERS:
+            auth_url:
+                Required Argument.
+                Specifies the endpoint URL for a keycloak server.
+                Types: str
+
+            client_id:
+                Required Argument.
+                Specifies the client/service for which keycloak server avails a token.
+                Types: str
+
+        RETURNS:
+            Instance of _KeycloakManager.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            >>> token_generator = _KeycloakManager(auth_url=auth_url,
+            ...                                    username=username,
+            ...                                    client_id=client_id)
+        """
+        self._auth_url = auth_url
+        self._client_id = client_id
+        self._header = {"Content-Type": "application/x-www-form-urlencoded"}
+        self._expires_at = None
+        self._refresh_expires_at = None
+
+    def generate_token(self, username=None, password=None, refresh=False):
+        """
+        DESCRIPTION:
+            Method generates keycloak token.
+            Token can be generated using any one of the following information:
+                * Username and password
+                * Refresh token
+
+        PARAMETERS:
+            username:
+                Optional Argument.
+                Specifies the username for database user for which keycloak token is
+                to be generated. If not specified, then user associated with current
+                connection is used.
+                Types: str
+
+            password:
+                Optional Argument.
+                Specifies the password for database user.
+                Types: str
+
+            refresh:
+                Optional Argument.
+                Specifies the boolean flag to indicate if token needs to be generated
+                using existing refresh token or not.
+                Default value: False
+                Types: Boolean
+
+        RETURNS:
+            Keycloak token
+
+        RAISES:
+            RuntimeError.
+
+        EXAMPLES:
+            # Example 1: Generate the authentication token using username and password.
+            >>> keycloak_obj.generate_token(username="username", password="password")
+
+            # Example 2: Generate the authentication token using default username for
+            #            current session and provided password.
+            >>> keycloak_obj.generate_token(password="password")
+
+            # Example 3: Generate the authentication token using refresh token which is
+            #            already available.
+            >>> keycloak_obj.generate_token(refresh=True)
+            """
+        # Define the payload.
+        if password:
+            payload = {
+                "grant_type": GrantType.PASS.value,
+                "client_id": self._client_id,
+                "username": username if username else _get_user(),
+                "password": password
+            }
+        if refresh:
+            payload = {
+                "grant_type": GrantType.REFRESH.value,
+                "client_id": self._client_id,
+                "refresh_token": self._refresh_token
+            }
+
+        # Make the POST request.
+        # Importing locally to avoid circular import.
+        from teradataml import UtilFuncs
+        response = UtilFuncs._http_request(self._auth_url, HTTPRequest.POST,
+                                           headers=self._header, data=payload)
+
+        # Check the response.
+        if 200 <= response.status_code < 300:
+            response_data = response.json()
+            self._auth_token = response_data['access_token']
+            self._refresh_token = response_data['refresh_token']
+            # 30 is buffer time to assume delay in processing of response_data.
+            self._expires_at = time.time() + response_data['expires_in'] - 30
+            self._refresh_expires_at = time.time() + response_data['refresh_expires_in'] - 30
+        else:
+            raise
+
+        return self._auth_token
+
+    def get_token(self):
+        """
+        DESCRIPTION:
+            Function to get keycloak token.
+            If access token is not expired, existing token is returned.
+            If access token is expired, and refresh token is alive, new access token is generated.
+            If both access token and refresh token are expired, TeradataMlException is raised
+
+        RETURNS:
+            Keycloak token
+
+        RAISES:
+            TeradataMlException.
+
+        """
+        # If existing auth_token is expired, regenerate using refresh token.
+        if self._expires_at and time.time() > self._expires_at:
+            # If refresh token is expired, raise error.
+            if self._refresh_expires_at and time.time() > self._refresh_expires_at:
+                raise TeradataMlException("Refresh token for keycloak is expired."
+                                          " Execute set_auth_token() to set fresh authentication token.",
+                                          MessageCodes.FUNC_EXECUTION_FAILED)
+            else:
+                # Regenerate fresh access token using refresh token.
+                self.generate_token(refresh=True)
+
+        return self._auth_token

teradataml/common/aed_utils.py

@@ -150,7 +150,7 @@ class AedUtils:
 
         return self.aed_context._validate_aed_return_code(ret_code[0], nodeid_out[0].decode("utf-8"))
 
-    def _aed_select(self, nodeid, select_expr, distinct=False):
+    def _aed_select(self, nodeid, select_expr, distinct=False, timestamp_expr=None):
         """
         This wrapper function facilitates a integration with 'aed_select',
         a C++ function, in AED library, with Python tdml library.
@@ -162,6 +162,7 @@ class AedUtils:
             nodeid - A DAG node, a input to the select API.
             select_expr - Columns, to be selected from the data frame.
             distinct - Boolean, to decide addition of Distinct clause.
+            timestamp_expr - A string, to specify the temporal table clause.
 
         EXAMPLES:
             aed_table_nodeid = AedObj._aed_table("dbname.tablename")
@@ -181,11 +182,16 @@ class AedUtils:
                                                   POINTER(c_char_p),
                                                   POINTER(c_char_p),
                                                   POINTER(c_char_p),
+                                                  POINTER(c_int),
                                                   POINTER(c_int)
                                                   ]
 
         arg_name = ["projection"]
         arg_value = ["DISTINCT " + select_expr if distinct else select_expr]
+        if timestamp_expr:
+            arg_name.append("timestamp_expr")
+            arg_value.append(timestamp_expr)
+
         temp_table_name = UtilFuncs._generate_temp_table_name(prefix="select_", use_default_database=True, quote=False)
         output_table = [UtilFuncs._extract_table_name(temp_table_name)]
         output_schema = [UtilFuncs._extract_db_name(temp_table_name)]
@@ -195,6 +201,8 @@ class AedUtils:
 
         # return code
         ret_code = self.aed_context._int_array1(0)
+
+        length = self.aed_context._int_array1(len(arg_value))
         try:
             # *** AED request to select columns
             self.aed_context.ele_common_lib.aed_select(self.aed_context._arr_c([nodeid]),
@@ -203,6 +211,7 @@ class AedUtils:
                                            self.aed_context._arr_c(output_table),
                                            self.aed_context._arr_c(output_schema),
                                            nodeid_out,
+                                           length,
                                            ret_code)
         except Exception as emsg:
             raise TeradataMlException(Messages.get_message(MessageCodes.AED_EXEC_FAILED, "(aed_select)" + str(emsg)),
@@ -2050,7 +2059,7 @@ class AedUtils:
                                                          POINTER(c_int)
                                                          ]
         # Get number of parent nodes present to allocate enough memory
-        number_of_parent_nodes = self._aed_get_parent_node_count(nodeid);
+        number_of_parent_nodes = self._aed_get_parent_node_count(nodeid)
         parent_nodeids = self.aed_context._arr_c(["00000000000000000000"] * number_of_parent_nodes)
         ret_code = self.aed_context._int_array1(0)
 

teradataml/common/bulk_exposed_utils.py

@@ -98,7 +98,9 @@ def _validate_unimplemented_function(func_name, func_params, *args, **kwargs):
                                                       function_signature,
                                                       return_statement)
     # Creating function object from the string in locals.
-    exec(function_expression)
+    global_scope = {}
+    namespace = {}
+    exec(function_expression, global_scope, namespace)
 
     # kwargs may contain other properties too. So, before we call the function,
     # copying kwargs to another variable and remove additional properties.
@@ -107,5 +109,5 @@ def _validate_unimplemented_function(func_name, func_params, *args, **kwargs):
         if not param in TDMLFrameworkKeywords.AGGREGATE_FUNCTION_DEFAULT_ARGUMENTS.value:
             kw[param] = kwargs[param]
 
-    return locals().get(func_name)(*args, **kw)
+    return namespace[func_name](*args, **kw)
 

teradataml/common/constants.py

@@ -63,8 +63,14 @@ class SQLConstants(Enum):
     SQL_SELECT_COLUMNNAMES_WITH_WHERE = 32
     SQL_HELP_DATABASE = 33
     SQL_HELP_DATALAKE = 34
+    SQL_INSERT_INTO_TABLE_VALUES_WITH_COLUMN_NAMES = 35
     CONSTRAINT = ["check_constraint", "primary_key_constraint",
                   "foreign_key_constraint", "unique_key_constraint"]
+    SQL_TD_OTF_METADATA = 35
+    SQL_TD_OTF_SNAPSHOT = 36
+    SQL_LIST_TRIGGERS = 37
+    SQL_SHOW_TABLE = 38
+    SQL_SHOW_VIEW = 39
 
 
 class TeradataConstants(Enum):
@@ -141,6 +147,9 @@ class TeradataTypes(Enum):
                     INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
                     INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
                     INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND, INTERVAL_SECOND)
+    TD_RANGE_N_CLAUSE_TYPES = (INTERVAL_YEAR, INTERVAL_DAY, INTERVAL_MONTH,
+                               INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_HOUR)
+
 
 
 class TeradataTableKindConstants(Enum):
@@ -153,6 +162,21 @@ class TeradataTableKindConstants(Enum):
     VOLATILE_TABLE_NAME = 'Table Name'
     REGULAR_TABLE_NAME = 'TableName'
 
+class DataFrameTypes(Enum):
+    VIEW = "VIEW"
+    VALID_TIME_VIEW = "VALID_TIME_VIEW"
+    TRANSACTION_TIME_VIEW = "TRANSACTION_TIME_VIEW"
+    BI_TEMPORAL_VIEW = "BI_TEMPORAL_VIEW"
+    REGULAR_TABLE = "TABLE"
+    OTF_TABLE = "OTF"
+    BI_TEMPORAL = "BI_TEMPORAL"
+    TRANSACTION_TIME= "TRANSACTION_TIME"
+    VALID_TIME = "VALID_TIME"
+    ART_TABLE = "ART"
+    VOLATILE_TABLE = "VOLATILE_TABLE"
+    VALID_TIME_VOLATILE_TABLE = "VALID_TIME_VOLATILE_TABLE"
+    TRANSACTION_TIME_VOLATILE_TABLE = "TRANSACTION_TIME_VOLATILE_TABLE"
+    BI_TEMPORAL_VOLATILE_TABLE = "BI_TEMPORAL_VOLATILE_TABLE"
 
 class SQLPattern(Enum):
     SQLMR = re.compile(r"SELECT \* FROM .*\((\s*.*)*\) as .*", re.IGNORECASE)
@@ -1432,7 +1456,8 @@ class TeradataReservedKeywords(Enum):
                                "SUMMARY",
                                "HASH",
                                "METHOD",
-                               "TYPE"
+                               "TYPE",
+                               "CATALOG"
                                ]
 
 
@@ -1507,10 +1532,21 @@ class AsyncStatusColumns(Enum):
 
 
 class AsyncOpStatus(Enum):
-    # Holds valid status for asynchronous operatiosns in UES.
+    # Holds valid status for asynchronous operations in UES.
     FILE_INSTALLED = "File Installed"
     ERRED = "Errored"
     FINISHED = "Finished"
+    MODEL_INSTALLED = "ModelInstalled"
+
+
+class AsyncOpStatusOAFColumns(Enum):
+    # Holds column names of dataframe representing status of given claim-id.
+    CLAIM_ID = "Claim Id"
+    FILE_LIB_MODEL_NAME = "File/Libs/Model"
+    METHOD_NAME = "Method Name"
+    STAGE = "Stage"
+    TIMESTAMP = "Timestamp"
+    ADDITIONAL_DETAILS = "Additional Details"
 
 
 class CloudProvider(Enum):
@@ -1557,6 +1593,23 @@ class SessionParamsPythonNames(Enum):
 class AutoMLConstants(Enum):
     # List stores feature selection methods
     FEATURE_SELECTION_MTDS = ["lasso", "rfe", "pca"]
+    # Model lists
+    SUPERVISED_MODELS = ["glm", "svm", "knn", "decision_forest", "xgboost"]
+    CLUSTERING_MODELS = ["KMeans", "GaussianMixture"]
+    ALL_MODELS = SUPERVISED_MODELS + CLUSTERING_MODELS
+    
+    # Metric lists  
+    CLASSIFICATION_METRICS = ["MICRO-F1", "MACRO-F1", "MICRO-RECALL", "MACRO-RECALL",
+                             "MICRO-PRECISION", "MACRO-PRECISION", "WEIGHTED-PRECISION", 
+                             "WEIGHTED-RECALL", "WEIGHTED-F1", "ACCURACY"]
+    
+    REGRESSION_METRICS = ["R2", "MAE", "MSE", "MSLE", "MAPE", "MPE", 
+                         "RMSE", "RMSLE", "ME", "EV", "MPD", "MGD"]
+                         
+    CLUSTERING_METRICS = ["SILHOUETTE", "CALINSKI", "DAVIES"]
+    
+    # Combined for default case
+    ALL_METRICS = REGRESSION_METRICS + CLASSIFICATION_METRICS + CLUSTERING_METRICS
 
 
 class AuthMechs(Enum):
@@ -1567,3 +1620,20 @@ class AuthMechs(Enum):
     JWT = "JWT"
     PAT = "PAT"
     BASIC = "BASIC"
+    KEYCLOAK = "KEYCLOAK"
+
+class TDServices(Enum):
+    """
+    Enum to hold permitted values for types for services availed on Teradata vantage.
+    """
+    VECTORSTORE = "vectorstore"
+    MOPS = "MODELOPS" # For future reference
+
+class AccessQueries(Enum):
+    """
+    Enum to hold permitted access queries.
+    """
+    read = ["{grant_revoke_} SELECT ON {database_} {to_from_} {user_}"]
+    write= ["{grant_revoke_} CREATE TABLE ON {database_} {to_from_} {user_}",
+            "{grant_revoke_} CREATE VIEW ON {database_} {to_from_} {user_}",
+            "{grant_revoke_} DELETE, UPDATE, INSERT ON {database_} {to_from_} {user_}"]

teradataml/common/exceptions.py

@@ -12,6 +12,12 @@ teradataml.common.exceptions
 An Error class for the teradataml python module
 """
 
+
+import warnings
+import json
+import pprint
+
+
 class TeradataMlException(Exception):
     """
     Teradata Ml Exception class.
@@ -71,3 +77,29 @@ class TeradataMlException(Exception):
         """
         super(TeradataMlException, self).__init__(msg)
         self.code = code
+
+class TeradatamlRestException(TeradataMlException):
+    def __init__(self, msg, code, raw_message=None):
+        super().__init__(msg, code)
+
+        self._msg = msg
+        self._raw_message = raw_message
+    
+    @property
+    def json_response(self):
+        """
+        Returns the JSON response from the server.
+        """
+        if self._raw_message is not None and self._raw_message.startswith("Error message: "):
+            failure_msg = f"Could not convert msg to json. Message is \n{self._raw_message}"
+            try:
+                json_resp = self._msg.split("Error message: ")[1]
+                json_resp = json.loads(json_resp)
+                return pprint.pformat(json_resp)
+            except json.JSONDecodeError as _:
+                warnings.warn(failure_msg)
+        elif self._raw_message is None:
+            return None
+        else:
+            warnings.warn(failure_msg)
+    

teradataml/common/garbagecollector.py

@@ -325,23 +325,26 @@ class GarbageCollector():
             raise
 
     @staticmethod
-    def _delete_object_entry(object_to_delete,
+    def _delete_object_entry(objects_to_delete,
                              object_type=TeradataConstants.TERADATA_TABLE,
                              remove_entry_from_gc_list=False):
         """
         DESCRIPTION:
             Deletes an entry of table/view/script from persisted file.
-            This makes sure that the object is not garbage collected.
+            This makes sure that the object(s) is/are not garbage collected.
 
         PARAMETERS:
-            object_to_delete:
+            objects_to_delete:
                 Required Argument.
-                Specifies the name of the table/view/script to be deleted.
-                Types: str
+                Specifies the names of the table/view/script to be deleted.
+                Types: str or list of str
 
             object_type:
                 Optional Argument.
                 Specifies the type of the object (table/view/script) to be deleted.
+                Note:
+                    Pass None, when object type is not available. In this case, the given object will be
+                    removed from GC file based on just object name and current process id.
                 Default Value: TeradataConstants.TERADATA_TABLE
                 Types: TeradataConstants
 
@@ -365,8 +368,11 @@ class GarbageCollector():
             None.
 
         EXAMPLES:
-            GarbageCollector._delete_table_view_entry(object_to_delete = 'temp.temp_table1')
+            GarbageCollector._delete_table_view_entry(objects_to_delete = 'temp.temp_table1')
         """
+        from teradataml.common.utils import UtilFuncs
+        objects_to_delete = UtilFuncs._as_list(objects_to_delete)
+
         try:
             tempfilename = GarbageCollector.__make_temp_file_name()
             if not os.path.isfile(tempfilename):
@@ -383,25 +389,37 @@ class GarbageCollector():
                     db_object_type = int(record_parts[2].strip())
                     db_object = record_parts[3].strip()
 
+                    _added_in_gc_file = False # Set to True if the entry is added to GC file.
+
                     # Avoid substring matches by comparing object names in full.
                     # Also make sure to check for the pid.
-                    if not (object_to_delete == db_object
+                    if object_type and not (db_object in objects_to_delete
                             and object_type.value == db_object_type
                             and int(os.getpid()) == contentpid):
                         fgc.write(db_object_entry)
-                    else:
-                        if remove_entry_from_gc_list and configure._validate_gc:
-                            # Delete the entry from gc lists if required.
-                            GarbageCollector.__delete_object_from_gc_list(object_to_delete,
-                                                                          object_type)
-
-                        # If object is a script, also delete the local copy of the file.
-                        if object_type in \
-                            [TeradataConstants.TERADATA_SCRIPT,
-                             TeradataConstants.TERADATA_APPLY,
-                             TeradataConstants.TERADATA_TEXT_FILE,
-                             TeradataConstants.TERADATA_LOCAL_SCRIPT]:
-                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, object_type)
+                        _added_in_gc_file = True
+
+                    elif object_type is None:
+                        if db_object in objects_to_delete and int(os.getpid()) == contentpid:
+                            # Skip adding to GC file if the object is being deleted but object_type is passed as None.
+                            pass
+                        else:
+                            fgc.write(db_object_entry)
+                            _added_in_gc_file = True
+
+
+                    if not _added_in_gc_file and remove_entry_from_gc_list and configure._validate_gc:
+                        # Delete the entry from gc lists if required.
+                        GarbageCollector.__delete_object_from_gc_list(db_object, object_type)
+
+
+                    # If object is a script, also delete the local copy of the file.
+                    if not _added_in_gc_file and object_type in \
+                        [TeradataConstants.TERADATA_SCRIPT,
+                         TeradataConstants.TERADATA_APPLY,
+                         TeradataConstants.TERADATA_TEXT_FILE,
+                         TeradataConstants.TERADATA_LOCAL_SCRIPT]:
+                        GarbageCollector.__delete_gc_tempdir_local_file(db_object, object_type)
                 fgc.truncate()
         except Exception as e:
             raise
@@ -456,8 +474,19 @@ class GarbageCollector():
                 GarbageCollector.__gc_container.remove(object_name)
             elif TeradataConstants.TERADATA_APPLY == object_type:
                 GarbageCollector.__gc_apply.remove(object_name)
-            else:
+            elif TeradataConstants.TERADATA_SCRIPT == object_type:
                 GarbageCollector.__gc_scripts.remove(object_name)
+            else:
+                # If none of the conditions met, then try removing from all.
+                _all_gc_lists = [GarbageCollector.__gc_tables, GarbageCollector.__gc_views,
+                                 GarbageCollector.__gc_scripts, GarbageCollector.__gc_container,
+                                 GarbageCollector.__gc_apply]
+                for _list in _all_gc_lists:
+                    try:
+                        _list.remove(object_name)
+                    except ValueError:
+                        # If the object is not found in the list, just ignore.
+                        pass
 
     @staticmethod
     def _delete_local_file(file_path):