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

teradataml/automl/feature_engineering.py

@@ -40,6 +40,9 @@ from teradataml.common.garbagecollector import GarbageCollector
 from teradataml.dataframe.sql_functions import case
 from teradataml.hyperparameter_tuner.utils import _ProgressBar
 from teradataml.utils.validators import _Validators
+from teradataml.common.utils import UtilFuncs
+from teradataml.common.constants import TeradataConstants
+from teradataml.options.configure import configure
 
 
 class _FeatureEngineering:
@@ -131,8 +134,9 @@ class _FeatureEngineering:
         self.data_transform_dict = {}
         self.one_hot_obj_count = 0
         self.is_classification_type = lambda: self.task_type.upper() == 'CLASSIFICATION'
-        self.volatile = kwargs.get('volatile', False)
         self.persist = kwargs.get('persist', False)
+        self.volatile = kwargs.get('volatile', False) or (configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE and self.persist is False)
+
     
     # Method for doing feature engineering on data -> adding id, removing futile col, imputation, encoding(one hot)
     def feature_engineering(self, 
@@ -259,6 +263,11 @@ class _FeatureEngineering:
             Returns extracted elements in form of list.
             
         """
+        # Ensure list1 and list2 are lists, default to empty list if None
+        if list1 is None:
+            list1 = []
+        if list2 is None:
+            list2 = []
         new_lst = list(set(list1) - set(list2))
         return new_lst
     
@@ -273,7 +282,7 @@ class _FeatureEngineering:
                           show_data=True)
         start_time = time.time()
         rows = self.data.shape[0]
-        self.data=self.data.drop_duplicate()
+        self.data=self.data.drop_duplicate(self.data.columns)
         if rows != self.data.shape[0]:
             self._display_msg(msg=f'Updated dataset sample after removing {rows-self.data.shape[0]} duplicate records:',
                               data=self.data,
@@ -347,12 +356,10 @@ class _FeatureEngineering:
 
         # Detecting and removing futile columns, if categorical_column exists
         if len(categorical_columns) != 0:
-            
             obj = CategoricalSummary(data=self.data, 
                                      target_columns=categorical_columns,
                                      volatile=self.volatile,
                                      persist=self.persist)
-            
             gfc_out = GetFutileColumns(data=self.data, 
                                        object=obj, 
                                        category_summary_column="ColumnName",
@@ -565,11 +572,18 @@ class _FeatureEngineering:
         
         # Removing rows with missing target column value
         self.data = self.data.dropna(subset=[self.target_column])
+
+        params = {
+            "data": self.data,
+            "target_columns": self.data.columns,
+            "persist": True,
+            "display_table_name": False
+        }
         
-        obj = ColumnSummary(data=self.data, 
-                            target_columns=self.data.columns,
-                            volatile=self.volatile,
-                            persist=self.persist)
+        obj = ColumnSummary(**params)
+
+        # Adding transformed data containing table to garbage collector
+        GarbageCollector._add_to_garbagecollector(obj.result._table_name)
         
         cols_miss_val={}
         # Iterating over each row in the column summary result
@@ -704,7 +718,7 @@ class _FeatureEngineering:
         for key, val in self.imputation_cols.items():
             
             col_stat.append(key)
-            if self.data_types[key] in ['float', 'int']:
+            if self.data_types[key] in ['float', 'int', 'decimal.Decimal']:
                 val = skew_data[f'skew_{key}']
                 # Median imputation method, if abs(skewness value) > 1
                 if abs(val) > 1:
@@ -713,7 +727,7 @@ class _FeatureEngineering:
                 else:
                     stat.append('mean')     
             # Mode imputation method, if categorical column
-            else:
+            elif self.data_types[key] in ['str']:
                 stat.append('mode')
         
         self._display_msg(msg="Columns with their imputation method:",
@@ -1802,10 +1816,11 @@ class _FeatureEngineering:
         RETURNS:
             Tuple containing volatile and persist parameters.
         """
-        volatile = self.volatile
+        # Prioritizing persist argument and then volatile
         persist = self.persist
+        volatile = self.volatile or (configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE and persist is False)
         if self.custom_data is not None and self.custom_data.get(func_indicator, False):
             volatile = self.custom_data[param_name].get("volatile", False)
             persist = self.custom_data[param_name].get("persist", False)
 
-        return (volatile, persist)
+        return (volatile, persist)

teradataml/automl/model_training.py

@@ -26,9 +26,10 @@ from teradataml.context import context as tdmlctx
 from teradataml.dataframe.copy_to import copy_to_sql
 from teradataml.dataframe.dataframe import DataFrame
 from teradataml import execute_sql, get_connection
-from teradataml import SVM, GLM, DecisionForest, XGBoost, GridSearch, KNN, RandomSearch
+from teradataml import configure, SVM, GLM, DecisionForest, XGBoost, GridSearch, KNN, RandomSearch
 from teradataml.utils.validators import _Validators
-
+from teradataml.common.utils import UtilFuncs
+from teradataml.common.constants import TeradataConstants
 
 class _ModelTraining:
     
@@ -113,6 +114,12 @@ class _ModelTraining:
                         session.
                         Default Value: False
                         Types: bool
+                    
+                    seed:
+                        Optional Argument.
+                        Specifies the random seed for reproducibility.
+                        Default Value: 42
+                        Types: int
         """
         self.data = data
         self.target_column = target_column
@@ -125,6 +132,7 @@ class _ModelTraining:
         self.startify_col = None
         self.persist = kwargs.get("persist", False)
         self.volatile = kwargs.get("volatile", False)
+        self.seed = kwargs.get("seed", 42)
 
     def model_training(self, 
                        auto=True,
@@ -498,7 +506,7 @@ class _ModelTraining:
                 'max_depth': tuple(max_depth),
                 'min_node_size': tuple(min_node_size),
                 'iter_num': tuple(iter_num),
-                'seed':42
+                'seed':self.seed
                 }
         # Hyperparameters for Decision Forest model
         df_params = {
@@ -509,7 +517,7 @@ class _ModelTraining:
                 'max_depth': tuple(max_depth),
                 'min_node_size': tuple(min_node_size),
                 'num_trees': tuple(num_trees),
-                'seed':42
+                'seed':self.seed
         }
         
         # Updating model type in case of classification
@@ -796,7 +804,8 @@ class _ModelTraining:
         trained_models = []
         for param in model_params:
             result = self._hyperparameter_tunning(param, trainng_datas)
-            trained_models.append(result)
+            if result is not None:
+                trained_models.append(result)
 
         models_df = pd.concat(trained_models, ignore_index=True)
         return models_df
@@ -872,53 +881,71 @@ class _ModelTraining:
             verbose = 0
             
         # Hyperparameter tunning
+        # Parallel run opens multiple connections for parallel execution, 
+        # but volatile tables are not accessible across different sessions. 
+        # Therefore, execution is performed sequentially by setting run_parallel=False.
+
+        run_parallel = configure.temp_object_type != TeradataConstants.TERADATA_VOLATILE_TABLE
+
+        common_params = {
+            "data": train_data,
+            "evaluation_metric": self.stopping_metric,
+            "early_stop": self.stopping_tolerance,
+            "run_parallel": run_parallel,
+            "sample_seed": self.seed,
+            "sample_id_column": "id",
+            "discard_invalid_column_params": True,
+            "stratify_column": self.startify_col,
+            "verbose": verbose,
+            "max_time": self.max_runtime_secs,
+            "suppress_refer_msg": True
+        }
+        
         if model_param['name'] == 'knn':
-            _obj.fit(data=train_data, evaluation_metric=self.stopping_metric,
-                    early_stop=self.stopping_tolerance, run_parallel=True, 
-                    sample_seed=42, sample_id_column='id', discard_invalid_column_params=True,
-                    stratify_column=self.startify_col,verbose=verbose, max_time=self.max_runtime_secs)
+            _obj.fit(**common_params)
         else:
-            _obj.fit(data=train_data, evaluation_metric=self.stopping_metric,
-                    early_stop=self.stopping_tolerance, **eval_params, 
-                    run_parallel=True, discard_invalid_column_params=True, sample_seed=42, 
-                    sample_id_column='id',stratify_column=self.startify_col, verbose=verbose, max_time=self.max_runtime_secs)
+            _obj.fit(**common_params, **eval_params)
 
         # Getting all passed models
         model_info = _obj.model_stats.merge(_obj.models[_obj.models['STATUS']=='PASS'][['MODEL_ID', 'DATA_ID', 'PARAMETERS']],
                                             on='MODEL_ID', how='inner')
-        # Creating mapping data ID to feature selection method
-        data_id_to_table_map = {"DF_0": ('lasso', train_data[0]._table_name), 
-                                "DF_1": ('rfe', train_data[1]._table_name),
-                                "DF_2": ('pca', train_data[2]._table_name)}
-        
-        # Updating model stats with feature selection method and result table
-        for index, row in model_info.iterrows():
-            model_info.loc[index, 'FEATURE_SELECTION'] = data_id_to_table_map[row['DATA_ID']][0]
-            model_info.loc[index, 'DATA_TABLE'] = data_id_to_table_map[row['DATA_ID']][1]
-            model_info.loc[index, 'RESULT_TABLE'] = _obj.get_model(row['MODEL_ID']).result._table_name
-            model_info.loc[index, 'model-obj'] = _obj.get_model(row['MODEL_ID'])
-        
-        # Dropping column 'DATA_ID'
-        model_info.drop(['DATA_ID'], axis=1, inplace=True)
-
-        model_info.insert(1, 'FEATURE_SELECTION', model_info.pop('FEATURE_SELECTION'))
-        
-        if not self.is_classification_type():
-            # Calculating Adjusted-R2 for regression
-            # Getting size and feature count for each feature selection method
-            methods = ["lasso", "rfe", "pca"]
-            size_map = {method : df.select('id').size for method, df in zip(methods, train_data)}
-            feature_count_map = {method : len(df.columns) - 2 for method, df in zip(methods, train_data)}
-            model_info['ADJUSTED_R2'] = model_info.apply(lambda row: 
-                1 - ((1 - row['R2']) * (size_map[row['FEATURE_SELECTION']] - 1) / 
-                (size_map[row['FEATURE_SELECTION']] - feature_count_map[row['FEATURE_SELECTION']] - 1)), axis=1)
-
-        self._display_msg(msg="-"*100,
-                          progress_bar=self.progress_bar,
-                          show_data=True)
-        self.progress_bar.update()
+        if not model_info.empty:
+            # Creating mapping data ID to feature selection method
+            data_id_to_table_map = {"DF_0": ('lasso', train_data[0]._table_name), 
+                                    "DF_1": ('rfe', train_data[1]._table_name),
+                                    "DF_2": ('pca', train_data[2]._table_name)}
+            
+            # Updating model stats with feature selection method and result table
+            for index, row in model_info.iterrows():
+                model_info.loc[index, 'FEATURE_SELECTION'] = data_id_to_table_map[row['DATA_ID']][0]
+                model_info.loc[index, 'DATA_TABLE'] = data_id_to_table_map[row['DATA_ID']][1]
+                model_info.loc[index, 'RESULT_TABLE'] = _obj.get_model(row['MODEL_ID']).result._table_name
+                model_info.loc[index, 'model-obj'] = _obj.get_model(row['MODEL_ID'])
+            
+            # Dropping column 'DATA_ID'
+            model_info.drop(['DATA_ID'], axis=1, inplace=True)
 
-        return model_info
+            model_info.insert(1, 'FEATURE_SELECTION', model_info.pop('FEATURE_SELECTION'))
+            
+            if not self.is_classification_type():
+                # Calculating Adjusted-R2 for regression
+                # Getting size and feature count for each feature selection method
+                methods = ["lasso", "rfe", "pca"]
+                size_map = {method : df.select('id').size for method, df in zip(methods, train_data)}
+                feature_count_map = {method : len(df.columns) - 2 for method, df in zip(methods, train_data)}
+                model_info['ADJUSTED_R2'] = model_info.apply(lambda row: 
+                    1 - ((1 - row['R2']) * (size_map[row['FEATURE_SELECTION']] - 1) / 
+                    (size_map[row['FEATURE_SELECTION']] - feature_count_map[row['FEATURE_SELECTION']] - 1)), axis=1)
+
+            self._display_msg(msg="-"*100,
+                            progress_bar=self.progress_bar,
+                            show_data=True)
+            self.progress_bar.update()
+
+            return model_info
+        
+        # Returning None, if no model is passed
+        return None
 
     @staticmethod
     def _eval_params_generation(ml_name,
@@ -986,4 +1013,4 @@ class _ModelTraining:
             elif ml_name == 'glm':
                 eval_params['family'] = 'GAUSSIAN'
                 
-        return eval_params
+        return eval_params

teradataml/common/constants.py

@@ -14,10 +14,17 @@ A class for holding all constants
 import re
 import sqlalchemy
 from enum import Enum
-from teradataml.options.configure import configure
 from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT, DECIMAL, FLOAT, NUMBER, VARCHAR)
 from teradatasqlalchemy.types import (DATE, TIME, TIMESTAMP)
 from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
+from teradatasqlalchemy import (CHAR, CLOB)
+from teradatasqlalchemy import (PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP)
+from teradatasqlalchemy import (INTERVAL_YEAR, INTERVAL_YEAR_TO_MONTH, INTERVAL_MONTH,
+                                INTERVAL_DAY,INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
+                                INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
+                                INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
+                                INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND,
+                                INTERVAL_SECOND)
 from teradatasqlalchemy import (GEOMETRY, MBR, MBB)
 
 
@@ -53,6 +60,9 @@ class SQLConstants(Enum):
     SQL_DELETE_ALL_ROWS = 29
     SQL_DELETE_SPECIFIC_ROW = 30
     SQL_EXEC_STORED_PROCEDURE = 31
+    SQL_SELECT_COLUMNNAMES_WITH_WHERE = 32
+    SQL_HELP_DATABASE = 33
+    SQL_HELP_DATALAKE = 34
     CONSTRAINT = ["check_constraint", "primary_key_constraint",
                   "foreign_key_constraint", "unique_key_constraint"]
 
@@ -123,6 +133,14 @@ class TeradataTypes(Enum):
     TD_DATE_TYPES = [DATE, sqlalchemy.sql.sqltypes.Date]
     TD_DATE_CODES = ["DA"]
     TD_NULL_TYPE = "NULLTYPE"
+    TD_ALL_TYPES = (BYTEINT, SMALLINT, INTEGER, BIGINT, DECIMAL, FLOAT, NUMBER,
+                    TIMESTAMP, DATE, TIME, CHAR, VARCHAR, CLOB, BYTE, VARBYTE,
+                    BLOB, PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP,
+                    INTERVAL_YEAR, INTERVAL_YEAR_TO_MONTH, INTERVAL_MONTH,
+                    INTERVAL_DAY, INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
+                    INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
+                    INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
+                    INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND, INTERVAL_SECOND)
 
 
 class TeradataTableKindConstants(Enum):
@@ -427,6 +445,8 @@ class TableOperatorConstants(Enum):
     APPLY_TEMPLATE = "dataframe_apply.template"
     # Template of the intermediate script that will be generated for UDF.
     UDF_TEMPLATE = "dataframe_udf.template"
+    # Template of the intermediate script that will be generated for register.
+    REGISTER_TEMPLATE = "dataframe_register.template"
     # In-DB execution mode.
     INDB_EXEC = "IN-DB"
     # Local execution mode.
@@ -443,6 +463,8 @@ class TableOperatorConstants(Enum):
     APPLY_OP = "apply"
     # udf operation.
     UDF_OP = "udf"
+    # register operation.
+    REGISTER_OP = "register"
     # Template of the script_executor that will be used to generate the temporary script_executor file.
     SCRIPT_TEMPLATE = "script_executor.template"
     # Log Type.
@@ -464,11 +486,18 @@ class TableOperatorConstants(Enum):
 
     # Check if Python interpretor and add-ons are installed or not.
     # Location of In-DB packages is indicated by configure.indb_install_location.
+    # Check for both python and pip versions.
     CHECK_PYTHON_INSTALLED = """SELECT distinct * FROM SCRIPT(
                                 ON (select 1) PARTITION BY ANY
-                                SCRIPT_COMMAND('{}/bin/pip3 --version')
-                                returns('package VARCHAR(256)'))
+                                SCRIPT_COMMAND('echo $({0}/bin/pip3 --version) -- $({0}/bin/python3 --version)')
+                                returns('pip VARCHAR(256)'))
                              """
+    # Check which version of rpms are installed.
+    INDB_PYTHON_PATH = """SEL DISTINCT os_ver
+            FROM SCRIPT(
+                SCRIPT_COMMAND('grep CPE_NAME /etc/os-release')
+                RETURNS('os_ver VARCHAR(100)')
+            );"""
 
     # Script Query to get Python packages and corresponding versions.
     # Location of In-DB packages is indicated by configure.indb_install_location.
@@ -480,6 +509,9 @@ class TableOperatorConstants(Enum):
                                                     "delimiter(' ') " \
                                                     "returns('package VARCHAR({2}), " \
                                                     "version VARCHAR({2})'))"
+    
+    SCRIPT_LIST_FILES_QUERY = "SELECT DISTINCT * FROM SCRIPT (SCRIPT_COMMAND " \
+                       "('ls ./{}') RETURNS ('Files VARCHAR({})'))"
 
 class ValibConstants(Enum):
     # A dictionary that maps teradataml name of the exposed VALIB function name
@@ -778,7 +810,8 @@ class ValibConstants(Enum):
             "subdivision_method": "subdivisionmethod",
             "subdivision_threshold": "subdivisionthreshold",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "DATAEXPLORER": {
@@ -795,7 +828,8 @@ class ValibConstants(Enum):
             "stats_options": "statsoptions",
             "distinct": "uniques",
             "filter": "where",
-            "gen_sql": "gensql"
+            "gen_sql": "gensql",
+            "charset": "charset"
         },
 
         "FREQUENCY": {
@@ -809,7 +843,8 @@ class ValibConstants(Enum):
             "style": "style",
             "top_n": "topvalues",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "HISTOGRAM": {
@@ -824,7 +859,8 @@ class ValibConstants(Enum):
             "stats_columns": "statisticscolumns",
             "hist_style": "style",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "STATISTICS": {
@@ -835,7 +871,8 @@ class ValibConstants(Enum):
             "statistical_method": "statisticalmethod",
             "stats_options": "statsoptions",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "TEXTFIELDANALYZER": {
@@ -843,7 +880,8 @@ class ValibConstants(Enum):
             "exclude_columns": "columnstoexclude",
             "analyze_numerics": "extendednumericanalysis",
             "analyze_unicode": "extendedunicodeanalysis",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "VALUES": {
@@ -852,7 +890,8 @@ class ValibConstants(Enum):
             "group_columns": "groupby",
             "distinct": "uniques",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "ASSOCIATION": {
@@ -877,7 +916,8 @@ class ValibConstants(Enum):
             "filter": "where",
             "no_support_results": "dropsupporttables",
             "support_result_prefix": "resulttableprefix",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "KMEANS": {
@@ -887,7 +927,8 @@ class ValibConstants(Enum):
             "continuation": "continuation",
             "max_iter": "iterations",
             "operator_database": "operatordatabase",
-            "threshold": "threshold"
+            "threshold": "threshold",
+            "charset": "charset"
         },
 
         "KMEANSSCORE": {
@@ -895,7 +936,8 @@ class ValibConstants(Enum):
             "cluster_column": "clustername",
             "fallback": "fallback",
             "operator_database": "operatordatabase",
-            "accumulate": "retain"
+            "accumulate": "retain",
+            "charset": "charset"
         },
 
         "DECISIONTREE": {
@@ -907,7 +949,8 @@ class ValibConstants(Enum):
             "max_depth": "max_depth",
             "num_splits": "min_records",
             "operator_database": "operatordatabase",
-            "pruning": "pruning"
+            "pruning": "pruning",
+            "charset": "charset"
         },
 
         "DECISIONTREESCORE": {
@@ -917,7 +960,8 @@ class ValibConstants(Enum):
             "profile": "profiletables",
             "accumulate": "retain",
             "targeted_value": "targetedvalue",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "MATRIX": {
@@ -927,7 +971,8 @@ class ValibConstants(Enum):
             "matrix_output": "matrixoutput",
             "type": "matrixtype",
             "handle_nulls": "nullhandling",
-            "filter": "where"
+            "filter": "where",
+            "charset": "charset"
         },
 
         "LINEAR": {
@@ -949,7 +994,8 @@ class ValibConstants(Enum):
             "stepwise": "stepwise",
             "use_fstat": "usefstat",
             "use_pvalue": "usepvalue",
-            "variance_prop_threshold": "varianceproportionthreshold"
+            "variance_prop_threshold": "varianceproportionthreshold",
+            "charset": "charset"
         },
 
         "LINEARSCORE": {
@@ -957,7 +1003,8 @@ class ValibConstants(Enum):
             "response_column": "predicted",
             "residual_column": "residual",
             "accumulate": "retain",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "LOGISTIC": {
@@ -987,7 +1034,8 @@ class ValibConstants(Enum):
             "end_threshold": "thresholdend",
             "increment_threshold": "thresholdincrement",
             "threshold_output": "thresholdtable",
-            "variance_prop_threshold": "varianceproportionthreshold"
+            "variance_prop_threshold": "varianceproportionthreshold",
+            "charset": "charset"
         },
 
         "LOGISTICSCORE": {
@@ -999,7 +1047,8 @@ class ValibConstants(Enum):
             "start_threshold": "thresholdbegin",
             "end_threshold": "thresholdend",
             "increment_threshold": "thresholdincrement",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
 
             # The following 3 arguments three should not be present for LogRegPredict function
             # where as when the function is LogRegEvaluator, at least one of these should be
@@ -1027,13 +1076,15 @@ class ValibConstants(Enum):
             "rotation_type": "rotationtype",
             "load_threshold": "thresholdloading",
             "percent_threshold": "thresholdpercent",
-            "variance_prop_threshold": "varianceproportionthreshold"
+            "variance_prop_threshold": "varianceproportionthreshold",
+            "charset": "charset"
         },
 
         "FACTORSCORE": {
             "index_columns": "index",
             "accumulate": "retain",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "PARAMETRICTEST": {
@@ -1052,7 +1103,8 @@ class ValibConstants(Enum):
             "style": "teststyle",
             "probability_threshold": "thresholdprobability",
             "with_indicator": "withindicator",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "BINOMIALTEST": {
@@ -1067,7 +1119,8 @@ class ValibConstants(Enum):
             "stats_database": "statsdatabase",
             "style": "teststyle",
             "probability_threshold": "thresholdprobability",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "KSTEST": {
@@ -1079,7 +1132,8 @@ class ValibConstants(Enum):
             "stats_database": "statsdatabase",
             "style": "teststyle",
             "probability_threshold": "thresholdprobability",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "CHISQUARETEST": {
@@ -1093,7 +1147,8 @@ class ValibConstants(Enum):
             "stats_database": "statsdatabase",
             "style": "teststyle",
             "probability_threshold": "thresholdprobability",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "RANKTEST": {
@@ -1112,7 +1167,8 @@ class ValibConstants(Enum):
             "style": "teststyle",
             "probability_threshold": "thresholdprobability",
             "treatment_column": "treatmentcolumn",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "VARTRAN": {
@@ -1123,13 +1179,15 @@ class ValibConstants(Enum):
             "allow_duplicates": "multiset",
             "nopi": "noindex",
             "filter": "whereclause",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         },
 
         "REPORT": {
             "analysis_type": "analysistype",
             "filter": "where",
-            "gen_sql_only": "gensqlonly"
+            "gen_sql_only": "gensqlonly",
+            "charset": "charset"
         }
     }
 
@@ -1424,6 +1482,7 @@ class HTTPRequest(Enum):
     POST = "post"
     PUT = "put"
     DELETE = "delete"
+    PATCH = "patch"
 
 
 class AsyncStatusColumns(Enum):

teradataml/common/garbagecollector.py

@@ -520,7 +520,8 @@ class GarbageCollector():
                             fileparts = file.split(GarbageCollector.__filenameseperator)
                             hostname = fileparts[1]
                             filepid = int(fileparts[2])
-                            if hostname == tdmlctx.context._get_host_ip():
+                            # Check for both host ip and hostname in case user passed hostname for creating connection.
+                            if hostname == tdmlctx.context._get_host_ip() or hostname == tdmlctx.context._get_host():
                                 if filepid == os.getpid() or not psutil.pid_exists(filepid):
                                     tempfiles.append(filepath)
                         except (IndexError, ValueError):