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

teradataml/scriptmgmt/UserEnv.py

@@ -26,7 +26,7 @@ import pandas as pd
 from teradataml import configure
 from teradataml.clients.pkce_client import _DAWorkflow
 from teradataml.common.constants import (AsyncOpStatus, CloudProvider,
-                                         HTTPRequest)
+                                         HTTPRequest, AsyncOpStatusOAFColumns)
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.messages import Messages
@@ -120,6 +120,7 @@ def _get_ues_url(env_type="users", **kwargs):
 
     ues_url = "{0}/{1}/{2}".format(ues_url, _get_user(), env_type)
     env_name, files, libs = kwargs.get("env_name"), kwargs.get("files", False), kwargs.get("libs", False)
+    models = kwargs.get("models", False)
 
     if env_name is not None:
         ues_url = "{0}/{1}".format(ues_url, env_name)
@@ -131,6 +132,8 @@ def _get_ues_url(env_type="users", **kwargs):
             ues_url = "{0}/{1}".format(ues_url, file_name)
     elif libs:
         ues_url = "{0}/{1}".format(ues_url, "libraries")
+    elif models:
+        ues_url = "{0}/{1}".format(ues_url, "models")
     return ues_url
 
 
@@ -3661,7 +3664,7 @@ class UserEnv:
             record.update(claim_id_details)
             return [record]
 
-    def __get_claim_status(self, claim_id, timeout, action):
+    def __get_claim_status(self, claim_id, timeout, action, **kwargs):
         """
         DESCRIPTION:
             Function to get the status of asynchronus process using the claim_id.
@@ -3687,12 +3690,13 @@ class UserEnv:
                 Specifies the action for asynchronous process.
                 Types: str
 
-            suppress_output:
-                Required Argument.
-                Specifies whether to print the output message or not.
-                When set to True, then the output message is not printed.
-                Default Value: False
-                Types: bool
+            kwargs:
+                suppress_output:
+                    Optional Argument.
+                    Specifies whether to print the output message or not.
+                    When set to True, then the output message is not printed.
+                    Default Value: False
+                    Types: bool
 
         RETURNS:
             Pandas DataFrame OR claim id.
@@ -3707,22 +3711,23 @@ class UserEnv:
         # If user specifies 'timeout', poll only for 'timeout' seconds. Otherwise,
         # poll status API indefinitely.
         timeout = UtilFuncs._get_positive_infinity() if timeout is None else timeout
-
+        suppress_output = kwargs.get("suppress_output", False)
         start_time = time.time()
         while time.time() - start_time <= timeout:
             time.sleep(3)
-            records = self.__is_async_operation_completed(claim_id)
+            records = self.__is_async_operation_completed(claim_id, suppress_output=suppress_output)
             if records:
                 return pd.DataFrame.from_records(records, columns=self.__status_columns)
 
         # Unable to get the response with in 'timeout' seconds. Print a message and
         # return claim id.
-        print("Request to {} initiated successfully in the remote user environment '{}' "
-              "but Timed out status check. Check the status using status() with the "
-              "claim id '{}'.".format(action, self.env_name, claim_id))
+        if not suppress_output:
+            print("Request to {} initiated successfully in the remote user environment '{}' "
+                  "but Timed out status check. Check the status using status() with the "
+                  "claim id '{}'.".format(action, self.env_name, claim_id))
         return claim_id
 
-    def __is_async_operation_completed(self, claim_id):
+    def __is_async_operation_completed(self, claim_id, **kwargs):
         """
         DESCRIPTION:
             Function to check whether asynchronous process to install/update/uninstall libraries/file
@@ -3735,6 +3740,14 @@ class UserEnv:
                 started by the UserEnv management methods.
                 Types: str
 
+            kwargs:
+                suppress_output:
+                    Optional Argument.
+                    Specifies whether to print the output message or not.
+                    When set to True, then the output message is not printed.
+                    Default Value: False
+                    Types: bool
+
         RETURNS:
             list OR bool.
 
