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

teradataml/README.md

@@ -16,6 +16,77 @@ Copyright 2024, Teradata. All Rights Reserved.
 * [License](#license)
 
 ## Release Notes:
+#### teradataml 20.00.00.01
+* teradataml no longer supports Python versions less than 3.8.
+
+* ##### New Features/Functionality
+  * ##### Personal Access Token (PAT) support in teradataml
+    * `set_auth_token()` - teradataml now supports authentication via PAT in addition to 
+      OAuth 2.0 Device Authorization Grant (formerly known as the Device Flow).
+      * It accepts UES URL, Personal AccessToken (PAT) and Private Key file generated from VantageCloud Lake Console 
+        and optional argument `username` and `expiration_time` in seconds. 
+
+* ##### Updates
+  * ##### teradataml: SQLE Engine Analytic Functions
+    * `ANOVA()`
+      * New arguments added: `group_name_column`, `group_value_name`, `group_names`, `num_groups` for data containing group values and group names. 
+    * `FTest()`
+      * New arguments added: `sample_name_column`, `sample_name_value`, `first_sample_name`, `second_sample_name`.
+    * `GLM()`
+      * Supports stepwise regression and accept new arguments `stepwise_direction`, `max_steps_num` and `initial_stepwise_columns`.
+      * New arguments added: `attribute_data`, `parameter_data`, `iteration_mode` and `partition_column`.
+    * `GetFutileColumns()`
+      * Arguments `category_summary_column` and `threshold_value` are now optional.
+    * `KMeans()`
+      * New argument added: `initialcentroids_method`.
+    * `NonLinearCombineFit()`
+        * Argument `result_column` is now optional.
+    * `ROC()`
+        * Argument `positive_class` is now optional. 
+    * `SVMPredict()`
+      * New argument added: `model_type`.   
+    * `ScaleFit()`
+      * New arguments added: `ignoreinvalid_locationscale`, `unused_attributes`, `attribute_name_column`, `attribute_value_column`.
+      * Arguments `attribute_name_column`, `attribute_value_column` and `target_attributes` are supported for sparse input.
+      * Arguments `attribute_data`, `parameter_data` and `partition_column` are supported for partitioning.
+    * `ScaleTransform()`
+      * New arguments added: `attribute_name_column` and `attribute_value_column` support for sparse input.
+    * `TDGLMPredict()`
+      * New arguments added: `family` and `partition_column`.
+    * `XGBoost()`
+      * New argument `base_score` is added for initial prediction value for all data points.
+    * `XGBoostPredict()`
+      * New argument `detailed` is added for detailed information of each prediction.
+    * `ZTest()`
+      * New arguments added: `sample_name_column`, `sample_value_column`,  `first_sample_name` and `second_sample_name`.
+  * ##### teradataml: AutoML
+    * `AutoML()`, `AutoRegressor()` and `AutoClassifier()`
+      * New argument `max_models` is added as an early stopping criterion to limit the maximum number of models to be trained.
+  * ##### teradataml: DataFrame functions
+    * `DataFrame.agg()` 
+      * Accepts ColumnExpressions and list of ColumnExpressions as arguments.
+  * ##### teradataml: General Functions
+    * Data Transfer Utility
+      * `fastload()` - Improved error and warning table handling with below-mentioned new arguments.
+        * `err_staging_db`
+        * `err_tbl_name`
+        * `warn_tbl_name`
+        * `err_tbl_1_suffix`
+        * `err_tbl_2_suffix`
+      * `fastload()` - Change in behaviour of `save_errors` argument.
+                       When `save_errors` is set to `True`, error information will be available in two persistent tables `ERR_1` and `ERR_2`.
+                       When `save_errors` is set to `False`, error information will be available in single pandas dataframe.
+    * Garbage collector location is now configurable. 
+      User can set configure.local_storage to a desired location.
+      
+* ##### Bug Fixes
+  * UAF functions now work if the database name has special characters.
+  * OpensourceML can now read and process NULL/nan values.
+  * Boolean values output will now be returned as VARBYTE column with 0 or 1 values in OpensourceML.
+  * Fixed bug for `Apply`'s `deploy()`.
+  * Issue with volatile table creation is fixed where it is created in the right database, i.e., user's spool space, regardless of the temp database specified.
+  * `ColumnTransformer` function now processes its arguments in the order they are passed.
+
 #### teradataml 20.00.00.00
 * ##### New Features/Functionality
     * ###### teradataml OpenML: Run Opensource packages through Teradata Vantage

teradataml/_version.py

@@ -1,6 +1,6 @@
 # ##################################################################
 # 
-# Copyright 2021 Teradata. All rights reserved.
+# Copyright 2024 Teradata. All rights reserved.
 # TERADATA CONFIDENTIAL AND TRADE SECRET
 # 
 # Primary Owner: Pankaj Purandare (PankajVinod.Purandare@teradata.com)
@@ -8,4 +8,4 @@
 # 
 # ################################################################## 
 
-version = "20.00.00.00"
+version = "20.00.00.01"

teradataml/analytics/analytic_function_executor.py

@@ -86,6 +86,9 @@ class _AnlyticFunctionExecutor:
         # Initialize FuncSpecialCaseHandler.
         self._spl_func_obj = FuncSpecialCaseHandler(self.func_name)
 
+        # Initialize database object type.
+        self.db_object_type = TeradataConstants.TERADATA_VIEW
+
     @staticmethod
     def _validate_analytic_function_argument(func_arg_name, func_arg_value, argument, additional_valid_types=None):
         """
@@ -178,7 +181,7 @@ class _AnlyticFunctionExecutor:
 
         EXAMPLES:
             self._execute_query()
-        """
+        """        
         # Generate STDOUT table name and add it to the output table list.
         func_params = self._get_generate_temp_table_params(persist=persist, volatile=volatile)
         sqlmr_stdout_temp_tablename = UtilFuncs._generate_temp_table_name(**func_params)
@@ -248,25 +251,18 @@ class _AnlyticFunctionExecutor:
             self._get_generate_temp_table_params(True, True)
         """
         use_default_database = True
-        db_object_type = TeradataConstants.TERADATA_VIEW
         prefix = "td_sqlmr_out_"
         gc_on_quit = True
 
-        # If function produces output tables, i.e., function has output table arguments,
-        # the 'db_object_type' should be "table" or if analytic function does not support
-        # reading from a view created on output, then 'db_object_type' should be "table".
-        if len(self._metadata.output_tables) > 0 or not self._metadata._is_view_supported:
-            db_object_type = TeradataConstants.TERADATA_TABLE
-
-        # If result is to be persisted or if the table is a volaile table then, db_object_type
-        # should be "table" and it must not be Garbage collected.
+        # If result is to be persisted or if the table is a volaile table then,
+        # it must not be Garbage collected.
         if persist or volatile:
             gc_on_quit = False
-            db_object_type = TeradataConstants.TERADATA_TABLE
             prefix = "td_sqlmr_{}_out_".format("persist" if persist else "volatile")
+            use_default_database = False if volatile else True
 
         return {"use_default_database": use_default_database,
-                "table_type": db_object_type,
+                "table_type": self.db_object_type,
                 "prefix": prefix,
                 "gc_on_quit": gc_on_quit}
 
@@ -694,10 +690,26 @@ class _AnlyticFunctionExecutor:
                 MessageCodes.CANNOT_USE_TOGETHER_WITH)
 
         self._dyn_cls_data_members.update(kwargs)
