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

teradataml/dbutils/dbutils.py

@@ -475,7 +475,7 @@ def _get_select_table_kind(schema_name, table_name, table_kind, datalake_name):
             object_name_str = _convert_sql_search_string_to_regex(object_name_str)
             if object_name_str:
                 name_filter = pddf['Table/View/Macro Name'].str.strip().str.match(object_name_str, na=False,
-                                                                      flags=re.IGNORECASE)
+                                                                                  flags=re.IGNORECASE)
                 pddf = pddf[name_filter]
 
         if object_table_kind is not None:
@@ -2089,13 +2089,13 @@ def set_session_param(name, value):
                             either ON or OFF.
                 10. dot_notation: DEFAULT, LIST, NULL ERROR
                 11. isolated_loading: NO, '', CONCURRENT
-                12. function_trace: should be a list first item should be "mask_string" and second should be table name.
+                12. function_trace: Should be a list. First item should be "mask_string" and second should be table name.
                 13. json_ignore_errors: ON, OFF
-                14. searchuifdbpath: string in format 'database_name, user_name'
+                14. searchuifdbpath: String in format 'database_name, user_name'
                 15. transaction_isolation_level: READ UNCOMMITTED, RU, SERIALIZABLE, SR
-                16. query_band: should be a list first item should be "band_specification" and second should be either
+                16. query_band: Should be a list. First item should be "band_specification" and second should be either
                                 SESSION or TRANSACTION
-                17. udfsearchpath: should be a list first item should be "database_name" and second should be "udf_name"
+                17. udfsearchpath: Should be a list. First item should be "database_name" and second should be "udf_name"
             Types: str or list of strings
 
     Returns:
@@ -2106,7 +2106,7 @@ def set_session_param(name, value):
 
     EXAMPLES:
         # Example 1: Set time zone offset for the session as the system default.
-        >>> set_session_param('timezone', "'LOCAL'")
+        >>> set_session_param('timezone', 'LOCAL')
         True
 
         # Example 2: Set time zone to "AMERICA PACIFIC".