@@ -3745,6 +3758,7 @@ class UserEnv:
             # Create a remote user environment.
             >>> env.__is_async_operation_completed('123-456')
         """
+        suppress_output = kwargs.get("suppress_output", False)
         records = self.__get_claim_id_status(claim_id)
 
         # For library installation/uninstallation/updation, if the background process in
@@ -3753,12 +3767,17 @@ class UserEnv:
         action = self.__claim_ids.get(claim_id, {}).get("action")
         if action in ["install_file", "install_model"]:
             for record in records:
-                if record["Stage"] in [AsyncOpStatus.FILE_INSTALLED.value, AsyncOpStatus.ERRED.value]:
-                    if record["Stage"] == AsyncOpStatus.FILE_INSTALLED.value:
-                        print("Request for {} is {}.".format(action, "completed successfully"))
+                if record["Stage"] in [AsyncOpStatus.FILE_INSTALLED.value,
+                                       AsyncOpStatus.ERRED.value,
+                                       AsyncOpStatus.MODEL_INSTALLED.value]:
+                    if record["Stage"] in [AsyncOpStatus.FILE_INSTALLED.value,
+                                           AsyncOpStatus.MODEL_INSTALLED.value]:
+                        if not suppress_output:
+                            print("Request for {} is {}.".format(action, "completed successfully"))
                     elif record["Stage"] == AsyncOpStatus.ERRED.value:
-                        print("Request for {} is {}.".format(action, AsyncOpStatus.ERRED.value))
-                        print("Check the status using status() with the claim id '{}'".format(claim_id))
+                        if not suppress_output:
+                            print("Request for {} is {}.".format(action, AsyncOpStatus.ERRED.value))
+                            print("Check the status using status() with the claim id '{}'".format(claim_id))
                     return records
             return False
 
@@ -3766,24 +3785,51 @@ class UserEnv:
         return records if len(records) == 2 else False
 
     @collect_queryband(queryband="InstlMdl")
-    def install_model(self, model_path, **kwargs):
+    def install_model(self, model_path=None, model_name=None, model_type=None, api_key=None, **kwargs):
         """
         DESCRIPTION:
-            Function installs a model from client machine to the remote
-            user environment created in Vantage Languages Ecosystem. If
-            model with same name already exists in the remote user
-            environment, error is thrown.
+            Function installs a model into the remote user environment created
+            in Vantage Languages Ecosystem. Model can be installed from a zip file
+            containing all the files related to the model or from a model registry
+            like Hugging Face. If model with same name already exists in the remote
+            user environment, error is thrown.
             Note:
-                Maximum size of the model should be less than or equal to 5GB.
+                Maximum size of the model should be less than or equal to 5GB when
+                installing using zip.
 
         PARAMETERS:
             model_path:
-                Required Argument.
+                Optional Argument.
                 Specifies absolute or relative path of the zip file containing
                 model (including file name) to be installed in the remote user
                 environment.
+                Notes:
+                    * Model file should be in zip format.
+                    * Arguments "model_path" and "model_name" are mutually exclusive.
+                Types: str
+
+            model_name:
+                Optional Argument.
+                Specifies the name/identifier of the model in the registry (e.g. "google-t5/t5-small"
+                from Hugging Face registry).
                 Note:
-                    Model file should be in zip format.
+                    * Arguments "model_name" and "model_path" are mutually exclusive.
+                Types: str
+
+            model_type:
+                Optional Argument.
+                Specifies the name of model registry like Hugging Face.
+                Note:
+                    * Applicable when model is installed from a model registry.
+                Default Value: "HF" (Hugging Face registry)
+                Permitted Values: "HF"
+                Types: str
+
+            api_key:
+                Optional Argument.
+                Specifies the API key for accessing the private models in registry.
+                Note:
+                    Applicable only when model is installed from a model registry.
                 Types: str
 
         **kwargs:
