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

teradataml/analytics/json_parser/utils.py

@@ -172,7 +172,7 @@ def __get_json_files_directory():
             # Check if current function type is allowed on connected Vantage version or not.
             if func_info.value["func_type"] in func_type_json_version.keys():
                 yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
-                                                    version=func_type_json_version[func_info.value["func_type"]]),
+                                                     version=func_type_json_version[func_info.value["func_type"]]),
                        func_info.name]
         else:
             yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info), func_info.name]
@@ -237,7 +237,7 @@ def _process_paired_functions():
     """
 
     json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
-    with open(json_path) as fp:
+    with open(json_path, encoding="utf8") as fp:
         _json = json.load(fp)
 
     _available_functions, _ = _JsonStore._get_function_list()
@@ -556,8 +556,10 @@ class _KNNPredict:
                   "train_data": self.train_data,
                   "input_columns": self.input_columns,
                   "response_column": kwargs.get("response_column", self.response_column),
-                  "accumulate": kwargs.get("accumulate", kwargs.get("response_column", self.response_column)
-                                if getattr(self.obj, "accumulate") is None else self.accumulate)}
+                  # Retrieve the accumulate value from kwargs if available.
+                  # otherwise, no accumulation will occur.
+                  "accumulate": kwargs.get("accumulate")
+                  }
 
         # KNN works in a different way. predict calls the same function with test data along with
         # the arguments passed to the actual function. The above parameters are required
@@ -608,12 +610,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 +726,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
 

teradataml/analytics/meta_class.py

@@ -192,6 +192,45 @@ def _common_init(self, function_type, **kwargs):
     elif function_type == 'byom':
         from teradataml.analytics.analytic_function_executor import _BYOMFunctionExecutor
         self.obj = _BYOMFunctionExecutor(self.__class__.__name__)._execute_function(**kwargs)
+    elif function_type == 'stored_procedure':
+        from teradataml.analytics.analytic_function_executor import _StoredProcedureExecutor
+        self.obj = _StoredProcedureExecutor(self.__class__.__name__)._execute_function(**kwargs)
     else:
         from teradataml.analytics.analytic_function_executor import _TableOperatorExecutor
-        self.obj = _TableOperatorExecutor(self.__class__.__name__)._execute_function(**kwargs)
+        self.obj = _TableOperatorExecutor(self.__class__.__name__)._execute_function(**kwargs)
+
+def _common_dir(self):
+    """
+    DESCRIPTION:
+        Function returns the attributes and/or names of the methods of the
+        Analytic function.
+
+    PARAMETERS:
+        None
+
+    RETURNS:
+        list
+
+    RAISES:
+        None
+
+    Examples:
+        # Load the data.
+        titanic_data = DataFrame.from_table("titanic")
+        bin_fit_ip = DataFrame.from_table("bin_fit_ip")
+
+        # Run the function.
+        bin_code_1 = BincodeFit(data=titanic_data,
+                                fit_data=bin_fit_ip,
+                                fit_data_order_column = ['minVal', 'maxVal'],
+                                target_columns='age',
+                                minvalue_column='minVal',
+                                maxvalue_column='maxVal',
+                                label_column='label',
+                                method_type='Variable-Width',
+                                label_prefix='label_prefix'
+                                )
+        # Run dir on the function.
+        dir(bin_code_1)
+    """
+    return [attr for attr in super(self.__class__, self).__dir__() if attr != 'obj']

teradataml/analytics/sqle/DecisionTreePredict.py

@@ -223,7 +223,7 @@ class DecisionTreePredict:
         
         # Check to make sure input table types are strings or data frame objects or of valid type.
         self.__awu._validate_input_table_datatype(self.newdata, "newdata", None)
-        self.__awu._validate_input_table_datatype(self.object, "object", DataFrame)
+        self.__awu._validate_input_table_datatype(self.object, "object", reference_function_name=None)
         
         # Check whether the input columns passed to the argument are not empty.
         # Also check whether the input columns passed to the argument valid or not.

teradataml/analytics/sqle/__init__.py

@@ -2,7 +2,7 @@ from teradataml.analytics.sqle.DecisionTreePredict import DecisionTreePredict
 from teradataml.analytics.sqle.NaiveBayesPredict import NaiveBayesPredict
 
 from teradataml.analytics.meta_class import _AnalyticFunction
-from teradataml.analytics.meta_class import _common_init
+from teradataml.analytics.meta_class import _common_init, _common_dir
 from teradataml.analytics.json_parser.utils import _get_associated_parent_classes
 
 _sqle_functions = ['ANOVA',
@@ -11,6 +11,7 @@ _sqle_functions = ['ANOVA',
                   'BincodeFit',
                   'BincodeTransform',
                   'CategoricalSummary',
+                  'CFilter',
                   'ChiSq',
                   'ClassificationEvaluator',
                   'ColumnSummary',
@@ -33,6 +34,8 @@ _sqle_functions = ['ANOVA',
                   'KMeansPredict',
                   'KNN',
                   'MovingAverage',
+                  'NaiveBayes',
+                  'TDNaiveBayesPredict',
                   'NaiveBayesTextClassifierPredict',
                   'NaiveBayesTextClassifierTrainer',
                   'NGramSplitter',
@@ -49,6 +52,7 @@ _sqle_functions = ['ANOVA',
                   'OutlierFilterFit',
                   'OutlierFilterTransform',
                   'Pack',
+                  'Pivoting',
                   'PolynomialFeaturesFit',
                   'PolynomialFeaturesTransform',
                   'QQNorm',
@@ -72,15 +76,18 @@ _sqle_functions = ['ANOVA',
                   'SVM',
                   'SVMPredict',
                   'SVMSparsePredict',
+                  'Shap',
                   'TDGLMPredict',
                   'TDDecisionForestPredict',
                   'TargetEncodingFit',
                   'TargetEncodingTransform',
                   'TextParser',
+                  'TFIDF',
                   'Transform',
                   'TrainTestSplit',
                   'UnivariateStatistics',
                   'Unpack',
+                  'Unpivoting',
                   'VectorDistance',
                   'WhichMax',
                   'WhichMin',
@@ -95,4 +102,5 @@ for func in _sqle_functions:
     for assoc_cl in _get_associated_parent_classes(func):
         _c = _c + (assoc_cl, )
     globals()[func] = type("{}".format(func), _c, {"__init__": lambda self, **kwargs: _common_init(self, 'sqle',
-                                                              **kwargs), "__doc__": _AnalyticFunction.__doc__})
+                                                              **kwargs), "__doc__": _AnalyticFunction.__doc__,
+                                                   "__dir__": _common_dir})

teradataml/analytics/table_operator/__init__.py

@@ -1,5 +1,5 @@
 from teradataml.analytics.meta_class import _AnalyticFunction
-from teradataml.analytics.meta_class import _common_init
+from teradataml.analytics.meta_class import _common_init, _common_dir
 
 _nos_functions = ['ReadNOS', 'WriteNOS']
 
@@ -7,4 +7,5 @@ for func in _nos_functions:
     globals()[func] = type("{}".format(func), (_AnalyticFunction,),
                            {"__init__": lambda self, **kwargs: _common_init(self,
                             'nos', **kwargs),
-                            "__doc__": _AnalyticFunction.__doc__})
+                            "__doc__": _AnalyticFunction.__doc__,
+                            "__dir__": _common_dir})

teradataml/analytics/uaf/__init__.py

@@ -1,5 +1,5 @@
 from teradataml.analytics.meta_class import _AnalyticFunction
-from teradataml.analytics.meta_class import _common_init
+from teradataml.analytics.meta_class import _common_init, _common_dir
 from teradataml.analytics.json_parser.utils import _get_associated_parent_classes
 
 _uaf_functions = ['ACF',
@@ -51,7 +51,17 @@ _uaf_functions = ['ACF',
                   'InputValidator',
                   'MInfo',
                   'SInfo',
-                  'TrackingOp']
+                  'TrackingOp',
+                  'AutoArima',
+                  'ArimaXEstimate',
+                  'DWT',
+                  'DWT2D',
+                  'IDWT',
+                  'IDWT2D',
+                  'IQR',
+                  'Matrix2Image',
+                  'SAX',
+                  'WindowDFFT']
 
 for func in _uaf_functions:
     _c = (_AnalyticFunction,)
@@ -60,4 +70,13 @@ for func in _uaf_functions:
     globals()[func] = type("{}".format(func), _c,
                            {"__init__": lambda self, **kwargs: _common_init(self,
                             'uaf', **kwargs),
+                            "__doc__": _AnalyticFunction.__doc__,
+                            "__dir__": _common_dir})
+
+_stored_procedure = ['FilterFactory1d']
+
+for func in _stored_procedure:
+    globals()[func] = type("{}".format(func), (_AnalyticFunction,),
+                           {"__init__": lambda self, **kwargs: _common_init(self,
+                            'stored_procedure', **kwargs),
                             "__doc__": _AnalyticFunction.__doc__})

teradataml/analytics/utils.py

@@ -434,7 +434,25 @@ class FuncSpecialCaseHandler():
                            "NPath": {"mode": self._avoid_quote_for_arg,
                                      "symbols": self._avoid_quote_for_arg,
                                      "result": self._avoid_quote_for_arg,
-                                     "filter": self._avoid_quote_for_arg}}
+                                     "filter": self._avoid_quote_for_arg},
+                           "Pivoting": {"combined_column_sizes": self._handle_multiple_datatype},
+                           "FilterFactory1d": {"database_name": self._single_quote_arg,
+                                               "table_name": self._single_quote_arg,
+                                               "filter_type": self._single_quote_arg,
+                                               "window_type": self._single_quote_arg,
+                                               "filter_description": self._single_quote_arg},
+                           "DWT": {"wavelet": self._single_quote_arg},
+                           "IDWT": {"part": self._single_quote_arg,
+                                    "wavelet": self._single_quote_arg,
+                                    "mode": self._single_quote_arg},
+                           "DWT2D": {"wavelet": self._single_quote_arg,
+                                     "mode": self._single_quote_arg},
+                           "IDWT2D": {"wavelet": self._single_quote_arg,
+                                      "mode": self._single_quote_arg},
+                           "Matrix2Image": {"type": self._single_quote_arg,
+                                            "colormap": self._single_quote_arg
+                                           }
+                           }
 
     # Setter method for argument.
     def set_arg_name(self, argument):
@@ -691,4 +709,47 @@ class FuncSpecialCaseHandler():
                     if sep in value and "-" != value[0]:
                         arg_value[num] = "[{}]".format(arg_value[num])
                         break
+        return arg_value
+    
+    def _handle_multiple_datatype(self, arg_value, *args, **kwargs):
+
+        """
+        DESCRIPTION:
+            Function to handle multiple data types in "arg_value".
+                * Function returns the "arg_value" in sqle expected format.
+
+        PARAMETERS:
+            arg_value:
+                Required Argument.
+                Specifies the arg_value to handle multiple data types.
+                Types: int or str or list of str(s)
+
+        RETURNS:
+            arg_value converted into sqle expected format.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Scenario 1: convert list of string into sqle expected format.
+                self._handle_multiple_datatype(arg_value)
+                # returns "'col1:1234','col2:1144','col3:214'"
+
+            # Scenario 2: convert string into sqle expected format.
+                self._handle_multiple_datatype(arg_value)
+                # returns "'col1:1234'"
+        """
+        # Datatype of arg_value already validated inside function.
+
+        # Convert the pass value into sqle expected format.
+        # If argument value is a list, convert into sqle expected string format.
+        # If argument value is a string, add single quote.
+        # If argument value is a integer, return as it is.
+        if isinstance(arg_value, list):
+            if all(isinstance(i, str) for i in arg_value):
+                arg_value = "'" + "','".join(arg_value) + "'"
+        elif isinstance(arg_value, str):
+            arg_value = [arg_value]
+            arg_value = "'" + "','".join(arg_value) + "'"
+
         return arg_value

teradataml/analytics/valib.py

@@ -13,7 +13,7 @@ import time
 import uuid
 from math import floor
 
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 from teradataml.common import messages
 from teradataml.common.constants import TeradataConstants, ValibConstants as VC
 from teradataml.common.exceptions import TeradataMlException