@@ -2195,10 +2195,18 @@ def set_session_param(name, value):
     """
     # Validate argument types
     function_args = []
-    function_args.append(["name", name, True, str, True])
-    function_args.append(["value", value, True, (int, str, float, list), False])
+    function_args.append(["name", name, False, str, True])
+    function_args.append(["value", value, False, (int, str, float, list), False])
     _Validators._validate_function_arguments(function_args)
 
+    # Validate Permitted values for session parameter name.
+    permitted_session_parameters = [key.name for key in SessionParamsSQL]
+    _Validators._validate_permitted_values(arg=name,
+                                           permitted_values=permitted_session_parameters,
+                                           arg_name='name',
+                                           case_insensitive=True,
+                                           includeNone=False)
+
     if not isinstance(value, list):
         value = [value]
 
@@ -2214,8 +2222,7 @@ def set_session_param(name, value):
     _InternalBuffer.add(function_name=value[0] if name.upper() == 'DEBUG_FUNCTION' else '')
 
     # Set the session parameter.
-    execute_sql(getattr(SessionParamsSQL, name.upper()).format(*value))
-
+    execute_sql(getattr(SessionParamsSQL, name.upper()).value.format(*value))
     return True
 
 
@@ -2241,7 +2248,7 @@ def unset_session_param(name):
     ValueError, teradatasql.OperationalError
 
     EXAMPLES:
-        # Example 1: unset session to previous time zone.
+        # Example 1: Unset session's time zone to previous time zone.
         >>> set_session_param('timezone', "'GMT+1'")
         True
         >>> unset_session_param("timezone")
@@ -2253,6 +2260,17 @@ def unset_session_param(name):
     function_args.append(["name", name, True, str, True])
     _Validators._validate_function_arguments(function_args)
 
+    # Validate Permitted values for session parameter name which can be unset.
+    permitted_session_parameters = [key.name for key in SessionParamsPythonNames] +\
+                                   ["character_set_unicode", "debug_function",
+                                    "isolated_loading", "function_trace",
+                                    "json_ignore_errors", "query_band"]
+    _Validators._validate_permitted_values(arg=name,
+                                           permitted_values=permitted_session_parameters,
+                                           arg_name='name',
+                                           case_insensitive=True,
+                                           includeNone=False)
+
     # Check whether session param is set or not first.
     session_params = _InternalBuffer.get('session_params')
     if session_params is None:
@@ -2261,6 +2279,8 @@ def unset_session_param(name):
         raise TeradataMlException(error_msg, msg_code)
     # unset_values stores params which are not available in _InternalBuffer, to unset create a dictionary
     # with param as key and unset param as value
+    # TODO: Unset for ISOLATED_LOADING should revert to previous behaviour, but we are setting it to NO.
+    #  This is not correct if  ISOLATED_LOADING was CONCURRENT before setting it to NO.
     unset_values = {"CHARACTER_SET_UNICODE": "OFF", "DEBUG_FUNCTION": [_InternalBuffer.get('function_name'), "OFF"],
                     "ISOLATED_LOADING": "NO", "FUNCTION_TRACE": "SET SESSION FUNCTION TRACE OFF",
                     "JSON_IGNORE_ERRORS": "OFF", "QUERY_BAND": ["", "SESSION"]}
@@ -2275,9 +2295,9 @@ def unset_session_param(name):
             set_session_param(name, unset_values[name.upper()])
         return True
 
-    previous_value = "{}".format(session_params[getattr(SessionParamsPythonNames, name.upper())]) \
+    previous_value = "{}".format(session_params[getattr(SessionParamsPythonNames, name.upper()).value]) \
         if name.upper() != 'TIMEZONE' else "'{}'".format(
-        session_params[getattr(SessionParamsPythonNames, name.upper())])
+        session_params[getattr(SessionParamsPythonNames, name.upper()).value])
 
     if name.upper() == "ACCOUNT":
         previous_value = [previous_value, 'SESSION']

teradataml/dbutils/filemgr.py

@@ -13,18 +13,22 @@ install_file, remove_file, replace_file.
 
 import os
 from pathlib import Path
+
 from sqlalchemy import func
-from sqlalchemy.sql.expression import text
-import teradataml.dataframe as tdmldf
-from teradataml.utils.internal_buffer import _InternalBuffer
 from teradatasql import OperationalError as SqlOperationalError
+
+import teradataml.dataframe as tdmldf
+from teradataml.common.constants import TableOperatorConstants
 from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.messages import Messages
 from teradataml.common.messagecodes import MessageCodes
-from teradataml.dbutils.dbutils import _execute_stored_procedure, set_session_param
-from teradataml.utils.validators import _Validators
+from teradataml.common.messages import Messages
+from teradataml.common.utils import UtilFuncs
+from teradataml.dbutils.dbutils import (_execute_stored_procedure,
+                                        set_session_param)
 from teradataml.options.configure import configure
-from teradataml.common.constants import TableOperatorConstants
+from teradataml.utils.internal_buffer import _InternalBuffer
+from teradataml.utils.validators import _Validators
+
 
 def install_file(file_identifier, file_path = None, file_on_client = True, is_binary = False,
                  replace = False, force_replace = False, suppress_output = False):
@@ -300,15 +304,15 @@ def list_files():
     database = context._get_current_databasename()
 
     # set_session_param maintains a buffer of session parameters.
-    # If the session parameter is not set or if setted SearchUIFDBPath is different
+    # If the session parameter is not set or if already set SearchUIFDBPath is different
     # from the current database, then we will set the SEARCHUIFDBPATH to the current
     # database. This will avoid setting the SEARCHUIFDBPATH multiple times.
     session_params = _InternalBuffer.get('session_params')
     if session_params is None or session_params["SearchUIFDBPath"] != database:
-        set_session_param("SEARCHUIFDBPATH", database)
+        set_session_param("SEARCHUIFDBPATH", UtilFuncs._get_dialect_quoted_name(database))
 
     # Get the query to list files installed in Vantage.
     list_files_query = TableOperatorConstants.SCRIPT_LIST_FILES_QUERY.value \
-                        .format(database, configure.default_varchar_size)
+                        .format(UtilFuncs._get_dialect_quoted_name(database), configure.default_varchar_size)
 
     return tdmldf.dataframe.DataFrame.from_query(list_files_query)

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,23 +89,19 @@ class _GenericObjectWrapper:
                 self._env = configure.openml_user_env
             else:
                 self._env = UtilFuncs._create_or_get_env("open_source_ml.json")
-
-            # Raise exception when python versions don't match between Lake user environment and local.
-            self._process_python_version_diff_lake()
-
         else:
-            set_session_param("searchuifdbpath",self._db_name)
-            from teradataml.dbutils.dbutils import db_python_version_diff
-            if len(db_python_version_diff()) > 0:
-                # Raise exception when python versions don't match between Vantage and local.
-                from teradataml.context import context as tdmlctx
-                py_major_vantage_version = tdmlctx.python_version_vantage.rsplit(".", 1)[0]
-                raise TeradataMlException(Messages.get_message(MessageCodes.PYTHON_VERSION_MISMATCH,
-                                                               tdmlctx.python_version_vantage, py_major_vantage_version),
-                                          MessageCodes.PYTHON_VERSION_MISMATCH)
+            set_session_param("searchuifdbpath", self._db_name)
+
+        # Check if the Python interpreter major versions are consistent between Vantage and local.
+        _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.
-        self._process_package_differences()
+        # OPENSOURCE_PACKAGE_NAME is set for each opensource package, but not for the base class.
+        # Add a check to avoid running this function for the base class.
+        if self.OPENSOURCE_PACKAGE_NAME is not None:
+            UtilFuncs._check_package_version_diff(self.OPENSOURCE_PACKAGE_NAME.value, self._pkgs, self._env) 
 
         global _file_installed
         ## Flag to check whether trained model is installed or not.
@@ -121,149 +118,6 @@ class _GenericObjectWrapper:
 
             _file_installed = True
 
-    def _process_python_version_diff_lake(self):
-        """
-        DESCRIPTION:
-            Internal function to process Python interpreter version differences between Lake user environment and local.
-            Note:
-                * Raises an exception if the Python interpreter major versions are not consistent between 
-                  Lake user environment and local.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            None
-
-        RAISES:
-            TeradataMlException
-        
-        EXAMPLES:
-            self._process_python_version_diff_lake()
-        """
-        # Get the Python interpreter version of the user environment.
-        env_list = list_user_envs()
-        user_env_name = self._env.env_name
-        env_base_version = env_list[env_list['env_name'] == user_env_name].base_env_name.values[0]
-        python_env = env_base_version.split("_")[1]
-
-        # Get the Python interpreter version of the local environment.
-        from teradataml.context import context as tdmlctx
-        python_local = tdmlctx.python_version_local.rsplit(".", 1)[0]
-        # Check if the Python interpreter major versions are consistent between Lake user environment and local.
-        # If not, raise an exception.
-        if python_env != python_local:
-            raise TeradataMlException(Messages.get_message(MessageCodes.PYTHON_VERSION_MISMATCH_OAF,
-                                                            python_env, python_local),
-                                        MessageCodes.PYTHON_VERSION_MISMATCH_OAF)
-            
-    def _process_package_differences(self):
-        """
-        DESCRIPTION:
-            Internal function to process package differences between Vantage and local.
-            Note:
-                * Raises a warning if the versions of certain Python packages are not consistent between Vantage and local.
-
-        PARAMETERS:
-            None
-
-        RETURNS:
-            None
-
-        RAISES:
-            PackageNotFoundError: If the package is not found in the local environment for OAF.
-
-        EXAMPLES:
-            self._process_package_differences()
-        """
-        # OPENSOURCE_PACKAGE_NAME is set for each opensource package, but not for the base class.
-        # Add a check to avoid running this function for the base class.
-        if self.OPENSOURCE_PACKAGE_NAME is None:
-            return
-        _is_packages_verfied_in_vantage = _packages_verified_in_vantage.get(
-            self.OPENSOURCE_PACKAGE_NAME.value, None)
-        if _is_packages_verfied_in_vantage:
-            return
-        
-        if self._is_lake_system:
-            env_pkg_df = self._env.libs
-            pkgs_dict = dict(zip(env_pkg_df['name'], env_pkg_df['version']))
-
-            i = 0
-            from importlib.metadata import version
-            warning_raised = False
-            for pkg in self._pkgs:
-                env_version = pkgs_dict.get(pkg)
-                try:
-                    local_version = version(pkg)
-                except Exception as e:
-                    raise
-                if env_version != local_version:
-                    warning_raised = True
-                    if i == 0:
-                        strr = f"{pkg}=={local_version}\n"
-                        i += 1
-                    else:
-                        strr += f"{pkg}=={local_version}\n"
-
-            # If there are differences in package versions, display a warning message to the user.
-            # about the package differences and the requirements file created for the user to install the packages
-            if warning_raised:
-                file_name = f"requirements_{self.OPENSOURCE_PACKAGE_NAME.value}.txt"
-                req_file = os.path.join(self._tdml_tmp_dir, file_name)
-                with open(req_file, "w") as f:
-                    f.write(strr)
-                _pkgs = "', '".join(self._pkgs[:-1]) + "' and '" + self._pkgs[-1]
-                warning_msg = "The versions of certain Python packages are not consistent between "\
-                    "Lake user environment and local. OpenSourceML compares the versions of '{}' "\
-                    f"(and also matches the patterns of these packages) used by 'td_{self.OPENSOURCE_PACKAGE_NAME.value}'. "\
-                    "Teradata recommends same versions for all the Python packages between Lake "\
-                    "user environment and local."
-                req = f"\nA requirements file listing all '{self.OPENSOURCE_PACKAGE_NAME.value}' " + \
-                    f"related packages and their versions has been written to '{req_file}'. "+ \
-                    "Update the Lake user environment with the required packages.\n"
-                
-                warning_msg += req
-                warnings.warn(warning_msg.format(_pkgs), category=OneTimeUserWarning)
-
-        else:
-            # Check if the versions of Python packages are consistent between Vantage and local.
-            from teradataml.dbutils.dbutils import _db_python_package_version_diff
-            all_package_versions = _db_python_package_version_diff(self._pkgs, only_diff=False)
-            package_difference = \
-                all_package_versions[all_package_versions.vantage != all_package_versions.local]
-            # If there are differences in package versions, raise a warning.
-            if package_difference.shape[0] > 0:
-                _pkgs = "', '".join(self._pkgs[:-1]) + "' and '" + self._pkgs[-1]
-                warning_msg = "The versions of certain Python packages are not consistent between "\
-                    "Vantage and local. User can identify them using db_python_package_version_diff() "\
-                    "function. OpenSourceML compares the versions of '{}' (and also matches the "\
-                    f"patterns of these packages) used by 'td_{self.OPENSOURCE_PACKAGE_NAME.value}'. Teradata "\
-                    "recommends to maintain same versions for all the Python packages between Vantage "\
-                    "and local."
-                i = 0
-                # Write the requirements file listing all the related packages and their versions.
-                for rec in all_package_versions.to_records():
-                    if i == 0:
-                        strr = f"{rec[1]}=={rec[2]}\n"
-                        i += 1
-                    else:
-                        strr += f"{rec[1]}=={rec[2]}\n"
-                file_name = f"requirements_{self.OPENSOURCE_PACKAGE_NAME.value}.txt"
-                req_file = os.path.join(self._tdml_tmp_dir, file_name)
-                with open(req_file, "w") as f:
-                    f.write(strr)
-
-                # Display a warning message to the user about the package differences
-                # and the requirements file created for the user to install the packages.
-                req = f"\nA requirements file listing all '{self.OPENSOURCE_PACKAGE_NAME.value}' " + \
-                    f"related packages and their versions has been written to '{req_file}'.\n"
-                
-                warning_msg += req
-                warnings.warn(warning_msg.format(_pkgs), category=OneTimeUserWarning)
-
-        _packages_verified_in_vantage[self.OPENSOURCE_PACKAGE_NAME.value] = True
-
     def _get_columns_as_list(self, cols):
         """
         Internal function to get columns as list of strings.