@@ -3860,13 +3906,148 @@ class UserEnv:
             >>> env.models
                      Model  Size             Timestamp
             0  large_model  6144  2023-10-30T13:34:03Z
+
+            # Example 3: Install the model from default registry 'Hugging Face'
+            #            in the 'testenv' environment synchronously.
+            >>> env.install_model(model_name="google-bert/bert-base-uncased")
+            Request for install_model is completed successfully.
+            Model 'google-bert/bert-base-uncased' installed successfully in the remote user environment 'testenv'.
+
+            # Verify the model installation.
+            >>> env.models
+                                                  Model       Size                  Timestamp
+            0    models--google-bert--bert-base-uncased       6144       2025-07-30T03:58:01Z
+
+            # Example 4: Install the model from default registry 'Hugging Face'
+            #            in the 'testenv' environment asynchronously.
+            >>> claim_id = env.install_model(model_name="Helsinki-NLP/opus-mt-en-fr", asynchronous=True)
+            Model installation is initiated. Check the status using <UserEnv_obj>.status() with the claim id 'ac284706-0b72-4b83-8add-3cff632747f4'.
+
+            # Check status using claim-id.
+            >>> env.status(claim_id)
+                                             Claim Id    File/Libs/Model                 Method Name    Stage                         Timestamp      Additional Details
+            0    ac284706-0b72-4b83-8add-3cff632747f4    Helsinki-NLP/opus-mt-en-fr    install_model    Started            2025-07-30T03:58:09Z    Begin downloading model named Helsinki-NLP/opu...
+            1    ac284706-0b72-4b83-8add-3cff632747f4    Helsinki-NLP/opus-mt-en-fr    install_model    ModelInstalled     2025-07-30T03:58:28Z    Model installed successfully
+
+            # Verify the model installation.
+            >>> env.models
+                                                  Model    Size               Timestamp
+            0       models--Helsinki-NLP--opus-mt-en-fr    6144    2025-07-30T03:58:27Z
+            1    models--google-bert--bert-base-uncased    6144    2025-07-30T03:58:01Z
         """
-        # Install model in User environment.
-        kwargs["is_model"] = True
-        if not "is_llm" in kwargs:
-            kwargs["is_llm"] = True
-        records = self.install_file(model_path, **kwargs)
-        return records
+        # Get default values for optional keyword arguments.
+        suppress_output = kwargs.get("suppress_output", False)
+        asynchronous = kwargs.get("asynchronous", False)
+        timeout = kwargs.get("timeout", None)
+
+        # Get default value for optional positional argument.
+        model_type = model_type if model_type is not None else "HF"
+
+        # Argument validation.
+        __arg_info_matrix = []
+        __arg_info_matrix.append(["model_path", model_path, True, (str), True])
+        __arg_info_matrix.append(["model_name", model_name, True, (str), True])
+        __arg_info_matrix.append(["model_type", model_type, True, (str), True, ["HF"]])
+        __arg_info_matrix.append(["api_key", api_key, True, (str), True])
+        __arg_info_matrix.append(["suppress_output", suppress_output, True, (bool)])
+        __arg_info_matrix.append(["asynchronous", asynchronous, True, (bool)])
+        __arg_info_matrix.append(["timeout", timeout, True, (int, float)])
+
+        _Validators._validate_function_arguments(__arg_info_matrix)
+
+        # Validate mutually exclusive arguments.
+        _Validators._validate_mutually_exclusive_argument_groups({"model_name": model_name},
+                                                                 {"model_path": model_path},
+                                                                 all_falsy_check=True)
+
+        # Install model from zip file.
+        if model_path:
+            kwargs["is_model"] = True
+            if not "is_llm" in kwargs:
+                kwargs["is_llm"] = True
+            records = self.install_file(model_path, **kwargs)
+            return records
+
+        # Install models from registry.
+        api_name = "install_model"
+        try:
+            # Prepare the payload
+            payload = {
+                "model_name": model_name,
+                "model_type": model_type
+            }
+
+            if api_key is not None:
+                payload["api_key"] = api_key
+
+            # Make the REST call to install model from registry
+            resource_url = _get_ues_url(env_name=self.env_name, api_name=api_name, models=True)
+            response = UtilFuncs._http_request(resource_url,
+                                               HTTPRequest.POST,
+                                               headers=_get_auth_token(),
+                                               json=payload)
+
+            data = _process_ues_response(api_name, response).json()
+
+            # Get claim-id model install async operation from response.
+            claim_id = data["claim_id"]
+
+            # Store the claim id locally to display the model name in status API.
+            self.__claim_ids[claim_id] = {"action": api_name, "value": model_name}
+            installation_status = "is initiated"
+
+            # In case of synchronous mode, keep polling the status
+            # of underlying asynchronous operation until it is either
+            # successful or errored or timed out.
+            if not asynchronous:
+                installation_status =  self.__get_claim_status(claim_id=claim_id,
+                                                               timeout=timeout,
+                                                               action=api_name,
+                                                               suppress_output=True)
+                self.__models_changed = True
+                # If model installation is complete(either success or fail),
+                # pandas DF will be returned.
+                if isinstance(installation_status, pd.DataFrame):
+                    # Model installation successful.
+                    if AsyncOpStatus.MODEL_INSTALLED.value in installation_status[AsyncOpStatusOAFColumns.STAGE.value].to_list():
+                        # Update the models changed flag
+                        self.__models_changed = True
+                        if not suppress_output:
+                            print("Model '{}' installed successfully in the remote user environment '{}'.".format(
+                                model_name, self.env_name))
+                        return True
+                    # Model installation erred out.
+                    if AsyncOpStatus.ERRED.value in installation_status[AsyncOpStatusOAFColumns.STAGE.value].to_list():
+                        err = ""
+                        for record in installation_status.to_dict("records"):
+                            if record["Stage"] == AsyncOpStatus.ERRED.value:
+                                err = record[AsyncOpStatusOAFColumns.ADDITIONAL_DETAILS.value]
+                        msg_code = MessageCodes.FUNC_EXECUTION_FAILED
+                        error_msg = Messages.get_message(msg_code, api_name, "Check the details using <UserEnv_obj>.status() with the claim id '{}'".format(claim_id) + "\nAdditional details: {}".format(err))
+                        raise TeradataMlException(error_msg, msg_code)
+
+                # Underlying asynchronous operation timed out, claim_id is returned.
+                else:
+                    if not suppress_output:
+                        print("Request to install_model initiated successfully in the remote user environment '{}' "
+                              "but it is timed out. Check the status using <UserEnv_obj>.status() with the "
+                              "claim id '{}'.".format(self.env_name, claim_id))
+                    return claim_id
+
+            if not suppress_output:
+                # Print a message to user console.
+                print("Model installation {}. Check the status"
+                      " using <UserEnv_obj>.status() with the claim id '{}'.".format(installation_status, claim_id))
+            self.__models_changed = True
+            return claim_id
+
+        except (TeradataMlException, RuntimeError):
+            raise
+        except Exception as emsg:
+            msg_code = MessageCodes.FUNC_EXECUTION_FAILED
+            error_msg = Messages.get_message(msg_code, api_name, str(emsg))
+            raise TeradataMlException(error_msg, msg_code)
+
 
     @collect_queryband(queryband="UninstlMdl")
     def uninstall_model(self, model_name, **kwargs):
@@ -3905,7 +4086,7 @@ class UserEnv:
             # API. Let's assume that all models files are zipped under 'large_model.zip'
             >>> model = 'large_model.zip'
 
-            # Install the model in the 'test_env' environment.
+            # Install the model in the 'test_env' environment using local zip file.
             >>> env.install_model(model_path = model)
             Request for install_model is completed successfully.
                                            Claim Id  File/Libs/Model    Method Name               Stage             Timestamp  Additional Details
@@ -3918,9 +4099,28 @@ class UserEnv:
                      Model  Size             Timestamp
             0  large_model  6144  2023-11-09T09:22:30Z
 
+            # Install model from Hugging Face registry.
+            >>> env.install_model(model_name="google-bert/bert-base-uncased")
+            Request for install_model is completed successfully.
+            Model 'google-bert/bert-base-uncased' installed successfully in the remote user environment 'test_env'.
+            # List models.
+            >>> env.models
+                                                  Model     Size               Timestamp
+            0                               large_model     6144    2023-11-09T09:22:30Z
+            1    models--google-bert--bert-base-uncased     6144    2025-07-30T03:58:01Z
+
             # Example 1: Uninstall model from remote user environment.
             >>> env.uninstall_model('large_model')
             Model 'large_model' uninstalled successfully from the remote user environment 'test_env'.
+            True
+
+             # Verify the uninstallation of model.
+                                                  Model    Size               Timestamp
+            0    models--google-bert--bert-base-uncased    6144    2025-07-30T03:58:01Z
+
+            # Example 2: Uninstall Hugging Face model from remote user environment.
+            >>> env.uninstall_model('models--google-bert--bert-base-uncased')
+            Model 'models--google-bert--bert-base-uncased' uninstalled successfully from the remote user environment 'test_env'.
             True
 
             # Verify the uninstallation of model.

teradataml/scriptmgmt/lls_utils.py

@@ -267,7 +267,7 @@ def list_user_envs(env_name=None, **kwargs):
 
         # Example 8: List all user environments where python 3 environment release version has 
         #            odd number. For e.g. python_3.7.x. 
-        >>> list_user_envs(base_env="\.\d*[13579]\.")
+        >>> list_user_envs(base_env="\\.\\d*[13579]\\.")
                   env_name                        env_description  base_env_name language
         1  Customer_Trends                Analyse customer trends        r_4.1.3        R
         2  Fraud_Detection  Fraud detection through time matching  python_3.7.13   Python
@@ -474,29 +474,51 @@ def __create_envs(template):
     return last_successful_env
 
 
-def __get_default_base_env():
+def __get_default_base_env(lang="python"):
     """
