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

teradataml/hyperparameter_tuner/utils.py

@@ -276,6 +276,8 @@ class _ProgressBar:
                progress_precent=_progress_percent,
                completed_jobs=self.completed_jobs,
                total_jobs=self.total_jobs)
+        # Add padding to clear any leftover characters from the previous message.
+        padded_msg = _msg.ljust(self.blank_space_len)
         # Display the formatted bar.
-        print(_msg, end='\r', file=self.STDOUT, flush=True)
-        self.blank_space_len = len(_msg)
+        print(padded_msg, end='\r', file=self.STDOUT, flush=True)
+        self.blank_space_len = len(padded_msg)

teradataml/opensource/_base.py

@@ -51,6 +51,7 @@ from teradataml.opensource._wrapper_utils import (_generate_new_name,
                                                   _validate_df_query_type)
 from teradataml.options.configure import configure
 from teradataml.utils.validators import _Validators
+from teradataml.utils.internal_buffer import _InternalBuffer
 
 logger = pylogger.getLogger()
 
@@ -88,9 +89,13 @@ class _GenericObjectWrapper:
                 self._env = configure.openml_user_env
             else:
                 self._env = UtilFuncs._create_or_get_env("open_source_ml.json")
+        else:
+            set_session_param("searchuifdbpath", self._db_name)
 
         # Check if the Python interpreter major versions are consistent between Vantage and local.
-        UtilFuncs._check_python_version_diff(self._env)
+        _check_py_version = _InternalBuffer.get('_check_py_version')
+        if _check_py_version:
+            UtilFuncs._check_python_version_diff(self._env)
             
         # Raise warning when python package versions don't match between Vantage and local.
         # OPENSOURCE_PACKAGE_NAME is set for each opensource package, but not for the base class.
@@ -1257,6 +1262,7 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
 
 class _FunctionWrapper(_GenericObjectWrapper):
     def __init__(self, module_name, func_name, file_type, template_file):
+
         super().__init__()
         self._module_name = module_name
         self._func_name = func_name

teradataml/options/configure.py

@@ -62,6 +62,7 @@ class _Configure(_ConfigureSuper):
     stored_procedure_install_location = _create_property('stored_procedure_install_location')
     table_operator = _create_property('table_operator')
     temp_object_type = _create_property('temp_object_type')
+    use_short_object_name = _create_property('use_short_object_name')
 
     def __init__(self, default_varchar_size=1024, column_casesensitive_handler=False,
                  vantage_version="vantage1.1", val_install_location=None,
@@ -71,7 +72,7 @@ class _Configure(_ConfigureSuper):
                  cran_repositories=None, inline_plot=True,
                  indb_install_location=None,
                  openml_user_env=None, local_storage=None, stored_procedure_install_location="SYSLIB",
-                 table_operator=None, temp_object_type=None):
+                 table_operator=None, temp_object_type=None, use_short_object_name=False):
 
         """
         PARAMETERS:
@@ -140,8 +141,8 @@ class _Configure(_ConfigureSuper):
 
             indb_install_location:
                 Specifies the installation location of In-DB Python package.
-                Types: string
                 Default Value: "/var/opt/teradata/languages/sles12sp3/Python/"
+                Types: string
                 Example:
                     # Set the installation location for older versions.
                     teradataml.options.configure.indb_install_location = "/opt/teradata/languages/Python/"
@@ -182,9 +183,9 @@ class _Configure(_ConfigureSuper):
                 Specifies the type of temporary database objects created internally by teradataml.
                 Permitted Values:
                     * "VT" - Volatile tables.
-                Types: String
                 Default Value: None
-                Note:
+                Types: String
+                Notes:
                     * If this option is set to "VT" and "persist" argument of analytic functions is
                       set to True, then volatile tables are not created as volatile table can't be
                       persisted and "persist" argument takes precedence.
@@ -193,6 +194,16 @@ class _Configure(_ConfigureSuper):
                     # Set the type of temporary database objects to "VT" to create volatile internal
                     # tables.
                     teradataml.options.configure.temp_object_type = "VT"
+
+            use_short_object_name:
+                Specifies whether to use shorter names for temporary tables created internally by teradataml.
+                When set to True, teradataml generates internal temporary table names with a maximum length 
+                of 20 characters. Otherwise, there is no restriction on the length of these table names.
+                Default Value: False
+                Types: bool
+                Example:
+                    # Set the option to use short names for temporary tables.
+                    teradataml.options.configure.use_short_object_name = True
         """
         super().__init__()
         super().__setattr__('default_varchar_size', default_varchar_size)
@@ -213,6 +224,7 @@ class _Configure(_ConfigureSuper):
         super().__setattr__('table_operator', table_operator)
         super().__setattr__('_indb_install_location', indb_install_location)
         super().__setattr__('temp_object_type', self.__get_temp_object_type(temp_object_type))
+        super().__setattr__('use_short_object_name', use_short_object_name)
 
         # internal configurations
         # These configurations are internal and should not be
@@ -447,6 +459,10 @@ class _Configure(_ConfigureSuper):
 
                 value = self.__get_temp_object_type(value)
 
+            elif name == 'use_short_object_name':
+                if not isinstance(value, bool):
+                    raise TypeError(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, name, 'bool'))
+
             super().__setattr__(name, value)
         else:
             raise AttributeError("'{}' object has no attribute '{}'".format(self.__class__.__name__, name))

teradataml/scriptmgmt/UserEnv.py

@@ -20,14 +20,13 @@ import time
 from concurrent.futures import ThreadPoolExecutor, wait
 from json.decoder import JSONDecodeError
 from urllib.parse import urlparse
+
 import pandas as pd
-import requests
 
 from teradataml import configure
-from teradataml.clients.auth_client import _AuthWorkflow
 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
@@ -121,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)
@@ -132,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
 
 
@@ -3662,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.
@@ -3688,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.
@@ -3708,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
@@ -3736,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.
 
@@ -3746,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
@@ -3754,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
 
@@ -3767,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:
+                    * 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:
-                    Model file should be in zip format.
+                    Applicable only when model is installed from a model registry.
                 Types: str
 
         **kwargs:
@@ -3861,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):
@@ -3906,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
@@ -3919,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.
@@ -4046,6 +4245,14 @@ class _AuthToken:
     def value(self):
         return self.__value
 
+    @value.setter
+    def value(self, token_value):
+        """
+        DESCRIPTION:
+            Sets value of _AuthToken.
+        """
+        self.__value = token_value
+
     @property
     def auth_type(self):
         return self.__auth_type
@@ -4060,3 +4267,7 @@ class _AuthToken:
         elif self.auth_type.lower() == "bearer":
             # Form the Authorization header value by prepending 'Bearer ' to the JWT token.
             return {"Authorization": "Bearer {}".format(self.value)}
+        elif self.auth_type.lower() == "keycloak":
+            # Get valid token value for current time.
+            self.value = _InternalBuffer.get("keycloak_manager").get_token()
+            return {"Authorization": "Bearer {}".format(self.value)}