-
+        
+        # If function produces output tables, i.e., function has output table arguments,
+        # then 'db_object_type' should be "table" or if analytic function does not support
+        # reading from a view created on output, then 'db_object_type' should be "table".
+        # If result is to be persisted or if the table is a volaile table then, db_object_type
+        # should be "table" else it should be "view".
+        self.db_object_type = (
+            TeradataConstants.TERADATA_VOLATILE_TABLE if volatile
+            else TeradataConstants.TERADATA_TABLE if len(self._metadata.output_tables) > 0 \
+                or not self._metadata._is_view_supported or persist 
+            else TeradataConstants.TERADATA_VIEW
+        )
         if not skip_input_arg_processing:
             self._process_input_argument(**kwargs)
 
+        # check func_name is GLM  and data_partition_column, data_hash_column, local_order_data are passed
+        if self.func_name in ['GLM', 'TDGLMPredict'] and \
+            any(key in kwargs for key in ['data_partition_column', 'data_hash_column', 'local_order_data']):
+            skip_output_arg_processing = True
+
         if not skip_output_arg_processing:
             self._process_output_argument(**kwargs)
 
@@ -856,22 +868,34 @@ class _SQLEFunctionExecutor(_AnlyticFunctionExecutor):
         EXAMPLES:
             self._get_input_args()
         """
+        sort_order = list(kwargs.keys())
+        input_table_dict = {}
+
         for _inp_attribute in self._metadata.input_tables:
             input_table_arg = _inp_attribute.get_lang_name()
-            yield input_table_arg, _inp_attribute
 
-            # Check if SQLE function allows multiple values as input.
+            # Store the first argument directly into the dictionary
+            input_table_dict[input_table_arg] = _inp_attribute
+
+            # Check if SQL function allows multiple values as input.
             if _inp_attribute.allows_lists():
                 _index = 1
                 while True:
                     _input_table_arg = "{}{}".format(input_table_arg, _index)
-                    # If the corresponding object is available in kwargs, then extract it.
-                    # Otherwise, stop looking for multiple arguments and proceed for next attribute.
                     if _input_table_arg in kwargs:
-                        yield _input_table_arg, _inp_attribute
-                        _index = _index + 1
+                        input_table_dict[_input_table_arg] = _inp_attribute
+                        _index += 1
                     else:
                         break
+        
+        # For ColumnTransformer, yield the input arguments in the order they are passed.
+        if self.func_name == "ColumnTransformer":
+            for key in sort_order:
+                if key in input_table_dict:
+                    yield key, input_table_dict[key]
+        else:
+            for key in input_table_dict:
+                yield key, input_table_dict[key]
 
     def _process_input_argument(self, **kwargs):
         """