-    Function returns the latest python environment available with
-    Open Analytics Framework.
+    DESCRIPTION:
+        Function returns the name of latest environment available with
+        Open Analytics Framework for given programming language.
+
+    PARAMETERS:
+        lang:
+            Optional Argument.
+            Specifies the language for which latest base env is to be retrieved.
+            Default value: "python"
+            Permitted values: "python", "r", "PYTHON", "R"
+            Types: str
+
+    RETURNS:
+        Base environment name.
+
+    RAISES:
+        None.
+
+    EXAMPLES:
+        # Get default R base environment.
+        >>> __get_default_base_env(lang="R")
     """
+    lang = lang.lower()
+    default_env_key = "default_base_env_{}".format(lang)
     # Check if the default base environment is already available.
-    if _InternalBuffer.get('default_base_env') is not None:
-        return _InternalBuffer.get('default_base_env')
+    if _InternalBuffer.get(default_env_key) is not None:
+        return _InternalBuffer.get(default_env_key)
 
     try:
         base_envs = list_base_envs()
-        python_versions = base_envs[base_envs.language == 'Python']['version']
+        versions = base_envs[base_envs.language.str.lower() == lang]['version']
         # Convert version strings to tuples of integers for comparison
-        version_tuples = [tuple(map(int, version.split('.'))) for version in python_versions]
+        version_tuples = [tuple(map(int, version.split('.'))) for version in versions]
         # Find the latest version tuple using max() function
         latest_version_tuple = max(version_tuples)
         # Convert the latest version tuple back to a string
         latest_version = '.'.join(map(str, latest_version_tuple))
-        # Get the base environment name for the latest version
-        _InternalBuffer.add(default_base_env=base_envs[base_envs.version == latest_version]['base_name'].to_list()[0])
-        return _InternalBuffer.get('default_base_env')
+        # Get the base environment name for the latest version and add in internal buffer.
+        _InternalBuffer.add(**{default_env_key:
+                                   base_envs[base_envs.version == latest_version]['base_name'].to_list()[0]})
+        return _InternalBuffer.get(default_env_key)
     except Exception as base_env_err:
-        raise Exception("Failed to obtain default base environment.", str(base_env_err.exception))
+        raise Exception("Failed to obtain default base environment.", str(base_env_err))
 
 
 def __install_files(env, directory):
@@ -799,12 +821,14 @@ def create_env(env_name=None, base_env=None, desc=None, template=None, conda_env
                 # the list of base envs. If not available, set base_env to the default python base env.
                 if not base_env or \
                         base_env.lower() not in list_base_envs()['base_name'].str.lower().to_list():
+                    lang = "python"
                     # Print warning message if base_env provided is not available.
                     if base_env:
                         print(f"Note: The specified base environment '{base_env}' is unavailable. " \
                               "Using the default base environment as specified in the documentation.")
+                        lang = base_env.split('_')[0].lower() # Extract language for given base_env.
                     # Set base_env to the default
-                    base_env = __get_default_base_env()
+                    base_env = __get_default_base_env(lang=lang)
         if not desc:
             desc = "This env '{}' is created with base env '{}'.".format(env_name, base_env)
         try:
@@ -1505,7 +1529,7 @@ def _remove_all_envs(env_type, **kwargs):
                             claim_id_list.append(future_result)
 
                     except (TeradataMlException, RuntimeError, Exception) as emsg:
-                        # Catching exceptions by remove_env if occured in any thread.
+                        # Catching exceptions by remove_env if occurred in any thread.
                         failed_envs[env] = emsg
 
             # Negative case - Failed to remove env.
@@ -1819,7 +1843,7 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
                 Specifies epoch seconds representing time from which JWT token will be valid.
                 Note:
                     * Applicable only when "auth_mech" is "PAT".
-                Default value: None
+                Default value: 0
                 Types: int
 
     RETURNS:
@@ -1906,7 +1930,7 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
                                   MessageCodes.INVALID_CONTEXT_CONNECTION)
 
     # Remove keys from _InternalBuffer which are interrelated to base_url and authentication token.
-    _InternalBuffer.remove_keys(['list_base_envs', 'default_base_env',
+    _InternalBuffer.remove_keys(['list_base_envs', 'default_base_env_python', 'default_base_env_r',
                                  'vs_session_id', 'vs_header'])
 
     # ---------------------------------ARGUMENT VALIDATION------------------------------------------------------
@@ -1949,7 +1973,7 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
     validate_jwt = kwargs.get("validate_jwt", True)
     __arg_info_matrix.append(["validate_jwt", validate_jwt, True, (bool)])
 
-    valid_from = kwargs.get("valid_from", None)
+    valid_from = kwargs.get("valid_from", 0) # This sets iat to UTC beginning.
     __arg_info_matrix.append(["valid_from", valid_from, True, int])
 
     # Validate arguments.
@@ -1968,6 +1992,8 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
 
         # Set the vector_store_base_url. This should only be done if base_url is set.
         # In case ues_url is set, vector_store_base_url should not be set.
+        # Remove trailing forward slash from base_url if present.
+        base_url = base_url[: -1] if base_url.endswith("/") else base_url
         configure._vector_store_base_url = f'{base_url}/data-insights'
 
     if ues_url:

teradataml/sdk/_json_parser.py

@@ -198,7 +198,7 @@ class _SdkJsonParser:
         # Hence adding `projection` argument for those endpoints as well.
 
         if ("/search" in path and "projection" not in query_params_dict.keys()) or \
-            (re.search(pattern="^/api/[a-zA-Z]+/\{id\}$", string=path) is not None and method == "get"):
+            (re.search(pattern=r"^/api/[a-zA-Z]+/\{id\}$", string=path) is not None and method == "get"):
             # TODO: Confirm with ModelOps team.
             #       There is "projection" parameter in query params for some endpoints
             #       but missing in some other endpoints.

teradataml/sdk/api_client.py

@@ -40,7 +40,7 @@ os.system("")  # enables ansi escape characters in terminal
 
 
 class Client(object):
-    DEFAULT_CONFIG_DIR = os.path.join(GarbageCollector._get_temp_dir_name(), ".sdk")
+    DEFAULT_CONFIG_DIR = os.path.join(GarbageCollector._get_temp_dir_name(), "sdk")
     DEFAULT_TOKEN_CACHE_FILE_PATH = os.path.join(DEFAULT_CONFIG_DIR, ".token")
     DEFAULT_CONFIG_FILE_PATH = os.path.join(DEFAULT_CONFIG_DIR, "config.yaml")
     MAX_RETRIES = 3
@@ -198,7 +198,10 @@ class Client(object):
         """
         self.logger = logging.getLogger(__name__)
 
