Implement error handling for transform_num()

[ETA444]

Implement error handling for each user input of the function.

[ETA444]

TypeErrors: Checking Parameter Types

1. df Parameter

• Purpose: Ensure that the input DataFrame is a valid pandas DataFrame.

if not isinstance(df, pd.DataFrame):
    raise TypeError("transform_num(): The 'df' parameter must be a pandas DataFrame.")

2. numerical_variables Parameter

• Purpose: Ensure that numerical_variables is a list of column names.

if not isinstance(numerical_variables, list):
    raise TypeError("transform_num(): The 'numerical_variables' parameter must be a list of column names.")
else:
    if not all(isinstance(var, str) for var in numerical_variables):
        raise TypeError("transform_num(): All elements in the 'numerical_variables' list must be strings representing column names.")

3. method Parameter

• Purpose: Ensure that method is a string.

if not isinstance(method, str):
    raise TypeError("transform_num(): The 'method' parameter must be a string.")

4. output_distribution Parameter

• Purpose: Ensure that output_distribution is a string.

if not isinstance(output_distribution, str):
    raise TypeError("transform_num(): The 'output_distribution' parameter must be a string.")

5. n_quantiles Parameter

• Purpose: Ensure that n_quantiles is an integer.

if not isinstance(n_quantiles, int):
    raise TypeError("transform_num(): The 'n_quantiles' parameter must be an integer.")

6. random_state Parameter

• Purpose: Ensure that random_state is an integer.

if not isinstance(random_state, int):
    raise TypeError("transform_num(): The 'random_state' parameter must be an integer.")

7. with_centering Parameter

• Purpose: Ensure that with_centering is a boolean.

if not isinstance(with_centering, bool):
    raise TypeError("transform_num(): The 'with_centering' parameter must be a boolean.")

8. quantile_range Parameter

• Purpose: Ensure that quantile_range is a tuple containing two float values.

if not (isinstance(quantile_range, tuple) and len(quantile_range) == 2 and all(isinstance(num, float) for num in quantile_range)):
    raise TypeError("transform_num(): The 'quantile_range' parameter must be a tuple containing two float values.")

9. power Parameter

• Purpose: Ensure that power is None, an integer, or a float.

if power is not None and not isinstance(power, (int, float)):
    raise TypeError("transform_num(): The 'power' parameter must be a float, integer, or None.")

10. power_map Parameter

• Purpose: Ensure that power_map is None or a dictionary.

if power_map is not None and not isinstance(power_map, dict):
    raise TypeError("transform_num(): The 'power_map' parameter must be a dictionary or None.")

11. lower_percentile and upper_percentile Parameters

• Purpose: Ensure that lower_percentile and upper_percentile are floats.

if not isinstance(lower_percentile, float) or not isinstance(upper_percentile, float):
    raise TypeError("transform_num(): The 'lower_percentile' and 'upper_percentile' parameters must be floats.")

12. winsorization_map Parameter

• Purpose: Ensure that winsorization_map is None or a dictionary.

if winsorization_map is not None and not isinstance(winsorization_map, dict):
    raise TypeError("transform_num(): The 'winsorization_map' parameter must be a dictionary or None.")

13. interaction_pairs Parameter

• Purpose: Ensure that interaction_pairs is None or a list of tuples.

if interaction_pairs is not None:
    if not (isinstance(interaction_pairs, list) and all(isinstance(pair, tuple) and len(pair) == 2 for pair in interaction_pairs)):
        raise TypeError("transform_num(): The 'interaction_pairs' parameter must be a list of tuples or None.")

14. degree Parameter

• Purpose: Ensure that degree is None or an integer.

if degree is not None and not isinstance(degree, int):
    raise TypeError("transform_num(): The 'degree' parameter must be an integer or None.")

15. degree_map Parameter

• Purpose: Ensure that degree_map is None or a dictionary.

if degree_map is not None and not isinstance(degree_map, dict):
    raise TypeError("transform_num(): The 'degree_map' parameter must be a dictionary or None.")

16. bins Parameter

• Purpose: Ensure that bins is None or an integer.

if bins is not None and not isinstance(bins, int):
    raise TypeError("transform_num(): The 'bins' parameter must be an integer or None.")

17. bin_map Parameter

• Purpose: Ensure that bin_map is None or a dictionary.

if bin_map is not None and not isinstance(bin_map, dict):
    raise TypeError("transform_num(): The 'bin_map' parameter must be a dictionary or None.")

ValueErrors: Checking Parameter Values

1. Empty DataFrame

• Purpose: Ensure the input DataFrame is not empty.

if df.empty:
    raise ValueError("transform_num(): The input DataFrame is empty.")

2. Empty numerical_variables List

• Purpose: Ensure that numerical_variables contains at least one column name.

if len(numerical_variables) == 0:
    raise ValueError("transform_num(): The 'numerical_variables' list must contain at least one column name.")

3. Non-Numerical Variables

• Purpose: Ensure all specified variables are numerical.

numerical_types = evaluate_dtype(df, numerical_variables, output='list_n')
if not all(numerical_types):
    raise ValueError(f"transform_num(): The 'numerical_variables' list must contain only names of numerical variables.")

4. Variables Not in DataFrame

• Purpose: Ensure all specified variables exist in the DataFrame.

missing_vars = [var for var in numerical_variables if var not in df.columns]
if missing_vars:
    raise ValueError(f"transform_num(): The following numerical variables were not found in the DataFrame: {', '.join(missing_vars)}")

5. Invalid Method