@@ -1707,14 +1731,17 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
             self._get_generate_temp_table_params(True, True)
         """
         prefix = "td_uaf_out_"
-
+        gc_on_quit = True
         # If result is to be persisted then, it must not be Garbage collected.
-        gc_on_quit = False if persist or volatile else True
+        if persist or volatile:
+            gc_on_quit = False
+            prefix = "td_uaf_{}_out_".format("persist" if persist else "volatile")
 
-        return {"table_type": TeradataConstants.TERADATA_TABLE,
+        return {"table_type": self.db_object_type,
                 "prefix": prefix,
                 "gc_on_quit": gc_on_quit,
-                "databasename": output_db if output_db else _get_context_temp_databasename()}
+                "databasename": output_db if output_db else _get_context_temp_databasename(
+                    table_type=self.db_object_type)}
 
     def _process_output_argument(self, **kwargs):
         """
@@ -1762,7 +1789,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
             # If database name is not provided by user, get the default database name
             # else use user provided database name.
             db_name = output_db_name if output_db_name is not None else \
-                _get_context_temp_databasename()
+                _get_context_temp_databasename(table_type=self.db_object_type)
 
             # Get the fully qualified table name.
             table_name = "{}.{}".format(UtilFuncs._teradata_quote_arg(db_name,

teradataml/analytics/json_parser/utils.py

@@ -608,12 +608,16 @@ class _Evaluate:
         if self.get_function_name() == "NaiveBayesTextClassifierTrainer":
             return True
         # name of argument is model_type for most of the functions but for some it is different
-        if "model_type" not in kwargs:
+        if "model_type" not in kwargs and "tree_type" not in kwargs:
             arg_name = self.get_arg_name()
             model_type = getattr(self.obj, arg_name)
-            kwargs["model_type"] = model_type
+            if self.get_function_name() == "DecisionForest":
+                kwargs["tree_type"] = model_type
+            else:
+                kwargs["model_type"] = model_type
 
-        if kwargs["model_type"].lower() == "binomial" or kwargs["model_type"].lower() == "classification":
+        if  ("model_type" in kwargs and (kwargs["model_type"].lower() == "binomial" or kwargs["model_type"].lower() == "classification")) \
+            or ( "tree_type" in kwargs and kwargs["tree_type"].lower() == "classification"):
             is_classification_model = True
 
         return is_classification_model
@@ -720,20 +724,10 @@ class _Evaluate:
             kwargs["observation_column"] = response_column
             kwargs["prediction_column"] = "Prediction" if "Prediction" in predict.result.columns else "prediction"
 
-            # get the column_names and types from the metaexpr to check if the datatype of prediction column
-            # and observation column is same or not.
-            col_names, col_types = df_utils._get_column_names_and_types_from_metaexpr(predict.result._metaexpr)
-            res = dict(zip(col_names,col_types))
-            pre_col_name = kwargs["prediction_column"]
-            if res[kwargs["observation_column"]] != res[pre_col_name]:
-                # Converting the prediction column datatype to observation column datatype.
-                cast_cols_pre = {pre_col_name: getattr(predict.result, pre_col_name).expression.cast(
-                    type_=res[kwargs["observation_column"]])}
-                # Update the predicted result dataframe.
-                predict.result = predict.result.assign(**cast_cols_pre)
-
-            # Update the num_labels by the number of unique values.
-            kwargs["num_labels"] = predict.result.drop_duplicate(kwargs["observation_column"]).shape[0]
+            # Update the num_labels by the number of unique values if
+            # Labels are not passed.
+            if "labels" not in kwargs:
+                kwargs["num_labels"] = predict.result.drop_duplicate(kwargs["observation_column"]).shape[0]
 
             kwargs["data"] = predict.result