-        os.makedirs(self.DEFAULT_CONFIG_DIR, exist_ok=True)
+        # Use the class attributes of the actual instance's class (could be a child class)
+        # rather than Client's class attributes
+        cls = self.__class__
+        os.makedirs(cls.DEFAULT_CONFIG_DIR, exist_ok=True)
 
 
         arg_info_matrix = []
@@ -239,14 +242,14 @@ class Client(object):
 
         if self.auth_mode == DeviceCodeAuth.AUTH_MODE.value:
             try:
-                self.session = auth.authenticate(token_cache_file_path=self.DEFAULT_TOKEN_CACHE_FILE_PATH)
+                self.session = auth.authenticate(token_cache_file_path=cls.DEFAULT_TOKEN_CACHE_FILE_PATH)
             except InvalidGrantError as ge:
                 if ge.description in ["Token is not active", "Session not active"]:
                     logging.warning(ge.description + "\nRetrying one more time\n")
 
                     self.__remove_cached_token()
 
-                    self.session = auth.authenticate(token_cache_file_path=self.DEFAULT_TOKEN_CACHE_FILE_PATH)
+                    self.session = auth.authenticate(token_cache_file_path=cls.DEFAULT_TOKEN_CACHE_FILE_PATH)
                 else:
                     raise ge
             except InvalidTokenError as ge:
@@ -294,8 +297,8 @@ class Client(object):
         yaml_file_path = None
         if self.__config_file is not None:
             yaml_file_path = self.__config_file
-        elif os.path.isfile(self.DEFAULT_CONFIG_FILE_PATH):
-            yaml_file_path = self.DEFAULT_CONFIG_FILE_PATH
+        elif os.path.isfile(self.__class__.DEFAULT_CONFIG_FILE_PATH):
+            yaml_file_path = self.__class__.DEFAULT_CONFIG_FILE_PATH
         if yaml_file_path:
             with open(yaml_file_path, "r") as handle:
                 conf = yaml.safe_load(handle)

teradataml/sdk/modelops/_client.py

@@ -27,6 +27,9 @@ from ..constants import SdkNames
 
 class ModelOpsClient(Client):
     DEFAULT_CONFIG_DIR = os.path.join(GarbageCollector._get_temp_dir_name(), "sdk", "modelops")
+    DEFAULT_TOKEN_CACHE_FILE_PATH = os.path.join(DEFAULT_CONFIG_DIR, ".token")
+    DEFAULT_CONFIG_FILE_PATH = os.path.join(DEFAULT_CONFIG_DIR, "config.yaml")
+    MAX_RETRIES = 3
     SDK_NAME = SdkNames.MODELOPS.value
 
     def __init__(self, base_url=None, auth=None, ssl_verify=True, config_file=None, project_id=None):