@@ -1408,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
@@ -244,9 +256,9 @@ class _Configure(_ConfigureSuper):
         super().__setattr__('ues_url', None)
         # base URL in Vector Store REST calls
         super().__setattr__('_vector_store_base_url', None)
-        # Whether tenant is CCP enabled or not.
-        # By default, it is set to False, as it can be Enterprise or NON-CCP.
-        super().__setattr__('_ccp_enabled', False)
+        # Internal parameter, which is used to specify whether SSL verification is to be done or not.
+        # By default, it is set to True.
+        super().__setattr__('_ssl_verify', True)
         # Internal parameter, that is used to specify the certificate file in a secured HTTP request.
         super().__setattr__('certificate_file', False)
         # Internal parameter, that is used for specify the maximum size of the file
@@ -330,7 +342,7 @@ class _Configure(_ConfigureSuper):
                                                                    "greater than or equal to"),
                                               MessageCodes.TDMLDF_POSITIVE_INT)
             elif name in ['column_casesensitive_handler', '_validate_metaexpression',
-                          '_validate_gc', 'inline_plot', '_oauth', '_ccp_enabled']:
+                          '_validate_gc', 'inline_plot', '_oauth', '_ssl_verify']:
 
                 if not isinstance(value, bool):
                     raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, name,
@@ -387,7 +399,6 @@ class _Configure(_ConfigureSuper):
                             MessageCodes.PATH_NOT_FOUND)
 
             elif name in {'ues_url', '_oauth_end_point', '_oauth_client_id', '_vector_store_base_url'}:
-
                 if not isinstance(value, str):
                     raise TypeError(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, name, 'str'))
 
@@ -448,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))