• Purpose: Ensure the specified method is valid.

valid_methods = ['standardize', 'log', 'normalize', 'quantile', 'robust', 'boxcox', 'yeojohnson', 'power', 'winsorization', 'interaction', 'polynomial', 'bin']
if method.lower() not in valid_methods:
    raise ValueError(f"transform_num(): Invalid method '{method}'. Valid options are: {', '.join(valid_methods)}")

6. Invalid output_distribution for quantile Method

• Purpose: Ensure output_distribution is either 'normal' or 'uniform' for the quantile method.

if method.lower() == 'quantile':
    if output_distribution not in ['normal', 'uniform']:
        raise ValueError("transform_num(): Invalid 'output_distribution' for 'quantile' method. Choose 'normal' or 'uniform'.")
    if not isinstance(n_quantiles, int) or n_quantiles <= 0:
        raise ValueError("transform_num(): The 'n_quantiles' must be a positive integer.")
    if not isinstance(random_state, int):
        raise ValueError("transform_num(): The 'random_state' must be an integer.")

7. Invalid quantile_range for robust Method

• Purpose: Ensure quantile_range is a tuple of two float values for the robust method.

if method.lower() == 'robust':
    if not isinstance(with_centering, bool):
        raise ValueError("transform_num(): The 'with_centering' parameter must be a boolean (True or False).")
    if not (isinstance(quantile_range, tuple) and len(quantile_range) == 2 and all(isinstance(num, float) for num in quantile_range)):
        raise ValueError("transform_num(): The 'quantile_range' must be a tuple of two float values.")

8. Invalid power or power_map for power Method

• Purpose: Ensure power is a float, integer, or None for the power method, and power_map is a dictionary or None.

if method.lower() == 'power':
    if power is not None and not isinstance(power, (float, int)):
        raise ValueError("transform_num(): The 'power' parameter

 must be a float, integer, or None.")
    if power_map is not None and not isinstance(power_map, dict):
        raise ValueError("transform_num(): The 'power_map' must be a dictionary mapping variables to powers or None.")

9. Invalid Percentiles for winsorization Method

• Purpose: Ensure lower_percentile and upper_percentile are valid for the winsorization method.

if method.lower() == 'winsorization':
    if not (isinstance(lower_percentile, float) and 0 <= lower_percentile < 1):
        raise ValueError("transform_num(): The 'lower_percentile' must be a float between 0 and 1.")
    if not (isinstance(upper_percentile, float) and 0 < upper_percentile <= 1):
        raise ValueError("transform_num(): The 'upper_percentile' must be a float between 0 and 1.")
    if lower_percentile >= upper_percentile:
        raise ValueError("transform_num(): The 'lower_percentile' must be less than 'upper_percentile'.")

10. Invalid degree or degree_map for polynomial Method

• Purpose: Ensure degree is a positive integer or None for the polynomial method, and degree_map is a dictionary or None.

if method.lower() == 'polynomial':
    if degree is not None and not (isinstance(degree, int) and degree > 0):
        raise ValueError("transform_num(): The 'degree' must be a positive integer or None.")
    if degree_map is not None and not isinstance(degree_map, dict):
        raise ValueError("transform_num(): The 'degree_map' must be a dictionary mapping variables to degrees or None.")

11. Invalid bins or bin_map for bin Method

• Purpose: Ensure bins is a positive integer or None for the bin method, and bin_map is a dictionary or None.

if method.lower() == 'bin':
    if bins is not None and not (isinstance(bins, int) and bins > 0):
        raise ValueError("transform_num(): The 'bins' must be a positive integer or None.")
    if bin_map is not None and not isinstance(bin_map, dict):
        raise ValueError("transform_num(): The 'bin_map' must be a dictionary specifying binning criteria or None.")

12. Invalid interaction_pairs

• Purpose: Ensure interaction_pairs is a list of tuples specifying pairs of variables or None.

if method.lower() == 'interaction':
    if interaction_pairs is not None:
        if not (isinstance(interaction_pairs, list) and all(isinstance(pair, tuple) and len(pair) == 2 for pair in interaction_pairs)):
            raise ValueError("transform_num(): The 'interaction_pairs' must be a list of tuples specifying pairs of variables or None.")
        missing_pairs = [pair for pair in interaction_pairs if pair[0] not in df.columns or pair[1] not in df.columns]
        if missing_pairs:
            raise ValueError(f"transform_num(): The following variable pairs in 'interaction_pairs' were not found in the DataFrame: {missing_pairs}")

13. Handling NaN or Infinite Values

• Purpose: Handle NaN or infinite values for methods that cannot handle them.

if method.lower() in ['log', 'boxcox', 'yeojohnson']:
    if df[numerical_variables].isnull().values.any() or np.isinf(df[numerical_variables].values).any():
        raise ValueError(f"transform_num(): The 'numerical_variables' contain NaN or infinite values, which are not compatible with the '{method}' method.")

14. Mapping Dictionary Keys

• Purpose: Ensure mapping dictionary keys exist in the DataFrame.

if power_map or winsorization_map or degree_map or bin_map:
    for mapping, map_name in zip([power_map, winsorization_map, degree_map, bin_map], ['power_map', 'winsorization_map', 'degree_map', 'bin_map']):
        if mapping:
            invalid_keys = [key for key in mapping.keys() if key not in df.columns]
            if invalid_keys:
                raise ValueError(f"transform_num(): The following keys in '{map_name}' were not found in the DataFrame columns: {', '.join(invalid_keys)}")

---

Full Code Implementation for transform_num()