From 903a9db9ae25ca574038108a20e0ab0f6e22cd0c Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sat, 27 Apr 2024 12:28:39 -0400 Subject: [PATCH 01/44] Auto stash before merge of "master" and "origin/master" --- miceforest/ImputedData.py | 418 ++--- miceforest/MeanMatchScheme.py | 395 ----- miceforest/__init__.py | 16 +- miceforest/builtin_mean_match_functions.py | 219 --- miceforest/impute.py | 1868 ++++++++++++++++++++ miceforest/logger.py | 28 +- miceforest/mean_match.py | 266 +++ miceforest/utils.py | 223 +-- poetry.lock | 1254 +++++++++++++ pyproject.toml | 25 + tests/test_ImputationKernel.py | 4 - 11 files changed, 3633 insertions(+), 1083 deletions(-) delete mode 100644 miceforest/MeanMatchScheme.py delete mode 100644 miceforest/builtin_mean_match_functions.py create mode 100644 miceforest/impute.py create mode 100644 miceforest/mean_match.py create mode 100644 poetry.lock create mode 100644 pyproject.toml diff --git a/miceforest/ImputedData.py b/miceforest/ImputedData.py index 8fd1dbb..f6119d3 100644 --- a/miceforest/ImputedData.py +++ b/miceforest/ImputedData.py @@ -1,258 +1,153 @@ import numpy as np from .compat import pd_DataFrame +from pandas import DataFrame, MultiIndex from .utils import ( + get_best_int_downcast, _t_dat, _t_var_list, _t_var_dict, _ensure_iterable, - _dict_set_diff, - _assign_col_values_without_copy, - _slice, - _subset_data, ) from itertools import combinations from typing import Dict, List, Union, Any, Optional from warnings import warn -class ImputedData: - """ - Imputed Data - - This class should not be instantiated directly. - Instead, it is returned when ImputationKernel.impute_new_data() is called. - For parameter arguments, see ImputationKernel documentation. - """ - +class ImputedPandasDataFrame: def __init__( self, - impute_data: _t_dat, - datasets: int = 5, - variable_schema: Union[_t_var_list, _t_var_dict, None] = None, - imputation_order: Union[str, _t_var_list] = "ascending", - train_nonmissing: bool = False, - categorical_feature: Union[str, _t_var_list] = "auto", - save_all_iterations: bool = True, + impute_data: pd_DataFrame, + num_datasets: int = 5, + variable_schema: Union[List[str], Dict[str, str]] = None, + imputation_order: str = "ascending", copy_data: bool = True, ): # All references to the data should be through self. self.working_data = impute_data.copy() if copy_data else impute_data data_shape = self.working_data.shape - int_storage_types = ["uint64", "uint32", "uint16", "uint8"] - na_where_type = "uint64" - for st in int_storage_types: - if data_shape[0] <= np.iinfo(st).max: - na_where_type = st - - # Collect metadata and format data - if isinstance(self.working_data, pd_DataFrame): - if len(self.working_data.shape) != 2 or self.working_data.shape[0] < 1: - raise ValueError("Input data must be 2 dimensional and non empty.") - - original_data_class = "pd_DataFrame" - column_names: List[str] = [str(x) for x in self.working_data.columns] - self.column_names = column_names - pd_dtypes_orig = self.working_data.dtypes - - if any([x.name == "object" for x in pd_dtypes_orig]): - raise ValueError( - "Please convert object columns to categorical or some numeric type." - ) - # Assume categories are set dtypes. - if categorical_feature == "auto": - categorical_variables = [ - column_names.index(var) - for var in pd_dtypes_orig.index - if pd_dtypes_orig[var].name in ["category"] - ] - - elif isinstance(categorical_feature, list): - if any([x.name == "category" for x in pd_dtypes_orig]): - raise ValueError( - "If categories are already encoded as such, set categorical_feature = auto" - ) - categorical_variables = self._get_var_ind_from_list(categorical_feature) - - else: - raise ValueError("Unknown categorical_feature") - - # Collect category counts. - category_counts = {} - for cat in categorical_variables: - cat_name = self._get_var_name_from_scalar(cat) - cat_dat = self.working_data.iloc[:, cat] - uniq = set(cat_dat.dropna()) - category_counts[cat] = len(uniq) - - # Collect info about what data is missing. - na_where: Dict[int, np.ndarray] = { - col: np.where(self.working_data.iloc[:, col].isnull())[0].astype( - na_where_type - ) - for col in range(data_shape[1]) - } - na_counts = {col: len(nw) for col, nw in na_where.items()} - vars_with_any_missing = [ - col for col, ind in na_where.items() if len(ind > 0) - ] - # if len(vars_with_any_missing) == 0: - # raise ValueError("No missing values to impute.") - - # Keep track of datatypes. Needed for loading kernels. - self.working_dtypes = self.working_data.dtypes - - elif isinstance(self.working_data, np.ndarray): - if len(self.working_data.shape) != 2 or self.working_data.shape[0] < 1: - raise ValueError("Input data must be 2 dimensional and non empty.") - - original_data_class = "np_ndarray" - - # DATASET ALTERATION - if ( - self.working_data.dtype != np.float32 - and self.working_data.dtype != np.float64 - ): - self.working_data = self.working_data.astype(np.float32) - - # Collect information about dataset - column_names = [str(x) for x in range(self.working_data.shape[1])] - self.column_names = column_names - na_where = { - col: np.where(np.isnan(self.working_data[:, col]))[0].astype( - na_where_type - ) - for col in range(data_shape[1]) - } - na_counts = {col: len(nw) for col, nw in na_where.items()} - vars_with_any_missing = [ - int(col) for col, ind in na_where.items() if len(ind > 0) - ] - if categorical_feature == "auto": - categorical_variables = [] - elif isinstance(categorical_feature, list): - categorical_variables = self._get_var_ind_from_list(categorical_feature) - assert ( - max(categorical_variables) < self.working_data.shape[1] - ), "categorical_feature not in dataset" - else: - raise ValueError("categorical_feature not recognized") - - # Collect category counts. - category_counts = {} - for cat in categorical_variables: - cat_dat = self.working_data[:, cat] - cat_dat = cat_dat[~np.isnan(cat_dat)] - uniq = set(cat_dat) - category_counts[cat] = len(uniq) - - # Keep track of datatype. - self.working_dtypes = self.working_data.dtype - - else: - raise ValueError("impute_data not recognized.") + column_names = [] + pd_dtypes_orig = {} + for col, series in self.working_data.items(): + assert isinstance(col, str), 'column names must be strings' + assert series.dtype.name != 'object', 'convert object dtypes to something else' + column_names.append(col) + pd_dtypes_orig[col] = series.dtype.name + + column_names: List[str] = [str(x) for x in self.working_data.columns] + self.column_names = column_names + pd_dtypes_orig = self.working_data.dtypes + + + # Collect info about what data is missing. + na_where = {} + for col in column_names: + nas = np.where(self.working_data[col].isnull())[0] + best_downcast = get_best_int_downcast(nas.max()) + na_where[col] = nas.astype(best_downcast) + na_counts = {col: len(nw) for col, nw in na_where.items()} + vars_with_any_missing = [ + col for col, ind in na_where.items() if len(ind > 0) + ] - # Formatting of variable_schema. + # If variable_schema was passed, use that as the + # list of variables that should have models trained. + # Otherwise, only train models on variables that have + # missing values, unless train_nonmissing, in which + # case we build imputation models for all variables. if variable_schema is None: - variable_schema = _dict_set_diff(range(data_shape[1]), range(data_shape[1])) + modeled_variables = vars_with_any_missing + variable_schema = { + target: [ + regressor + for regressor in column_names + if regressor != target + ] + for target in modeled_variables + } else: if isinstance(variable_schema, list): - var_schem = self._get_var_ind_from_list(variable_schema) - variable_schema = _dict_set_diff(var_schem, range(data_shape[1])) - + variable_schema = { + target: [ + regressor + for regressor in column_names + if regressor != target + ] + for target in variable_schema + } elif isinstance(variable_schema, dict): - variable_schema = self._get_var_ind_from_dict(variable_schema) + for target, regressors in variable_schema.items(): + if target in regressors: + raise ValueError(f'{target} being used to impute itself') + + # variable schema at this point should only + # contain the variables that are to have models trained. + modeled_variables = list(variable_schema) + imputed_variables = [ + col for col in modeled_variables + if col in vars_with_any_missing + ] + modeled_but_not_imputed_variables = [ + col for col in modeled_variables + if col not in imputed_variables + ] - # Check for any self-impute attempts - self_impute_attempt = [ - var for var, prd in variable_schema.items() if var in prd - ] - if len(self_impute_attempt) > 0: - raise ValueError( - ",".join(self._get_var_name_from_list(self_impute_attempt)) - + " variables cannot be used to impute itself." - ) - - # Format imputation order - if isinstance(imputation_order, list): - imputation_order = self._get_var_ind_from_list(imputation_order) - assert set(imputation_order).issubset( - variable_schema - ), "variable_schema does not include all variables to be imputed." - imputation_order = [i for i in imputation_order if na_counts[i] > 0] - elif isinstance(imputation_order, str): - if imputation_order in ["ascending", "descending"]: - imputation_order = self._get_var_ind_from_list( - np.argsort(list(na_counts.values())).tolist() - if imputation_order == "ascending" - else np.argsort(list(na_counts.values()))[::-1].tolist() - ) - imputation_order = [ - int(i) - for i in imputation_order - if na_counts[i] > 0 and i in list(variable_schema) - ] - elif imputation_order == "roman": - imputation_order = list(variable_schema).copy() - elif imputation_order == "arabic": - imputation_order = list(variable_schema).copy() - imputation_order.reverse() - else: - raise ValueError("imputation_order not recognized.") - - self.imputation_order = imputation_order - self.variable_schema = variable_schema - self.unimputed_variables = list( - np.setdiff1d(np.arange(data_shape[1]), imputation_order) - ) - if train_nonmissing: - self.variable_training_order = [ - v - for v in self.imputation_order + self.unimputed_variables - if v in list(self.variable_schema) - ] + # Model Training Order: + # Variables with missing data are always trained + # first, according to imputation_order. Afterwards, + # variables with no missing values have models trained. + if imputation_order in ["ascending", "descending"]: + na_counts_of_imputed_variables = { + key: value + for key, value in self.na_counts.items() + if key in imputed_variables + } + self.imputation_order = list(sorted( + na_counts_of_imputed_variables.items(), + key=lambda item: item[1] + )) + if imputation_order == "decending": + self.imputation_order.reverse() + elif imputation_order == "roman": + self.imputation_order = imputed_variables.copy() + elif imputation_order == "arabic": + self.imputation_order = imputed_variables.copy() + self.imputation_order.reverse() else: - self.variable_training_order = self.imputation_order - predictor_vars = [prd for prd in variable_schema.values()] - self.predictor_vars = list( - dict.fromkeys([item for sublist in predictor_vars for item in sublist]) - ) - self.categorical_feature = categorical_feature - self.categorical_variables = categorical_variables - self.category_counts = category_counts - self.original_data_class = original_data_class - self.save_all_iterations = save_all_iterations + raise ValueError("imputation_order not recognized.") + + model_training_order = self.imputation_order + modeled_but_not_imputed_variables + + self.variable_schema = variable_schema + self.model_training_order = model_training_order self.data_shape = data_shape self.na_counts = na_counts self.na_where = na_where self.vars_with_any_missing = vars_with_any_missing - self.imputed_variable_count = len(imputation_order) - self.modeled_variable_count = len(self.variable_training_order) + self.imputed_variable_count = len(self.imputation_order) + self.modeled_variable_count = len(self.model_training_order) self.iterations = np.zeros( - shape=(datasets, self.modeled_variable_count) + shape=(num_datasets, self.modeled_variable_count) ).astype(int) - # Create structure to store imputation values. - # These will be initialized by an ImputationKernel. - self.imputation_values: Dict[Any, np.ndarray] = {} - self.initialized = False - - # Sanity checks - # if self.imputed_variable_count == 0: - # raise ValueError("Something went wrong. No variables to impute.") + iv_multiindex = MultiIndex.from_arrays([np.arange(num_datasets), [0]], names=('dataset', 'iteration')) + self.imputation_values = { + var: DataFrame(index=na_where[var], columns=iv_multiindex).astype(pd_dtypes_orig[var]) + for var in self.imputation_order + } # Subsetting allows us to get to the imputation values: def __getitem__(self, tup): - ds, var, iter = tup - return self.imputation_values[ds, var, iter] + var, ds, iter = tup + return self.imputation_values[var].loc[:, (ds, iter)] def __setitem__(self, tup, newitem): - ds, var, iter = tup - self.imputation_values[ds, var, iter] = newitem + var, ds, iter = tup + self.imputation_values[var].loc[:, (ds, iter)] = newitem def __delitem__(self, tup): - ds, var, iter = tup - del self.imputation_values[ds, var, iter] + var, ds, iter = tup + del self.imputation_values[var][ds, iter] def __repr__(self): summary_string = f'\n{" " * 14}Class: ImputedData\n{self._ids_info()}' @@ -264,89 +159,24 @@ def _ids_info(self): Iterations: {self.iteration_count()} Data Samples: {self.data_shape[0]} Data Columns: {self.data_shape[1]} - Imputed Variables: {len(self.imputation_order)} -save_all_iterations: {self.save_all_iterations}""" - return summary_string - - def dataset_count(self): - """ - Return the number of datasets. - Datasets are defined by how many different sets of imputation - values we have accumulated. - """ - return self.iterations.shape[0] - - def _get_var_name_from_scalar(self, ind: Union[str, int]) -> str: + Imputed Variables: {self.imputed_variable_count} + Modeled Variables: {self.modeled_variable_count} """ - Gets the variable name from an index. - Returns a list of names if a list of indexes was passed. - Otherwise, returns the variable name directly from self.column_names. - """ - if isinstance(ind, str): - return ind - else: - return self.column_names[ind] - - def _get_var_name_from_list(self, variable_list: _t_var_list) -> List[str]: - ret = [ - self.column_names[x] if isinstance(x, int) else str(x) - for x in variable_list - ] - return ret - - def _get_var_ind_from_dict(self, variable_dict) -> Dict[int, List[int]]: - indx: Dict[int, List[int]] = {} - for variable, value in variable_dict.items(): - if isinstance(variable, str): - variable = self.column_names.index(variable) - variable = int(variable) - val = [ - int(self.column_names.index(v)) if isinstance(v, str) else int(v) - for v in value - ] - indx[variable] = sorted(val) - - return indx - - def _get_var_ind_from_list(self, variable_list) -> List[int]: - ret = [ - int(self.column_names.index(x)) if isinstance(x, str) else int(x) - for x in variable_list - ] - - return ret - - def _get_var_ind_from_scalar(self, variable) -> int: - if isinstance(variable, str): - variable = self.column_names.index(variable) - variable = int(variable) - return variable + return summary_string - def _get_nonmissing_indx(self, var): - non_missing_ind = np.setdiff1d( - np.arange(self.data_shape[0]), self.na_where[var] - ) + def _get_nonmissing_index(self, column): + na_where = self.na_where[column] + dtype = na_where.dtype + non_missing_ind = np.setdiff1d(np.arange(self.data_shape[0], dtype=dtype), na_where) return non_missing_ind + + def _get_nonmissing_values(self, column): + ind = self._get_nonmissing_index(column) + return self.working_data.loc[ind, column] - def _insert_new_data(self, dataset, variable_index, new_data): + def _add_imputed_values(self, dataset, variable_index, new_data): current_iter = self.iteration_count(datasets=dataset, variables=variable_index) - # We need to insert the categories if the raw data is stored as a category. - # Otherwise, pandas won't let us insert. - view = _slice(self.working_data, col_slice=variable_index) - if view.dtype.name == "category": - new_data = np.array(view.cat.categories)[new_data] - - _assign_col_values_without_copy( - dat=self.working_data, - row_ind=self.na_where[variable_index], - col_ind=variable_index, - val=new_data, - ) - self[dataset, variable_index, current_iter + 1] = new_data - if not self.save_all_iterations: - del self[dataset, variable_index, current_iter] - def _ampute_original_data(self): """Need to put self.working_data back in its original form""" for c in self.imputation_order: @@ -357,7 +187,11 @@ def _ampute_original_data(self): val=np.array([np.nan]), ) - def _get_num_vars(self, subset: Optional[List] = None): + def _get_numeric_columns( + self, + imputed: bool = True, + modeled: bool = True, + ): """Returns the non-categorical imputed variable indexes.""" num_vars = [ @@ -600,7 +434,7 @@ def plot_imputed_distributions( ds: self[ds, var, iteration] for ds in datasets } plt.sca(ax[axr, axc]) - non_missing_ind = self._get_nonmissing_indx(var) + non_missing_ind = self._get_nonmissing_index(var) nonmissing_values = _subset_data( self.working_data, row_ind=non_missing_ind, col_ind=var, return_1d=True ) diff --git a/miceforest/MeanMatchScheme.py b/miceforest/MeanMatchScheme.py deleted file mode 100644 index a15fbcd..0000000 --- a/miceforest/MeanMatchScheme.py +++ /dev/null @@ -1,395 +0,0 @@ -from .compat import pd_DataFrame -import inspect -from copy import deepcopy -from typing import Callable, Union, Dict, Set -from numpy import dtype - - -_REGRESSIVE_OBJECTIVES = [ - "regression", - "regression_l1", - "poisson", - "huber", - "fair", - "mape", - "cross_entropy", - "cross_entropy_lambda" "quantile", - "tweedie", - "gamma", -] - -_CATEGORICAL_OBJECTIVES = [ - "binary", - "multiclass", - "multiclassova", -] - -AVAILABLE_MEAN_MATCH_ARGS = [ - "mean_match_candidates", - "lgb_booster", - "bachelor_preds", - "bachelor_features", - "candidate_values", - "candidate_features", - "candidate_preds", - "random_state", - "hashed_seeds", -] - -_DEFAULT_MMC = 5 - -_t_mmc = Union[int, Dict[str, int], Dict[int, int]] -_t_obj_func = Dict[str, Callable] -_t_np_dt = Dict[str, str] - - -class MeanMatchScheme: - def __init__( - self, - mean_match_candidates: _t_mmc, - mean_match_functions: _t_obj_func, - lgb_model_pred_functions: _t_obj_func, - objective_pred_dtypes: Dict[str, str], - ): - """ - Stores information and methods surrounding how mean matching should - behave for each variable. This class is responsible for determining: - - * The mean matching function - * How predictions are obtained from a lightgbm model - * The datatype of the predictions - * The number of mean matching candidates - * Which variables will have candidate predictions compiled - - During the imputation process, the following series of events occur - for each variable: - - 1) ImputationKernel trains a lightgbm model - 2) MeanMatchScheme gets predictions from lightgbm model based on the model objective. - 3) MeanMatchScheme performs mean matching on the predictions. - - Parameters - ---------- - mean_match_candidates: int or dict, default = 5 - The number of mean matching candidates to pull. - One of these candidates will be chosen randomly - as the imputation value. To skip mean matching, - set to 0. - - If int, that value is used for all variables. - - If a dict is passed, it should be of the form: - {variable: int} pairs. Any variables not specified - will use the default. Variables can be passed as - column names or indexes. - - For more information about mean matching, see: - https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching - - mean_match_functions: dict - A dict of {objective: callable} pairs. The objective should be - a lightgbm objective. The provided function will be used to - perform mean matching for all models with the given objective. - - RULES FOR FUNCTIONS: - 1) The only arguments allowed are those listed in - miceforest.mean_match_schemes.AVAILABLE_MEAN_MATCH_ARGS - 2) Not all of those arguments are required, the process - will only pass arguments that the function requires - - lgb_model_pred_functions: dict - A dict of {objective: callable} pairs. The objective should be - a lightgbm objective. The provided function will be used to - obtain predictions from lightgbm models with the paired objective. - - For example, passing: {"binary": func, "regression": func2} will call - func(model, data) to obtain the predictions from the model, if the - model objective was binary. - - objective_pred_dtypes: dict - A dict of {objective: np.datatype} pairs. - Datatype must be the string datatype name, i.e. "float32" - How prediction data types will be cast. Casting to a smaller bit - value can be beneficial when compiling candidates. Depending on - the data, smaller bit rates tend to result in imputations of - sufficient quality, while taking up much less space. - - """ - - self.mean_match_functions: Dict[str, Callable] = {} - self.objective_args: Dict[str, Set[str]] = {} - self.objective_pred_funcs: Dict[str, Callable] = {} - self.objective_pred_dtypes = objective_pred_dtypes.copy() - - for objective, function in mean_match_functions.items(): - self._add_mmf(objective, function) - - for objective, function in lgb_model_pred_functions.items(): - self._add_lgbpred(objective, function) - - self.mean_match_candidates = mean_match_candidates - self._mmc_formatted = False - - def _add_mmf(self, objective: str, func: Callable): - obj_args = set(inspect.getfullargspec(func).args) - assert obj_args.issubset( - set(AVAILABLE_MEAN_MATCH_ARGS) - ), f"arg not available to mean match function for objective {objective}, check arguments." - self.mean_match_functions[objective] = func - self.objective_args[objective] = obj_args - - def _add_lgbpred(self, objective: str, func: Callable): - obj_args = set(inspect.getfullargspec(func).args) - assert obj_args == { - "data", - "model", - }, f"functions in lgb_model_pred_functions should only have 2: parameters, model and data." - self.objective_pred_funcs[objective] = func - - def _format_mean_match_candidates(self, data, available_candidates): - var_indx_list = list(available_candidates) - assert not self._mmc_formatted, "mmc are already formatted" - - if isinstance(self.mean_match_candidates, int): - mmc_formatted = {v: self.mean_match_candidates for v in var_indx_list} - - elif isinstance(self.mean_match_candidates, dict): - mmc_formatted = {} - for v, mmc in self.mean_match_candidates.items(): - if isinstance(v, str): - assert isinstance( - data, pd_DataFrame - ), "columns cannot be names unless data is pandas DF" - v_ind = data.columns.tolist().index(v) - assert ( - v_ind in var_indx_list - ), f"{v} is not having a model built, should not get mmc." - assert ( - mmc <= available_candidates[v_ind] - ), f"{v} doesn't have enough candidates for mmc {mmc}" - - else: - v_ind = v - - if isinstance(mmc, float): - assert 0.0 < mmc < 1.0, f"{v} mmc malformed" - print("A") - mmc_formatted[v_ind] = int(mmc * available_candidates[v_ind]) - else: - mmc_formatted[v_ind] = mmc - print("B") - - for v in var_indx_list: - if v not in list(mmc_formatted): - mmc_formatted[v] = _DEFAULT_MMC - - else: - raise ValueError( - "malformed mean_match_candidates was passed to MeanMatchScheme" - ) - - self.mean_match_candidates = mmc_formatted - self._mmc_formatted = True - - def copy(self): - """ - Return a copy of this schema. - - Returns - ------- - A copy of this MeanMatchSchema - """ - return deepcopy(self) - - def set_mean_match_candidates(self, mean_match_candidates: _t_mmc): - """ - Set the mean match candidates - - Parameters - ---------- - mean_match_candidates: int or dict - The number of mean matching candidates to pull. - One of these candidates will be chosen randomly - as the imputation value. To skip mean matching, - set to 0. - - If int, that value is used for all variables. - - If a dict is passed, it should be of the form: - {variable: int} pairs. Any variables not specified - will use the default. Variables can be passed as - column names or indexes. - - For more information about mean matching, see: - https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching - """ - self.mean_match_candidates = mean_match_candidates - self._mmc_formatted = False - - def set_mean_match_function(self, mean_match_functions: _t_obj_func): - """ - Overwrite the current mean matching functions for certain - objectives. - - Parameters - ---------- - mean_match_functions: dict - A dict of {objective: callable} pairs. The objective should be - a lightgbm objective. The provided function will be used to - perform mean matching for all models with the given objective. - - RULES FOR FUNCTIONS: - 1) The only arguments allowed are those listed in - miceforest.mean_match_schemes.AVAILABLE_MEAN_MATCH_ARGS - 2) Not all of those arguments are required, the process - will only pass arguments that the function requires - - """ - for objective, function in mean_match_functions.items(): - self._add_mmf(objective, function) - - def set_lgb_model_pred_functions(self, lgb_model_pred_functions: _t_obj_func): - """ - Overwrite the current prediction functions for certain - objectives. - - Parameters - ---------- - lgb_model_pred_functions: dict - A dict of {objective: callable} pairs. The objective should be - a lightgbm objective. The provided function will be used to - obtain predictions from lightgbm models with the paired objective. - - For example, passing: {"binary": func, "regression": func2} will call - func(model, data) to obtain the predictions from the model, if the - model objective was binary. - """ - for objective, function in lgb_model_pred_functions.items(): - self._add_lgbpred(objective, function) - - def set_objective_pred_dtypes(self, objective_pred_dtypes: Dict[str, str]): - """ - Overwrite the current datatypes for certain objectives. - Predictions obtained from lightgbm are stored as these - datatypes. - - Parameters - ---------- - objective_pred_dtypes: dict - A dict of {objective: np.datatype} pairs. - Datatype must be the string datatype name, i.e. "float32" - How prediction data types will be cast. Casting to a smaller bit - value can be beneficial when compiling candidates. Depending on - the data, smaller bit rates tend to result in imputations of - sufficient quality, while taking up much less space. - - """ - self.objective_pred_dtypes.update(objective_pred_dtypes) - - def get_objectives_requiring_candidate_preds(self): - """ - Easy way to determine which lightgbm objectives will - require candidate predictions to run mean matching. - - Returns - ------- - list of objectives. - """ - objs = [] - for objective, obj_args in self.objective_args.items(): - if "candidate_preds" in obj_args: - objs.append(objective) - return objs - - def get_mean_match_args(self, objective): - """ - Determine what arguments we need to procure for a mean matching function. - - Parameters - ---------- - objective: str - The objective of the model that will create the candidate - and bachelor predictions. - - Returns - ------- - list of arguments required by this objectives mean matching function. - """ - try: - obj_args = self.objective_args[objective] - - except: - raise ValueError( - f"Could not get mean matching args for objective {objective}" - + "Add this objective to the MeanMatchSchema by using .set_mean_match_function()" - ) - - return obj_args - - def model_predict(self, model, data, dtype=None): - """ - Get the predictions from a model on data using the - internal prediction functions. - - Parameters - ---------- - model: Booster - The model - - data: pd.DataFrame or np.array - The data to get predictions for - - dtype: string or np.datatype - Returns prediction as this datatype. - Datatypes are kept track of internally, however - you can overwrite the data type with this parameter. - - Returns - ------- - np.ndarray of predictions - - """ - objective = model.params["objective"] - if dtype is None: - dtype = self.objective_pred_dtypes[objective] - pred_func = self.objective_pred_funcs[objective] - preds = pred_func(model=model, data=data).astype(dtype) - return preds - - def _mean_match(self, variable, objective, **kwargs): - """ - Perform mean matching - - Parameters - ---------- - variable: int - The variable being imputed - - objective: str - The lightgbm objective used to create predictions for - the variable. - - kwargs - miceforest will automatically determine which objects - need to be generated based on the mean matching function - arguments. These arguments are passed as kwargs. - - Returns - ------- - np.ndarray of imputation values. - - """ - obj_args = self.objective_args[objective] - mmf = self.mean_match_functions[objective] - mmc = self.mean_match_candidates[variable] - if "mean_match_candidates" in obj_args: - kwargs["mean_match_candidates"] = mmc - - for oa in obj_args: - assert oa in list( - kwargs - ), f"objective {objective} requires {oa}, but it wasn't passed." - - mmf_args = {arg: val for arg, val in kwargs.items() if arg in obj_args} - imp_values = mmf(**mmf_args) - return imp_values diff --git a/miceforest/__init__.py b/miceforest/__init__.py index 57beced..35942ce 100644 --- a/miceforest/__init__.py +++ b/miceforest/__init__.py @@ -10,22 +10,14 @@ from .utils import ampute_data, load_kernel -from .ImputedData import ImputedData -from .ImputationKernel import ImputationKernel -from .builtin_mean_match_schemes import ( - mean_match_default, - mean_match_fast_cat, - mean_match_shap, -) +from .ImputedData import ImputedPandasDataFrame +from .impute import ImputationKernel -__version__ = "5.7.0" +# __version__ = "5.7.0" __all__ = [ - "ImputedData", + "ImputedPandasDataFrame", "ImputationKernel", - "mean_match_default", - "mean_match_fast_cat", - "mean_match_shap", "ampute_data", "load_kernel", ] diff --git a/miceforest/builtin_mean_match_functions.py b/miceforest/builtin_mean_match_functions.py deleted file mode 100644 index 851fa93..0000000 --- a/miceforest/builtin_mean_match_functions.py +++ /dev/null @@ -1,219 +0,0 @@ -import numpy as np - -try: - from scipy.spatial import KDTree -except ImportError: - raise ImportError( - "scipy.spatial.KDTree is required for " + "the default mean matching function." - ) - - -def _to_2d(x): - if x.ndim == 1: - x.shape = (-1, 1) - - -def _mean_match_reg( - mean_match_candidates, - bachelor_preds, - candidate_preds, - candidate_values, - random_state, - hashed_seeds, -): - """ - Determines the values of candidates which will be used to impute the bachelors - """ - - if mean_match_candidates == 0: - imp_values = bachelor_preds - - else: - _to_2d(bachelor_preds) - _to_2d(candidate_preds) - - num_bachelors = bachelor_preds.shape[0] - - # balanced_tree = False fixes a recursion issue for some reason. - # https://github.com/scipy/scipy/issues/14799 - kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) - _, knn_indices = kd_tree.query( - bachelor_preds, k=mean_match_candidates, workers=-1 - ) - - # We can skip the random selection process if mean_match_candidates == 1 - if mean_match_candidates == 1: - index_choice = knn_indices - - else: - # Use the random_state if seed_array was not passed. Faster - if hashed_seeds is None: - ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) - # Use the random_seed_array if it was passed. Deterministic. - else: - ind = hashed_seeds % mean_match_candidates - - index_choice = knn_indices[np.arange(num_bachelors), ind] - - imp_values = np.array(candidate_values)[index_choice] - - return imp_values - - -def _mean_match_binary_accurate( - mean_match_candidates, - bachelor_preds, - candidate_preds, - candidate_values, - random_state, - hashed_seeds, -): - """ - Determines the values of candidates which will be used to impute the bachelors - """ - - if mean_match_candidates == 0: - imp_values = np.floor(bachelor_preds + 0.5) - - else: - _to_2d(bachelor_preds) - _to_2d(candidate_preds) - - num_bachelors = bachelor_preds.shape[0] - - # balanced_tree = False fixes a recursion issue for some reason. - # https://github.com/scipy/scipy/issues/14799 - kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) - _, knn_indices = kd_tree.query( - bachelor_preds, k=mean_match_candidates, workers=-1 - ) - - # We can skip the random selection process if mean_match_candidates == 1 - if mean_match_candidates == 1: - index_choice = knn_indices - - else: - # Use the random_state if seed_array was not passed. Faster - if hashed_seeds is None: - ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) - # Use the random_seed_array if it was passed. Deterministic. - else: - ind = hashed_seeds % mean_match_candidates - - index_choice = knn_indices[np.arange(num_bachelors), ind] - - imp_values = np.array(candidate_values)[index_choice] - - return imp_values - - -def _mean_match_binary_fast( - mean_match_candidates, bachelor_preds, random_state, hashed_seeds -): - """ - Chooses 0/1 randomly based on probability obtained from prediction. - If mean_match_candidates is 0, choose class with highest probability. - """ - if mean_match_candidates == 0: - imp_values = np.floor(bachelor_preds + 0.5) - - else: - num_bachelors = bachelor_preds.shape[0] - if hashed_seeds is None: - imp_values = random_state.binomial(n=1, p=bachelor_preds) - else: - imp_values = [] - for i in range(num_bachelors): - np.random.seed(seed=hashed_seeds[i]) - imp_values.append(np.random.binomial(n=1, p=bachelor_preds[i])) - - imp_values = np.array(imp_values) - - return imp_values - - -def _mean_match_multiclass_fast( - mean_match_candidates, bachelor_preds, random_state, hashed_seeds -): - """ - If mean_match_candidates is 0, choose class with highest probability. - Otherwise, randomly choose class weighted by class probabilities. - """ - if mean_match_candidates == 0: - imp_values = np.argmax(bachelor_preds, axis=1) - - else: - num_bachelors = bachelor_preds.shape[0] - - # Turn bachelor_preds into discrete cdf: - bachelor_preds = bachelor_preds.cumsum(axis=1) - - # Randomly choose uniform numbers 0-1 - if hashed_seeds is None: - # This is the fastest way to adjust for numeric - # imprecision of float16 dtype. Actually ends up - # barely taking any time at all. - bp_dtype = bachelor_preds.dtype - unif = np.minimum( - random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype), - bachelor_preds[:, -1], - ) - else: - unif = [] - for i in range(num_bachelors): - np.random.seed(seed=hashed_seeds[i]) - unif.append(np.random.uniform(0, 1, size=1)[0]) - unif = np.array(unif) - - # Choose classes according to their cdf. - # Distribution will match probabilities - imp_values = np.array( - [ - np.searchsorted(bachelor_preds[i, :], unif[i]) - for i in range(num_bachelors) - ] - ) - - return imp_values - - -def _mean_match_multiclass_accurate( - mean_match_candidates, - bachelor_preds, - candidate_preds, - candidate_values, - random_state, - hashed_seeds, -): - """ - Performs nearest neighbors search on class probabilities. - """ - if mean_match_candidates == 0: - imp_values = np.argmax(bachelor_preds, axis=1) - - else: - _to_2d(bachelor_preds) - _to_2d(candidate_preds) - - num_bachelors = bachelor_preds.shape[0] - kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) - _, knn_indices = kd_tree.query( - bachelor_preds, k=mean_match_candidates, workers=-1 - ) - - # We can skip the random selection process if mean_match_candidates == 1 - if mean_match_candidates == 1: - index_choice = knn_indices - - else: - # Come up with random numbers 0-mean_match_candidates, with priority given to hashed_seeds - if hashed_seeds is None: - ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) - else: - ind = hashed_seeds % mean_match_candidates - - index_choice = knn_indices[np.arange(knn_indices.shape[0]), ind] - - imp_values = np.array(candidate_values)[index_choice] - - return imp_values diff --git a/miceforest/impute.py b/miceforest/impute.py new file mode 100644 index 0000000..aea842a --- /dev/null +++ b/miceforest/impute.py @@ -0,0 +1,1868 @@ + +from miceforest.default_lightgbm_parameters import default_parameters, make_default_tuning_space +from miceforest.logger import Logger +from miceforest.ImputedData import ImputedPandasDataFrame +from miceforest.utils import ( + _expand_value_to_dict, + _list_union, + _assert_dataset_equivalent, + _draw_random_int32, + ensure_rng, + hash_int32, + stratified_categorical_folds, + stratified_continuous_folds, + stratified_subset, +) +import numpy as np +from warnings import warn +from lightgbm import train, Dataset, cv, log_evaluation, early_stopping, Booster +from lightgbm.basic import _ConfigAliases +from io import BytesIO +import blosc2 +import dill +from copy import copy +from typing import Union, List, Dict, Any, Optional, Tuple +from pandas import Series, DataFrame + + +_DEFAULT_DATA_SUBSET = 0 +_DEFAULT_MEANMATCH_CANDIDATES = 5 +_DEFAULT_MEANMATCH_STRATEGY = 'accurate' + + + +class ImputationKernelPandas(ImputedPandasDataFrame): + """ + Creates a kernel dataset. This dataset can perform MICE on itself, + and impute new data from models obtained during MICE. + + Parameters + ---------- + data : np.ndarray or pandas DataFrame. + + .. code-block:: text + + The data to be imputed. + + variable_schema : None or list or dict, default=None + + .. code-block:: text + + Specifies the feature - target relationships used to train models. + This parameter also controls which models are built. Models can be built + even if a variable contains no missing values, or is not being imputed + (train_nonmissing must be set to True). + + - If None, all columns will be used as features in the training of each model. + - If list, all columns in data are used to impute the variables in the list + - If dict the values will be used to impute the keys. Can be either column + indices or names (if data is a pd.DataFrame). + + No models will be trained for variables not specified by variable_schema + (either by None, a list, or in dict keys). + + imputation_order: str, list[str], list[int], default="ascending" + + .. code-block:: text + + The order the imputations should occur in. If a string from the + items below, all variables specified by variable_schema with + missing data are imputed: + ascending: variables are imputed from least to most missing + descending: most to least missing + roman: from left to right in the dataset + arabic: from right to left in the dataset. + If a list is provided: + - the variables will be imputed in that order. + - only variables with missing values should be included in the list. + - must be a subset of variables specified by variable_schema. + If a variable with missing values is in variable_schema, but not in + imputation_order, then models to impute that variable will be trained, + but the actual values will not be imputed. See examples for details. + + data_subset: None or int or float or dict. + + .. code-block:: text + + Subsets the data used in each iteration, which can save a significant amount of time. + This can also help with memory consumption, as the candidate data must be copied to + make a feature dataset for lightgbm. + + The number of rows used for each variable is (# rows in raw data) - (# missing variable values) + for each variable. data_subset takes a random sample of this. + + If float, must be 0.0 < data_subset <= 1.0. Interpreted as a percentage of available candidates + If int must be data_subset >= 0. Interpreted as the number of candidates. + If 0, no subsetting is done. + If dict, keys must be variable names, and values must follow two above rules. + + It is recommended to carefully select this value for each variable if dealing + with very large data that barely fits into memory. + + mean_match_scheme: Dict, default = None + + .. code-block:: text + + An instance of the miceforest.MeanMatchScheme class. + + If None is passed, a sensible default scheme is used. There are multiple helpful + schemes that can be accessed from miceforest.builtin_mean_match_schemes, or + you can build your own. + + A description of the defaults: + - mean_match_default (default, if mean_match_scheme is None)) + This scheme is has medium speed and accuracy for most data. + + Categorical: + If mmc = 0, the class with the highest probability is chosen. + If mmc > 0, get N nearest neighbors from class probabilities. + Select 1 at random. + Numeric: + If mmc = 0, the predicted value is used + If mmc > 0, obtain the mmc closest candidate + predictions and collect the associated + real candidate values. Choose 1 randomly. + + - mean_match_shap + This scheme is the most accurate, but takes the longest. + It works the same as mean_match_default, except all nearest + neighbor searches are performed on the shap values of the + predictions, instead of the predictions themselves. + + - mean_match_scheme_fast_cat: + This scheme is faster for categorical variables, + but may be less accurate as well.. + + Categorical: + If mmc = 0, the class with the highest probability is chosen. + If mmc > 0, return class based on random draw weighted by + class probability for each sample. + Numeric or binary: + If mmc = 0, the predicted value is used + If mmc > 0, obtain the mmc closest candidate + predictions and collect the associated + real candidate values. Choose 1 randomly. + + categorical_feature: str or list, default="auto" + + .. code-block:: text + + The categorical features in the dataset. This handling depends on class of impute_data: + + pandas DataFrame: + - "auto": categorical information is inferred from any columns with + datatype category or object. + - list of column names (or indices): Useful if all categorical columns + have already been cast to numeric encodings of some type, otherwise you + should just use "auto". Will throw an error if a list is provided AND + categorical dtypes exist in data. If a list is provided, values in the + columns must be consecutive integers starting at 0, as required by lightgbm. + + numpy ndarray: + - "auto": no categorical information is stored. + - list of column indices: Specified columns are treated as categorical. Column + values must be consecutive integers starting at 0, as required by lightgbm. + + initialize_empty: bool, default = False + + .. code-block:: text + + If True, missing data is not filled in randomly before model training starts. + LightGBM is capable of learning from missing data - this might result in + faster convergence, or data leakage, depending on the data passed in. + + save_all_iterations: boolean, optional(default=True) + + .. code-block:: text + + Save all the imputation values from all iterations, or just + the latest. Saving all iterations allows for additional + plotting, but may take more memory + + save_models: int + + .. code-block:: text + + Which models should be saved: + = 0: no models are saved. Cannot get feature importance or + impute new data. + = 1: only the last model iteration is saved. Can only get + feature importance of last iteration. New data is + imputed using the last model for all specified iterations. + This is only an issue if data is heavily Missing At Random. + = 2: all model iterations are saved. Can get feature importance + for any iteration. When imputing new data, each iteration is + imputed using the model obtained at that iteration in mice. + This allows for imputations that most closely resemble those + that would have been obtained in mice. + + copy_data: boolean (default = False) + + .. code-block:: text + + Should the dataset be referenced directly? If False, this will cause + the dataset to be altered in place. If a copy is created, it is saved + in self.working_data. There are different ways in which the dataset + can be altered: + + 1) complete_data() will fill in missing values + 2) To save space, mice() references and manipulates self.working_data directly. + If self.working_data is a reference to the original dataset, the original + dataset will undergo these manipulations during the mice process. + At the end of the mice process, missing values will be set back to np.NaN + where they were originally missing. + + save_loggers: boolean (default = False) + + .. code-block:: text + + A logger is created each time mice() or impute_new_data() is called. + If True, the loggers are stored in a list ImputationKernel.loggers. + If you wish to start saving logs, call ImputationKernel.start_logging(). + If you wish to stop saving logs, call ImputationKernel.stop_logging(). + + random_state: None,int, or numpy.random.RandomState + + .. code-block:: text + + The random_state ensures script reproducibility. It only ensures reproducible + results if the same script is called multiple times. It does not guarantee + reproducible results at the record level, if a record is imputed multiple + different times. If reproducible record-results are desired, a seed must be + passed for each record in the random_seed_array parameter. + + """ + + def __init__( + self, + data: DataFrame, + num_datasets: int = 1, + variable_schema: Union[List[str], Dict[str, str]] = None, + imputation_order: str = "ascending", + mean_match_candidates: Union[int, Dict[str, int]] = _DEFAULT_MEANMATCH_CANDIDATES, + mean_match_strategy: Optional[Union[str, Dict[str, str]]] = _DEFAULT_MEANMATCH_STRATEGY, + data_subset: Union[int, Dict[str, int]] = _DEFAULT_DATA_SUBSET, + initialize_empty: bool = False, + save_all_iterations_data: bool = True, + copy_data: bool = True, + random_state: Optional[Union[int, np.random.RandomState]] = None, + verbose: bool = False + ): + super().__init__( + impute_data=data, + num_datasets=num_datasets, + variable_schema=variable_schema, + imputation_order=imputation_order, + copy_data=copy_data, + ) + + self.initialize_empty = initialize_empty + self.save_all_iterations_data = save_all_iterations_data + self.logger = Logger(verbose=verbose) + + # Models are stored in a dict, keys are (variable, dataset, iteration) + self.models: Dict[Tuple[str, int, int], Booster] = {} + + # Candidate preds are stored the same as models. + self.candidate_preds: Dict[Tuple[str, int, int], Series] = [{}] + + # Optimal parameters can only be found on 1 dataset at the current iteration. + self.optimal_parameters: Dict[str, Dict[str, Any]] = {} + + # Determine available candidates and interpret data subset. + available_candidates = { + v: (self.data_shape[0] - self.na_counts[v]) + for v in self.model_training_order + } + data_subset = _expand_value_to_dict( + _DEFAULT_DATA_SUBSET, + data_subset, + keys=self.model_training_order + ) + for col in self.model_training_order: + assert data_subset[col] <= available_candidates[col], ( + f'data_subset is more than available candidates for {col}' + ) + self.available_candidates = available_candidates + self.data_subset = data_subset + + # Collect category information. + categorical_columns: List[str] = [ + var for var, dtype in self.working_data.dtypes.items() + if dtype.name == "category" + ] + category_counts = { + col: len(self.working_data[col].cat.categories) + for col in categorical_columns + } + numeric_columns = [ + col for col in self.working_data.columns + if col not in categorical_columns + ] + binary_columns = [ + col for col, count in category_counts.items() + if count == 2 + ] + # Determine which columns should be binary instead of numeric: + for col in numeric_columns: + unique_values = self.working_data.drop_duplicates().dropna().astype('float64') + if {0.0, 1.0} == set(unique_values): + binary_columns.append(col) + numeric_columns.remove(col) + + self.modeled_categorical_columns = _list_union(categorical_columns, self.model_training_order) + self.modeled_numeric_columns = _list_union(numeric_columns, self.model_training_order) + self.modeled_binary_columns = _list_union(binary_columns, self.model_training_order) + + # Make sure all pandas categorical levels are used. + rare_level_cols = [] + for col in self.modeled_categorical_columns: + value_counts = data[col].value_counts(normalize=True) + if np.any(value_counts < 0.002): + rare_level_cols.append(col) + if rare_level_cols: + warn( + f"{','.join(rare_level_cols)} have very rare categories, it is a good " + "idea to group these, or set the min_data_in_leaf parameter to prevent " + "lightgbm from outputting 0.0 probabilities." + ) + + self.mean_match_candidates = _expand_value_to_dict( + _DEFAULT_MEANMATCH_CANDIDATES, + mean_match_candidates, + self.model_training_order + ) + self.mean_match_strategy = _expand_value_to_dict( + _DEFAULT_MEANMATCH_STRATEGY, + mean_match_strategy, + self.model_training_order + ) + + # Manage randomness + self._completely_random_kernel = random_state is None + self._random_state = ensure_rng(random_state) + + # Set initial imputations (iteration 0). + self._initialize_dataset( + self, random_state=self._random_state, random_seed_array=None + ) + + def __repr__(self): + summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self._ids_info()}' + return summary_string + + def _initialize_random_seed_array(self, random_seed_array, expected_shape): + """ + Formats and takes the first hash of the random_seed_array. + """ + + # Format random_seed_array if it was passed. + if random_seed_array is not None: + if self._completely_random_kernel: + warn( + 'This kernel is completely random (no random_state was provided on ' + 'initialization). Values imputed using self.impute_new_data() will be ' + 'deterministic, however the kernel itself is non-reproducible.' + ) + assert isinstance(random_seed_array, np.ndarray) + assert ( + random_seed_array.dtype.name == "int32" + ), "random_seed_array must be a np.ndarray of type int32" + assert ( + random_seed_array.shape[0] == expected_shape + ), "random_seed_array must be the same length as data." + random_seed_array = hash_int32(random_seed_array) + else: + random_seed_array = None + + return random_seed_array + + def _initialize_dataset(self, imputed_data, random_state, random_seed_array): + """ + Sets initial imputation values for iteration 0. + If "random", draw values from the working data at random. + If "empty", keep the values missing, since missing values + can be handled natively by lightgbm. + """ + + assert not imputed_data.initialized, "dataset has already been initialized" + + if self.initialize_empty : + for var in imputed_data.imputation_order: + for ds in range(imputed_data.dataset_count()): + # Saves space, since np.nan will be broadcast. + imputed_data[ds, var, 0] = np.array([np.nan]) + else: + for var in imputed_data.imputation_order: + # Pulls from the kernel working data + candidate_values = self._get_nonmissing_values(var) + candidate_num = candidate_values.shape[0] + + # Pulls from the ImputedData + missing_ind = imputed_data.na_where[var] + missing_num = imputed_data.na_counts[var] + + for ds in range(imputed_data.dataset_count()): + # Initialize using the random_state if no record seeds were passed. + if random_seed_array is None: + imputation_values = ( + candidate_values + .sample(n=missing_num, replace=True, random_state=random_state) + .reindex(missing_ind) + ) + imputed_data[var, ds, 0] = imputation_values + else: + assert ( + len(random_seed_array) == imputed_data.data_shape[0] + ), "The random_seed_array did not match the number of rows being imputed." + selection_ind = random_seed_array[missing_ind] % candidate_num + init_imps = candidate_values.iloc[selection_ind].reindex(missing_ind) + imputed_data[var, ds, 0] = init_imps + random_seed_array[missing_ind] = hash_int32( + random_seed_array[missing_ind] + ) + + imputed_data.initialized = True + + def _reconcile_parameters(self, defaults, user_supplied): + """ + Checks in user_supplied for aliases of each parameter in defaults. + Combines the dicts once the aliases have been reconciled. + """ + params = defaults.copy() + for par, val in defaults.items(): + alias_names = _ConfigAliases.get(par) + user_supplied_aliases = [ + i for i in alias_names if i in list(user_supplied) and i != par + ] + if len(user_supplied_aliases) == 0: + continue + elif len(user_supplied_aliases) == 1: + params[par] = user_supplied.pop(user_supplied_aliases[0]) + else: + raise ValueError( + f"Supplied 2 aliases for the same parameter: {user_supplied_aliases}" + ) + + params.update(user_supplied) + + return params + + def _format_variable_parameters( + self, variable_parameters: Optional[Dict] + ) -> Dict[int, Any]: + """ + Unpacking will expect an empty dict at a minimum. + This function collects parameters if they were + provided, and returns empty dicts if they weren't. + """ + if variable_parameters is None: + vsp: Dict[int, Any] = {var: {} for var in self.variable_training_order} + + else: + for variable in list(variable_parameters): + variable_parameters[ + self._get_var_ind_from_scalar(variable) + ] = variable_parameters.pop(variable) + vsp_vars = set(variable_parameters) + + assert vsp_vars.issubset( + self.variable_training_order + ), "Some variable_parameters are not associated with models being trained." + vsp = { + var: variable_parameters[var] if var in vsp_vars else {} + for var in self.variable_training_order + } + + return vsp + + def _get_lgb_params(self, var, vsp, random_state, **kwlgb): + """ + Builds the parameters for a lightgbm model. Infers objective based on + datatype of the response variable, assigns a random seed, finds + aliases in the user supplied parameters, and returns a final dict. + + Parameters + ---------- + var: int + The variable to be modeled + + vsp: dict + Variable specific parameters. These are supplied by the user. + + random_state: np.random.RandomState + The random state to use (used to set the seed). + + kwlgb: dict + Any additional parameters that should take presidence + over the defaults or user supplied. + """ + + seed = _draw_random_int32(random_state, size=1)[0] + + if var in self.categorical_variables: + n_c = self.category_counts[var] + if n_c > 2: + obj = {"objective": "multiclass", "num_class": n_c} + else: + obj = {"objective": "binary"} + else: + obj = {"objective": "regression"} + + default_lgb_params = {**default_parameters, **obj, "seed": seed} + + # Priority is [variable specific] > [global in kwargs] > [defaults] + params = self._reconcile_parameters(default_lgb_params, kwlgb) + params = self._reconcile_parameters(params, vsp) + + return params + + def _get_random_sample(self, parameters, random_state): + """ + Searches through a parameter set and selects a random + number between the values in any provided tuple of length 2. + """ + + parameters = parameters.copy() + for p, v in parameters.items(): + if hasattr(v, "__iter__"): + if isinstance(v, list): + parameters[p] = random_state.choice(v) + elif isinstance(v, tuple): + parameters[p] = random_state.uniform(v[0], v[1], size=1)[0] + else: + pass + parameters = self._make_params_digestible(parameters) + return parameters + + def _make_params_digestible(self, params): + """ + Cursory checks to force parameters to be digestible + """ + + int_params = [ + "num_leaves", + "min_data_in_leaf", + "num_threads", + "max_depth", + "num_iterations", + "bagging_freq", + "max_drop", + "min_data_per_group", + "max_cat_to_onehot", + ] + params = { + key: int(val) if key in int_params else val for key, val in params.items() + } + return params + + def _get_oof_performance( + self, parameters, folds, train_pointer, categorical_feature + ): + """ + Performance is gathered from built-in lightgbm.cv out of fold metric. + Optimal number of iterations is also obtained. + """ + + num_iterations = parameters.pop("num_iterations") + lgbcv = cv( + params=parameters, + train_set=train_pointer, + folds=folds, + num_boost_round=num_iterations, + categorical_feature=categorical_feature, + return_cvbooster=True, + callbacks=[ + early_stopping(stopping_rounds=10, verbose=False), + log_evaluation(period=0), + ], + ) + best_iteration = lgbcv["cvbooster"].best_iteration + loss_metric_key = list(lgbcv)[0] + loss = np.min(lgbcv[loss_metric_key]) + + return loss, best_iteration + + def _get_candidate_subset(self, column, subset_count, random_seed): + """ + Returns a reproducible subset index of the + non-missing values for a given variable. + """ + nonmissing_index = self._get_nonmissing_indx(var_indx) + + # Get the subset indices + if subset_count < len(nonmissing_index): + candidate_values = self._get_nonmissing_values(column) + candidates = candidate_values.shape[0] + groups = max(10, int(candidates / 1000)) + ss = stratified_subset( + y=candidate_values, + size=subset_count, + groups=groups, + seed=random_seed, + ) + candidate_subset = nonmissing_index[ss] + + else: + candidate_subset = nonmissing_index + + return candidate_subset + + def _get_nonmissing_subset_index(self, column, size, replace): + nonmissing_ind = self._get_nonmissing_index(column=column) + subset_ind = self._random_state.choice( + nonmissing_ind, + size=size, + replace=replace + ) + return subset_ind + + def _make_label(self, target_column, size): + """ + Returns a reproducible subset of the non-missing values of a variable. + """ + subset_index = self._get_nonmissing_subset_index(column=target_column, size=size) + label = self.working_data.loc[subset_index, target_column].copy() + return label + + def _make_features_label(self, target_column, size, random_seed): + """ + Makes a reproducible set of features and + target needed to train a lightgbm model. + """ + + subset_index = self._get_nonmissing_subset_index(column=target_column, size=size) + predictor_columns = self.variable_schema[target_column] + features = self.working_data.loc[subset_index, predictor_columns + [target_column]].copy() + label = features.pop(target_column) + return features, label + + # def append(self, imputation_kernel): + # """ + # Combine two imputation kernels together. + # For compatibility, the following attributes of each must be equal: + + # - working_data + # - iteration_count + # - categorical_feature + # - mean_match_scheme + # - variable_schema + # - imputation_order + # - save_models + # - save_all_iterations + + # Only cursory checks are done to ensure working_data is equal. + # Appending a kernel with different working_data could ruin this kernel. + + # Parameters + # ---------- + # imputation_kernel: ImputationKernel + # The kernel to merge. + + # """ + + # _assert_dataset_equivalent(self.working_data, imputation_kernel.working_data) + # assert self.iteration_count() == imputation_kernel.iteration_count() + # assert self.variable_schema == imputation_kernel.variable_schema + # assert self.imputation_order == imputation_kernel.imputation_order + # assert self.variable_training_order == imputation_kernel.variable_training_order + # assert self.categorical_feature == imputation_kernel.categorical_feature + # assert self.save_models == imputation_kernel.save_models + # assert self.save_all_iterations == imputation_kernel.save_all_iterations + # assert ( + # self.mean_match_scheme.objective_pred_dtypes + # == imputation_kernel.mean_match_scheme.objective_pred_dtypes + # ) + # assert ( + # self.mean_match_scheme.objective_pred_funcs + # == imputation_kernel.mean_match_scheme.objective_pred_funcs + # ) + # assert ( + # self.mean_match_scheme.objective_args + # == imputation_kernel.mean_match_scheme.objective_args + # ) + # assert ( + # self.mean_match_scheme.mean_match_candidates + # == imputation_kernel.mean_match_scheme.mean_match_candidates + # ) + + # current_datasets = self.dataset_count() + # new_datasets = imputation_kernel.dataset_count() + + # for key, model in imputation_kernel.models.items(): + # new_ds_indx = key[0] + current_datasets + # insert_key = new_ds_indx, key[1], key[2] + # self.models[insert_key] = model + + # for key, cp in imputation_kernel.candidate_preds.items(): + # new_ds_indx = key[0] + current_datasets + # insert_key = new_ds_indx, key[1], key[2] + # self.candidate_preds[insert_key] = cp + + # for key, iv in imputation_kernel.imputation_values.items(): + # new_ds_indx = key[0] + current_datasets + # self[new_ds_indx, key[1], key[2]] = iv + + # # Combine dicts + # for ds in range(new_datasets): + # insert_index = current_datasets + ds + # self.optimal_parameters[ + # insert_index + # ] = imputation_kernel.optimal_parameters[ds] + # self.optimal_parameter_losses[ + # insert_index + # ] = imputation_kernel.optimal_parameter_losses[ds] + + # # Append iterations + # self.iterations = np.append( + # self.iterations, imputation_kernel.iterations, axis=0 + # ) + + def compile_candidate_preds(self): + """ + Candidate predictions can be pre-generated before imputing new data. + This can save a substantial amount of time, especially if save_models == 1. + """ + + compile_objectives = ( + self.mean_match_scheme.get_objectives_requiring_candidate_preds() + ) + + for key, model in self.models.items(): + already_compiled = key in self.candidate_preds.keys() + objective = model.params["objective"] + if objective in compile_objectives and not already_compiled: + var = key[1] + candidate_features, _, _ = self._make_features_label( + variable=var, + subset_count=self.data_subset[var], + random_seed=model.params["seed"], + ) + self.candidate_preds[key] = self.mean_match_scheme.model_predict( + model, candidate_features + ) + + else: + continue + + def delete_candidate_preds(self): + """ + Deletes the pre-computed candidate predictions. + """ + + self.candidate_preds = {} + + def fit(self, X, y, **fit_params): + """ + Method for fitting a kernel when used in a sklearn pipeline. + Should not be called by the user directly. + """ + + assert self.dataset_count() == 1, ( + "miceforest kernel should be initialized with datasets=1 if " + + "being used in a sklearn pipeline." + ) + _assert_dataset_equivalent(self.working_data, X), ( + "The dataset passed to fit() was not the same as the " + "dataset passed to ImputationKernel()" + ) + self.mice(**fit_params) + return self + + def get_model( + self, dataset: int, variable: Union[str, int], iteration: Optional[int] = None + ): + """ + Return the model for a specific dataset, variable, iteration. + + Parameters + ---------- + dataset: int + The dataset to return the model for. + + var: str + The variable that was imputed + + iteration: int + The model iteration to return. Keep in mind if save_models ==1, + the model was not saved. If none is provided, the latest model + is returned. + + Returns: lightgbm.Booster + The model used to impute this specific variable, iteration. + """ + + var_indx = self._get_var_ind_from_scalar(variable) + itrn = ( + self.iteration_count(datasets=dataset, variables=var_indx) + if iteration is None + else iteration + ) + try: + return self.models[dataset, var_indx, itrn] + except Exception: + raise ValueError("Could not find model.") + + def get_raw_prediction( + self, + variable: Union[int, str], + imp_dataset: int = 0, + imp_iteration: Optional[int] = None, + model_dataset: Optional[int] = None, + model_iteration: Optional[int] = None, + dtype: Union[str, np.dtype, None] = None, + ): + """ + Get the raw model output for a specific variable. + + The data is pulled from the imp_dataset dataset, at the imp_iteration iteration. + The model is pulled from model_dataset dataset, at the model_iteration iteration. + + So, for example, it is possible to get predictions using the imputed values for + dataset 3, at iteration 2, using the model obtained from dataset 10, at iteration + 6. This is assuming desired iterations and models have been saved. + + Parameters + ---------- + variable: int or str + The variable to get the raw predictions for. + Can be an index or variable name. + + imp_dataset: int + The imputation dataset to use when creating the feature dataset. + + imp_iteration: int + The iteration from which to draw the imputation values when + creating the feature dataset. If None, the latest iteration + is used. + + model_dataset: int + The dataset from which to pull the trained model for this variable. + If None, it is selected to be the same as imp_dataset. + + model_iteration: int + The iteration from which to pull the trained model for this variable + If None, it is selected to be the same as imp_iteration. + + dtype: str, np.dtype + The datatype to cast the raw prediction as. + Passed to MeanMatchScheme.model_predict(). + + Returns + ------- + np.ndarray of raw predictions. + + """ + + var_indx = self._get_var_ind_from_scalar(variable) + predictor_variables = self.variable_schema[var_indx] + + # Get the latest imputation iteration if imp_iteration was not specified + if imp_iteration is None: + imp_iteration = self.iteration_count( + datasets=imp_dataset, variables=var_indx + ) + + # If model dataset / iteration wasn't specified, assume it is from the same + # dataset / iteration we are pulling the imputation values from + model_iteration = imp_iteration if model_iteration is None else model_iteration + model_dataset = imp_dataset if model_dataset is None else model_dataset + + # Get our internal dataset ready + self.complete_data(dataset=imp_dataset, iteration=imp_iteration, inplace=True) + + features = _subset_data(self.working_data, col_ind=predictor_variables) + model = self.get_model(model_dataset, var_indx, iteration=model_iteration) + preds = self.mean_match_scheme.model_predict(model, features, dtype=dtype) + + return preds + + def mice( + self, + iterations: int, + verbose: bool = False, + variable_parameters: Dict[str, Any] = None, + compile_candidates: bool = False, + **kwlgb, + ): + """ + Perform mice on a given dataset. + + Multiple Imputation by Chained Equations (MICE) is an + iterative method which fills in (imputes) missing data + points in a dataset by modeling each column using the + other columns, and then inferring the missing data. + + For more information on MICE, and missing data in + general, see Stef van Buuren's excellent online book: + https://stefvanbuuren.name/fimd/ch-introduction.html + + For detailed usage information, see this project's + README on the github repository: + https://github.com/AnotherSamWilson/miceforest + + Parameters + ---------- + iterations: int + The number of iterations to run. + + verbose: bool + Should information about the process be printed? + + variable_parameters: None or dict + Model parameters can be specified by variable here. Keys should + be variable names or indices, and values should be a dict of + parameter which should apply to that variable only. + + compile_candidates: bool + Candidate predictions can be stored as they are created while + performing mice. This prevents kernel.compile_candidate_preds() + from having to be called separately, and can save a significant + amount of time if compiled candidate predictions are desired. + + kwlgb: + Additional arguments to pass to lightgbm. Applied to all models. + + """ + + __MICE_TIMED_EVENTS = ["prepare_xy", "training", "predict", "mean_matching"] + iter_pairs = self._iter_pairs(iterations) + + # Delete models and candidate_preds if we shouldn't be saving every iteration + if self.save_models < 2: + self.models = {} + self.candidate_preds = {} + + logger = Logger( + name=f"mice {str(iter_pairs[0][0])}-{str(iter_pairs[-1][0])}", + verbose=verbose, + ) + + vsp = self._format_variable_parameters(variable_parameters) + + for ds in range(self.dataset_count()): + logger.log("Dataset " + str(ds)) + + # set self.working_data to the most current iteration. + self.complete_data(dataset=ds, inplace=True) + last_iteration = False + + for iter_abs, iter_rel in iter_pairs: + logger.log(str(iter_abs) + " ", end="") + if iter_rel == iterations: + last_iteration = True + save_model = self.save_models == 2 or ( + last_iteration and self.save_models == 1 + ) + + for variable in self.variable_training_order: + var_name = self._get_var_name_from_scalar(variable) + logger.log(" | " + var_name, end="") + predictor_variables = self.variable_schema[variable] + data_subset = self.data_subset[variable] + nawhere = self.na_where[variable] + log_context = { + "dataset": ds, + "variable_name": var_name, + "iteration": iter_abs, + } + + # Define the lightgbm parameters + lgbpars = self._get_lgb_params( + variable, vsp[variable], self._random_state, **kwlgb + ) + objective = lgbpars["objective"] + + # These are necessary for building model in mice. + logger.set_start_time() + ( + candidate_features, + candidate_values, + feature_cat_index, + ) = self._make_features_label( + variable=variable, + subset_count=data_subset, + random_seed=lgbpars["seed"], + ) + if ( + self.original_data_class == "pd_DataFrame" + or len(feature_cat_index) == 0 + ): + feature_cat_index = "auto" + + # lightgbm requires integers for label. Categories won't work. + if candidate_values.dtype.name == "category": + candidate_values = candidate_values.cat.codes + + num_iterations = lgbpars.pop("num_iterations") + train_pointer = Dataset( + data=candidate_features, + label=candidate_values, + categorical_feature=feature_cat_index, + ) + logger.record_time(timed_event="prepare_xy", **log_context) + logger.set_start_time() + current_model = train( + params=lgbpars, + train_set=train_pointer, + num_boost_round=num_iterations, + categorical_feature=feature_cat_index, + ) + logger.record_time(timed_event="training", **log_context) + + if save_model: + self.models[ds, variable, iter_abs] = current_model + + # Only perform mean matching and insertion + # if variable is being imputed. + if variable in self.imputation_order: + mean_match_args = self.mean_match_scheme.get_mean_match_args( + objective + ) + + # Start creating kwargs for mean matching function + mm_kwargs = {} + + if "lgb_booster" in mean_match_args: + mm_kwargs["lgb_booster"] = current_model + + if {"bachelor_preds", "bachelor_features"}.intersection( + mean_match_args + ): + logger.set_start_time() + bachelor_features = _subset_data( + self.working_data, + row_ind=nawhere, + col_ind=predictor_variables, + ) + logger.record_time(timed_event="prepare_xy", **log_context) + if "bachelor_features" in mean_match_args: + mm_kwargs["bachelor_features"] = bachelor_features + + if "bachelor_preds" in mean_match_args: + logger.set_start_time() + bachelor_preds = self.mean_match_scheme.model_predict( + current_model, bachelor_features + ) + logger.record_time(timed_event="predict", **log_context) + mm_kwargs["bachelor_preds"] = bachelor_preds + + if "candidate_values" in mean_match_args: + mm_kwargs["candidate_values"] = candidate_values + + if "candidate_features" in mean_match_args: + mm_kwargs["candidate_features"] = candidate_features + + # Calculate the candidate predictions if + # the mean matching function calls for it + if "candidate_preds" in mean_match_args: + logger.set_start_time() + candidate_preds = self.mean_match_scheme.model_predict( + current_model, candidate_features + ) + logger.record_time(timed_event="predict", **log_context) + mm_kwargs["candidate_preds"] = candidate_preds + + if compile_candidates and save_model: + self.candidate_preds[ + ds, variable, iter_abs + ] = candidate_preds + + if "random_state" in mean_match_args: + mm_kwargs["random_state"] = self._random_state + + # Hashed seeds are only to ensure record reproducibility + # for impute_new_data(). + if "hashed_seeds" in mean_match_args: + mm_kwargs["hashed_seeds"] = None + + logger.set_start_time() + imp_values = self.mean_match_scheme._mean_match( + variable, objective, **mm_kwargs + ) + logger.record_time(timed_event="mean_matching", **log_context) + + assert imp_values.shape == ( + self.na_counts[variable], + ), f"{variable} mean matching returned malformed array" + + # Updates our working data and saves the imputations. + self._insert_new_data( + dataset=ds, variable_index=variable, new_data=imp_values + ) + + self.iterations[ + ds, self.variable_training_order.index(variable) + ] += 1 + + logger.log("\n", end="") + + self._ampute_original_data() + if self.save_loggers: + self.loggers.append(logger) + + def transform(self, X, y=None): + """ + Method for calling a kernel when used in a sklearn pipeline. + Should not be called by the user directly. + """ + + new_dat = self.impute_new_data(X, datasets=[0]) + return new_dat.complete_data(dataset=0, inplace=False) + + def tune_parameters( + self, + dataset: int, + variables: Union[List[int], List[str], None] = None, + variable_parameters: Optional[Dict[Any, Any]] = None, + parameter_sampling_method: str = "random", + nfold: int = 10, + optimization_steps: int = 5, + random_state: Optional[Union[int, np.random.RandomState]] = None, + verbose: bool = False, + **kwbounds, + ): + """ + Perform hyperparameter tuning on models at the current iteration. + + .. code-block:: text + + A few notes: + - Underlying models will now be gradient boosted trees by default (or any + other boosting type compatible with lightgbm.cv). + - The parameters are tuned on the data that would currently be returned by + complete_data(dataset). It is usually a good idea to run at least 1 iteration + of mice with the default parameters to get a more accurate idea of the + real optimal parameters, since Missing At Random (MAR) data imputations + tend to converge over time. + - num_iterations is treated as the maximum number of boosting rounds to run + in lightgbm.cv. It is NEVER optimized. The num_iterations that is returned + is the best_iteration returned by lightgbm.cv. num_iterations can be passed to + limit the boosting rounds, but the returned value will always be obtained + from best_iteration. + - lightgbm parameters are chosen in the following order of priority: + 1) Anything specified in variable_parameters + 2) Parameters specified globally in **kwbounds + 3) Default tuning space (miceforest.default_lightgbm_parameters.make_default_tuning_space) + 4) Default parameters (miceforest.default_lightgbm_parameters.default_parameters) + - See examples for a detailed run-through. See + https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters + for even more detailed examples. + + + Parameters + ---------- + + dataset: int (required) + + .. code-block:: text + + The dataset to run parameter tuning on. Tuning parameters on 1 dataset usually results + in acceptable parameters for all datasets. However, tuning results are still stored + seperately for each dataset. + + variables: None or list + + .. code-block:: text + + - If None, default hyper-parameter spaces are selected based on kernel data, and + all variables with missing values are tuned. + - If list, must either be indexes or variable names corresponding to the variables + that are to be tuned. + + variable_parameters: None or dict + + .. code-block:: text + + Defines the tuning space. Dict keys must be variable names or indices, and a subset + of the variables parameter. Values must be a dict with lightgbm parameter names as + keys, and values that abide by the following rules: + scalar: If a single value is passed, that parameter will be used to build the + model, and will not be tuned. + tuple: If a tuple is passed, it must have length = 2 and will be interpreted as + the bounds to search within for that parameter. + list: If a list is passed, values will be randomly selected from the list. + NOTE: This is only possible with method = 'random'. + + example: If you wish to tune the imputation model for the 4th variable with specific + bounds and parameters, you could pass: + variable_parameters = { + 4: { + 'learning_rate: 0.01', + 'min_sum_hessian_in_leaf: (0.1, 10), + 'extra_trees': [True, False] + } + } + All models for variable 4 will have a learning_rate = 0.01. The process will randomly + search within the bounds (0.1, 10) for min_sum_hessian_in_leaf, and extra_trees will + be randomly selected from the list. Also note, the variable name for the 4th column + could also be passed instead of the integer 4. All other variables will be tuned with + the default search space, unless **kwbounds are passed. + + parameter_sampling_method: str + + .. code-block:: text + + If 'random', parameters are randomly selected. + Other methods will be added in future releases. + + nfold: int + + .. code-block:: text + + The number of folds to perform cross validation with. More folds takes longer, but + Gives a more accurate distribution of the error metric. + + optimization_steps: + + .. code-block:: text + + How many steps to run the process for. + + random_state: int or np.random.RandomState or None (default=None) + + .. code-block:: text + + The random state of the process. Ensures reproduceability. If None, the random state + of the kernel is used. Beware, this permanently alters the random state of the kernel + and ensures non-reproduceable results, unless the entire process up to this point + is re-run. + + kwbounds: + + .. code-block:: text + + Any additional arguments that you want to apply globally to every variable. + For example, if you want to limit the number of iterations, you could pass + num_iterations = x to this functions, and it would apply globally. Custom + bounds can also be passed. + + + Returns + ------- + 2 dicts: optimal_parameters, optimal_parameter_losses + + - optimal_parameters: dict + A dict of the optimal parameters found for each variable. + This can be passed directly to the variable_parameters parameter in mice() + + .. code-block:: text + + {variable: {parameter_name: parameter_value}} + + - optimal_parameter_losses: dict + The average out of fold cv loss obtained directly from + lightgbm.cv() associated with the optimal parameter set. + + .. code-block:: text + + {variable: loss} + + """ + + if random_state is None: + random_state = self._random_state + else: + random_state = ensure_rng(random_state) + + if variables is None: + variables = self.imputation_order + else: + variables = self._get_var_ind_from_list(variables) + + self.complete_data(dataset, inplace=True) + + logger = Logger( + name=f"tune: {optimization_steps}", + verbose=verbose, + ) + + vsp = self._format_variable_parameters(variable_parameters) + variable_parameter_space = {} + + for var in variables: + default_tuning_space = make_default_tuning_space( + self.category_counts[var] if var in self.categorical_variables else 1, + int((self.data_shape[0] - len(self.na_where[var])) / 10), + ) + + variable_parameter_space[var] = self._get_lgb_params( + var=var, + vsp={**kwbounds, **vsp[var]}, + random_state=random_state, + **default_tuning_space, + ) + + if parameter_sampling_method == "random": + for var, parameter_space in variable_parameter_space.items(): + logger.log(self._get_var_name_from_scalar(var) + " | ", end="") + + ( + candidate_features, + candidate_values, + feature_cat_index, + ) = self._make_features_label( + variable=var, + subset_count=self.data_subset[var], + random_seed=_draw_random_int32( + random_state=self._random_state, size=1 + )[0], + ) + + # lightgbm requires integers for label. Categories won't work. + if candidate_values.dtype.name == "category": + candidate_values = candidate_values.cat.codes + + is_categorical = var in self.categorical_variables + + for step in range(optimization_steps): + logger.log(str(step), end="") + + # Make multiple attempts to learn something. + non_learners = 0 + learning_attempts = 10 + while non_learners < learning_attempts: + # Pointer and folds need to be re-initialized after every run. + train_pointer = Dataset( + data=candidate_features, + label=candidate_values, + categorical_feature=feature_cat_index, + free_raw_data=False, + ) + if is_categorical: + folds = stratified_categorical_folds( + candidate_values, nfold + ) + else: + folds = stratified_continuous_folds(candidate_values, nfold) + sampling_point = self._get_random_sample( + parameters=parameter_space, random_state=random_state + ) + try: + loss, best_iteration = self._get_oof_performance( + parameters=sampling_point.copy(), + folds=folds, + train_pointer=train_pointer, + categorical_feature=feature_cat_index, + ) + except: + loss, best_iteration = np.Inf, 0 + + if best_iteration > 1: + break + else: + non_learners += 1 + + if loss < self.optimal_parameter_losses[dataset][var]: + del sampling_point["seed"] + sampling_point["num_iterations"] = best_iteration + self.optimal_parameters[dataset][var] = sampling_point + self.optimal_parameter_losses[dataset][var] = loss + + logger.log(" - ", end="") + + logger.log("\n", end="") + + self._ampute_original_data() + return ( + self.optimal_parameters[dataset], + self.optimal_parameter_losses[dataset], + ) + + def impute_new_data( + self, + new_data: _t_dat, + datasets: Optional[List[int]] = None, + iterations: Optional[int] = None, + save_all_iterations: bool = True, + copy_data: bool = True, + random_state: Optional[Union[int, np.random.RandomState]] = None, + random_seed_array: Optional[np.ndarray] = None, + verbose: bool = False, + ) -> ImputedPandasDataFrame: + """ + Impute a new dataset + + Uses the models obtained while running MICE to impute new data, + without fitting new models. Pulls mean matching candidates from + the original data. + + save_models must be > 0. If save_models == 1, the last model + obtained in mice is used for every iteration. If save_models > 1, + the model obtained at each iteration is used to impute the new + data for that iteration. If specified iterations is greater than + the number of iterations run so far using mice, the last model + is used for each additional iteration. + + Type checking is not done. It is up to the user to ensure that the + kernel data matches the new data being imputed. + + Parameters + ---------- + new_data: pandas DataFrame or numpy ndarray + The new data to impute + + datasets: int or List[int] (default = None) + The datasets from the kernel to use to impute the new data. + If None, all datasets from the kernel are used. + + iterations: int + The number of iterations to run. + If None, the same number of iterations run so far in mice is used. + + save_all_iterations: bool + Should the imputation values of all iterations be archived? + If False, only the latest imputation values are saved. + + copy_data: boolean + Should the dataset be referenced directly? This will cause the dataset to be altered + in place. If a copy is created, it is saved in self.working_data. There are different + ways in which the dataset can be altered: + + 1) complete_data() will fill in missing values + 2) mice() references and manipulates self.working_data directly. + + random_state: int or np.random.RandomState or None (default=None) + The random state of the process. Ensures reproducibility. If None, the random state + of the kernel is used. Beware, this permanently alters the random state of the kernel + and ensures non-reproduceable results, unless the entire process up to this point + is re-run. + + random_seed_array: None or np.ndarray (int32) + + .. code-block:: text + + Record-level seeds. + + Ensures deterministic imputations at the record level. random_seed_array causes + deterministic imputations for each record no matter what dataset each record is + imputed with, assuming the same number of iterations and datasets are used. + If random_seed_array os passed, random_state must also be passed. + + Record-level imputations are deterministic if the following conditions are met: + 1) The associated seed is the same. + 2) The same kernel is used. + 3) The same number of iterations are run. + 4) The same number of datasets are run. + + Notes: + a) This will slightly slow down the imputation process, because random + number generation in numpy can no longer be vectorized. If you don't have a + specific need for deterministic imputations at the record level, it is better to + keep this parameter as None. + + b) Using this parameter may change the global numpy seed by calling np.random.seed(). + + c) Internally, these seeds are hashed each time they are used, in order + to obtain different results for each dataset / iteration. + + + verbose: boolean + Should information about the process be printed? + + Returns + ------- + miceforest.ImputedData + + """ + + datasets = list(range(self.dataset_count())) if datasets is None else datasets + kernel_iterations = self.iteration_count() + iterations = kernel_iterations if iterations is None else iterations + iter_pairs = self._iter_pairs(iterations) + __IND_TIMED_EVENTS = ["prepare_xy", "predict", "mean_matching"] + logger = Logger( + name=f"ind {str(iter_pairs[0][1])}-{str(iter_pairs[-1][1])}", + verbose=verbose, + ) + + if isinstance(self.working_data, DataFrame): + assert isinstance(new_data, DataFrame) + assert set(self.working_data.columns) == set( + new_data.columns + ), "Different columns from original dataset." + assert all( + [ + self.working_data[col].dtype == new_data[col].dtype + for col in self.working_data.columns + ] + ), "Column types are not the same as the original data. Check categorical columns." + + if self.save_models < 1: + raise ValueError("No models were saved.") + + imputed_data = ImputedData( + impute_data=new_data, + datasets=len(datasets), + variable_schema=self.variable_schema.copy(), + imputation_order=self.variable_training_order.copy(), + train_nonmissing=False, + categorical_feature=self.categorical_feature, + save_all_iterations=save_all_iterations, + copy_data=copy_data, + ) + + ### Manage Randomness. + if random_state is None: + assert ( + random_seed_array is None + ), "random_state is also required when using random_seed_array" + random_state = self._random_state + else: + random_state = ensure_rng(random_state) + # use_seed_array = random_seed_array is not None + random_seed_array = self._initialize_random_seed_array( + random_seed_array=random_seed_array, + expected_shape=imputed_data.data_shape[0], + ) + self._initialize_dataset( + imputed_data, random_state=random_state, random_seed_array=random_seed_array + ) + + for ds_kern in datasets: + logger.log("Dataset " + str(ds_kern)) + self.complete_data(dataset=ds_kern, inplace=True) + ds_new = datasets.index(ds_kern) + imputed_data.complete_data(dataset=ds_new, inplace=True) + + for iter_abs, iter_rel in iter_pairs: + logger.log(str(iter_rel) + " ", end="") + + # Determine which model iteration to grab + if self.save_models == 1 or iter_abs > kernel_iterations: + iter_model = kernel_iterations + else: + iter_model = iter_abs + + for var in imputed_data.imputation_order: + var_name = self._get_var_name_from_scalar(var) + logger.log(" | " + var_name, end="") + log_context = { + "dataset": ds_kern, + "variable_name": var_name, + "iteration": iter_rel, + } + nawhere = imputed_data.na_where[var] + predictor_variables = self.variable_schema[var] + + # Select our model. + current_model = self.get_model( + variable=var, dataset=ds_kern, iteration=iter_model + ) + objective = current_model.params["objective"] + model_seed = current_model.params["seed"] + + # Start building mean matching kwargs + mean_match_args = self.mean_match_scheme.get_mean_match_args( + objective + ) + mm_kwargs = {} + + if "lgb_booster" in mean_match_args: + mm_kwargs["lgb_booster"] = current_model + + # Procure bachelor information + if {"bachelor_preds", "bachelor_features"}.intersection( + mean_match_args + ): + logger.set_start_time() + bachelor_features = _subset_data( + imputed_data.working_data, + row_ind=imputed_data.na_where[var], + col_ind=predictor_variables, + ) + logger.record_time(timed_event="prepare_xy", **log_context) + if "bachelor_features" in mean_match_args: + mm_kwargs["bachelor_features"] = bachelor_features + + if "bachelor_preds" in mean_match_args: + logger.set_start_time() + bachelor_preds = self.mean_match_scheme.model_predict( + current_model, bachelor_features + ) + logger.record_time(timed_event="predict", **log_context) + mm_kwargs["bachelor_preds"] = bachelor_preds + + # Procure candidate information + if { + "candidate_values", + "candidate_features", + "candidate_preds", + }.intersection(mean_match_args): + # Need to return candidate features if we need to calculate + # candidate_preds or candidate_features is needed by mean matching function + calculate_candidate_preds = ( + ds_kern, + var, + iter_model, + ) not in self.candidate_preds.keys() and "candidate_preds" in mean_match_args + return_features = ( + "candidate_features" in mean_match_args + ) or calculate_candidate_preds + # Set up like this so we only have to subset once + logger.set_start_time() + if return_features: + ( + candidate_features, + candidate_values, + _, + ) = self._make_features_label( + variable=var, + subset_count=self.data_subset[var], + random_seed=model_seed, + ) + else: + candidate_values = self._make_label( + variable=var, + subset_count=self.data_subset[var], + random_seed=model_seed, + ) + logger.record_time(timed_event="prepare_xy", **log_context) + + if "candidate_values" in mean_match_args: + # lightgbm requires integers for label. Categories won't work. + if candidate_values.dtype.name == "category": + candidate_values = candidate_values.cat.codes + mm_kwargs["candidate_values"] = candidate_values + + if "candidate_features" in mean_match_args: + mm_kwargs["candidate_features"] = candidate_features + + # Calculate the candidate predictions if + # the mean matching function calls for it + if "candidate_preds" in mean_match_args: + if calculate_candidate_preds: + logger.set_start_time() + candidate_preds = self.mean_match_scheme.model_predict( + current_model, candidate_features + ) + logger.record_time(timed_event="predict", **log_context) + else: + candidate_preds = self.candidate_preds[ + ds_kern, var, iter_model + ] + mm_kwargs["candidate_preds"] = candidate_preds + + if "random_state" in mean_match_args: + mm_kwargs["random_state"] = random_state + + if "hashed_seeds" in mean_match_args: + if isinstance(random_seed_array, np.ndarray): + seeds = random_seed_array[nawhere] + rehash_seeds = True + + else: + seeds = None + rehash_seeds = False + + mm_kwargs["hashed_seeds"] = seeds + + else: + rehash_seeds = False + + logger.set_start_time() + imp_values = self.mean_match_scheme._mean_match( + var, objective, **mm_kwargs + ) + logger.record_time(timed_event="mean_matching", **log_context) + imputed_data._insert_new_data( + dataset=ds_new, variable_index=var, new_data=imp_values + ) + # Refresh our seeds. + if rehash_seeds: + assert isinstance(random_seed_array, np.ndarray) + random_seed_array[nawhere] = hash_int32(seeds) + + imputed_data.iterations[ + ds_new, imputed_data.imputation_order.index(var) + ] += 1 + + logger.log("\n", end="") + + imputed_data._ampute_original_data() + if self.save_loggers: + self.loggers.append(logger) + + return imputed_data + + def start_logging(self): + """ + Start saving loggers to self.loggers + """ + + self.save_loggers = True + + def stop_logging(self): + """ + Stop saving loggers to self.loggers + """ + + self.save_loggers = False + + def save_kernel( + self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True + ): + """ + Compresses and saves the kernel to a file. + + Parameters + ---------- + filepath: str + The file to save to. + + clevel: int + The compression level, sent to clevel argument in blosc.compress() + + cname: str + The compression algorithm used. + Sent to cname argument in blosc.compress. + If None is specified, the default is lz4hc. + + n_threads: int + The number of threads to use for compression. + By default, all threads are used. + + copy_while_saving: boolean + Should the kernel be copied while saving? Copying is safer, but + may take more memory. + + """ + + clevel = 9 if clevel is None else clevel + cname = "lz4hc" if cname is None else cname + n_threads = blosc2.detect_number_of_cores() if n_threads is None else n_threads + + if copy_while_saving: + kernel = copy(self) + else: + kernel = self + + # convert working data to parquet bytes object + if kernel.original_data_class == "pd_DataFrame": + working_data_bytes = BytesIO() + kernel.working_data.to_parquet(working_data_bytes) + kernel.working_data = working_data_bytes + + blosc2.set_nthreads(n_threads) + + with open(filepath, "wb") as f: + dill.dump( + blosc2.compress( + dill.dumps(kernel), + clevel=clevel, + typesize=8, + shuffle=blosc2.NOSHUFFLE, + cname=cname, + ), + f, + ) + + def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: + """ + Return a matrix of feature importance. The cells + represent the normalized feature importance of the + columns to impute the rows. This is calculated + internally by lightgbm.Booster.feature_importance(). + + Parameters + ---------- + dataset: int + The dataset to get the feature importance for. + + iteration: int + The iteration to return the feature importance for. + Right now, the model must be saved to return importance + + Returns + ------- + np.ndarray of importance values. Rows are imputed variables, and + columns are predictor variables. + + """ + + if iteration is None: + iteration = self.iteration_count(datasets=dataset) + + importance_matrix = np.full( + shape=(len(self.imputation_order), len(self.predictor_vars)), + fill_value=np.NaN, + ) + + for ivar in self.imputation_order: + importance_dict = dict( + zip( + self.variable_schema[ivar], + self.get_model(dataset, ivar, iteration).feature_importance(), + ) + ) + for pvar in importance_dict: + importance_matrix[ + np.sort(self.imputation_order).tolist().index(ivar), + np.sort(self.predictor_vars).tolist().index(pvar), + ] = importance_dict[pvar] + + return importance_matrix + + def plot_feature_importance( + self, + dataset, + normalize: bool = True, + iteration: Optional[int] = None, + **kw_plot, + ): + """ + Plot the feature importance. See get_feature_importance() + for more details. + + Parameters + ---------- + dataset: int + The dataset to plot the feature importance for. + + iteration: int + The iteration to plot the feature importance of. + + normalize: book + Should the values be normalize from 0-1? + If False, values are raw from Booster.feature_importance() + + kw_plot + Additional arguments sent to sns.heatmap() + + """ + + # Move this to .compat at some point. + try: + from seaborn import heatmap + except ImportError: + raise ImportError("seaborn must be installed to plot importance") + + importance_matrix = self.get_feature_importance( + dataset=dataset, iteration=iteration + ) + if normalize: + importance_matrix = ( + importance_matrix / np.nansum(importance_matrix, 1).reshape(-1, 1) + ).round(2) + + imputed_var_names = [ + self._get_var_name_from_scalar(int(i)) + for i in np.sort(self.imputation_order) + ] + predictor_var_names = [ + self._get_var_name_from_scalar(int(i)) for i in np.sort(self.predictor_vars) + ] + + params = { + **{ + "cmap": "coolwarm", + "annot": True, + "fmt": ".2f", + "xticklabels": predictor_var_names, + "yticklabels": imputed_var_names, + "annot_kws": {"size": 16}, + }, + **kw_plot, + } + + print(heatmap(importance_matrix, **params)) diff --git a/miceforest/logger.py b/miceforest/logger.py index e4d9d9f..8163090 100644 --- a/miceforest/logger.py +++ b/miceforest/logger.py @@ -1,10 +1,15 @@ from .compat import pd_Series, pd_DataFrame, PANDAS_INSTALLED -from datetime import datetime as dt -from typing import Dict, Any +from datetime import datetime, timedelta +from typing import Dict, Any, List, Tuple, Optional class Logger: - def __init__(self, name: str, verbose: bool = False) -> None: + def __init__( + self, + name: str, + recording_levels: Tuple, + verbose: bool = False, + ) -> None: """ miceforest logger. @@ -24,8 +29,10 @@ def __init__(self, name: str, verbose: bool = False) -> None: Should information be printed. """ self.name = name + self.recording_levels = recording_levels self.verbose = verbose - self.initialization_time = dt.now() + self.initialization_time = datetime.now() + self._start_time: Optional[datetime] = None if self.verbose: print(f"Initialized logger with name {name}") @@ -41,20 +48,19 @@ def log(self, *args, **kwargs): print(*args, **kwargs) def set_start_time(self): - self._start_time = dt.now() + assert self._start_time is None, 'Recording has already started' + self._start_time = datetime.now() def record_time( self, - dataset: int, - variable_name: str, - iteration: int, - timed_event: str, + level_items: Dict[str, str], ): """ Compares the current time with the start time, and records the time difference in our time log in the appropriate register. Times can stack for a context. """ - seconds = (dt.now() - self._start_time).total_seconds() + seconds = (datetime.now() - self._start_time).total_seconds() + self._start_time = None time_key = (dataset, variable_name, iteration, timed_event) if time_key in self.time_seconds: self.time_seconds[time_key] += seconds @@ -75,4 +81,4 @@ def get_time_df_summary(self): piv = df.pivot_table(values="Seconds", index="Variable", columns="Event") return piv else: - raise ValueError("Returning times as a frame requires pandas") + raise ValueError("Returning times as a frame requires pandas") \ No newline at end of file diff --git a/miceforest/mean_match.py b/miceforest/mean_match.py new file mode 100644 index 0000000..45f9480 --- /dev/null +++ b/miceforest/mean_match.py @@ -0,0 +1,266 @@ + +from pandas import Series +import inspect +from copy import deepcopy +from lightgbm import Booster +from typing import Callable, Union, Dict, Set, Optional +import numpy as np +from scipy.spatial import KDTree +from .utils import logodds + + +# Lightgbm can output 0.0 probabilities for extremely +# rare categories. This causes logodds to return inf. +_LIGHTGBM_PROB_THRESHOLD = 0.00000001 + + +_REGRESSIVE_OBJECTIVES = [ + "regression", + "regression_l1", + "poisson", + "huber", + "fair", + "mape", + "cross_entropy", + "cross_entropy_lambda" "quantile", + "tweedie", + "gamma", +] + +_CATEGORICAL_OBJECTIVES = [ + "binary", + "multiclass", + "multiclassova", +] + + +def _to_2d(x): + if x.ndim == 1: + x.shape = (-1, 1) + + +def mean_match_reg( + mean_match_candidates: int, + bachelor_preds: np.ndarray, + candidate_preds: np.ndarray, + candidate_values: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], +): + """ + Determines the values of candidates which will be used to impute the bachelors + """ + + if mean_match_candidates == 0: + imp_values = bachelor_preds + + else: + _to_2d(bachelor_preds) + _to_2d(candidate_preds) + + num_bachelors = bachelor_preds.shape[0] + + # balanced_tree = False fixes a recursion issue for some reason. + # https://github.com/scipy/scipy/issues/14799 + kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) + _, knn_indices = kd_tree.query( + bachelor_preds, k=mean_match_candidates, workers=-1 + ) + + # We can skip the random selection process if mean_match_candidates == 1 + if mean_match_candidates == 1: + index_choice = knn_indices + + else: + # Use the random_state if seed_array was not passed. Faster + if hashed_seeds is None: + ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) + # Use the random_seed_array if it was passed. Deterministic. + else: + ind = hashed_seeds % mean_match_candidates + + index_choice = knn_indices[np.arange(num_bachelors), ind] + + imp_values = np.array(candidate_values)[index_choice] + + return imp_values + + +def mean_match_binary_accurate( + mean_match_candidates: int, + bachelor_preds: np.ndarray, + candidate_preds: np.ndarray, + candidate_values: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], +): + """ + Determines the values of candidates which will be used to impute the bachelors. + This function works just like the regression version - chooses candidates with + close probabilities to the bachelor prediction. + """ + + return mean_match_reg( + mean_match_candidates, + bachelor_preds, + candidate_preds, + candidate_values, + random_state, + hashed_seeds, + ) + + +def mean_match_binary_fast( + mean_match_candidates: int, + bachelor_preds: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], +): + """ + Chooses 0/1 randomly weighted by probability obtained from prediction. + If mean_match_candidates is 0, choose class with highest probability. + """ + if mean_match_candidates == 0: + imp_values = np.floor(bachelor_preds + 0.5) + + else: + num_bachelors = bachelor_preds.shape[0] + if hashed_seeds is None: + imp_values = random_state.binomial(n=1, p=bachelor_preds) + else: + imp_values = [] + for i in range(num_bachelors): + np.random.seed(seed=hashed_seeds[i]) + imp_values.append(np.random.binomial(n=1, p=bachelor_preds[i])) + + imp_values = np.array(imp_values) + + return imp_values + + +def mean_match_multiclass_fast( + mean_match_candidates: int, + bachelor_preds: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], +): + """ + If mean_match_candidates is 0, choose class with highest probability. + Otherwise, randomly choose class weighted by class probabilities. + """ + if mean_match_candidates == 0: + imp_values = np.argmax(bachelor_preds, axis=1) + + else: + num_bachelors = bachelor_preds.shape[0] + + # Turn bachelor_preds into discrete cdf: + bachelor_preds = bachelor_preds.cumsum(axis=1) + + # Randomly choose uniform numbers 0-1 + if hashed_seeds is None: + # This is the fastest way to adjust for numeric + # imprecision of float16 dtype. Actually ends up + # barely taking any time at all. + bp_dtype = bachelor_preds.dtype + unif = np.minimum( + random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype), + bachelor_preds[:, -1], + ) + else: + unif = [] + for i in range(num_bachelors): + np.random.seed(seed=hashed_seeds[i]) + unif.append(np.random.uniform(0, 1, size=1)[0]) + unif = np.array(unif) + + # Choose classes according to their cdf. + # Distribution will match probabilities + imp_values = np.array( + [ + np.searchsorted(bachelor_preds[i, :], unif[i]) + for i in range(num_bachelors) + ] + ) + + return imp_values + + +def mean_match_multiclass_accurate( + mean_match_candidates: int, + bachelor_preds: np.ndarray, + candidate_preds: np.ndarray, + candidate_values: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], +): + """ + Performs nearest neighbors search on class probabilities. + """ + if mean_match_candidates == 0: + return np.argmax(bachelor_preds, axis=1) + + else: + return mean_match_reg( + mean_match_candidates, + bachelor_preds, + candidate_preds, + candidate_values, + random_state, + hashed_seeds, + ) + + +def adjust_shap_for_rf(model, sv): + if model.params["boosting"] in ["random_forest", "rf"]: + sv /= model.current_iteration() + + +def predict_normal(model: Booster, data): + preds = model.predict(data) + return preds + + +def predict_normal_shap(model: Booster, data): + preds = model.predict(data, pred_contrib=True)[:, :-1] # type: ignore + adjust_shap_for_rf(model, preds) + return preds + + +def predict_binary_logodds(model: Booster, data): + preds = logodds( + model.predict(data).clip( # type: ignore + _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD + ) + ) + return preds + + +def predict_multiclass_logodds(model: Booster, data): + preds = model.predict(data).clip( # type: ignore + _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD + ) + preds = logodds(preds) + return preds + + +def predict_multiclass_shap(model: Booster, data): + """ + Returns a 3d array of shape (samples, columns, classes) + It is faster to copy into a new array than delete from + the old one. + """ + preds = model.predict(data, pred_contrib=True) + samples, cols = data.shape + classes = model._Booster__num_class # type: ignore + p = np.empty(shape=(samples, cols * classes), dtype=preds.dtype) # type: ignore + for c in range(classes): + s1 = slice(c * cols, (c + 1) * cols) + s2 = slice(c * (cols + 1), (c + 1) * (cols + 1) - 1) + p[:, s1] = preds[:, s2] # type: ignore + + # If objective is random forest, the shap values are summed + # without ever taking an average, so we divide by the iters + adjust_shap_for_rf(model, p) + + return p diff --git a/miceforest/utils.py b/miceforest/utils.py index e83577c..7c9bec3 100644 --- a/miceforest/utils.py +++ b/miceforest/utils.py @@ -1,23 +1,32 @@ -from .compat import pd_DataFrame, pd_Series, pd_read_parquet + import numpy as np from numpy.random import RandomState import blosc2 import dill +from pandas import Series, DataFrame, read_parquet from typing import Union, List, Dict, Optional -_t_var_list = Union[List[str], List[int]] -_t_var_dict = Union[Dict[str, List[str]], Dict[int, List[int]]] -_t_var_sub = Union[Dict[Union[int, int], Union[int, float]]] -_t_dat = Union[pd_DataFrame, np.ndarray] -_t_random_state = Union[int, RandomState, None] +def get_best_int_downcast(x: int): + assert isinstance(x, int) + int_dtypes = ['uint8', 'uint16', 'uint32', 'uint64'] + np_iinfo_max = { + np.iinfo(dtype).max + for dtype in int_dtypes + } + for dtype, max in np_iinfo_max.items(): + if x <= max: + break + if dtype == 'uint64': + raise ValueError('Number too large to downcast') + return dtype def ampute_data( - data: _t_dat, - variables: Optional[_t_var_list] = None, + data: DataFrame, + variables: Optional[List[str]] = None, perc: float = 0.1, - random_state: _t_random_state = None, + random_state: Optional[Union[int, np.random.RandomState]] = None, ): """ Ampute Data @@ -44,40 +53,13 @@ def ampute_data( The amputed data """ amputed_data = data.copy() - data_shape = amputed_data.shape - amp_rows = int(perc * data_shape[0]) + num_rows = amputed_data.shape[0] + amp_rows = int(perc * num_rows[0]) random_state = ensure_rng(random_state) - if len(data_shape) > 1: - if variables is None: - variables = [i for i in range(amputed_data.shape[1])] - elif isinstance(variables, list): - if isinstance(variables[0], str): - assert isinstance( - data, pd_DataFrame - ), "np array was passed but variables are strings" - variables = [data.columns.tolist().index(i) for i in variables] - - if isinstance(amputed_data, pd_DataFrame): - for v in variables: - na_ind = random_state.choice( - np.arange(data_shape[0]), replace=False, size=amp_rows - ) - amputed_data.iloc[na_ind, v] = np.NaN - - if isinstance(amputed_data, np.ndarray): - amputed_data = amputed_data.astype("float64") - for v in variables: - na_ind = random_state.choice( - np.arange(data_shape[0]), replace=False, size=amp_rows - ) - amputed_data[na_ind, v] = np.NaN - - else: - na_ind = random_state.choice( - np.arange(data_shape[0]), replace=False, size=amp_rows - ) - amputed_data[na_ind] = np.NaN + for col in ampute_data.columns: + ind = random_state.choice(amputed_data.index, size=amp_rows, replace=False) + ampute_data.loc[ind, col] = np.nan return amputed_data @@ -104,7 +86,7 @@ def load_kernel(filepath: str, n_threads: Optional[int] = None): kernel = dill.loads(blosc2.decompress(dill.load(f))) if kernel.original_data_class == "pd_DataFrame": - kernel.working_data = pd_read_parquet(kernel.working_data) + kernel.working_data = read_parquet(kernel.working_data) for col in kernel.working_data.columns: kernel.working_data[col] = kernel.working_data[col].astype( kernel.working_dtypes[col] @@ -113,7 +95,12 @@ def load_kernel(filepath: str, n_threads: Optional[int] = None): return kernel -def stratified_subset(y, size, groups, cat, seed): +def stratified_subset( + y: Series, + size: int, + groups: int, + random_state: Optional[Union[int, np.random.RandomState]], + ): """ Subsample y using stratification. y is divided into quantiles, and then elements are randomly chosen from each quantile to @@ -138,12 +125,12 @@ def stratified_subset(y, size, groups, cat, seed): The indices of y that have been chosen. """ - rs = RandomState(seed) - if isinstance(y, pd_Series): - if y.dtype.name == "category": - y = y.cat.codes - y = y.values + cat = False + if y.dtype.name == "category": + cat = True + y = y.cat.codes + y = y.to_numpy() if cat: digits = y @@ -158,7 +145,7 @@ def stratified_subset(y, size, groups, cat, seed): digits_s = (digits_p * size).round(0).astype("int32") diff = size - digits_s.sum() if diff != 0: - digits_fix = rs.choice(digits_i, size=abs(diff), p=digits_p, replace=False) + digits_fix = random_state.choice(digits_i, size=abs(diff), p=digits_p, replace=False) if diff < 0: for d in digits_fix: digits_s[d] -= 1 @@ -172,7 +159,7 @@ def stratified_subset(y, size, groups, cat, seed): d_v = digits_v[d_i] n = digits_s[d_i] ind = np.where(digits == d_v)[0] - choice = rs.choice(ind, size=n, replace=False) + choice = random_state.choice(ind, size=n, replace=False) sub[added : (added + n)] = choice added += n @@ -181,28 +168,26 @@ def stratified_subset(y, size, groups, cat, seed): return sub -def stratified_continuous_folds(y, nfold): +def stratified_continuous_folds(y: Series, nfold: int): """ Create primitive stratified folds for continuous data. Should be digestible by lightgbm.cv function. """ - if isinstance(y, pd_Series): - y = y.values - elements = len(y) + y = y.to_numpy() + elements = y.shape[0] assert elements >= nfold, "more splits then elements." sorted = np.argsort(y) val = [sorted[range(i, len(y), nfold)] for i in range(nfold)] for v in val: - yield (np.setdiff1d(range(elements), v), v) + yield (np.setdiff1d(np.arange(elements), v), v) -def stratified_categorical_folds(y, nfold): +def stratified_categorical_folds(y: Series, nfold: int): """ Create primitive stratified folds for categorical data. Should be digestible by lightgbm.cv function. """ - if isinstance(y, pd_Series): - y = y.values + y = y.cat.codes.to_numpy() y = y.reshape( y.shape[0], ).copy() @@ -257,109 +242,47 @@ def ensure_rng(random_state) -> RandomState: return random_state -def _ensure_iterable(x): - """ - If the object is iterable, return the object. - Else, return the object in a length 1 list. - """ - return x if hasattr(x, "__iter__") else [x] +# def _ensure_iterable(x): +# """ +# If the object is iterable, return the object. +# Else, return the object in a length 1 list. +# """ +# return x if hasattr(x, "__iter__") else [x] -def _assert_dataset_equivalent(ds1: _t_dat, ds2: _t_dat): - if isinstance(ds1, pd_DataFrame): - assert isinstance(ds2, pd_DataFrame) - assert ds1.equals(ds2) - else: - assert isinstance(ds2, np.ndarray) - np.testing.assert_array_equal(ds1, ds2) +# def _assert_dataset_equivalent(ds1: _t_dat, ds2: _t_dat): +# if isinstance(ds1, DataFrame): +# assert isinstance(ds2, DataFrame) +# assert ds1.equals(ds2) +# else: +# assert isinstance(ds2, np.ndarray) +# np.testing.assert_array_equal(ds1, ds2) -def _ensure_np_array(x): - if isinstance(x, np.ndarray): - return x - if isinstance(x, pd_DataFrame) | isinstance(x, pd_Series): - return x.values - else: - raise ValueError("Can't cast to numpy array") +# def _ensure_np_array(x): +# if isinstance(x, np.ndarray): +# return x +# if isinstance(x, DataFrame) | isinstance(x, Series): +# return x.values +# else: +# raise ValueError("Can't cast to numpy array") -def _interpret_ds(val, avail_can): - if isinstance(val, int): - assert val <= avail_can, "data subset is more than available candidates" - elif isinstance(val, float): - assert (val <= 1.0) and (val > 0.0), "if float, 0.0 < data_subset <= 1.0" - val = int(val * avail_can) +def _expand_value_to_dict(default, value, keys): + if isinstance(value, dict): + ret = { + key: value.get(key, default) + for key in keys + } else: - raise ValueError("malformed data_subset passed") - return val - + assert default.__class__ == value.__class__ + ret = {key: default for key in keys} -def _dict_set_diff(iter1, iter2) -> Dict[int, List[int]]: - """ - Returns a dict, where the elements in iter1 are - the keys, and the values are the set differences - between the key and the values of iter2. - """ - ret = {int(y): [int(x) for x in iter2 if int(x) != int(y)] for y in iter1} return ret -def _slice(dat, row_slice=slice(None), col_slice=slice(None)): - """ - Returns a view of the subset data if possible. - """ - - if isinstance(dat, pd_DataFrame): - return dat.iloc[row_slice, col_slice] - elif isinstance(dat, np.ndarray): - return dat[row_slice, col_slice] - else: - raise ValueError("Unknown data class passed.") - - -def _assign_col_values_without_copy(dat, row_ind, col_ind, val): - """ - Insert values into different data frame objects. - """ - - row_ind = _ensure_iterable(row_ind) - - if isinstance(dat, pd_DataFrame): - # Remove iterable attribute if - # we are only assigning 1 value - if len(val) == 1: - val = val[0] - - dat.iloc[row_ind, col_ind] = val - - elif isinstance(dat, np.ndarray): - val.shape = -1 - dat[row_ind, col_ind] = val - - else: - raise ValueError("Unknown data class passed.") - - -def _subset_data(dat, row_ind=None, col_ind=None, return_1d=False): - """ - Can subset data along 2 axis. - Explicitly returns a copy. - """ - - row_ind = range(dat.shape[0]) if row_ind is None else row_ind - col_ind = range(dat.shape[1]) if col_ind is None else col_ind - - if isinstance(dat, pd_DataFrame): - data_copy = dat.iloc[row_ind, col_ind] - return data_copy.to_numpy().flatten() if return_1d else data_copy - elif isinstance(dat, np.ndarray): - row_ind = _ensure_iterable(row_ind) - col_ind = _ensure_iterable(col_ind) - data_copy = dat[np.ix_(row_ind, col_ind)] - return data_copy.flatten() if return_1d else data_copy - else: - raise ValueError("Unknown data class passed.") - +def _list_union(x: List, y: List): + return [z for z in x if z in y] def logodds(probability): try: diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..f659e20 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,1254 @@ +# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. + +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "blosc2" +version = "2.6.2" +description = "Python wrapper for the C-Blosc2 library" +optional = false +python-versions = "<4,>=3.10" +files = [ + {file = "blosc2-2.6.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:00db67006601f534553a7948213595f384eac0e3afa41a4f5600fbb3ba580ae2"}, + {file = "blosc2-2.6.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:407627050d116d1cce85b197616350d3f2852f7e036a4f59a97d5cc07f345ead"}, + {file = "blosc2-2.6.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8aeb8eb12c60522bf0eb6d49687aba925e710ba4f9976cdde519d7af3bc547df"}, + {file = "blosc2-2.6.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:072a8753d627499893129d480042a61ee47845ce99106fa0e7d8ea4f0ced37a1"}, + {file = "blosc2-2.6.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:afb962aef4f2b3b5cd20a3ae2d92311bb829836ae283b5ac595fa14dd2fad47c"}, + {file = "blosc2-2.6.2-cp310-cp310-win32.whl", hash = "sha256:abc87b8bda70290a33b0d5631121d189f90046b86f7992865428672471cccba0"}, + {file = "blosc2-2.6.2-cp310-cp310-win_amd64.whl", hash = "sha256:8291cd97f3730873c498df610acb0177ff11901e09771197e1eace5c3e1b9669"}, + {file = "blosc2-2.6.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:15d91ba9fd24391a67dcb1051b82490b0cbde3a1d473209fa578e7a96d801bf7"}, + {file = "blosc2-2.6.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cbe8e97f0bc94a45456f186c374e5fb91d35123ebe80e530d849d1da95cf6770"}, + {file = "blosc2-2.6.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50661d5e9147b8f50a86c7d86ec2be907ac33418c5ec82963f4487d851e9c88c"}, + {file = "blosc2-2.6.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81b0d7cf029b097fd130817ddae66e67a92253136812a5dddba3d9504bce15ed"}, + {file = "blosc2-2.6.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:be1925fbf1ce37d384f47d3f02710abe79cc7722d09c2d50044845947e85d2fa"}, + {file = "blosc2-2.6.2-cp311-cp311-win32.whl", hash = "sha256:6c5b861a8c51af1cd7eabf59c3bdd944f873ea5de8497602af9c5617cabe4f7e"}, + {file = "blosc2-2.6.2-cp311-cp311-win_amd64.whl", hash = "sha256:db38cc7aed6547f0855ef5dbb13853f653a91174bf5e79841dd00ff1914a83d3"}, + {file = "blosc2-2.6.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bb8fc5c0420eab9c4c0c7eddf1b8747b817f7aae5145e3e99607918af3f42588"}, + {file = "blosc2-2.6.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f4c2272915e0f28cd10258393506cc31616317d94fed77b61617c98734588016"}, + {file = "blosc2-2.6.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ca4c24cb1f64dba1b900fbfc165649bbfd9c890d76e356a682a9cff4c34f967"}, + {file = "blosc2-2.6.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c4fec36f58267fa0b5b1ed7f688469313e5af83ed1cc70ba01001d3fe4b824f"}, + {file = "blosc2-2.6.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8a63ad8ae52af974d4ffa1490aa7715cfe0d6408363686fb141ff6f7513bb0ad"}, + {file = "blosc2-2.6.2-cp312-cp312-win32.whl", hash = "sha256:3025e4d0bdab498853e0cf971ece10ac5709c875f0b6b4272fe069326b69ef42"}, + {file = "blosc2-2.6.2-cp312-cp312-win_amd64.whl", hash = "sha256:b99157758b5d3ba11c46db26602750555053aee2b917ba3209eaf37ee266ccb4"}, + {file = "blosc2-2.6.2.tar.gz", hash = "sha256:8ca29d9aa988b85318bd8a9b707a7a06c8d6604ae1304cae059170437ae4f53a"}, +] + +[package.dependencies] +msgpack = "*" +ndindex = ">=1.4" +numexpr = "*" +numpy = ">=1.20.3" +py-cpuinfo = "*" + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "contourpy" +version = "1.2.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.9" +files = [ + {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"}, + {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"}, + {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"}, + {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"}, + {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"}, + {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"}, + {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"}, + {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"}, + {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"}, + {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"}, + {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"}, +] + +[package.dependencies] +numpy = ">=1.20" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] + +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "dill" +version = "0.3.8" +description = "serialize all of Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, + {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, +] + +[package.extras] +graph = ["objgraph (>=1.7.2)"] +profile = ["gprof2dot (>=2022.7.29)"] + +[[package]] +name = "exceptiongroup" +version = "1.2.1" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, + {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "fonttools" +version = "4.51.0" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, + {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, + {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, + {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, + {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, + {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, + {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, + {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, + {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, + {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, + {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, + {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, + {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "pycairo", "scipy"] +lxml = ["lxml (>=4.0)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.1.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipython" +version = "8.23.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.23.0-py3-none-any.whl", hash = "sha256:07232af52a5ba146dc3372c7bf52a0f890a23edf38d77caef8d53f9cdc2584c1"}, + {file = "ipython-8.23.0.tar.gz", hash = "sha256:7468edaf4f6de3e1b912e57f66c241e6fd3c7099f2ec2136e239e142e800274d"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5.13.0" +typing-extensions = {version = "*", markers = "python_version < \"3.12\""} + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "joblib" +version = "1.4.0" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.8" +files = [ + {file = "joblib-1.4.0-py3-none-any.whl", hash = "sha256:42942470d4062537be4d54c83511186da1fc14ba354961a2114da91efa9a4ed7"}, + {file = "joblib-1.4.0.tar.gz", hash = "sha256:1eb0dc091919cd384490de890cb5dfd538410a6d4b3b54eef09fb8c50b409b1c"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + +[[package]] +name = "lightgbm" +version = "4.3.0" +description = "LightGBM Python Package" +optional = false +python-versions = ">=3.6" +files = [ + {file = "lightgbm-4.3.0-py3-none-macosx_10_15_x86_64.macosx_11_6_x86_64.macosx_12_5_x86_64.whl", hash = "sha256:7e7c84e30607d043cc07ab7c0ffe3109120bde8e7e126f6a6151ca010c40fe3f"}, + {file = "lightgbm-4.3.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:25eb3dd661d75ccf8a46de686b07def3a2e06eacab7da5937d82543732183688"}, + {file = "lightgbm-4.3.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:104496a3404cb2452d3412cbddcfbfadbef9c372ea91e3a9b8794bcc5183bf07"}, + {file = "lightgbm-4.3.0-py3-none-win_amd64.whl", hash = "sha256:89bc9ef2b97552bfa07523416513d27cf3344bedf9bcb1f286e636ebe169ed51"}, + {file = "lightgbm-4.3.0.tar.gz", hash = "sha256:006f5784a9bcee43e5a7e943dc4f02de1ba2ee7a7af1ee5f190d383f3b6c9ebe"}, +] + +[package.dependencies] +numpy = "*" +scipy = "*" + +[package.extras] +arrow = ["cffi (>=1.15.1)", "pyarrow (>=6.0.1)"] +dask = ["dask[array,dataframe,distributed] (>=2.0.0)", "pandas (>=0.24.0)"] +pandas = ["pandas (>=0.24.0)"] +scikit-learn = ["scikit-learn (!=0.22.0)"] + +[[package]] +name = "matplotlib" +version = "3.8.4" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"}, + {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"}, + {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"}, + {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"}, + {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"}, + {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"}, + {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"}, + {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"}, + {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"}, + {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"}, + {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.21" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "msgpack" +version = "1.0.8" +description = "MessagePack serializer" +optional = false +python-versions = ">=3.8" +files = [ + {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:505fe3d03856ac7d215dbe005414bc28505d26f0c128906037e66d98c4e95868"}, + {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b7842518a63a9f17107eb176320960ec095a8ee3b4420b5f688e24bf50c53c"}, + {file = "msgpack-1.0.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:376081f471a2ef24828b83a641a02c575d6103a3ad7fd7dade5486cad10ea659"}, + {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e390971d082dba073c05dbd56322427d3280b7cc8b53484c9377adfbae67dc2"}, + {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e073efcba9ea99db5acef3959efa45b52bc67b61b00823d2a1a6944bf45982"}, + {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82d92c773fbc6942a7a8b520d22c11cfc8fd83bba86116bfcf962c2f5c2ecdaa"}, + {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9ee32dcb8e531adae1f1ca568822e9b3a738369b3b686d1477cbc643c4a9c128"}, + {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e3aa7e51d738e0ec0afbed661261513b38b3014754c9459508399baf14ae0c9d"}, + {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:69284049d07fce531c17404fcba2bb1df472bc2dcdac642ae71a2d079d950653"}, + {file = "msgpack-1.0.8-cp310-cp310-win32.whl", hash = "sha256:13577ec9e247f8741c84d06b9ece5f654920d8365a4b636ce0e44f15e07ec693"}, + {file = "msgpack-1.0.8-cp310-cp310-win_amd64.whl", hash = "sha256:e532dbd6ddfe13946de050d7474e3f5fb6ec774fbb1a188aaf469b08cf04189a"}, + {file = "msgpack-1.0.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9517004e21664f2b5a5fd6333b0731b9cf0817403a941b393d89a2f1dc2bd836"}, + {file = "msgpack-1.0.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d16a786905034e7e34098634b184a7d81f91d4c3d246edc6bd7aefb2fd8ea6ad"}, + {file = "msgpack-1.0.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2872993e209f7ed04d963e4b4fbae72d034844ec66bc4ca403329db2074377b"}, + {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c330eace3dd100bdb54b5653b966de7f51c26ec4a7d4e87132d9b4f738220ba"}, + {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83b5c044f3eff2a6534768ccfd50425939e7a8b5cf9a7261c385de1e20dcfc85"}, + {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1876b0b653a808fcd50123b953af170c535027bf1d053b59790eebb0aeb38950"}, + {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:dfe1f0f0ed5785c187144c46a292b8c34c1295c01da12e10ccddfc16def4448a"}, + {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3528807cbbb7f315bb81959d5961855e7ba52aa60a3097151cb21956fbc7502b"}, + {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e2f879ab92ce502a1e65fce390eab619774dda6a6ff719718069ac94084098ce"}, + {file = "msgpack-1.0.8-cp311-cp311-win32.whl", hash = "sha256:26ee97a8261e6e35885c2ecd2fd4a6d38252246f94a2aec23665a4e66d066305"}, + {file = "msgpack-1.0.8-cp311-cp311-win_amd64.whl", hash = "sha256:eadb9f826c138e6cf3c49d6f8de88225a3c0ab181a9b4ba792e006e5292d150e"}, + {file = "msgpack-1.0.8-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:114be227f5213ef8b215c22dde19532f5da9652e56e8ce969bf0a26d7c419fee"}, + {file = "msgpack-1.0.8-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d661dc4785affa9d0edfdd1e59ec056a58b3dbb9f196fa43587f3ddac654ac7b"}, + {file = "msgpack-1.0.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d56fd9f1f1cdc8227d7b7918f55091349741904d9520c65f0139a9755952c9e8"}, + {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0726c282d188e204281ebd8de31724b7d749adebc086873a59efb8cf7ae27df3"}, + {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8db8e423192303ed77cff4dce3a4b88dbfaf43979d280181558af5e2c3c71afc"}, + {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99881222f4a8c2f641f25703963a5cefb076adffd959e0558dc9f803a52d6a58"}, + {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b5505774ea2a73a86ea176e8a9a4a7c8bf5d521050f0f6f8426afe798689243f"}, + {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:ef254a06bcea461e65ff0373d8a0dd1ed3aa004af48839f002a0c994a6f72d04"}, + {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e1dd7839443592d00e96db831eddb4111a2a81a46b028f0facd60a09ebbdd543"}, + {file = "msgpack-1.0.8-cp312-cp312-win32.whl", hash = "sha256:64d0fcd436c5683fdd7c907eeae5e2cbb5eb872fafbc03a43609d7941840995c"}, + {file = "msgpack-1.0.8-cp312-cp312-win_amd64.whl", hash = "sha256:74398a4cf19de42e1498368c36eed45d9528f5fd0155241e82c4082b7e16cffd"}, + {file = "msgpack-1.0.8-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0ceea77719d45c839fd73abcb190b8390412a890df2f83fb8cf49b2a4b5c2f40"}, + {file = "msgpack-1.0.8-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1ab0bbcd4d1f7b6991ee7c753655b481c50084294218de69365f8f1970d4c151"}, + {file = "msgpack-1.0.8-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1cce488457370ffd1f953846f82323cb6b2ad2190987cd4d70b2713e17268d24"}, + {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3923a1778f7e5ef31865893fdca12a8d7dc03a44b33e2a5f3295416314c09f5d"}, + {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a22e47578b30a3e199ab067a4d43d790249b3c0587d9a771921f86250c8435db"}, + {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd739c9251d01e0279ce729e37b39d49a08c0420d3fee7f2a4968c0576678f77"}, + {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d3420522057ebab1728b21ad473aa950026d07cb09da41103f8e597dfbfaeb13"}, + {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:5845fdf5e5d5b78a49b826fcdc0eb2e2aa7191980e3d2cfd2a30303a74f212e2"}, + {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6a0e76621f6e1f908ae52860bdcb58e1ca85231a9b0545e64509c931dd34275a"}, + {file = "msgpack-1.0.8-cp38-cp38-win32.whl", hash = "sha256:374a8e88ddab84b9ada695d255679fb99c53513c0a51778796fcf0944d6c789c"}, + {file = "msgpack-1.0.8-cp38-cp38-win_amd64.whl", hash = "sha256:f3709997b228685fe53e8c433e2df9f0cdb5f4542bd5114ed17ac3c0129b0480"}, + {file = "msgpack-1.0.8-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f51bab98d52739c50c56658cc303f190785f9a2cd97b823357e7aeae54c8f68a"}, + {file = "msgpack-1.0.8-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:73ee792784d48aa338bba28063e19a27e8d989344f34aad14ea6e1b9bd83f596"}, + {file = "msgpack-1.0.8-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f9904e24646570539a8950400602d66d2b2c492b9010ea7e965025cb71d0c86d"}, + {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e75753aeda0ddc4c28dce4c32ba2f6ec30b1b02f6c0b14e547841ba5b24f753f"}, + {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5dbf059fb4b7c240c873c1245ee112505be27497e90f7c6591261c7d3c3a8228"}, + {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4916727e31c28be8beaf11cf117d6f6f188dcc36daae4e851fee88646f5b6b18"}, + {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7938111ed1358f536daf311be244f34df7bf3cdedb3ed883787aca97778b28d8"}, + {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:493c5c5e44b06d6c9268ce21b302c9ca055c1fd3484c25ba41d34476c76ee746"}, + {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fbb160554e319f7b22ecf530a80a3ff496d38e8e07ae763b9e82fadfe96f273"}, + {file = "msgpack-1.0.8-cp39-cp39-win32.whl", hash = "sha256:f9af38a89b6a5c04b7d18c492c8ccf2aee7048aff1ce8437c4683bb5a1df893d"}, + {file = "msgpack-1.0.8-cp39-cp39-win_amd64.whl", hash = "sha256:ed59dd52075f8fc91da6053b12e8c89e37aa043f8986efd89e61fae69dc1b011"}, + {file = "msgpack-1.0.8.tar.gz", hash = "sha256:95c02b0e27e706e48d0e5426d1710ca78e0f0628d6e89d5b5a5b91a5f12274f3"}, +] + +[[package]] +name = "ndindex" +version = "1.8" +description = "A Python library for manipulating indices of ndarrays." +optional = false +python-versions = ">=3.8" +files = [ + {file = "ndindex-1.8-py3-none-any.whl", hash = "sha256:b5132cd331f3e4106913ed1a974a3e355967a5991543c2f512b40cb8bb9f50b8"}, + {file = "ndindex-1.8.tar.gz", hash = "sha256:5fc87ebc784605f01dd5367374cb40e8da8f2c30988968990066c5098a7eebe8"}, +] + +[package.extras] +arrays = ["numpy"] + +[[package]] +name = "numexpr" +version = "2.10.0" +description = "Fast numerical expression evaluator for NumPy" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numexpr-2.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1af6dc6b3bd2e11a802337b352bf58f30df0b70be16c4f863b70a3af3a8ef95e"}, + {file = "numexpr-2.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c66dc0188358cdcc9465b6ee54fd5eef2e83ac64b1d4ba9117c41df59bf6fca"}, + {file = "numexpr-2.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83f1e7a7f7ee741b8dcd20c56c3f862a3a3ec26fa8b9fcadb7dcd819876d2f35"}, + {file = "numexpr-2.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f0b045e1831953a47cc9fabae76a6794c69cbb60921751a5cf2d555034c55bf"}, + {file = "numexpr-2.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1d8eb88b0ae3d3c609d732a17e71096779b2bf47b3a084320ffa93d9f9132786"}, + {file = "numexpr-2.10.0-cp310-cp310-win32.whl", hash = "sha256:629b66cc1b750671e7fb396506b3f9410612e5bd8bc1dd55b5a0a0041d839f95"}, + {file = "numexpr-2.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:78e0a8bc4417c3dedcbae3c473505b69080535246edc977c7dccf3ec8454a685"}, + {file = "numexpr-2.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a602692cd52ce923ce8a0a90fb1d6cf186ebe8706eed83eee0de685e634b9aa9"}, + {file = "numexpr-2.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:745b46a1fb76920a3eebfaf26e50bc94a9c13b5aee34b256ab4b2d792dbaa9ca"}, + {file = "numexpr-2.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10789450032357afaeda4ac4d06da9542d1535c13151e8d32b49ae1a488d1358"}, + {file = "numexpr-2.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4feafc65ea3044b8bf8f305b757a928e59167a310630c22b97a57dff07a56490"}, + {file = "numexpr-2.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:937d36c6d3cf15601f26f84f0f706649f976491e9e0892d16cd7c876d77fa7dc"}, + {file = "numexpr-2.10.0-cp311-cp311-win32.whl", hash = "sha256:03d0ba492e484a5a1aeb24b300c4213ed168f2c246177be5733abb4e18cbb043"}, + {file = "numexpr-2.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:6b5f8242c075477156d26b3a6b8e0cd0a06d4c8eb68d907bde56dd3c9c683e92"}, + {file = "numexpr-2.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b276e2ba3e87ace9a30fd49078ad5dcdc6a1674d030b1ec132599c55465c0346"}, + {file = "numexpr-2.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb5e12787101f1216f2cdabedc3417748f2e1f472442e16bbfabf0bab2336300"}, + {file = "numexpr-2.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05278bad96b5846d712eba58b44e5cec743bdb3e19ca624916c921d049fdbcf6"}, + {file = "numexpr-2.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6cdf9e64c5b3dbb61729edb505ea75ee212fa02b85c5b1d851331381ae3b0e1"}, + {file = "numexpr-2.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e3a973265591b0a875fd1151c4549e468959c7192821aac0bb86937694a08efa"}, + {file = "numexpr-2.10.0-cp312-cp312-win32.whl", hash = "sha256:416e0e9f0fc4cced67767585e44cb6b301728bdb9edbb7c534a853222ec62cac"}, + {file = "numexpr-2.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:748e8d4cde22d9a5603165293fb293a4de1a4623513299416c64fdab557118c2"}, + {file = "numexpr-2.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dc3506c30c03b082da2cadef43747d474e5170c1f58a6dcdf882b3dc88b1e849"}, + {file = "numexpr-2.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:efa63ecdc9fcaf582045639ddcf56e9bdc1f4d9a01729be528f62df4db86c9d6"}, + {file = "numexpr-2.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96a64d0dd8f8e694da3f8582d73d7da8446ff375f6dd239b546010efea371ac3"}, + {file = "numexpr-2.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d47bb567e330ebe86781864219a36cbccb3a47aec893bd509f0139c6b23e8104"}, + {file = "numexpr-2.10.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c7517b774d309b1f0896c89bdd1ddd33c4418a92ecfbe5e1df3ac698698f6fcf"}, + {file = "numexpr-2.10.0-cp39-cp39-win32.whl", hash = "sha256:04e8620e7e676504201d4082e7b3ee2d9b561d1cb9470b47a6104e10c1e2870e"}, + {file = "numexpr-2.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:56d0d96b130f7cd4d78d0017030d6a0e9d9fc2a717ac51d4cf4860b39637e86a"}, + {file = "numexpr-2.10.0.tar.gz", hash = "sha256:c89e930752639df040539160326d8f99a84159bbea41943ab8e960591edaaef0"}, +] + +[package.dependencies] +numpy = ">=1.19.3" + +[[package]] +name = "numpy" +version = "1.26.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, +] + +[[package]] +name = "packaging" +version = "24.0" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, + {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, +] + +[[package]] +name = "pandas" +version = "2.2.2" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.9" +files = [ + {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"}, + {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"}, + {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08"}, + {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0"}, + {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51"}, + {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e5a0b00e1e56a842f922e7fae8ae4077aee4af0acb5ae3622bd4b4c30aedf99"}, + {file = "pandas-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ddf818e4e6c7c6f4f7c8a12709696d193976b591cc7dc50588d3d1a6b5dc8772"}, + {file = "pandas-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:696039430f7a562b74fa45f540aca068ea85fa34c244d0deee539cb6d70aa288"}, + {file = "pandas-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8e90497254aacacbc4ea6ae5e7a8cd75629d6ad2b30025a4a8b09aa4faf55151"}, + {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58b84b91b0b9f4bafac2a0ac55002280c094dfc6402402332c0913a59654ab2b"}, + {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2123dc9ad6a814bcdea0f099885276b31b24f7edf40f6cdbc0912672e22eee"}, + {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2925720037f06e89af896c70bca73459d7e6a4be96f9de79e2d440bd499fe0db"}, + {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1"}, + {file = "pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24"}, + {file = "pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef"}, + {file = "pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce"}, + {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad"}, + {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad"}, + {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76"}, + {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32"}, + {file = "pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23"}, + {file = "pandas-2.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0ca6377b8fca51815f382bd0b697a0814c8bda55115678cbc94c30aacbb6eff2"}, + {file = "pandas-2.2.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9057e6aa78a584bc93a13f0a9bf7e753a5e9770a30b4d758b8d5f2a62a9433cd"}, + {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:001910ad31abc7bf06f49dcc903755d2f7f3a9186c0c040b827e522e9cef0863"}, + {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66b479b0bd07204e37583c191535505410daa8df638fd8e75ae1b383851fe921"}, + {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a77e9d1c386196879aa5eb712e77461aaee433e54c68cf253053a73b7e49c33a"}, + {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:92fd6b027924a7e178ac202cfbe25e53368db90d56872d20ffae94b96c7acc57"}, + {file = "pandas-2.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:640cef9aa381b60e296db324337a554aeeb883ead99dc8f6c18e81a93942f5f4"}, + {file = "pandas-2.2.2.tar.gz", hash = "sha256:9e79019aba43cb4fda9e4d983f8e88ca0373adbb697ae9c6c43093218de28b54"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.22.4", markers = "python_version < \"3.11\""}, + {version = ">=1.23.2", markers = "python_version == \"3.11\""}, + {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, +] +python-dateutil = ">=2.8.2" +pytz = ">=2020.1" +tzdata = ">=2022.7" + +[package.extras] +all = ["PyQt5 (>=5.15.9)", "SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)", "beautifulsoup4 (>=4.11.2)", "bottleneck (>=1.3.6)", "dataframe-api-compat (>=0.1.7)", "fastparquet (>=2022.12.0)", "fsspec (>=2022.11.0)", "gcsfs (>=2022.11.0)", "html5lib (>=1.1)", "hypothesis (>=6.46.1)", "jinja2 (>=3.1.2)", "lxml (>=4.9.2)", "matplotlib (>=3.6.3)", "numba (>=0.56.4)", "numexpr (>=2.8.4)", "odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "pandas-gbq (>=0.19.0)", "psycopg2 (>=2.9.6)", "pyarrow (>=10.0.1)", "pymysql (>=1.0.2)", "pyreadstat (>=1.2.0)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "qtpy (>=2.3.0)", "s3fs (>=2022.11.0)", "scipy (>=1.10.0)", "tables (>=3.8.0)", "tabulate (>=0.9.0)", "xarray (>=2022.12.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)", "zstandard (>=0.19.0)"] +aws = ["s3fs (>=2022.11.0)"] +clipboard = ["PyQt5 (>=5.15.9)", "qtpy (>=2.3.0)"] +compression = ["zstandard (>=0.19.0)"] +computation = ["scipy (>=1.10.0)", "xarray (>=2022.12.0)"] +consortium-standard = ["dataframe-api-compat (>=0.1.7)"] +excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)"] +feather = ["pyarrow (>=10.0.1)"] +fss = ["fsspec (>=2022.11.0)"] +gcp = ["gcsfs (>=2022.11.0)", "pandas-gbq (>=0.19.0)"] +hdf5 = ["tables (>=3.8.0)"] +html = ["beautifulsoup4 (>=4.11.2)", "html5lib (>=1.1)", "lxml (>=4.9.2)"] +mysql = ["SQLAlchemy (>=2.0.0)", "pymysql (>=1.0.2)"] +output-formatting = ["jinja2 (>=3.1.2)", "tabulate (>=0.9.0)"] +parquet = ["pyarrow (>=10.0.1)"] +performance = ["bottleneck (>=1.3.6)", "numba (>=0.56.4)", "numexpr (>=2.8.4)"] +plot = ["matplotlib (>=3.6.3)"] +postgresql = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "psycopg2 (>=2.9.6)"] +pyarrow = ["pyarrow (>=10.0.1)"] +spss = ["pyreadstat (>=1.2.0)"] +sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)"] +test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] +xml = ["lxml (>=4.9.2)"] + +[[package]] +name = "parso" +version = "0.8.4" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[package.extras] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["docopt", "pytest"] + +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pillow" +version = "10.3.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, + {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, + {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, + {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, + {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, + {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, + {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, + {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, + {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, + {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, + {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, + {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, + {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, + {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, + {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, + {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, + {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + +[[package]] +name = "pluggy" +version = "1.5.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.43" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, + {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "py-cpuinfo" +version = "9.0.0" +description = "Get CPU info with pure Python" +optional = false +python-versions = "*" +files = [ + {file = "py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690"}, + {file = "py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5"}, +] + +[[package]] +name = "pygments" +version = "2.17.2" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, + {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, +] + +[package.extras] +plugins = ["importlib-metadata"] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pyparsing" +version = "3.1.2" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"}, + {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "pytest" +version = "8.1.1" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"}, + {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=1.4,<2.0" +tomli = {version = ">=1", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "pytz" +version = "2024.1" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"}, + {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, +] + +[[package]] +name = "scikit-learn" +version = "1.4.2" +description = "A set of python modules for machine learning and data mining" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scikit-learn-1.4.2.tar.gz", hash = "sha256:daa1c471d95bad080c6e44b4946c9390a4842adc3082572c20e4f8884e39e959"}, + {file = "scikit_learn-1.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8539a41b3d6d1af82eb629f9c57f37428ff1481c1e34dddb3b9d7af8ede67ac5"}, + {file = "scikit_learn-1.4.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:68b8404841f944a4a1459b07198fa2edd41a82f189b44f3e1d55c104dbc2e40c"}, + {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81bf5d8bbe87643103334032dd82f7419bc8c8d02a763643a6b9a5c7288c5054"}, + {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36f0ea5d0f693cb247a073d21a4123bdf4172e470e6d163c12b74cbb1536cf38"}, + {file = "scikit_learn-1.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:87440e2e188c87db80ea4023440923dccbd56fbc2d557b18ced00fef79da0727"}, + {file = "scikit_learn-1.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:45dee87ac5309bb82e3ea633955030df9bbcb8d2cdb30383c6cd483691c546cc"}, + {file = "scikit_learn-1.4.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1d0b25d9c651fd050555aadd57431b53d4cf664e749069da77f3d52c5ad14b3b"}, + {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0203c368058ab92efc6168a1507d388d41469c873e96ec220ca8e74079bf62e"}, + {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44c62f2b124848a28fd695db5bc4da019287abf390bfce602ddc8aa1ec186aae"}, + {file = "scikit_learn-1.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:5cd7b524115499b18b63f0c96f4224eb885564937a0b3477531b2b63ce331904"}, + {file = "scikit_learn-1.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:90378e1747949f90c8f385898fff35d73193dfcaec3dd75d6b542f90c4e89755"}, + {file = "scikit_learn-1.4.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ff4effe5a1d4e8fed260a83a163f7dbf4f6087b54528d8880bab1d1377bd78be"}, + {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:671e2f0c3f2c15409dae4f282a3a619601fa824d2c820e5b608d9d775f91780c"}, + {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d36d0bc983336bbc1be22f9b686b50c964f593c8a9a913a792442af9bf4f5e68"}, + {file = "scikit_learn-1.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:d762070980c17ba3e9a4a1e043ba0518ce4c55152032f1af0ca6f39b376b5928"}, + {file = "scikit_learn-1.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d9993d5e78a8148b1d0fdf5b15ed92452af5581734129998c26f481c46586d68"}, + {file = "scikit_learn-1.4.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:426d258fddac674fdf33f3cb2d54d26f49406e2599dbf9a32b4d1696091d4256"}, + {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5460a1a5b043ae5ae4596b3126a4ec33ccba1b51e7ca2c5d36dac2169f62ab1d"}, + {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49d64ef6cb8c093d883e5a36c4766548d974898d378e395ba41a806d0e824db8"}, + {file = "scikit_learn-1.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:c97a50b05c194be9146d61fe87dbf8eac62b203d9e87a3ccc6ae9aed2dfaf361"}, +] + +[package.dependencies] +joblib = ">=1.2.0" +numpy = ">=1.19.5" +scipy = ">=1.6.0" +threadpoolctl = ">=2.0.0" + +[package.extras] +benchmark = ["matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "pandas (>=1.1.5)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] +tests = ["black (>=23.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.19.12)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.17.2)"] + +[[package]] +name = "scipy" +version = "1.13.0" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scipy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba419578ab343a4e0a77c0ef82f088238a93eef141b2b8017e46149776dfad4d"}, + {file = "scipy-1.13.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:22789b56a999265431c417d462e5b7f2b487e831ca7bef5edeb56efe4c93f86e"}, + {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05f1432ba070e90d42d7fd836462c50bf98bd08bed0aa616c359eed8a04e3922"}, + {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8434f6f3fa49f631fae84afee424e2483289dfc30a47755b4b4e6b07b2633a4"}, + {file = "scipy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:dcbb9ea49b0167de4167c40eeee6e167caeef11effb0670b554d10b1e693a8b9"}, + {file = "scipy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:1d2f7bb14c178f8b13ebae93f67e42b0a6b0fc50eba1cd8021c9b6e08e8fb1cd"}, + {file = "scipy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fbcf8abaf5aa2dc8d6400566c1a727aed338b5fe880cde64907596a89d576fa"}, + {file = "scipy-1.13.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5e4a756355522eb60fcd61f8372ac2549073c8788f6114449b37e9e8104f15a5"}, + {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5acd8e1dbd8dbe38d0004b1497019b2dbbc3d70691e65d69615f8a7292865d7"}, + {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ff7dad5d24a8045d836671e082a490848e8639cabb3dbdacb29f943a678683d"}, + {file = "scipy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4dca18c3ffee287ddd3bc8f1dabaf45f5305c5afc9f8ab9cbfab855e70b2df5c"}, + {file = "scipy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a2f471de4d01200718b2b8927f7d76b5d9bde18047ea0fa8bd15c5ba3f26a1d6"}, + {file = "scipy-1.13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0de696f589681c2802f9090fff730c218f7c51ff49bf252b6a97ec4a5d19e8b"}, + {file = "scipy-1.13.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b2a3ff461ec4756b7e8e42e1c681077349a038f0686132d623fa404c0bee2551"}, + {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf9fe63e7a4bf01d3645b13ff2aa6dea023d38993f42aaac81a18b1bda7a82a"}, + {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e7626dfd91cdea5714f343ce1176b6c4745155d234f1033584154f60ef1ff42"}, + {file = "scipy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:109d391d720fcebf2fbe008621952b08e52907cf4c8c7efc7376822151820820"}, + {file = "scipy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8930ae3ea371d6b91c203b1032b9600d69c568e537b7988a3073dfe4d4774f21"}, + {file = "scipy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5407708195cb38d70fd2d6bb04b1b9dd5c92297d86e9f9daae1576bd9e06f602"}, + {file = "scipy-1.13.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:ac38c4c92951ac0f729c4c48c9e13eb3675d9986cc0c83943784d7390d540c78"}, + {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09c74543c4fbeb67af6ce457f6a6a28e5d3739a87f62412e4a16e46f164f0ae5"}, + {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28e286bf9ac422d6beb559bc61312c348ca9b0f0dae0d7c5afde7f722d6ea13d"}, + {file = "scipy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:33fde20efc380bd23a78a4d26d59fc8704e9b5fd9b08841693eb46716ba13d86"}, + {file = "scipy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:45c08bec71d3546d606989ba6e7daa6f0992918171e2a6f7fbedfa7361c2de1e"}, + {file = "scipy-1.13.0.tar.gz", hash = "sha256:58569af537ea29d3f78e5abd18398459f195546bb3be23d16677fb26616cc11e"}, +] + +[package.dependencies] +numpy = ">=1.22.4,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "seaborn" +version = "0.11.2" +description = "seaborn: statistical data visualization" +optional = false +python-versions = ">=3.6" +files = [ + {file = "seaborn-0.11.2-py3-none-any.whl", hash = "sha256:85a6baa9b55f81a0623abddc4a26b334653ff4c6b18c418361de19dbba0ef283"}, + {file = "seaborn-0.11.2.tar.gz", hash = "sha256:cf45e9286d40826864be0e3c066f98536982baf701a7caa386511792d61ff4f6"}, +] + +[package.dependencies] +matplotlib = ">=2.2" +numpy = ">=1.15" +pandas = ">=0.23" +scipy = ">=1.0" + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "threadpoolctl" +version = "3.4.0" +description = "threadpoolctl" +optional = false +python-versions = ">=3.8" +files = [ + {file = "threadpoolctl-3.4.0-py3-none-any.whl", hash = "sha256:8f4c689a65b23e5ed825c8436a92b818aac005e0f3715f6a1664d7c7ee29d262"}, + {file = "threadpoolctl-3.4.0.tar.gz", hash = "sha256:f11b491a03661d6dd7ef692dd422ab34185d982466c49c8f98c8f716b5c93196"}, +] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "typing-extensions" +version = "4.11.0" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, + {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +description = "Provider of IANA time zone data" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[metadata] +lock-version = "2.0" +python-versions = "^3.10" +content-hash = "d7271a2e0d7c785a57363c2d11ef8dc542a2288659c8e017dda71b9e98f975ae" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..907b71b --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,25 @@ +[tool.poetry] +name = "miceforest" +license = "MIT" +version = "6.0.0" +description = "Multiple Imputation by Chained Equations with LightGBM" +authors = ["Sam Wilson"] +readme = "README.md" +package-mode = true + +[tool.poetry.dependencies] +python = "^3.10" + +lightgbm = "^4.0.0" +pandas = "^2.2.0" +numpy = "^1.26.0" +blosc2 = "^2.6.0" +dill = "^0.3.7" +scipy = "^1.11.1" +seaborn = "^0.11.0" +matplotlib = "^3.3.0" +scikit-learn = "^1.4.0" + +[tool.poetry.group.dev.dependencies] +ipython = "^8.17.2" +pytest = "^8.0.0" diff --git a/tests/test_ImputationKernel.py b/tests/test_ImputationKernel.py index fe2f90d..c9fe86e 100644 --- a/tests/test_ImputationKernel.py +++ b/tests/test_ImputationKernel.py @@ -4,10 +4,6 @@ import numpy as np import miceforest as mf from datetime import datetime -from miceforest import ( - mean_match_fast_cat, - mean_match_shap -) from matplotlib.pyplot import close from tempfile import mkstemp From 28197bf1b442009e90d7b070ea06e41c38a86200 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Thu, 9 May 2024 20:10:54 -0400 Subject: [PATCH 02/44] Before I start messing with the mean matching logic --- miceforest/ImputationKernel.py | 1990 ----------------- miceforest/ImputedData.py | 552 ----- miceforest/__init__.py | 6 +- miceforest/default_lightgbm_parameters.py | 6 +- .../{impute.py => imputation_kernel.py} | 1500 +++++++------ miceforest/imputed_data.py | 567 +++++ miceforest/logger.py | 53 +- miceforest/mean_match.py | 183 +- miceforest/utils.py | 50 +- poetry.lock | 172 +- pyproject.toml | 4 +- tests/test_ImputationKernel.py | 263 ++- tests/test_imputed_accuracy.py | 66 +- 13 files changed, 1753 insertions(+), 3659 deletions(-) delete mode 100644 miceforest/ImputationKernel.py delete mode 100644 miceforest/ImputedData.py rename miceforest/{impute.py => imputation_kernel.py} (55%) create mode 100644 miceforest/imputed_data.py diff --git a/miceforest/ImputationKernel.py b/miceforest/ImputationKernel.py deleted file mode 100644 index fec80a4..0000000 --- a/miceforest/ImputationKernel.py +++ /dev/null @@ -1,1990 +0,0 @@ -from .ImputedData import ImputedData -from .MeanMatchScheme import MeanMatchScheme -from .utils import ( - _t_dat, - _t_var_list, - _t_var_dict, - _t_var_sub, - _t_random_state, - _assert_dataset_equivalent, - _draw_random_int32, - _interpret_ds, - _subset_data, - ensure_rng, - hash_int32, - stratified_categorical_folds, - stratified_continuous_folds, - stratified_subset, -) -from .compat import pd_DataFrame, pd_Series -from .default_lightgbm_parameters import default_parameters, make_default_tuning_space -from .logger import Logger -import numpy as np -from numpy.random import RandomState -from warnings import warn -from lightgbm import train, Dataset, cv, log_evaluation, early_stopping, Booster -from lightgbm.basic import _ConfigAliases -from io import BytesIO -import blosc2 -import dill -from copy import copy -from typing import Union, List, Dict, Any, Optional - -_DEFAULT_DATA_SUBSET = 1.0 - - -class ImputationKernel(ImputedData): - """ - Creates a kernel dataset. This dataset can perform MICE on itself, - and impute new data from models obtained during MICE. - - Parameters - ---------- - data : np.ndarray or pandas DataFrame. - - .. code-block:: text - - The data to be imputed. - - variable_schema : None or list or dict, default=None - - .. code-block:: text - - Specifies the feature - target relationships used to train models. - This parameter also controls which models are built. Models can be built - even if a variable contains no missing values, or is not being imputed - (train_nonmissing must be set to True). - - - If None, all columns will be used as features in the training of each model. - - If list, all columns in data are used to impute the variables in the list - - If dict the values will be used to impute the keys. Can be either column - indices or names (if data is a pd.DataFrame). - - No models will be trained for variables not specified by variable_schema - (either by None, a list, or in dict keys). - - imputation_order: str, list[str], list[int], default="ascending" - - .. code-block:: text - - The order the imputations should occur in. If a string from the - items below, all variables specified by variable_schema with - missing data are imputed: - ascending: variables are imputed from least to most missing - descending: most to least missing - roman: from left to right in the dataset - arabic: from right to left in the dataset. - If a list is provided: - - the variables will be imputed in that order. - - only variables with missing values should be included in the list. - - must be a subset of variables specified by variable_schema. - If a variable with missing values is in variable_schema, but not in - imputation_order, then models to impute that variable will be trained, - but the actual values will not be imputed. See examples for details. - - train_nonmissing: boolean - - .. code-block:: text - - Should models be trained for variables with no missing values? Useful if you - expect you will need to impute new data which will have missing values, but - the training data is fully recognized. - - If True, parameters are interpreted like so: - - models are run for all variables specified by variable_schema - - if variable_schema is None, models are run for all variables - - each iteration, models build for fully recognized variables are - always trained after the models trained during mice. - - imputation_order does not have any affect on fully recognized - variable model training. - - WARNING: Setting this to True without specifying a variable schema will build - models for all variables in the dataset, whether they have missing values or - not. This may or may not be what you want. - - data_subset: None or int or float or dict. - - .. code-block:: text - - Subsets the data used in each iteration, which can save a significant amount of time. - This can also help with memory consumption, as the candidate data must be copied to - make a feature dataset for lightgbm. - - The number of rows used for each variable is (# rows in raw data) - (# missing variable values) - for each variable. data_subset takes a random sample of this. - - If float, must be 0.0 < data_subset <= 1.0. Interpreted as a percentage of available candidates - If int must be data_subset >= 0. Interpreted as the number of candidates. - If 0, no subsetting is done. - If dict, keys must be variable names, and values must follow two above rules. - - It is recommended to carefully select this value for each variable if dealing - with very large data that barely fits into memory. - - mean_match_scheme: Dict, default = None - - .. code-block:: text - - An instance of the miceforest.MeanMatchScheme class. - - If None is passed, a sensible default scheme is used. There are multiple helpful - schemes that can be accessed from miceforest.builtin_mean_match_schemes, or - you can build your own. - - A description of the defaults: - - mean_match_default (default, if mean_match_scheme is None)) - This scheme is has medium speed and accuracy for most data. - - Categorical: - If mmc = 0, the class with the highest probability is chosen. - If mmc > 0, get N nearest neighbors from class probabilities. - Select 1 at random. - Numeric: - If mmc = 0, the predicted value is used - If mmc > 0, obtain the mmc closest candidate - predictions and collect the associated - real candidate values. Choose 1 randomly. - - - mean_match_shap - This scheme is the most accurate, but takes the longest. - It works the same as mean_match_default, except all nearest - neighbor searches are performed on the shap values of the - predictions, instead of the predictions themselves. - - - mean_match_scheme_fast_cat: - This scheme is faster for categorical variables, - but may be less accurate as well.. - - Categorical: - If mmc = 0, the class with the highest probability is chosen. - If mmc > 0, return class based on random draw weighted by - class probability for each sample. - Numeric or binary: - If mmc = 0, the predicted value is used - If mmc > 0, obtain the mmc closest candidate - predictions and collect the associated - real candidate values. Choose 1 randomly. - - categorical_feature: str or list, default="auto" - - .. code-block:: text - - The categorical features in the dataset. This handling depends on class of impute_data: - - pandas DataFrame: - - "auto": categorical information is inferred from any columns with - datatype category or object. - - list of column names (or indices): Useful if all categorical columns - have already been cast to numeric encodings of some type, otherwise you - should just use "auto". Will throw an error if a list is provided AND - categorical dtypes exist in data. If a list is provided, values in the - columns must be consecutive integers starting at 0, as required by lightgbm. - - numpy ndarray: - - "auto": no categorical information is stored. - - list of column indices: Specified columns are treated as categorical. Column - values must be consecutive integers starting at 0, as required by lightgbm. - - initialization: str - - .. code-block:: text - - "random" - missing values will be filled in randomly from existing values. - "empty" - lightgbm will start MICE without initial imputation - - save_all_iterations: boolean, optional(default=True) - - .. code-block:: text - - Save all the imputation values from all iterations, or just - the latest. Saving all iterations allows for additional - plotting, but may take more memory - - save_models: int - - .. code-block:: text - - Which models should be saved: - = 0: no models are saved. Cannot get feature importance or - impute new data. - = 1: only the last model iteration is saved. Can only get - feature importance of last iteration. New data is - imputed using the last model for all specified iterations. - This is only an issue if data is heavily Missing At Random. - = 2: all model iterations are saved. Can get feature importance - for any iteration. When imputing new data, each iteration is - imputed using the model obtained at that iteration in mice. - This allows for imputations that most closely resemble those - that would have been obtained in mice. - - copy_data: boolean (default = False) - - .. code-block:: text - - Should the dataset be referenced directly? If False, this will cause - the dataset to be altered in place. If a copy is created, it is saved - in self.working_data. There are different ways in which the dataset - can be altered: - - 1) complete_data() will fill in missing values - 2) To save space, mice() references and manipulates self.working_data directly. - If self.working_data is a reference to the original dataset, the original - dataset will undergo these manipulations during the mice process. - At the end of the mice process, missing values will be set back to np.NaN - where they were originally missing. - - save_loggers: boolean (default = False) - - .. code-block:: text - - A logger is created each time mice() or impute_new_data() is called. - If True, the loggers are stored in a list ImputationKernel.loggers. - If you wish to start saving logs, call ImputationKernel.start_logging(). - If you wish to stop saving logs, call ImputationKernel.stop_logging(). - - random_state: None,int, or numpy.random.RandomState - - .. code-block:: text - - The random_state ensures script reproducibility. It only ensures reproducible - results if the same script is called multiple times. It does not guarantee - reproducible results at the record level, if a record is imputed multiple - different times. If reproducible record-results are desired, a seed must be - passed for each record in the random_seed_array parameter. - - """ - - def __init__( - self, - data: _t_dat, - datasets: int = 1, - variable_schema: Union[_t_var_list, _t_var_dict, None] = None, - imputation_order: Union[str, _t_var_list] = "ascending", - train_nonmissing: bool = False, - mean_match_scheme: Optional[MeanMatchScheme] = None, - data_subset: Union[int, float, _t_var_sub, None] = None, - categorical_feature: Union[str, _t_var_list] = "auto", - initialization: str = "random", - save_all_iterations: bool = True, - save_models: int = 1, - copy_data: bool = True, - save_loggers: bool = False, - random_state: _t_random_state = None, - ): - super().__init__( - impute_data=data, - datasets=datasets, - variable_schema=variable_schema, - imputation_order=imputation_order, - train_nonmissing=train_nonmissing, - categorical_feature=categorical_feature, - save_all_iterations=save_all_iterations, - copy_data=copy_data, - ) - - self.initialization = initialization - self.train_nonmissing = train_nonmissing - self.save_models = save_models - self.save_loggers = save_loggers - self.loggers: List[Logger] = [] - self.models: Dict[Any, Booster] = {} - self.candidate_preds: Dict[Any, np.ndarray] = {} - self.optimal_parameters: Dict[Any, Any] = { - ds: {var: {} for var in self.variable_training_order} - for ds in range(datasets) - } - self.optimal_parameter_losses: Dict[Any, Any] = { - ds: {var: np.inf for var in self.variable_training_order} - for ds in range(datasets) - } - - # Format data_subset and available_candidates - available_candidates = { - v: (self.data_shape[0] - self.na_counts[v]) - for v in self.variable_training_order - } - data_subset = _DEFAULT_DATA_SUBSET if data_subset is None else data_subset - if not isinstance(data_subset, dict): - data_subset = {v: data_subset for v in self.variable_training_order} - if set(data_subset) != set(self.variable_training_order): - # Change variable names to indices - for v in list(data_subset): - data_subset[self._get_var_ind_from_scalar(v)] = data_subset.pop(v) - ds_supplement = { - v: _DEFAULT_DATA_SUBSET - for v in self.variable_training_order - if v not in data_subset.keys() - } - data_subset.update(ds_supplement) - for v, ds in data_subset.items(): - assert v in self.variable_training_order, ( - f"Variable {self._get_var_name_from_scalar(v)} will not have a model trained " - + "but it is in data_subset." - ) - data_subset[v] = _interpret_ds(data_subset[v], available_candidates[v]) - - self.available_candidates = available_candidates - self.data_subset = data_subset - - # Get mean matching function - if mean_match_scheme is None: - from .builtin_mean_match_schemes import mean_match_default - - self.mean_match_scheme = mean_match_default.copy() - - else: - assert isinstance(mean_match_scheme, MeanMatchScheme) - self.mean_match_scheme = mean_match_scheme.copy() - - # Format and run through mean match candidate checks. - self.mean_match_scheme._format_mean_match_candidates(data, available_candidates) - - # Ensure mmc and mms make sense: - # mmc <= mms <= available candidates for each var - for v in self.imputation_order: - mmc = self.mean_match_scheme.mean_match_candidates[v] - assert mmc <= data_subset[v], f"{v} mean_match_candidates > data_subset" - assert ( - data_subset[v] <= available_candidates[v] - ), f"{v} data_subset > available candidates" - - # Make sure all pandas categorical levels are used. - rare_levels = [] - for cat in self.categorical_variables: - cat_name = self._get_var_name_from_scalar(cat) - cat_dat = self._get_nonmissing_values(cat) - cat_levels, cat_count = np.unique(cat_dat, return_counts=True) - cat_dtype = cat_dat.dtype - if cat_dtype.name == "category": - levels_in_data = set(cat_levels) - levels_in_catdt = set(cat_dtype.categories) - levels_not_in_data = levels_in_catdt - levels_in_data - assert ( - len(levels_not_in_data) == 0 - ), f"{cat_name} has unused categories: {','.join(levels_not_in_data)}" - - if any(cat_count / cat_count.sum() < 0.002): - rare_levels.append(cat_name) - - if len(rare_levels) > 0: - warn( - f"[{','.join(rare_levels)}] have very rare categories, it is a good " - "idea to group these, or set the min_data_in_leaf parameter to prevent " - "lightgbm from outputting 0.0 probabilities." - ) - - # Manage randomness - self._completely_random_kernel = random_state is None - self._random_state = ensure_rng(random_state) - - # Set initial imputations (iteration 0). - self._initialize_dataset( - self, random_state=self._random_state, random_seed_array=None - ) - - def __repr__(self): - summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self._ids_info()}' - return summary_string - - # def _mm_type_handling(self, mm, available_candidates) -> int: - # if isinstance(mm, float): - # - # assert (mm > 0.0) and ( - # mm <= 1.0 - # ), "mean_matching must be < 0.0 and >= 1.0 if a float" - # - # ret = int(mm * available_candidates) - # - # elif isinstance(mm, int): - # - # assert mm >= 0, "mean_matching must be above 0 if an int is passed." - # ret = mm - # - # else: - # - # raise ValueError( - # "mean_match_candidates type not recognized. " - # + "Any supplied values must be a 0.0 < float <= 1.0 or int >= 1" - # ) - # - # return ret - - def _initialize_random_seed_array(self, random_seed_array, expected_shape): - """ - Formats and takes the first hash of the random_seed_array. - """ - - # Format random_seed_array if it was passed. - if random_seed_array is not None: - if self._completely_random_kernel: - warn( - """ - This kernel is completely random (no random_state was provided on initialization). - Values imputed using ThisKernel.impute_new_data() will be deterministic, however - the kernel itself is non-reproducible. - """ - ) - assert isinstance(random_seed_array, np.ndarray) - assert ( - random_seed_array.dtype == "int32" - ), "random_seed_array must be a np.ndarray of type int32" - assert ( - random_seed_array.shape[0] == expected_shape - ), "random_seed_array must be the same length as data." - random_seed_array = hash_int32(random_seed_array) - else: - random_seed_array = None - - return random_seed_array - - def _iter_pairs(self, new_iterations): - """ - Returns the absolute and relative iterations that are going to be - run for a given function call. - """ - current_iters = self.iteration_count() - iter_pairs = [(current_iters + i + 1, i + 1) for i in range(new_iterations)] - return iter_pairs - - def _initialize_dataset(self, imputed_data, random_state, random_seed_array): - """ - Sets initial imputation values for iteration 0. - If "random", draw values from the kernel at random. - If "empty", keep the values missing, since missing values - can be handled natively by lightgbm. - """ - - assert not imputed_data.initialized, "dataset has already been initialized" - - if self.initialization == "random": - for var in imputed_data.imputation_order: - kernel_nonmissing_ind = self._get_nonmissing_indx(var) - candidate_values = _subset_data( - self.working_data, kernel_nonmissing_ind, var, return_1d=True - ) - n_candidates = kernel_nonmissing_ind.shape[0] - missing_ind = imputed_data.na_where[var] - - for ds in range(imputed_data.dataset_count()): - # Initialize using the random_state if no record seeds were passed. - if random_seed_array is None: - imputed_data[ds, var, 0] = random_state.choice( - candidate_values, - size=imputed_data.na_counts[var], - replace=True, - ) - else: - assert ( - len(random_seed_array) == imputed_data.data_shape[0] - ), "The random_seed_array did not match the number of rows being imputed." - selection_ind = random_seed_array[missing_ind] % n_candidates - init_imps = candidate_values[selection_ind] - imputed_data[ds, var, 0] = np.array(init_imps) - random_seed_array[missing_ind] = hash_int32( - random_seed_array[missing_ind] - ) - - elif self.initialization == "empty": - for var in imputed_data.imputation_order: - for ds in range(imputed_data.dataset_count()): - # Saves space, since np.nan will be broadcast. - imputed_data[ds, var, 0] = np.array([np.nan]) - - else: - raise ValueError("initialization parameter not recognized.") - - imputed_data.initialized = True - - def _reconcile_parameters(self, defaults, user_supplied): - """ - Checks in user_supplied for aliases of each parameter in defaults. - Combines the dicts once the aliases have been reconciled. - """ - params = defaults.copy() - for par, val in defaults.items(): - alias_names = _ConfigAliases.get(par) - user_supplied_aliases = [ - i for i in alias_names if i in list(user_supplied) and i != par - ] - if len(user_supplied_aliases) == 0: - continue - elif len(user_supplied_aliases) == 1: - params[par] = user_supplied.pop(user_supplied_aliases[0]) - else: - raise ValueError( - f"Supplied 2 aliases for the same parameter: {user_supplied_aliases}" - ) - - params.update(user_supplied) - - return params - - def _format_variable_parameters( - self, variable_parameters: Optional[Dict] - ) -> Dict[int, Any]: - """ - Unpacking will expect an empty dict at a minimum. - This function collects parameters if they were - provided, and returns empty dicts if they weren't. - """ - if variable_parameters is None: - vsp: Dict[int, Any] = {var: {} for var in self.variable_training_order} - - else: - for variable in list(variable_parameters): - variable_parameters[ - self._get_var_ind_from_scalar(variable) - ] = variable_parameters.pop(variable) - vsp_vars = set(variable_parameters) - - assert vsp_vars.issubset( - self.variable_training_order - ), "Some variable_parameters are not associated with models being trained." - vsp = { - var: variable_parameters[var] if var in vsp_vars else {} - for var in self.variable_training_order - } - - return vsp - - def _get_lgb_params(self, var, vsp, random_state, **kwlgb): - """ - Builds the parameters for a lightgbm model. Infers objective based on - datatype of the response variable, assigns a random seed, finds - aliases in the user supplied parameters, and returns a final dict. - - Parameters - ---------- - var: int - The variable to be modeled - - vsp: dict - Variable specific parameters. These are supplied by the user. - - random_state: np.random.RandomState - The random state to use (used to set the seed). - - kwlgb: dict - Any additional parameters that should take presidence - over the defaults or user supplied. - """ - - seed = _draw_random_int32(random_state, size=1)[0] - - if var in self.categorical_variables: - n_c = self.category_counts[var] - if n_c > 2: - obj = {"objective": "multiclass", "num_class": n_c} - else: - obj = {"objective": "binary"} - else: - obj = {"objective": "regression"} - - default_lgb_params = {**default_parameters, **obj, "seed": seed} - - # Priority is [variable specific] > [global in kwargs] > [defaults] - params = self._reconcile_parameters(default_lgb_params, kwlgb) - params = self._reconcile_parameters(params, vsp) - - return params - - def _get_random_sample(self, parameters, random_state): - """ - Searches through a parameter set and selects a random - number between the values in any provided tuple of length 2. - """ - - parameters = parameters.copy() - for p, v in parameters.items(): - if hasattr(v, "__iter__"): - if isinstance(v, list): - parameters[p] = random_state.choice(v) - elif isinstance(v, tuple): - parameters[p] = random_state.uniform(v[0], v[1], size=1)[0] - else: - pass - parameters = self._make_params_digestible(parameters) - return parameters - - def _make_params_digestible(self, params): - """ - Cursory checks to force parameters to be digestible - """ - - int_params = [ - "num_leaves", - "min_data_in_leaf", - "num_threads", - "max_depth", - "num_iterations", - "bagging_freq", - "max_drop", - "min_data_per_group", - "max_cat_to_onehot", - ] - params = { - key: int(val) if key in int_params else val for key, val in params.items() - } - return params - - def _get_oof_performance( - self, parameters, folds, train_pointer, categorical_feature - ): - """ - Performance is gathered from built-in lightgbm.cv out of fold metric. - Optimal number of iterations is also obtained. - """ - - num_iterations = parameters.pop("num_iterations") - lgbcv = cv( - params=parameters, - train_set=train_pointer, - folds=folds, - num_boost_round=num_iterations, - categorical_feature=categorical_feature, - return_cvbooster=True, - callbacks=[ - early_stopping(stopping_rounds=10, verbose=False), - log_evaluation(period=0), - ], - ) - best_iteration = lgbcv["cvbooster"].best_iteration - loss_metric_key = list(lgbcv)[0] - loss = np.min(lgbcv[loss_metric_key]) - - return loss, best_iteration - - def _get_nonmissing_values(self, variable): - """ - Returns the non-missing values of a column. - """ - - var_indx = self._get_var_ind_from_scalar(variable) - nonmissing_index = self._get_nonmissing_indx(variable) - candidate_values = _subset_data( - self.working_data, row_ind=nonmissing_index, col_ind=var_indx - ) - return candidate_values - - def _get_candidate_subset(self, variable, subset_count, random_seed): - """ - Returns a reproducible subset index of the - non-missing values for a given variable. - """ - - var_indx = self._get_var_ind_from_scalar(variable) - nonmissing_index = self._get_nonmissing_indx(var_indx) - - # Get the subset indices - if subset_count < len(nonmissing_index): - candidate_values = _subset_data( - self.working_data, row_ind=nonmissing_index, col_ind=var_indx - ) - candidates = candidate_values.shape[0] - groups = max(10, int(candidates / 1000)) - ss = stratified_subset( - y=candidate_values, - size=subset_count, - groups=groups, - cat=var_indx in self.categorical_variables, - seed=random_seed, - ) - candidate_subset = nonmissing_index[ss] - - else: - candidate_subset = nonmissing_index - - return candidate_subset - - def _make_label(self, variable, subset_count, random_seed): - """ - Returns a reproducible subset of the non-missing values of a variable. - """ - - var_indx = self._get_var_ind_from_scalar(variable) - candidate_subset = self._get_candidate_subset( - var_indx, subset_count, random_seed - ) - label = _subset_data( - self.working_data, row_ind=candidate_subset, col_ind=var_indx - ) - - return label - - def _make_features_label(self, variable, subset_count, random_seed): - """ - Makes a reproducible set of features and - target needed to train a lightgbm model. - """ - - var_indx = self._get_var_ind_from_scalar(variable) - candidate_subset = self._get_candidate_subset( - var_indx, subset_count, random_seed - ) - xvars = self.variable_schema[var_indx] - ret_cols = sorted(xvars + [var_indx]) - features = _subset_data( - self.working_data, row_ind=candidate_subset, col_ind=ret_cols - ) - - if self.original_data_class == "pd_DataFrame": - y_name = self._get_var_name_from_scalar(var_indx) - label = features.pop(y_name) - - elif self.original_data_class == "np_ndarray": - y_col = ret_cols.index(var_indx) - label = features[:, y_col].copy() - features = np.delete(features, y_col, axis=1) - - x_cat = [xvars.index(var) for var in self.categorical_variables if var in xvars] - - return features, label, x_cat - - def append(self, imputation_kernel): - """ - Combine two imputation kernels together. - For compatibility, the following attributes of each must be equal: - - - working_data - - iteration_count - - categorical_feature - - mean_match_scheme - - variable_schema - - imputation_order - - save_models - - save_all_iterations - - Only cursory checks are done to ensure working_data is equal. - Appending a kernel with different working_data could ruin this kernel. - - Parameters - ---------- - imputation_kernel: ImputationKernel - The kernel to merge. - - """ - - _assert_dataset_equivalent(self.working_data, imputation_kernel.working_data) - assert self.iteration_count() == imputation_kernel.iteration_count() - assert self.variable_schema == imputation_kernel.variable_schema - assert self.imputation_order == imputation_kernel.imputation_order - assert self.variable_training_order == imputation_kernel.variable_training_order - assert self.categorical_feature == imputation_kernel.categorical_feature - assert self.save_models == imputation_kernel.save_models - assert self.save_all_iterations == imputation_kernel.save_all_iterations - assert ( - self.mean_match_scheme.objective_pred_dtypes - == imputation_kernel.mean_match_scheme.objective_pred_dtypes - ) - assert ( - self.mean_match_scheme.objective_pred_funcs - == imputation_kernel.mean_match_scheme.objective_pred_funcs - ) - assert ( - self.mean_match_scheme.objective_args - == imputation_kernel.mean_match_scheme.objective_args - ) - assert ( - self.mean_match_scheme.mean_match_candidates - == imputation_kernel.mean_match_scheme.mean_match_candidates - ) - - current_datasets = self.dataset_count() - new_datasets = imputation_kernel.dataset_count() - - for key, model in imputation_kernel.models.items(): - new_ds_indx = key[0] + current_datasets - insert_key = new_ds_indx, key[1], key[2] - self.models[insert_key] = model - - for key, cp in imputation_kernel.candidate_preds.items(): - new_ds_indx = key[0] + current_datasets - insert_key = new_ds_indx, key[1], key[2] - self.candidate_preds[insert_key] = cp - - for key, iv in imputation_kernel.imputation_values.items(): - new_ds_indx = key[0] + current_datasets - self[new_ds_indx, key[1], key[2]] = iv - - # Combine dicts - for ds in range(new_datasets): - insert_index = current_datasets + ds - self.optimal_parameters[ - insert_index - ] = imputation_kernel.optimal_parameters[ds] - self.optimal_parameter_losses[ - insert_index - ] = imputation_kernel.optimal_parameter_losses[ds] - - # Append iterations - self.iterations = np.append( - self.iterations, imputation_kernel.iterations, axis=0 - ) - - def compile_candidate_preds(self): - """ - Candidate predictions can be pre-generated before imputing new data. - This can save a substantial amount of time, especially if save_models == 1. - """ - - compile_objectives = ( - self.mean_match_scheme.get_objectives_requiring_candidate_preds() - ) - - for key, model in self.models.items(): - already_compiled = key in self.candidate_preds.keys() - objective = model.params["objective"] - if objective in compile_objectives and not already_compiled: - var = key[1] - candidate_features, _, _ = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model.params["seed"], - ) - self.candidate_preds[key] = self.mean_match_scheme.model_predict( - model, candidate_features - ) - - else: - continue - - def delete_candidate_preds(self): - """ - Deletes the pre-computed candidate predictions. - """ - - self.candidate_preds = {} - - def fit(self, X, y, **fit_params): - """ - Method for fitting a kernel when used in a sklearn pipeline. - Should not be called by the user directly. - """ - - assert self.dataset_count() == 1, ( - "miceforest kernel should be initialized with datasets=1 if " - + "being used in a sklearn pipeline." - ) - _assert_dataset_equivalent(self.working_data, X), ( - "The dataset passed to fit() was not the same as the " - "dataset passed to ImputationKernel()" - ) - self.mice(**fit_params) - return self - - def get_model( - self, dataset: int, variable: Union[str, int], iteration: Optional[int] = None - ): - """ - Return the model for a specific dataset, variable, iteration. - - Parameters - ---------- - dataset: int - The dataset to return the model for. - - var: str - The variable that was imputed - - iteration: int - The model iteration to return. Keep in mind if save_models ==1, - the model was not saved. If none is provided, the latest model - is returned. - - Returns: lightgbm.Booster - The model used to impute this specific variable, iteration. - """ - - var_indx = self._get_var_ind_from_scalar(variable) - itrn = ( - self.iteration_count(datasets=dataset, variables=var_indx) - if iteration is None - else iteration - ) - try: - return self.models[dataset, var_indx, itrn] - except Exception: - raise ValueError("Could not find model.") - - def get_raw_prediction( - self, - variable: Union[int, str], - imp_dataset: int = 0, - imp_iteration: Optional[int] = None, - model_dataset: Optional[int] = None, - model_iteration: Optional[int] = None, - dtype: Union[str, np.dtype, None] = None, - ): - """ - Get the raw model output for a specific variable. - - The data is pulled from the imp_dataset dataset, at the imp_iteration iteration. - The model is pulled from model_dataset dataset, at the model_iteration iteration. - - So, for example, it is possible to get predictions using the imputed values for - dataset 3, at iteration 2, using the model obtained from dataset 10, at iteration - 6. This is assuming desired iterations and models have been saved. - - Parameters - ---------- - variable: int or str - The variable to get the raw predictions for. - Can be an index or variable name. - - imp_dataset: int - The imputation dataset to use when creating the feature dataset. - - imp_iteration: int - The iteration from which to draw the imputation values when - creating the feature dataset. If None, the latest iteration - is used. - - model_dataset: int - The dataset from which to pull the trained model for this variable. - If None, it is selected to be the same as imp_dataset. - - model_iteration: int - The iteration from which to pull the trained model for this variable - If None, it is selected to be the same as imp_iteration. - - dtype: str, np.dtype - The datatype to cast the raw prediction as. - Passed to MeanMatchScheme.model_predict(). - - Returns - ------- - np.ndarray of raw predictions. - - """ - - var_indx = self._get_var_ind_from_scalar(variable) - predictor_variables = self.variable_schema[var_indx] - - # Get the latest imputation iteration if imp_iteration was not specified - if imp_iteration is None: - imp_iteration = self.iteration_count( - datasets=imp_dataset, variables=var_indx - ) - - # If model dataset / iteration wasn't specified, assume it is from the same - # dataset / iteration we are pulling the imputation values from - model_iteration = imp_iteration if model_iteration is None else model_iteration - model_dataset = imp_dataset if model_dataset is None else model_dataset - - # Get our internal dataset ready - self.complete_data(dataset=imp_dataset, iteration=imp_iteration, inplace=True) - - features = _subset_data(self.working_data, col_ind=predictor_variables) - model = self.get_model(model_dataset, var_indx, iteration=model_iteration) - preds = self.mean_match_scheme.model_predict(model, features, dtype=dtype) - - return preds - - def mice( - self, - iterations=2, - verbose=False, - variable_parameters=None, - compile_candidates=False, - **kwlgb, - ): - """ - Perform mice on a given dataset. - - Multiple Imputation by Chained Equations (MICE) is an - iterative method which fills in (imputes) missing data - points in a dataset by modeling each column using the - other columns, and then inferring the missing data. - - For more information on MICE, and missing data in - general, see Stef van Buuren's excellent online book: - https://stefvanbuuren.name/fimd/ch-introduction.html - - For detailed usage information, see this project's - README on the github repository: - https://github.com/AnotherSamWilson/miceforest - - Parameters - ---------- - iterations: int - The number of iterations to run. - - verbose: bool - Should information about the process be printed? - - variable_parameters: None or dict - Model parameters can be specified by variable here. Keys should - be variable names or indices, and values should be a dict of - parameter which should apply to that variable only. - - compile_candidates: bool - Candidate predictions can be stored as they are created while - performing mice. This prevents kernel.compile_candidate_preds() - from having to be called separately, and can save a significant - amount of time if compiled candidate predictions are desired. - - kwlgb: - Additional arguments to pass to lightgbm. Applied to all models. - - """ - - __MICE_TIMED_EVENTS = ["prepare_xy", "training", "predict", "mean_matching"] - iter_pairs = self._iter_pairs(iterations) - - # Delete models and candidate_preds if we shouldn't be saving every iteration - if self.save_models < 2: - self.models = {} - self.candidate_preds = {} - - logger = Logger( - name=f"mice {str(iter_pairs[0][0])}-{str(iter_pairs[-1][0])}", - verbose=verbose, - ) - - vsp = self._format_variable_parameters(variable_parameters) - - for ds in range(self.dataset_count()): - logger.log("Dataset " + str(ds)) - - # set self.working_data to the most current iteration. - self.complete_data(dataset=ds, inplace=True) - last_iteration = False - - for iter_abs, iter_rel in iter_pairs: - logger.log(str(iter_abs) + " ", end="") - if iter_rel == iterations: - last_iteration = True - save_model = self.save_models == 2 or ( - last_iteration and self.save_models == 1 - ) - - for variable in self.variable_training_order: - var_name = self._get_var_name_from_scalar(variable) - logger.log(" | " + var_name, end="") - predictor_variables = self.variable_schema[variable] - data_subset = self.data_subset[variable] - nawhere = self.na_where[variable] - log_context = { - "dataset": ds, - "variable_name": var_name, - "iteration": iter_abs, - } - - # Define the lightgbm parameters - lgbpars = self._get_lgb_params( - variable, vsp[variable], self._random_state, **kwlgb - ) - objective = lgbpars["objective"] - - # These are necessary for building model in mice. - logger.set_start_time() - ( - candidate_features, - candidate_values, - feature_cat_index, - ) = self._make_features_label( - variable=variable, - subset_count=data_subset, - random_seed=lgbpars["seed"], - ) - if ( - self.original_data_class == "pd_DataFrame" - or len(feature_cat_index) == 0 - ): - feature_cat_index = "auto" - - # lightgbm requires integers for label. Categories won't work. - if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes - - num_iterations = lgbpars.pop("num_iterations") - train_pointer = Dataset( - data=candidate_features, - label=candidate_values, - categorical_feature=feature_cat_index, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - logger.set_start_time() - current_model = train( - params=lgbpars, - train_set=train_pointer, - num_boost_round=num_iterations, - categorical_feature=feature_cat_index, - ) - logger.record_time(timed_event="training", **log_context) - - if save_model: - self.models[ds, variable, iter_abs] = current_model - - # Only perform mean matching and insertion - # if variable is being imputed. - if variable in self.imputation_order: - mean_match_args = self.mean_match_scheme.get_mean_match_args( - objective - ) - - # Start creating kwargs for mean matching function - mm_kwargs = {} - - if "lgb_booster" in mean_match_args: - mm_kwargs["lgb_booster"] = current_model - - if {"bachelor_preds", "bachelor_features"}.intersection( - mean_match_args - ): - logger.set_start_time() - bachelor_features = _subset_data( - self.working_data, - row_ind=nawhere, - col_ind=predictor_variables, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - if "bachelor_features" in mean_match_args: - mm_kwargs["bachelor_features"] = bachelor_features - - if "bachelor_preds" in mean_match_args: - logger.set_start_time() - bachelor_preds = self.mean_match_scheme.model_predict( - current_model, bachelor_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["bachelor_preds"] = bachelor_preds - - if "candidate_values" in mean_match_args: - mm_kwargs["candidate_values"] = candidate_values - - if "candidate_features" in mean_match_args: - mm_kwargs["candidate_features"] = candidate_features - - # Calculate the candidate predictions if - # the mean matching function calls for it - if "candidate_preds" in mean_match_args: - logger.set_start_time() - candidate_preds = self.mean_match_scheme.model_predict( - current_model, candidate_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["candidate_preds"] = candidate_preds - - if compile_candidates and save_model: - self.candidate_preds[ - ds, variable, iter_abs - ] = candidate_preds - - if "random_state" in mean_match_args: - mm_kwargs["random_state"] = self._random_state - - # Hashed seeds are only to ensure record reproducibility - # for impute_new_data(). - if "hashed_seeds" in mean_match_args: - mm_kwargs["hashed_seeds"] = None - - logger.set_start_time() - imp_values = self.mean_match_scheme._mean_match( - variable, objective, **mm_kwargs - ) - logger.record_time(timed_event="mean_matching", **log_context) - - assert imp_values.shape == ( - self.na_counts[variable], - ), f"{variable} mean matching returned malformed array" - - # Updates our working data and saves the imputations. - self._insert_new_data( - dataset=ds, variable_index=variable, new_data=imp_values - ) - - self.iterations[ - ds, self.variable_training_order.index(variable) - ] += 1 - - logger.log("\n", end="") - - self._ampute_original_data() - if self.save_loggers: - self.loggers.append(logger) - - def transform(self, X, y=None): - """ - Method for calling a kernel when used in a sklearn pipeline. - Should not be called by the user directly. - """ - - new_dat = self.impute_new_data(X, datasets=[0]) - return new_dat.complete_data(dataset=0, inplace=False) - - def tune_parameters( - self, - dataset: int, - variables: Union[List[int], List[str], None] = None, - variable_parameters: Optional[Dict[Any, Any]] = None, - parameter_sampling_method: str = "random", - nfold: int = 10, - optimization_steps: int = 5, - random_state: _t_random_state = None, - verbose: bool = False, - **kwbounds, - ): - """ - Perform hyperparameter tuning on models at the current iteration. - - .. code-block:: text - - A few notes: - - Underlying models will now be gradient boosted trees by default (or any - other boosting type compatible with lightgbm.cv). - - The parameters are tuned on the data that would currently be returned by - complete_data(dataset). It is usually a good idea to run at least 1 iteration - of mice with the default parameters to get a more accurate idea of the - real optimal parameters, since Missing At Random (MAR) data imputations - tend to converge over time. - - num_iterations is treated as the maximum number of boosting rounds to run - in lightgbm.cv. It is NEVER optimized. The num_iterations that is returned - is the best_iteration returned by lightgbm.cv. num_iterations can be passed to - limit the boosting rounds, but the returned value will always be obtained - from best_iteration. - - lightgbm parameters are chosen in the following order of priority: - 1) Anything specified in variable_parameters - 2) Parameters specified globally in **kwbounds - 3) Default tuning space (miceforest.default_lightgbm_parameters.make_default_tuning_space) - 4) Default parameters (miceforest.default_lightgbm_parameters.default_parameters) - - See examples for a detailed run-through. See - https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters - for even more detailed examples. - - - Parameters - ---------- - - dataset: int (required) - - .. code-block:: text - - The dataset to run parameter tuning on. Tuning parameters on 1 dataset usually results - in acceptable parameters for all datasets. However, tuning results are still stored - seperately for each dataset. - - variables: None or list - - .. code-block:: text - - - If None, default hyper-parameter spaces are selected based on kernel data, and - all variables with missing values are tuned. - - If list, must either be indexes or variable names corresponding to the variables - that are to be tuned. - - variable_parameters: None or dict - - .. code-block:: text - - Defines the tuning space. Dict keys must be variable names or indices, and a subset - of the variables parameter. Values must be a dict with lightgbm parameter names as - keys, and values that abide by the following rules: - scalar: If a single value is passed, that parameter will be used to build the - model, and will not be tuned. - tuple: If a tuple is passed, it must have length = 2 and will be interpreted as - the bounds to search within for that parameter. - list: If a list is passed, values will be randomly selected from the list. - NOTE: This is only possible with method = 'random'. - - example: If you wish to tune the imputation model for the 4th variable with specific - bounds and parameters, you could pass: - variable_parameters = { - 4: { - 'learning_rate: 0.01', - 'min_sum_hessian_in_leaf: (0.1, 10), - 'extra_trees': [True, False] - } - } - All models for variable 4 will have a learning_rate = 0.01. The process will randomly - search within the bounds (0.1, 10) for min_sum_hessian_in_leaf, and extra_trees will - be randomly selected from the list. Also note, the variable name for the 4th column - could also be passed instead of the integer 4. All other variables will be tuned with - the default search space, unless **kwbounds are passed. - - parameter_sampling_method: str - - .. code-block:: text - - If 'random', parameters are randomly selected. - Other methods will be added in future releases. - - nfold: int - - .. code-block:: text - - The number of folds to perform cross validation with. More folds takes longer, but - Gives a more accurate distribution of the error metric. - - optimization_steps: - - .. code-block:: text - - How many steps to run the process for. - - random_state: int or np.random.RandomState or None (default=None) - - .. code-block:: text - - The random state of the process. Ensures reproduceability. If None, the random state - of the kernel is used. Beware, this permanently alters the random state of the kernel - and ensures non-reproduceable results, unless the entire process up to this point - is re-run. - - kwbounds: - - .. code-block:: text - - Any additional arguments that you want to apply globally to every variable. - For example, if you want to limit the number of iterations, you could pass - num_iterations = x to this functions, and it would apply globally. Custom - bounds can also be passed. - - - Returns - ------- - 2 dicts: optimal_parameters, optimal_parameter_losses - - - optimal_parameters: dict - A dict of the optimal parameters found for each variable. - This can be passed directly to the variable_parameters parameter in mice() - - .. code-block:: text - - {variable: {parameter_name: parameter_value}} - - - optimal_parameter_losses: dict - The average out of fold cv loss obtained directly from - lightgbm.cv() associated with the optimal parameter set. - - .. code-block:: text - - {variable: loss} - - """ - - if random_state is None: - random_state = self._random_state - else: - random_state = ensure_rng(random_state) - - if variables is None: - variables = self.imputation_order - else: - variables = self._get_var_ind_from_list(variables) - - self.complete_data(dataset, inplace=True) - - logger = Logger( - name=f"tune: {optimization_steps}", - verbose=verbose, - ) - - vsp = self._format_variable_parameters(variable_parameters) - variable_parameter_space = {} - - for var in variables: - default_tuning_space = make_default_tuning_space( - self.category_counts[var] if var in self.categorical_variables else 1, - int((self.data_shape[0] - len(self.na_where[var])) / 10), - ) - - variable_parameter_space[var] = self._get_lgb_params( - var=var, - vsp={**kwbounds, **vsp[var]}, - random_state=random_state, - **default_tuning_space, - ) - - if parameter_sampling_method == "random": - for var, parameter_space in variable_parameter_space.items(): - logger.log(self._get_var_name_from_scalar(var) + " | ", end="") - - ( - candidate_features, - candidate_values, - feature_cat_index, - ) = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=_draw_random_int32( - random_state=self._random_state, size=1 - )[0], - ) - - # lightgbm requires integers for label. Categories won't work. - if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes - - is_categorical = var in self.categorical_variables - - for step in range(optimization_steps): - logger.log(str(step), end="") - - # Make multiple attempts to learn something. - non_learners = 0 - learning_attempts = 10 - while non_learners < learning_attempts: - # Pointer and folds need to be re-initialized after every run. - train_pointer = Dataset( - data=candidate_features, - label=candidate_values, - categorical_feature=feature_cat_index, - free_raw_data=False, - ) - if is_categorical: - folds = stratified_categorical_folds( - candidate_values, nfold - ) - else: - folds = stratified_continuous_folds(candidate_values, nfold) - sampling_point = self._get_random_sample( - parameters=parameter_space, random_state=random_state - ) - try: - loss, best_iteration = self._get_oof_performance( - parameters=sampling_point.copy(), - folds=folds, - train_pointer=train_pointer, - categorical_feature=feature_cat_index, - ) - except: - loss, best_iteration = np.inf, 0 - - if best_iteration > 1: - break - else: - non_learners += 1 - - if loss < self.optimal_parameter_losses[dataset][var]: - del sampling_point["seed"] - sampling_point["num_iterations"] = best_iteration - self.optimal_parameters[dataset][var] = sampling_point - self.optimal_parameter_losses[dataset][var] = loss - - logger.log(" - ", end="") - - logger.log("\n", end="") - - self._ampute_original_data() - return ( - self.optimal_parameters[dataset], - self.optimal_parameter_losses[dataset], - ) - - def impute_new_data( - self, - new_data: _t_dat, - datasets: Optional[List[int]] = None, - iterations: Optional[int] = None, - save_all_iterations: bool = True, - copy_data: bool = True, - random_state: _t_random_state = None, - random_seed_array: Optional[np.ndarray] = None, - verbose: bool = False, - ) -> ImputedData: - """ - Impute a new dataset - - Uses the models obtained while running MICE to impute new data, - without fitting new models. Pulls mean matching candidates from - the original data. - - save_models must be > 0. If save_models == 1, the last model - obtained in mice is used for every iteration. If save_models > 1, - the model obtained at each iteration is used to impute the new - data for that iteration. If specified iterations is greater than - the number of iterations run so far using mice, the last model - is used for each additional iteration. - - Type checking is not done. It is up to the user to ensure that the - kernel data matches the new data being imputed. - - Parameters - ---------- - new_data: pandas DataFrame or numpy ndarray - The new data to impute - - datasets: int or List[int] (default = None) - The datasets from the kernel to use to impute the new data. - If None, all datasets from the kernel are used. - - iterations: int - The number of iterations to run. - If None, the same number of iterations run so far in mice is used. - - save_all_iterations: bool - Should the imputation values of all iterations be archived? - If False, only the latest imputation values are saved. - - copy_data: boolean - Should the dataset be referenced directly? This will cause the dataset to be altered - in place. If a copy is created, it is saved in self.working_data. There are different - ways in which the dataset can be altered: - - 1) complete_data() will fill in missing values - 2) mice() references and manipulates self.working_data directly. - - random_state: int or np.random.RandomState or None (default=None) - The random state of the process. Ensures reproducibility. If None, the random state - of the kernel is used. Beware, this permanently alters the random state of the kernel - and ensures non-reproduceable results, unless the entire process up to this point - is re-run. - - random_seed_array: None or np.ndarray (int32) - - .. code-block:: text - - Record-level seeds. - - Ensures deterministic imputations at the record level. random_seed_array causes - deterministic imputations for each record no matter what dataset each record is - imputed with, assuming the same number of iterations and datasets are used. - If random_seed_array os passed, random_state must also be passed. - - Record-level imputations are deterministic if the following conditions are met: - 1) The associated seed is the same. - 2) The same kernel is used. - 3) The same number of iterations are run. - 4) The same number of datasets are run. - - Notes: - a) This will slightly slow down the imputation process, because random - number generation in numpy can no longer be vectorized. If you don't have a - specific need for deterministic imputations at the record level, it is better to - keep this parameter as None. - - b) Using this parameter may change the global numpy seed by calling np.random.seed(). - - c) Internally, these seeds are hashed each time they are used, in order - to obtain different results for each dataset / iteration. - - - verbose: boolean - Should information about the process be printed? - - Returns - ------- - miceforest.ImputedData - - """ - - datasets = list(range(self.dataset_count())) if datasets is None else datasets - kernel_iterations = self.iteration_count() - iterations = kernel_iterations if iterations is None else iterations - iter_pairs = self._iter_pairs(iterations) - __IND_TIMED_EVENTS = ["prepare_xy", "predict", "mean_matching"] - logger = Logger( - name=f"ind {str(iter_pairs[0][1])}-{str(iter_pairs[-1][1])}", - verbose=verbose, - ) - - if isinstance(self.working_data, pd_DataFrame): - assert isinstance(new_data, pd_DataFrame) - assert set(self.working_data.columns) == set( - new_data.columns - ), "Different columns from original dataset." - assert all( - [ - self.working_data[col].dtype == new_data[col].dtype - for col in self.working_data.columns - ] - ), "Column types are not the same as the original data. Check categorical columns." - - if self.save_models < 1: - raise ValueError("No models were saved.") - - imputed_data = ImputedData( - impute_data=new_data, - datasets=len(datasets), - variable_schema=self.variable_schema.copy(), - imputation_order=self.variable_training_order.copy(), - train_nonmissing=False, - categorical_feature=self.categorical_feature, - save_all_iterations=save_all_iterations, - copy_data=copy_data, - ) - - ### Manage Randomness. - if random_state is None: - assert ( - random_seed_array is None - ), "random_state is also required when using random_seed_array" - random_state = self._random_state - else: - random_state = ensure_rng(random_state) - # use_seed_array = random_seed_array is not None - random_seed_array = self._initialize_random_seed_array( - random_seed_array=random_seed_array, - expected_shape=imputed_data.data_shape[0], - ) - self._initialize_dataset( - imputed_data, random_state=random_state, random_seed_array=random_seed_array - ) - - for ds_kern in datasets: - logger.log("Dataset " + str(ds_kern)) - self.complete_data(dataset=ds_kern, inplace=True) - ds_new = datasets.index(ds_kern) - imputed_data.complete_data(dataset=ds_new, inplace=True) - - for iter_abs, iter_rel in iter_pairs: - logger.log(str(iter_rel) + " ", end="") - - # Determine which model iteration to grab - if self.save_models == 1 or iter_abs > kernel_iterations: - iter_model = kernel_iterations - else: - iter_model = iter_abs - - for var in imputed_data.imputation_order: - var_name = self._get_var_name_from_scalar(var) - logger.log(" | " + var_name, end="") - log_context = { - "dataset": ds_kern, - "variable_name": var_name, - "iteration": iter_rel, - } - nawhere = imputed_data.na_where[var] - predictor_variables = self.variable_schema[var] - - # Select our model. - current_model = self.get_model( - variable=var, dataset=ds_kern, iteration=iter_model - ) - objective = current_model.params["objective"] - model_seed = current_model.params["seed"] - - # Start building mean matching kwargs - mean_match_args = self.mean_match_scheme.get_mean_match_args( - objective - ) - mm_kwargs = {} - - if "lgb_booster" in mean_match_args: - mm_kwargs["lgb_booster"] = current_model - - # Procure bachelor information - if {"bachelor_preds", "bachelor_features"}.intersection( - mean_match_args - ): - logger.set_start_time() - bachelor_features = _subset_data( - imputed_data.working_data, - row_ind=imputed_data.na_where[var], - col_ind=predictor_variables, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - if "bachelor_features" in mean_match_args: - mm_kwargs["bachelor_features"] = bachelor_features - - if "bachelor_preds" in mean_match_args: - logger.set_start_time() - bachelor_preds = self.mean_match_scheme.model_predict( - current_model, bachelor_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["bachelor_preds"] = bachelor_preds - - # Procure candidate information - if { - "candidate_values", - "candidate_features", - "candidate_preds", - }.intersection(mean_match_args): - # Need to return candidate features if we need to calculate - # candidate_preds or candidate_features is needed by mean matching function - calculate_candidate_preds = ( - ds_kern, - var, - iter_model, - ) not in self.candidate_preds.keys() and "candidate_preds" in mean_match_args - return_features = ( - "candidate_features" in mean_match_args - ) or calculate_candidate_preds - # Set up like this so we only have to subset once - logger.set_start_time() - if return_features: - ( - candidate_features, - candidate_values, - _, - ) = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model_seed, - ) - else: - candidate_values = self._make_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model_seed, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - - if "candidate_values" in mean_match_args: - # lightgbm requires integers for label. Categories won't work. - if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes - mm_kwargs["candidate_values"] = candidate_values - - if "candidate_features" in mean_match_args: - mm_kwargs["candidate_features"] = candidate_features - - # Calculate the candidate predictions if - # the mean matching function calls for it - if "candidate_preds" in mean_match_args: - if calculate_candidate_preds: - logger.set_start_time() - candidate_preds = self.mean_match_scheme.model_predict( - current_model, candidate_features - ) - logger.record_time(timed_event="predict", **log_context) - else: - candidate_preds = self.candidate_preds[ - ds_kern, var, iter_model - ] - mm_kwargs["candidate_preds"] = candidate_preds - - if "random_state" in mean_match_args: - mm_kwargs["random_state"] = random_state - - if "hashed_seeds" in mean_match_args: - if isinstance(random_seed_array, np.ndarray): - seeds = random_seed_array[nawhere] - rehash_seeds = True - - else: - seeds = None - rehash_seeds = False - - mm_kwargs["hashed_seeds"] = seeds - - else: - rehash_seeds = False - - logger.set_start_time() - imp_values = self.mean_match_scheme._mean_match( - var, objective, **mm_kwargs - ) - logger.record_time(timed_event="mean_matching", **log_context) - imputed_data._insert_new_data( - dataset=ds_new, variable_index=var, new_data=imp_values - ) - # Refresh our seeds. - if rehash_seeds: - assert isinstance(random_seed_array, np.ndarray) - random_seed_array[nawhere] = hash_int32(seeds) - - imputed_data.iterations[ - ds_new, imputed_data.imputation_order.index(var) - ] += 1 - - logger.log("\n", end="") - - imputed_data._ampute_original_data() - if self.save_loggers: - self.loggers.append(logger) - - return imputed_data - - def start_logging(self): - """ - Start saving loggers to self.loggers - """ - - self.save_loggers = True - - def stop_logging(self): - """ - Stop saving loggers to self.loggers - """ - - self.save_loggers = False - - def save_kernel( - self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True - ): - """ - Compresses and saves the kernel to a file. - - Parameters - ---------- - filepath: str - The file to save to. - - clevel: int - The compression level, sent to clevel argument in blosc2.compress() - - cname: str - The compression algorithm used. - Sent to cname argument in blosc2.compress. - If None is specified, the default is lz4hc. - - n_threads: int - The number of threads to use for compression. - By default, all threads are used. - - copy_while_saving: boolean - Should the kernel be copied while saving? Copying is safer, but - may take more memory. - - """ - - clevel = 9 if clevel is None else clevel - cname = "lz4hc" if cname is None else cname - - # make interface compatible - codec_mapping = { - "blosclz": blosc2.Codec.BLOSCLZ, - "lz4":blosc2.Codec.LZ4, - "lz4hc":blosc2.Codec.LZ4HC, - "zlib":blosc2.Codec.ZLIB, - "zstd":blosc2.Codec.ZSTD, - "ndlz":blosc2.Codec.NDLZ, - "zfp_acc":blosc2.Codec.ZFP_ACC, - "zfp_prec":blosc2.Codec.ZFP_PREC, - "zfp_rate":blosc2.Codec.ZFP_RATE, - "openhtj2k":blosc2.Codec.OPENHTJ2K, - "grok":blosc2.Codec.GROK - } - if cname in codec_mapping.keys(): - codec=codec_mapping[cname] - else: - codec=blosc2.Codec.LZ4HC - - n_threads = blosc2.detect_number_of_cores() if n_threads is None else n_threads - - if copy_while_saving: - kernel = copy(self) - else: - kernel = self - - # convert working data to parquet bytes object - if kernel.original_data_class == "pd_DataFrame": - working_data_bytes = BytesIO() - kernel.working_data.to_parquet(working_data_bytes) - kernel.working_data = working_data_bytes - - blosc2.set_nthreads(n_threads) - - with open(filepath, "wb") as f: - dill.dump( - blosc2.compress( - dill.dumps(kernel), - clevel=clevel, - filter=blosc2.Filter.NOFILTER, - codec=codec, - ), - f, - ) - - def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: - """ - Return a matrix of feature importance. The cells - represent the normalized feature importance of the - columns to impute the rows. This is calculated - internally by lightgbm.Booster.feature_importance(). - - Parameters - ---------- - dataset: int - The dataset to get the feature importance for. - - iteration: int - The iteration to return the feature importance for. - Right now, the model must be saved to return importance - - Returns - ------- - np.ndarray of importance values. Rows are imputed variables, and - columns are predictor variables. - - """ - - if iteration is None: - iteration = self.iteration_count(datasets=dataset) - - importance_matrix = np.full( - shape=(len(self.imputation_order), len(self.predictor_vars)), - fill_value=np.NaN, - ) - - for ivar in self.imputation_order: - importance_dict = dict( - zip( - self.variable_schema[ivar], - self.get_model(dataset, ivar, iteration).feature_importance(), - ) - ) - for pvar in importance_dict: - importance_matrix[ - np.sort(self.imputation_order).tolist().index(ivar), - np.sort(self.predictor_vars).tolist().index(pvar), - ] = importance_dict[pvar] - - return importance_matrix - - def plot_feature_importance( - self, - dataset, - normalize: bool = True, - iteration: Optional[int] = None, - **kw_plot, - ): - """ - Plot the feature importance. See get_feature_importance() - for more details. - - Parameters - ---------- - dataset: int - The dataset to plot the feature importance for. - - iteration: int - The iteration to plot the feature importance of. - - normalize: book - Should the values be normalize from 0-1? - If False, values are raw from Booster.feature_importance() - - kw_plot - Additional arguments sent to sns.heatmap() - - """ - - # Move this to .compat at some point. - try: - from seaborn import heatmap - except ImportError: - raise ImportError("seaborn must be installed to plot importance") - - importance_matrix = self.get_feature_importance( - dataset=dataset, iteration=iteration - ) - if normalize: - importance_matrix = ( - importance_matrix / np.nansum(importance_matrix, 1).reshape(-1, 1) - ).round(2) - - imputed_var_names = [ - self._get_var_name_from_scalar(int(i)) - for i in np.sort(self.imputation_order) - ] - predictor_var_names = [ - self._get_var_name_from_scalar(int(i)) for i in np.sort(self.predictor_vars) - ] - - params = { - **{ - "cmap": "coolwarm", - "annot": True, - "fmt": ".2f", - "xticklabels": predictor_var_names, - "yticklabels": imputed_var_names, - "annot_kws": {"size": 16}, - }, - **kw_plot, - } - - print(heatmap(importance_matrix, **params)) diff --git a/miceforest/ImputedData.py b/miceforest/ImputedData.py deleted file mode 100644 index f6119d3..0000000 --- a/miceforest/ImputedData.py +++ /dev/null @@ -1,552 +0,0 @@ -import numpy as np -from .compat import pd_DataFrame -from pandas import DataFrame, MultiIndex -from .utils import ( - get_best_int_downcast, - _t_dat, - _t_var_list, - _t_var_dict, - _ensure_iterable, -) -from itertools import combinations -from typing import Dict, List, Union, Any, Optional -from warnings import warn - - -class ImputedPandasDataFrame: - def __init__( - self, - impute_data: pd_DataFrame, - num_datasets: int = 5, - variable_schema: Union[List[str], Dict[str, str]] = None, - imputation_order: str = "ascending", - copy_data: bool = True, - ): - # All references to the data should be through self. - self.working_data = impute_data.copy() if copy_data else impute_data - data_shape = self.working_data.shape - - column_names = [] - pd_dtypes_orig = {} - for col, series in self.working_data.items(): - assert isinstance(col, str), 'column names must be strings' - assert series.dtype.name != 'object', 'convert object dtypes to something else' - column_names.append(col) - pd_dtypes_orig[col] = series.dtype.name - - column_names: List[str] = [str(x) for x in self.working_data.columns] - self.column_names = column_names - pd_dtypes_orig = self.working_data.dtypes - - - # Collect info about what data is missing. - na_where = {} - for col in column_names: - nas = np.where(self.working_data[col].isnull())[0] - best_downcast = get_best_int_downcast(nas.max()) - na_where[col] = nas.astype(best_downcast) - na_counts = {col: len(nw) for col, nw in na_where.items()} - vars_with_any_missing = [ - col for col, ind in na_where.items() if len(ind > 0) - ] - - # If variable_schema was passed, use that as the - # list of variables that should have models trained. - # Otherwise, only train models on variables that have - # missing values, unless train_nonmissing, in which - # case we build imputation models for all variables. - if variable_schema is None: - modeled_variables = vars_with_any_missing - variable_schema = { - target: [ - regressor - for regressor in column_names - if regressor != target - ] - for target in modeled_variables - } - else: - if isinstance(variable_schema, list): - variable_schema = { - target: [ - regressor - for regressor in column_names - if regressor != target - ] - for target in variable_schema - } - elif isinstance(variable_schema, dict): - for target, regressors in variable_schema.items(): - if target in regressors: - raise ValueError(f'{target} being used to impute itself') - - # variable schema at this point should only - # contain the variables that are to have models trained. - modeled_variables = list(variable_schema) - imputed_variables = [ - col for col in modeled_variables - if col in vars_with_any_missing - ] - modeled_but_not_imputed_variables = [ - col for col in modeled_variables - if col not in imputed_variables - ] - - # Model Training Order: - # Variables with missing data are always trained - # first, according to imputation_order. Afterwards, - # variables with no missing values have models trained. - if imputation_order in ["ascending", "descending"]: - na_counts_of_imputed_variables = { - key: value - for key, value in self.na_counts.items() - if key in imputed_variables - } - self.imputation_order = list(sorted( - na_counts_of_imputed_variables.items(), - key=lambda item: item[1] - )) - if imputation_order == "decending": - self.imputation_order.reverse() - elif imputation_order == "roman": - self.imputation_order = imputed_variables.copy() - elif imputation_order == "arabic": - self.imputation_order = imputed_variables.copy() - self.imputation_order.reverse() - else: - raise ValueError("imputation_order not recognized.") - - model_training_order = self.imputation_order + modeled_but_not_imputed_variables - - self.variable_schema = variable_schema - self.model_training_order = model_training_order - self.data_shape = data_shape - self.na_counts = na_counts - self.na_where = na_where - self.vars_with_any_missing = vars_with_any_missing - self.imputed_variable_count = len(self.imputation_order) - self.modeled_variable_count = len(self.model_training_order) - self.iterations = np.zeros( - shape=(num_datasets, self.modeled_variable_count) - ).astype(int) - - iv_multiindex = MultiIndex.from_arrays([np.arange(num_datasets), [0]], names=('dataset', 'iteration')) - self.imputation_values = { - var: DataFrame(index=na_where[var], columns=iv_multiindex).astype(pd_dtypes_orig[var]) - for var in self.imputation_order - } - - # Subsetting allows us to get to the imputation values: - def __getitem__(self, tup): - var, ds, iter = tup - return self.imputation_values[var].loc[:, (ds, iter)] - - def __setitem__(self, tup, newitem): - var, ds, iter = tup - self.imputation_values[var].loc[:, (ds, iter)] = newitem - - def __delitem__(self, tup): - var, ds, iter = tup - del self.imputation_values[var][ds, iter] - - def __repr__(self): - summary_string = f'\n{" " * 14}Class: ImputedData\n{self._ids_info()}' - return summary_string - - def _ids_info(self): - summary_string = f"""\ - Datasets: {self.dataset_count()} - Iterations: {self.iteration_count()} - Data Samples: {self.data_shape[0]} - Data Columns: {self.data_shape[1]} - Imputed Variables: {self.imputed_variable_count} - Modeled Variables: {self.modeled_variable_count} - """ - return summary_string - - def _get_nonmissing_index(self, column): - na_where = self.na_where[column] - dtype = na_where.dtype - non_missing_ind = np.setdiff1d(np.arange(self.data_shape[0], dtype=dtype), na_where) - return non_missing_ind - - def _get_nonmissing_values(self, column): - ind = self._get_nonmissing_index(column) - return self.working_data.loc[ind, column] - - def _add_imputed_values(self, dataset, variable_index, new_data): - current_iter = self.iteration_count(datasets=dataset, variables=variable_index) - - def _ampute_original_data(self): - """Need to put self.working_data back in its original form""" - for c in self.imputation_order: - _assign_col_values_without_copy( - dat=self.working_data, - row_ind=self.na_where[c], - col_ind=c, - val=np.array([np.nan]), - ) - - def _get_numeric_columns( - self, - imputed: bool = True, - modeled: bool = True, - ): - """Returns the non-categorical imputed variable indexes.""" - - num_vars = [ - v for v in self.imputation_order if v not in self.categorical_variables - ] - - if subset is not None: - subset = self._get_var_ind_from_list(subset) - num_vars = [v for v in num_vars if v in subset] - - return num_vars - - def _prep_multi_plot( - self, - variables, - ): - plots = len(variables) - plotrows, plotcols = int(np.ceil(np.sqrt(plots))), int( - np.ceil(plots / np.ceil(np.sqrt(plots))) - ) - return plots, plotrows, plotcols - - def iteration_count(self, datasets=None, variables=None): - """ - Grabs the iteration count for specified variables, datasets. - If the iteration count is not consistent across the provided - datasets/variables, an error will be thrown. Providing None - will use all datasets/variables. - - This is to ensure the process is in a consistent state when - the iteration count is needed. - - Parameters - ---------- - datasets: int or list[int] - The datasets to check the iteration count for. - variables: int, str, list[int] or list[str]: - The variables to check the iteration count for. - Variables can be specified by their names or indexes. - - Returns - ------- - An integer representing the iteration count. - """ - - ds = ( - list(range(self.dataset_count())) - if datasets is None - else _ensure_iterable(datasets) - ) - - if variables is None: - var = self.variable_training_order - else: - variables = _ensure_iterable(variables) - var = self._get_var_ind_from_list(variables) - - assert set(var).issubset(self.variable_training_order) - - iter_indx = [self.variable_training_order.index(v) for v in var] - ds_uniq = np.unique(self.iterations[np.ix_(ds, iter_indx)]) - if len(ds_uniq) == 0: - return -1 - if len(ds_uniq) > 1: - raise ValueError( - "iterations were not consistent across provided datasets, variables." - ) - - return ds_uniq[0] - - def complete_data( - self, - dataset: int = 0, - iteration: Optional[int] = None, - inplace: bool = False, - variables: Optional[_t_var_list] = None, - ): - """ - Return dataset with missing values imputed. - - Parameters - ---------- - dataset: int - The dataset to complete. - iteration: int - Impute data with values obtained at this iteration. - If None, returns the most up-to-date iterations, - even if different between variables. If not none, - iteration must have been saved in imputed values. - inplace: bool - Should the data be completed in place? If True, - self.working_data is imputed,and nothing is returned. - This is useful if the dataset is very large. If - False, a copy of the data is returned, with missing - values imputed. - - Returns - ------- - The completed data, with values imputed for specified variables. - - """ - - # Return a copy if not inplace. - impute_data = self.working_data if inplace else self.working_data.copy() - - # Figure out which variables we need to impute. - # Never impute variables that are not in imputation_order. - imp_vars = self.imputation_order if variables is None else variables - imp_vars = self._get_var_ind_from_list(imp_vars) - imp_vars = [v for v in imp_vars if v in self.imputation_order] - - for var in imp_vars: - if iteration is None: - iteration = self.iteration_count(datasets=dataset, variables=var) - _assign_col_values_without_copy( - dat=impute_data, - row_ind=self.na_where[var], - col_ind=var, - val=self[dataset, var, iteration], - ) - - if not inplace: - return impute_data - - def get_means(self, datasets, variables=None): - """ - Return a dict containing the average imputation value - for specified variables at each iteration. - """ - num_vars = self._get_num_vars(variables) - - # For every variable, get the correlations between every dataset combination - # at each iteration - curr_iteration = self.iteration_count(datasets=datasets) - if self.save_all_iterations: - iter_range = list(range(curr_iteration + 1)) - else: - iter_range = [curr_iteration] - mean_dict = { - ds: { - var: {itr: np.mean(self[ds, var, itr]) for itr in iter_range} - for var in num_vars - } - for ds in datasets - } - - return mean_dict - - def plot_mean_convergence(self, datasets=None, variables=None, **adj_args): - """ - Plots the average value of imputations over each iteration. - - Parameters - ---------- - variables: None or list - The variables to plot. Must be numeric. - adj_args - Passed to matplotlib.pyplot.subplots_adjust() - - """ - - # Move this to .compat at some point. - try: - import matplotlib.pyplot as plt - from matplotlib import gridspec - except ImportError: - raise ImportError("matplotlib must be installed to plot mean convergence") - - if self.iteration_count() < 2 or not self.save_all_iterations: - raise ValueError("There is only one iteration.") - - if datasets is None: - datasets = list(range(self.dataset_count())) - else: - datasets = _ensure_iterable(datasets) - num_vars = self._get_num_vars(variables) - mean_dict = self.get_means(datasets=datasets, variables=variables) - plots, plotrows, plotcols = self._prep_multi_plot(num_vars) - gs = gridspec.GridSpec(plotrows, plotcols) - fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) - - for v in range(plots): - axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) - var = num_vars[v] - for d in mean_dict.values(): - ax[axr, axc].plot(list(d[var].values()), color="black") - ax[axr, axc].set_title(var) - ax[axr, axc].set_xlabel("Iteration") - ax[axr, axc].set_ylabel("mean") - plt.subplots_adjust(**adj_args) - - def plot_imputed_distributions( - self, datasets=None, variables=None, iteration=None, **adj_args - ): - """ - Plot the imputed value distributions. - Red lines are the distribution of original data - Black lines are the distribution of the imputed values. - - Parameters - ---------- - datasets: None, int, list[int] - variables: None, str, int, list[str], or list[int] - The variables to plot. If None, all numeric variables - are plotted. - iteration: None, int - The iteration to plot the distribution for. - If None, the latest iteration is plotted. - save_all_iterations must be True if specifying - an iteration. - adj_args - Additional arguments passed to plt.subplots_adjust() - - """ - # Move this to .compat at some point. - try: - import seaborn as sns - import matplotlib.pyplot as plt - from matplotlib import gridspec - except ImportError: - raise ImportError( - "matplotlib and seaborn must be installed to plot distributions." - ) - - if datasets is None: - datasets = list(range(self.dataset_count())) - else: - datasets = _ensure_iterable(datasets) - if iteration is None: - iteration = self.iteration_count(datasets=datasets, variables=variables) - num_vars = self._get_num_vars(variables) - plots, plotrows, plotcols = self._prep_multi_plot(num_vars) - gs = gridspec.GridSpec(plotrows, plotcols) - fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) - - for v in range(plots): - var = num_vars[v] - axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) - iteration_level_imputations = { - ds: self[ds, var, iteration] for ds in datasets - } - plt.sca(ax[axr, axc]) - non_missing_ind = self._get_nonmissing_index(var) - nonmissing_values = _subset_data( - self.working_data, row_ind=non_missing_ind, col_ind=var, return_1d=True - ) - ax[axr, axc] = sns.kdeplot(nonmissing_values, color="red", linewidth=2) - for imparray in iteration_level_imputations.values(): - ax[axr, axc] = sns.kdeplot( - imparray, color="black", linewidth=1, warn_singular=False - ) - ax[axr, axc].set(xlabel=self._get_var_name_from_scalar(var)) - - plt.subplots_adjust(**adj_args) - - def get_correlations( - self, datasets: List[int], variables: Union[List[int], List[str]] - ): - """ - Return the correlations between datasets for - the specified variables. - - Parameters - ---------- - variables: list[str], list[int] - The variables to return the correlations for. - - Returns - ------- - dict - The correlations at each iteration for the specified - variables. - - """ - - if self.dataset_count() < 3: - raise ValueError( - "Not enough datasets to calculate correlations between them" - ) - curr_iteration = self.iteration_count() - var_indx = self._get_var_ind_from_list(variables) - - # For every variable, get the correlations between every dataset combination - # at each iteration - correlation_dict = {} - if self.save_all_iterations: - iter_range = list(range(1, curr_iteration + 1)) - else: - # Make this iterable for code tidyness - iter_range = [curr_iteration] - - for var in var_indx: - # Get a dict of variables and imputations for all datasets for this iteration - iteration_level_imputations = { - iteration: {ds: self[ds, var, iteration] for ds in datasets} - for iteration in iter_range - } - - combination_correlations = { - iteration: [ - round(np.corrcoef(impcomb)[0, 1], 3) - for impcomb in list(combinations(varimps.values(), 2)) - ] - for iteration, varimps in iteration_level_imputations.items() - } - - correlation_dict[var] = combination_correlations - - return correlation_dict - - def plot_correlations(self, datasets=None, variables=None, **adj_args): - """ - Plot the correlations between datasets. - See get_correlations() for more details. - - Parameters - ---------- - datasets: None or list[int] - The datasets to plot. - variables: None,list - The variables to plot. - adj_args - Additional arguments passed to plt.subplots_adjust() - - """ - - # Move this to .compat at some point. - try: - import matplotlib.pyplot as plt - from matplotlib import gridspec - except ImportError: - raise ImportError("matplotlib must be installed to plot importance") - - if self.dataset_count() < 4: - raise ValueError("Not enough datasets to make box plot") - if datasets is None: - datasets = list(range(self.dataset_count())) - else: - datasets = _ensure_iterable(datasets) - var_indx = self._get_var_ind_from_list(variables) - num_vars = self._get_num_vars(var_indx) - plots, plotrows, plotcols = self._prep_multi_plot(num_vars) - correlation_dict = self.get_correlations(datasets=datasets, variables=num_vars) - gs = gridspec.GridSpec(plotrows, plotcols) - fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) - - for v in range(plots): - axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) - var = list(correlation_dict)[v] - ax[axr, axc].boxplot( - list(correlation_dict[var].values()), - labels=range(len(correlation_dict[var])), - ) - ax[axr, axc].set_title(self._get_var_name_from_scalar(var)) - ax[axr, axc].set_xlabel("Iteration") - ax[axr, axc].set_ylabel("Correlations") - ax[axr, axc].set_ylim([-1, 1]) - plt.subplots_adjust(**adj_args) diff --git a/miceforest/__init__.py b/miceforest/__init__.py index 35942ce..9615b61 100644 --- a/miceforest/__init__.py +++ b/miceforest/__init__.py @@ -10,13 +10,13 @@ from .utils import ampute_data, load_kernel -from .ImputedData import ImputedPandasDataFrame -from .impute import ImputationKernel +from .imputed_data import ImputedData +from .imputation_kernel import ImputationKernel # __version__ = "5.7.0" __all__ = [ - "ImputedPandasDataFrame", + "ImputedData", "ImputationKernel", "ampute_data", "load_kernel", diff --git a/miceforest/default_lightgbm_parameters.py b/miceforest/default_lightgbm_parameters.py index 0c0556c..eb0491c 100644 --- a/miceforest/default_lightgbm_parameters.py +++ b/miceforest/default_lightgbm_parameters.py @@ -3,6 +3,7 @@ # These need to be main parameter names, not aliases default_parameters = { "boosting": "random_forest", + "data_sample_strategy": "bagging", "num_iterations": 48, "max_depth": 8, "num_leaves": 128, @@ -10,8 +11,9 @@ "min_sum_hessian_in_leaf": 0.00001, "min_gain_to_split": 0.0, "bagging_fraction": 0.632, - "feature_fraction": 1.0, - "feature_fraction_bynode": 0.632, + # "feature_fraction": 1.0, + "feature_fraction": 0.632, + # "feature_fraction_bynode": 0.632, "bagging_freq": 1, "verbosity": -1, } diff --git a/miceforest/impute.py b/miceforest/imputation_kernel.py similarity index 55% rename from miceforest/impute.py rename to miceforest/imputation_kernel.py index aea842a..1e2d38e 100644 --- a/miceforest/impute.py +++ b/miceforest/imputation_kernel.py @@ -1,17 +1,19 @@ from miceforest.default_lightgbm_parameters import default_parameters, make_default_tuning_space from miceforest.logger import Logger -from miceforest.ImputedData import ImputedPandasDataFrame +from miceforest.imputed_data import ImputedData from miceforest.utils import ( + logodds, _expand_value_to_dict, _list_union, - _assert_dataset_equivalent, _draw_random_int32, ensure_rng, - hash_int32, + hash_numpy_int_array, stratified_categorical_folds, stratified_continuous_folds, stratified_subset, + _to_2d, + _to_1d ) import numpy as np from warnings import warn @@ -19,19 +21,23 @@ from lightgbm.basic import _ConfigAliases from io import BytesIO import blosc2 +from scipy.spatial import KDTree import dill from copy import copy from typing import Union, List, Dict, Any, Optional, Tuple -from pandas import Series, DataFrame +from pandas import Series, DataFrame, MultiIndex, read_parquet, Categorical _DEFAULT_DATA_SUBSET = 0 _DEFAULT_MEANMATCH_CANDIDATES = 5 -_DEFAULT_MEANMATCH_STRATEGY = 'accurate' +_DEFAULT_MEANMATCH_STRATEGY = 'normal' +_MICE_TIMED_LEVELS = ['Dataset', 'Iteration', 'Variable', 'Event'] +_IMPUTE_NEW_DATA_TIMED_LEVELS = ['Dataset', 'Iteration', 'Variable', 'Event'] +# These can inherently be 2D, Series cannot. +_MEAN_MATCH_PRED_TYPE = Union[np.ndarray, DataFrame] - -class ImputationKernelPandas(ImputedPandasDataFrame): +class ImputationKernel(ImputedData): """ Creates a kernel dataset. This dataset can perform MICE on itself, and impute new data from models obtained during MICE. @@ -99,69 +105,42 @@ class ImputationKernelPandas(ImputedPandasDataFrame): It is recommended to carefully select this value for each variable if dealing with very large data that barely fits into memory. - mean_match_scheme: Dict, default = None + mean_match_strategy: str or Dict[str, str] .. code-block:: text - An instance of the miceforest.MeanMatchScheme class. - - If None is passed, a sensible default scheme is used. There are multiple helpful - schemes that can be accessed from miceforest.builtin_mean_match_schemes, or - you can build your own. - - A description of the defaults: - - mean_match_default (default, if mean_match_scheme is None)) - This scheme is has medium speed and accuracy for most data. - - Categorical: - If mmc = 0, the class with the highest probability is chosen. - If mmc > 0, get N nearest neighbors from class probabilities. - Select 1 at random. - Numeric: - If mmc = 0, the predicted value is used - If mmc > 0, obtain the mmc closest candidate - predictions and collect the associated - real candidate values. Choose 1 randomly. - - - mean_match_shap - This scheme is the most accurate, but takes the longest. - It works the same as mean_match_default, except all nearest - neighbor searches are performed on the shap values of the - predictions, instead of the predictions themselves. - - - mean_match_scheme_fast_cat: - This scheme is faster for categorical variables, - but may be less accurate as well.. - - Categorical: - If mmc = 0, the class with the highest probability is chosen. - If mmc > 0, return class based on random draw weighted by - class probability for each sample. - Numeric or binary: - If mmc = 0, the predicted value is used - If mmc > 0, obtain the mmc closest candidate - predictions and collect the associated - real candidate values. Choose 1 randomly. - - categorical_feature: str or list, default="auto" + There are 3 mean matching strategies included in miceforest: + - "normal" - this is the default. For all predictions, K-nearest-neighbors + is performed on the candidate predictions and bachelor predictions. + The top MMC closest candidate values are chosen at random. + - "fast" - Only available for categorical and binary columns. A value + is selected at random weighted by the class probabilities. + - "shap" - Similar to "normal" but more robust. A K-nearest-neighbors + search is performed on the shap values of the candidate predictions + and the bachelor predictions. A value from the top MMC closest candidate + values is chosen at random. + + A dict of strategies by variable can be passed as well. Any unmentioned variables + will be set to the default, "normal". + + Special rules are enacted when mean_match_candidates == 0 for a variable. See the + mean_match_candidates parameter for more information. + + mean_match_candidates: int or Dict[str, int] .. code-block:: text - The categorical features in the dataset. This handling depends on class of impute_data: + When mean matching relies on selecting one of the top N closest candidate predictions, + this number is used for N. - pandas DataFrame: - - "auto": categorical information is inferred from any columns with - datatype category or object. - - list of column names (or indices): Useful if all categorical columns - have already been cast to numeric encodings of some type, otherwise you - should just use "auto". Will throw an error if a list is provided AND - categorical dtypes exist in data. If a list is provided, values in the - columns must be consecutive integers starting at 0, as required by lightgbm. + Special rules apply when this value is set to 0. This will skip mean matching entirely. + The algorithm that applies depends on the objective type: + - Regression: The bachelor predictions are used as the imputation values. + - Binary: The class with the higher probability is chosen. + - Multiclass: The class with the highest probability is chosen. - numpy ndarray: - - "auto": no categorical information is stored. - - list of column indices: Specified columns are treated as categorical. Column - values must be consecutive integers starting at 0, as required by lightgbm. + Setting mmc to 0 will result in much faster process times, but at the cost of random + variability that is desired when performing Multiple Imputation by Chained Equations. initialize_empty: bool, default = False @@ -179,23 +158,6 @@ class probability for each sample. the latest. Saving all iterations allows for additional plotting, but may take more memory - save_models: int - - .. code-block:: text - - Which models should be saved: - = 0: no models are saved. Cannot get feature importance or - impute new data. - = 1: only the last model iteration is saved. Can only get - feature importance of last iteration. New data is - imputed using the last model for all specified iterations. - This is only an issue if data is heavily Missing At Random. - = 2: all model iterations are saved. Can get feature importance - for any iteration. When imputing new data, each iteration is - imputed using the model obtained at that iteration in mice. - This allows for imputations that most closely resemble those - that would have been obtained in mice. - copy_data: boolean (default = False) .. code-block:: text @@ -246,32 +208,60 @@ def __init__( save_all_iterations_data: bool = True, copy_data: bool = True, random_state: Optional[Union[int, np.random.RandomState]] = None, - verbose: bool = False ): + super().__init__( impute_data=data, num_datasets=num_datasets, variable_schema=variable_schema, - imputation_order=imputation_order, + save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, + random_seed_array=None ) + # Model Training / Imputation Order: + # Variables with missing data are always trained + # first, according to imputation_order. Afterwards, + # variables with no missing values have models trained. + if imputation_order in ["ascending", "descending"]: + _na_counts = { + key: value + for key, value in self.na_counts.items() + if key in self.imputed_variables + } + self.imputation_order = list(Series(_na_counts).sort_values(ascending=False).index) + if imputation_order == "decending": + self.imputation_order.reverse() + elif imputation_order == "roman": + self.imputation_order = self.imputed_variables.copy() + elif imputation_order == "arabic": + self.imputation_order = self.imputed_variables.copy() + self.imputation_order.reverse() + else: + raise ValueError("imputation_order not recognized.") + + modeled_but_not_imputed_variables = [ + col for col in self.modeled_variables + if col not in self.imputed_variables + ] + model_training_order = self.imputation_order + modeled_but_not_imputed_variables + self.model_training_order = model_training_order + self.initialize_empty = initialize_empty self.save_all_iterations_data = save_all_iterations_data - self.logger = Logger(verbose=verbose) - # Models are stored in a dict, keys are (variable, dataset, iteration) + # Models are stored in a dict, keys are (variable, iteration, dataset) self.models: Dict[Tuple[str, int, int], Booster] = {} # Candidate preds are stored the same as models. - self.candidate_preds: Dict[Tuple[str, int, int], Series] = [{}] + self.candidate_preds: Dict[Tuple[str, int, int], Series] = {} # Optimal parameters can only be found on 1 dataset at the current iteration. self.optimal_parameters: Dict[str, Dict[str, Any]] = {} # Determine available candidates and interpret data subset. available_candidates = { - v: (self.data_shape[0] - self.na_counts[v]) + v: (self.shape[0] - self.na_counts[v]) for v in self.model_training_order } data_subset = _expand_value_to_dict( @@ -299,17 +289,18 @@ def __init__( col for col in self.working_data.columns if col not in categorical_columns ] - binary_columns = [ - col for col, count in category_counts.items() - if count == 2 - ] - # Determine which columns should be binary instead of numeric: - for col in numeric_columns: - unique_values = self.working_data.drop_duplicates().dropna().astype('float64') - if {0.0, 1.0} == set(unique_values): + binary_columns = [] + for col, count in category_counts.items(): + if count == 2: binary_columns.append(col) - numeric_columns.remove(col) + categorical_columns.remove(col) + # Probably a better way of doing this + assert set(categorical_columns).isdisjoint(set(numeric_columns)) + assert set(categorical_columns).isdisjoint(set(binary_columns)) + assert set(binary_columns).isdisjoint(set(numeric_columns)) + + self.category_counts = category_counts self.modeled_categorical_columns = _list_union(categorical_columns, self.model_training_order) self.modeled_numeric_columns = _list_union(numeric_columns, self.model_training_order) self.modeled_binary_columns = _list_union(binary_columns, self.model_training_order) @@ -338,6 +329,27 @@ def __init__( self.model_training_order ) + for col in self.model_training_order: + mmc = self.mean_match_candidates[col] + mms = self.mean_match_strategy[col] + assert not ((mmc == 0) and (mms == "shap")), ( + f'Failing because {col} mean_match_candidates == 0 and ' + 'mean_match_strategy == shap. This implies an unintentional setup.' + ) + + # Determine if the mean matching scheme will + # require candidate information for each variable + self.mean_matching_requires_candidates = [] + for variable in self.model_training_order: + mean_match_strategy = self.mean_match_strategy[variable] + if ( + (mean_match_strategy in ['normal', 'shap']) or + (variable in self.modeled_numeric_columns) + ): + self.mean_matching_requires_candidates.append(variable) + + self.loggers = [] + # Manage randomness self._completely_random_kernel = random_state is None self._random_state = ensure_rng(random_state) @@ -347,35 +359,52 @@ def __init__( self, random_state=self._random_state, random_seed_array=None ) - def __repr__(self): - summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self._ids_info()}' - return summary_string - - def _initialize_random_seed_array(self, random_seed_array, expected_shape): + def __getstate__(self): """ - Formats and takes the first hash of the random_seed_array. + For pickling + """ + # Copy the entire object, minus the big stuff + + special_handling = ['imputation_values'] + if self.save_all_iterations_data: + special_handling.append('candidate_preds') + + state = { + key: value + for key, value in self.__dict__.items() + if key not in special_handling + }.copy() + + state['imputation_values'] = {} + state['candidate_preds'] = {} + + for col, df in self.imputation_values.items(): + byte_stream = BytesIO() + df.to_parquet(byte_stream) + state['imputation_values'][col] = byte_stream + for col, df in self.candidate_preds.items(): + byte_stream = BytesIO() + df.to_parquet(byte_stream) + state['candidate_preds'][col] = byte_stream + + return state + + def __setstate__(self, state): """ + For unpickling + """ + self.__dict__ = state - # Format random_seed_array if it was passed. - if random_seed_array is not None: - if self._completely_random_kernel: - warn( - 'This kernel is completely random (no random_state was provided on ' - 'initialization). Values imputed using self.impute_new_data() will be ' - 'deterministic, however the kernel itself is non-reproducible.' - ) - assert isinstance(random_seed_array, np.ndarray) - assert ( - random_seed_array.dtype.name == "int32" - ), "random_seed_array must be a np.ndarray of type int32" - assert ( - random_seed_array.shape[0] == expected_shape - ), "random_seed_array must be the same length as data." - random_seed_array = hash_int32(random_seed_array) - else: - random_seed_array = None + for col, bytes in self.imputation_values.items(): + self.imputation_values[col] = read_parquet(bytes) - return random_seed_array + if self.save_all_iterations_data: + for col, bytes in self.candidate_preds.items(): + self.candidate_preds[col] = read_parquet(bytes) + + def __repr__(self): + summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self.__ids_info()}' + return summary_string def _initialize_dataset(self, imputed_data, random_state, random_seed_array): """ @@ -388,95 +417,49 @@ def _initialize_dataset(self, imputed_data, random_state, random_seed_array): assert not imputed_data.initialized, "dataset has already been initialized" if self.initialize_empty : - for var in imputed_data.imputation_order: - for ds in range(imputed_data.dataset_count()): - # Saves space, since np.nan will be broadcast. - imputed_data[ds, var, 0] = np.array([np.nan]) + # The default value when initialized is np.nan, nothing to do here + pass else: - for var in imputed_data.imputation_order: + for variable in imputed_data.imputed_variables: # Pulls from the kernel working data - candidate_values = self._get_nonmissing_values(var) + candidate_values = self._get_nonmissing_values(variable) candidate_num = candidate_values.shape[0] # Pulls from the ImputedData - missing_ind = imputed_data.na_where[var] - missing_num = imputed_data.na_counts[var] + missing_ind = imputed_data.na_where[variable] + missing_num = imputed_data.na_counts[variable] - for ds in range(imputed_data.dataset_count()): + for dataset in range(imputed_data.num_datasets): # Initialize using the random_state if no record seeds were passed. if random_seed_array is None: imputation_values = ( candidate_values .sample(n=missing_num, replace=True, random_state=random_state) - .reindex(missing_ind) ) - imputed_data[var, ds, 0] = imputation_values + imputation_values.index = missing_ind + imputed_data[variable, 0, dataset] = imputation_values else: assert ( - len(random_seed_array) == imputed_data.data_shape[0] + len(random_seed_array) == imputed_data.shape[0] ), "The random_seed_array did not match the number of rows being imputed." selection_ind = random_seed_array[missing_ind] % candidate_num - init_imps = candidate_values.iloc[selection_ind].reindex(missing_ind) - imputed_data[var, ds, 0] = init_imps - random_seed_array[missing_ind] = hash_int32( - random_seed_array[missing_ind] + imputation_values = candidate_values.iloc[selection_ind] + imputation_values.index = missing_ind + imputed_data[variable, 0, dataset] = imputation_values + random_seed_array = hash_numpy_int_array( + x=random_seed_array, + ind=missing_ind ) imputed_data.initialized = True - def _reconcile_parameters(self, defaults, user_supplied): - """ - Checks in user_supplied for aliases of each parameter in defaults. - Combines the dicts once the aliases have been reconciled. - """ - params = defaults.copy() - for par, val in defaults.items(): - alias_names = _ConfigAliases.get(par) - user_supplied_aliases = [ - i for i in alias_names if i in list(user_supplied) and i != par - ] - if len(user_supplied_aliases) == 0: - continue - elif len(user_supplied_aliases) == 1: - params[par] = user_supplied.pop(user_supplied_aliases[0]) - else: - raise ValueError( - f"Supplied 2 aliases for the same parameter: {user_supplied_aliases}" - ) - - params.update(user_supplied) - - return params - - def _format_variable_parameters( - self, variable_parameters: Optional[Dict] - ) -> Dict[int, Any]: - """ - Unpacking will expect an empty dict at a minimum. - This function collects parameters if they were - provided, and returns empty dicts if they weren't. - """ - if variable_parameters is None: - vsp: Dict[int, Any] = {var: {} for var in self.variable_training_order} - - else: - for variable in list(variable_parameters): - variable_parameters[ - self._get_var_ind_from_scalar(variable) - ] = variable_parameters.pop(variable) - vsp_vars = set(variable_parameters) - - assert vsp_vars.issubset( - self.variable_training_order - ), "Some variable_parameters are not associated with models being trained." - vsp = { - var: variable_parameters[var] if var in vsp_vars else {} - for var in self.variable_training_order - } - - return vsp - - def _get_lgb_params(self, var, vsp, random_state, **kwlgb): + def _get_lgb_params( + self, + variable, + variable_parameters, + random_state, + **kwlgb + ): """ Builds the parameters for a lightgbm model. Infers objective based on datatype of the response variable, assigns a random seed, finds @@ -500,22 +483,23 @@ def _get_lgb_params(self, var, vsp, random_state, **kwlgb): seed = _draw_random_int32(random_state, size=1)[0] - if var in self.categorical_variables: - n_c = self.category_counts[var] - if n_c > 2: - obj = {"objective": "multiclass", "num_class": n_c} - else: - obj = {"objective": "binary"} + if variable in self.modeled_categorical_columns: + n_c = self.category_counts[variable] + obj = {"objective": "multiclass", "num_class": n_c} + elif variable in self.modeled_binary_columns: + obj = {"objective": "binary"} else: obj = {"objective": "regression"} - default_lgb_params = {**default_parameters, **obj, "seed": seed} + lgb_params = default_parameters.copy() + lgb_params.update(obj) + lgb_params['seed'] = seed # Priority is [variable specific] > [global in kwargs] > [defaults] - params = self._reconcile_parameters(default_lgb_params, kwlgb) - params = self._reconcile_parameters(params, vsp) + lgb_params.update(kwlgb) + lgb_params.update(variable_parameters) - return params + return lgb_params def _get_random_sample(self, parameters, random_state): """ @@ -583,141 +567,49 @@ def _get_oof_performance( return loss, best_iteration - def _get_candidate_subset(self, column, subset_count, random_seed): + def _get_nonmissing_subset_index(self, variable: str, seed: int): """ - Returns a reproducible subset index of the - non-missing values for a given variable. + Get random indices for a subset of the data in which variable is not missing. + Used to create feature / label for training. + + replace = False because it would NOT mimic bagging for random forests. """ - nonmissing_index = self._get_nonmissing_indx(var_indx) - - # Get the subset indices - if subset_count < len(nonmissing_index): - candidate_values = self._get_nonmissing_values(column) - candidates = candidate_values.shape[0] - groups = max(10, int(candidates / 1000)) - ss = stratified_subset( - y=candidate_values, - size=subset_count, - groups=groups, - seed=random_seed, - ) - candidate_subset = nonmissing_index[ss] + data_subset = self.data_subset[variable] + available_candidates = self.available_candidates[variable] + if (data_subset == 0) or (data_subset >= available_candidates): + subset_index = slice(None) else: - candidate_subset = nonmissing_index - - return candidate_subset - - def _get_nonmissing_subset_index(self, column, size, replace): - nonmissing_ind = self._get_nonmissing_index(column=column) - subset_ind = self._random_state.choice( - nonmissing_ind, - size=size, - replace=replace - ) - return subset_ind + nonmissing_ind = self._get_nonmissing_index(variable=variable) + rs = np.random.RandomState(seed) + subset_index = rs.choice( + nonmissing_ind, + size=data_subset, + replace=False + ) + return subset_index - def _make_label(self, target_column, size): + def _make_label(self, variable: str, seed: int): """ Returns a reproducible subset of the non-missing values of a variable. """ - subset_index = self._get_nonmissing_subset_index(column=target_column, size=size) - label = self.working_data.loc[subset_index, target_column].copy() + # Don't subset at all if data_subset == 0 or we want more than there are candidates + + subset_index = self._get_nonmissing_subset_index(variable=variable, seed=seed) + label = self.working_data.loc[subset_index, variable].copy() return label - def _make_features_label(self, target_column, size, random_seed): + def _make_features_label(self, variable: str, seed: int): """ Makes a reproducible set of features and target needed to train a lightgbm model. """ - - subset_index = self._get_nonmissing_subset_index(column=target_column, size=size) - predictor_columns = self.variable_schema[target_column] - features = self.working_data.loc[subset_index, predictor_columns + [target_column]].copy() - label = features.pop(target_column) + subset_index = self._get_nonmissing_subset_index(variable=variable, seed=seed) + predictor_columns = self.variable_schema[variable] + features = self.working_data.loc[subset_index, predictor_columns + [variable]].copy() + label = features.pop(variable) return features, label - # def append(self, imputation_kernel): - # """ - # Combine two imputation kernels together. - # For compatibility, the following attributes of each must be equal: - - # - working_data - # - iteration_count - # - categorical_feature - # - mean_match_scheme - # - variable_schema - # - imputation_order - # - save_models - # - save_all_iterations - - # Only cursory checks are done to ensure working_data is equal. - # Appending a kernel with different working_data could ruin this kernel. - - # Parameters - # ---------- - # imputation_kernel: ImputationKernel - # The kernel to merge. - - # """ - - # _assert_dataset_equivalent(self.working_data, imputation_kernel.working_data) - # assert self.iteration_count() == imputation_kernel.iteration_count() - # assert self.variable_schema == imputation_kernel.variable_schema - # assert self.imputation_order == imputation_kernel.imputation_order - # assert self.variable_training_order == imputation_kernel.variable_training_order - # assert self.categorical_feature == imputation_kernel.categorical_feature - # assert self.save_models == imputation_kernel.save_models - # assert self.save_all_iterations == imputation_kernel.save_all_iterations - # assert ( - # self.mean_match_scheme.objective_pred_dtypes - # == imputation_kernel.mean_match_scheme.objective_pred_dtypes - # ) - # assert ( - # self.mean_match_scheme.objective_pred_funcs - # == imputation_kernel.mean_match_scheme.objective_pred_funcs - # ) - # assert ( - # self.mean_match_scheme.objective_args - # == imputation_kernel.mean_match_scheme.objective_args - # ) - # assert ( - # self.mean_match_scheme.mean_match_candidates - # == imputation_kernel.mean_match_scheme.mean_match_candidates - # ) - - # current_datasets = self.dataset_count() - # new_datasets = imputation_kernel.dataset_count() - - # for key, model in imputation_kernel.models.items(): - # new_ds_indx = key[0] + current_datasets - # insert_key = new_ds_indx, key[1], key[2] - # self.models[insert_key] = model - - # for key, cp in imputation_kernel.candidate_preds.items(): - # new_ds_indx = key[0] + current_datasets - # insert_key = new_ds_indx, key[1], key[2] - # self.candidate_preds[insert_key] = cp - - # for key, iv in imputation_kernel.imputation_values.items(): - # new_ds_indx = key[0] + current_datasets - # self[new_ds_indx, key[1], key[2]] = iv - - # # Combine dicts - # for ds in range(new_datasets): - # insert_index = current_datasets + ds - # self.optimal_parameters[ - # insert_index - # ] = imputation_kernel.optimal_parameters[ds] - # self.optimal_parameter_losses[ - # insert_index - # ] = imputation_kernel.optimal_parameter_losses[ds] - - # # Append iterations - # self.iterations = np.append( - # self.iterations, imputation_kernel.iterations, axis=0 - # ) - def compile_candidate_preds(self): """ Candidate predictions can be pre-generated before imputing new data. @@ -757,132 +649,455 @@ def fit(self, X, y, **fit_params): Method for fitting a kernel when used in a sklearn pipeline. Should not be called by the user directly. """ - - assert self.dataset_count() == 1, ( + assert self.num_datasets == 1, ( "miceforest kernel should be initialized with datasets=1 if " + "being used in a sklearn pipeline." ) - _assert_dataset_equivalent(self.working_data, X), ( - "The dataset passed to fit() was not the same as the " - "dataset passed to ImputationKernel()" + assert X.equals(self.working_data), ( + 'Data passed was not the same as original ' + 'data used to train ImputationKernel.' ) self.mice(**fit_params) return self + + @staticmethod + def _mean_match_nearest_neighbors( + mean_match_candidates: int, + bachelor_preds: _MEAN_MATCH_PRED_TYPE, + candidate_preds: _MEAN_MATCH_PRED_TYPE, + candidate_values: Series, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray] = None, + ): + """ + Determines the values of candidates which will be used to impute the bachelors + """ - def get_model( - self, dataset: int, variable: Union[str, int], iteration: Optional[int] = None + assert mean_match_candidates > 0, 'Do not use nearest_neighbors with 0 mmc.' + + _to_2d(bachelor_preds) + _to_2d(candidate_preds) + + num_bachelors = bachelor_preds.shape[0] + + # balanced_tree = False fixes a recursion issue for some reason. + # https://github.com/scipy/scipy/issues/14799 + kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) + _, knn_indices = kd_tree.query( + bachelor_preds, k=mean_match_candidates, workers=-1 + ) + + # We can skip the random selection process if mean_match_candidates == 1 + if mean_match_candidates == 1: + index_choice = knn_indices + + else: + # Use the random_state if seed_array was not passed. Faster + if hashed_seeds is None: + ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) + # Use the random_seed_array if it was passed. Deterministic. + else: + ind = hashed_seeds % mean_match_candidates + + index_choice = knn_indices[np.arange(num_bachelors), ind] + + imp_values = candidate_values.iloc[index_choice] + + return imp_values + + + @staticmethod + def _mean_match_binary_fast( + mean_match_candidates: int, + bachelor_preds: _MEAN_MATCH_PRED_TYPE, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], ): """ - Return the model for a specific dataset, variable, iteration. + Chooses 0/1 randomly weighted by probability obtained from prediction. + If mean_match_candidates is 0, choose class with highest probability. + """ + if mean_match_candidates == 0: + imp_values = np.floor(bachelor_preds + 0.5) - Parameters - ---------- - dataset: int - The dataset to return the model for. + else: + num_bachelors = bachelor_preds.shape[0] + if hashed_seeds is None: + imp_values = random_state.binomial(n=1, p=bachelor_preds) + else: + imp_values = [] + for i in range(num_bachelors): + np.random.seed(seed=hashed_seeds[i]) + imp_values.append(np.random.binomial(n=1, p=bachelor_preds[i])) - var: str - The variable that was imputed + imp_values = np.array(imp_values) - iteration: int - The model iteration to return. Keep in mind if save_models ==1, - the model was not saved. If none is provided, the latest model - is returned. + return imp_values - Returns: lightgbm.Booster - The model used to impute this specific variable, iteration. + @staticmethod + def _mean_match_multiclass_fast( + mean_match_candidates: int, + bachelor_preds: _MEAN_MATCH_PRED_TYPE, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], + ): """ + If mean_match_candidates is 0, choose class with highest probability. + Otherwise, randomly choose class weighted by class probabilities. + """ + if mean_match_candidates == 0: + imp_values = np.argmax(bachelor_preds, axis=1) - var_indx = self._get_var_ind_from_scalar(variable) - itrn = ( - self.iteration_count(datasets=dataset, variables=var_indx) - if iteration is None - else iteration - ) - try: - return self.models[dataset, var_indx, itrn] - except Exception: - raise ValueError("Could not find model.") + else: + num_bachelors = bachelor_preds.shape[0] + + # Turn bachelor_preds into discrete cdf: + bachelor_preds = bachelor_preds.cumsum(axis=1) + + # Randomly choose uniform numbers 0-1 + if hashed_seeds is None: + # This is the fastest way to adjust for numeric + # imprecision of float16 dtype. Actually ends up + # barely taking any time at all. + bp_dtype = bachelor_preds.dtype + unif = np.minimum( + random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype), + bachelor_preds[:, -1], + ) + else: + unif = [] + for i in range(num_bachelors): + np.random.seed(seed=hashed_seeds[i]) + unif.append(np.random.uniform(0, 1, size=1)[0]) + unif = np.array(unif) + + # Choose classes according to their cdf. + # Distribution will match probabilities + imp_values = np.array( + [ + np.searchsorted(bachelor_preds[i, :], unif[i]) + for i in range(num_bachelors) + ] + ) - def get_raw_prediction( + return imp_values + + def _impute_with_predictions( self, - variable: Union[int, str], - imp_dataset: int = 0, - imp_iteration: Optional[int] = None, - model_dataset: Optional[int] = None, - model_iteration: Optional[int] = None, - dtype: Union[str, np.dtype, None] = None, + variable: str, + bachelor_preds: _MEAN_MATCH_PRED_TYPE, ): - """ - Get the raw model output for a specific variable. - The data is pulled from the imp_dataset dataset, at the imp_iteration iteration. - The model is pulled from model_dataset dataset, at the model_iteration iteration. + dtype = self.working_data[variable].dtype + if variable in self.modeled_numeric_columns: + return Series(bachelor_preds, dtype=dtype) + else: + if variable in self.modeled_binary_columns: + selection_ind = np.floor(bachelor_preds + 0.5) + else: + assert variable in self.modeled_categorical_columns, ( + f'{variable} is not in numeric, binary or categorical columns' + ) + selection_ind = np.argmax(bachelor_preds, axis=1) + values = dtype.categories[selection_ind] + return Series(values, dtype=dtype) + + def _get_candidate_preds( + self, + variable: str, + lgbmodel: Booster, + candidate_features: Optional[DataFrame], + pred_contrib: bool, + is_logistic_link: bool, + dataset: int, + iteration: int, + mice: bool, + ): + + if mice: + assert hasattr(lgbmodel, 'train_set'), ( + 'Model was passed that does not have training data.' + ) + if pred_contrib: + print(f'Getting {variable} preds from pred_contrib') + candidate_preds = lgbmodel.predict( + candidate_features, + pred_contrib=True, + ) + else: + print(f'Getting {variable} preds from inner predict') + candidate_preds = lgbmodel._Booster__inner_predict(0) + if is_logistic_link and not pred_contrib: + candidate_preds = logodds(candidate_preds) + + candidate_preds = self._prepare_prediction_multiindex( + variable=variable, + preds=candidate_preds, + pred_contrib=pred_contrib, + dataset=dataset, + iteration=iteration, + ) - So, for example, it is possible to get predictions using the imputed values for - dataset 3, at iteration 2, using the model obtained from dataset 10, at iteration - 6. This is assuming desired iterations and models have been saved. + if self.save_all_iterations_data: + self._record_candidate_preds( + variable=variable, + candidate_preds=candidate_preds, + ) + + else: - Parameters - ---------- - variable: int or str - The variable to get the raw predictions for. - Can be an index or variable name. + # Candidate predictions are only stored + # for imputed variables during mice + if variable in self.imputed_variables: + print(f'Getting {variable} preds from store') + candidate_preds = self._get_candidate_preds_from_store( + variable=variable, + iteration=iteration, + dataset=dataset, + ) + # We need to make the features and get the + # predictions if they weren't saved during mice + else: + print(f'Getting {variable} preds from features') + seed = lgbmodel.params['seed'] + candidate_features, _ = self._make_features_label(variable=variable, seed=seed) + candidate_preds = lgbmodel.predict(candidate_features) - imp_dataset: int - The imputation dataset to use when creating the feature dataset. + return candidate_preds + + def _get_candidate_preds_from_store( + self, + variable: str, + dataset: int, + iteration: int, + ) -> DataFrame: + """ + Mean matching requires 2D array, so always return a dataframe + """ + ret = self.candidate_preds[variable][iteration][[dataset]] + assert isinstance(ret, DataFrame) + return ret + + def mean_match( + self, + variable: str, + lgbmodel: Booster, + bachelor_features: DataFrame, + candidate_features: DataFrame, + candidate_values: Series, + dataset: int, + iteration: int, + mice: bool, + hashed_seeds: Optional[np.ndarray] = None, + ): + """ + Efficient mean matching called during MICE. + """ + mean_match_strategy = self.mean_match_strategy[variable] + mean_match_candidates = self.mean_match_candidates[variable] + using_candidate_data = variable in self.mean_matching_requires_candidates + use_mean_matching = mean_match_candidates > 0 + pred_contrib = mean_match_strategy == 'shap' + is_logistic_link = variable in (self.modeled_binary_columns + self.modeled_categorical_columns) + + # Special handling for imputing with predictions. + # Takes priority over other mean match settings. + if not use_mean_matching: + assert mean_match_strategy != 'shap', ( + 'Should have failed before this, please open an issue on github. ' + 'mean_match_strategy == shap and mean_match_candidates == 0. ' + 'This implies an unintentional setup.' + ) - imp_iteration: int - The iteration from which to draw the imputation values when - creating the feature dataset. If None, the latest iteration - is used. + print(f'Imputing {variable} with Predictions') + + # Get bachelor predictions + bachelor_preds = lgbmodel.predict( + bachelor_features, + pred_contrib=False, + raw_score=False, + ) - model_dataset: int - The dataset from which to pull the trained model for this variable. - If None, it is selected to be the same as imp_dataset. + imputation_values = self._impute_with_predictions( + variable=variable, + bachelor_preds=bachelor_preds, + ) + return imputation_values - model_iteration: int - The iteration from which to pull the trained model for this variable - If None, it is selected to be the same as imp_iteration. + if using_candidate_data: - dtype: str, np.dtype - The datatype to cast the raw prediction as. - Passed to MeanMatchScheme.model_predict(). + print(f'Mean matching {variable} using nearest neighbor') - Returns - ------- - np.ndarray of raw predictions. + # Get bachelor predictions + bachelor_preds = lgbmodel.predict( + bachelor_features, + pred_contrib=pred_contrib, + ) + if is_logistic_link and not pred_contrib: + bachelor_preds = logodds(bachelor_preds) + _to_2d(bachelor_preds) + bachelor_preds = self._prepare_prediction_multiindex( + variable=variable, + preds=bachelor_preds, + pred_contrib=pred_contrib, + dataset=dataset, + iteration=iteration, + ) - """ + candidate_preds = self._get_candidate_preds( + variable=variable, + lgbmodel=lgbmodel, + candidate_features=candidate_features, + pred_contrib=pred_contrib, + is_logistic_link=is_logistic_link, + dataset=dataset, + iteration=iteration, + mice=mice, + ) - var_indx = self._get_var_ind_from_scalar(variable) - predictor_variables = self.variable_schema[var_indx] + if candidate_values is None: + candidate_values = self._make_label( + variable=variable, + seed = lgbmodel.params['seed'] + ) - # Get the latest imputation iteration if imp_iteration was not specified - if imp_iteration is None: - imp_iteration = self.iteration_count( - datasets=imp_dataset, variables=var_indx + # By now, a numeric variable will be post-link, and + # categorical / binary variables will be pre-link. + imputation_values = self._mean_match_nearest_neighbors( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + candidate_preds=candidate_preds, + candidate_values=candidate_values, + random_state=self._random_state, + hashed_seeds=hashed_seeds, ) - # If model dataset / iteration wasn't specified, assume it is from the same - # dataset / iteration we are pulling the imputation values from - model_iteration = imp_iteration if model_iteration is None else model_iteration - model_dataset = imp_dataset if model_dataset is None else model_dataset + else: - # Get our internal dataset ready - self.complete_data(dataset=imp_dataset, iteration=imp_iteration, inplace=True) + # Get bachelor predictions + bachelor_preds = lgbmodel.predict( + bachelor_features, + pred_contrib=False, + raw_score=False, + ) + _to_2d(bachelor_preds) + + if variable in self.modeled_categorical_columns: + print(f'Mean matching {variable} using fast multiclass') + imputation_values = self._mean_match_multiclass_fast( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=self._random_state, + hashed_seeds=hashed_seeds + ) + _to_1d(imputation_values) + dtype = self.working_data[variable].dtype + imputation_values = Categorical.from_codes( + codes=imputation_values, + dtype=dtype + ) + elif variable in self.modeled_binary_columns: + print(f'Mean matching {variable} using fast binary') + imputation_values = self._mean_match_binary_fast( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=self._random_state, + hashed_seeds=hashed_seeds + ) + _to_1d(imputation_values) + dtype = self.working_data[variable].dtype + imputation_values = Categorical.from_codes( + codes=imputation_values, + dtype=dtype + ) + else: + raise ValueError('Shouldnt be able to get here') + + return imputation_values + + def _record_candidate_preds( + self, + variable: str, + candidate_preds: DataFrame, + ): + + assign_col_index = candidate_preds.columns + + if variable not in self.candidate_preds.keys(): + inferred_iteration = assign_col_index.get_level_values('iteration').unique() + assert len(inferred_iteration) == 1, f'Malformed iteration multiindex for {variable}: {print(assign_col_index)}' + inferred_iteration = inferred_iteration[0] + assert inferred_iteration == 1, 'Adding initial candidate preds after iteration 1.' + self.candidate_preds[variable] = candidate_preds + else: + self.candidate_preds[variable][assign_col_index] = candidate_preds + + def _prepare_prediction_multiindex( + self, + variable: str, + preds: np.ndarray, + pred_contrib: bool, + dataset: int, + iteration: int, + ) -> DataFrame: + + multiclass = variable in self.modeled_categorical_columns + cols = self.variable_schema[variable] + ['Intercept'] + + if pred_contrib: + + if multiclass: + + categories = self.working_data[variable].dtype.categories + cat_count = self.category_counts[variable] + preds = DataFrame(preds, columns=cols * cat_count) + del preds['Intercept'] + cols.remove('Intercept') + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], categories, cols], + names=('iteration', 'dataset', 'categories', 'predictor') + ) + preds.columns = assign_col_index + + else: + preds = DataFrame(preds, columns=cols) + del preds['Intercept'] + cols.remove('Intercept') + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], cols], + names=('iteration', 'dataset', 'predictor') + ) + preds.columns = assign_col_index + + else: - features = _subset_data(self.working_data, col_ind=predictor_variables) - model = self.get_model(model_dataset, var_indx, iteration=model_iteration) - preds = self.mean_match_scheme.model_predict(model, features, dtype=dtype) + if multiclass: + + categories = self.working_data[variable].dtype.categories + preds = DataFrame(preds, columns=categories) + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], categories], + names=('iteration', 'dataset', 'categories') + ) + preds.columns = assign_col_index + + else: + + preds = DataFrame(preds, columns=[variable]) + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset]], + names=('iteration', 'dataset') + ) + preds.columns = assign_col_index return preds + def mice( self, iterations: int, verbose: bool = False, - variable_parameters: Dict[str, Any] = None, - compile_candidates: bool = False, + variable_parameters: Dict[str, Any] = {}, **kwlgb, ): """ @@ -925,181 +1140,135 @@ def mice( """ - __MICE_TIMED_EVENTS = ["prepare_xy", "training", "predict", "mean_matching"] - iter_pairs = self._iter_pairs(iterations) + current_iterations = self.iteration_count() + start_iter = current_iterations + 1 + end_iter = current_iterations + iterations + 1 # Delete models and candidate_preds if we shouldn't be saving every iteration - if self.save_models < 2: - self.models = {} - self.candidate_preds = {} - logger = Logger( - name=f"mice {str(iter_pairs[0][0])}-{str(iter_pairs[-1][0])}", + name=f"MICE Iterations {current_iterations + 1} - {current_iterations + iterations}", + timed_levels=_MICE_TIMED_LEVELS, verbose=verbose, ) - vsp = self._format_variable_parameters(variable_parameters) + if len(variable_parameters) > 0: + assert isinstance(variable_parameters, dict), 'variable_parameters should be a dict.' + assert set(variable_parameters).issubset(self.model_training_order), ( + 'Variables in variable_parameters will not have models trained. ' + 'Check kernel.model_training_order' + ) - for ds in range(self.dataset_count()): - logger.log("Dataset " + str(ds)) + for iteration in range(start_iter, end_iter, 1): + # absolute_iteration = self.iteration_count(datasets=dataset) + logger.log(str(iteration) + " ", end="") - # set self.working_data to the most current iteration. - self.complete_data(dataset=ds, inplace=True) - last_iteration = False + for dataset in range(self.num_datasets): + logger.log("Dataset " + str(dataset)) - for iter_abs, iter_rel in iter_pairs: - logger.log(str(iter_abs) + " ", end="") - if iter_rel == iterations: - last_iteration = True - save_model = self.save_models == 2 or ( - last_iteration and self.save_models == 1 - ) + # Set self.working_data to the most current iteration. + self.complete_data(dataset=dataset, inplace=True) - for variable in self.variable_training_order: - var_name = self._get_var_name_from_scalar(variable) - logger.log(" | " + var_name, end="") - predictor_variables = self.variable_schema[variable] - data_subset = self.data_subset[variable] - nawhere = self.na_where[variable] - log_context = { - "dataset": ds, - "variable_name": var_name, - "iteration": iter_abs, - } + for variable in self.model_training_order: + logger.log(" | " + variable, end="") # Define the lightgbm parameters lgbpars = self._get_lgb_params( - variable, vsp[variable], self._random_state, **kwlgb + variable, + variable_parameters.get(variable, {}), + self._random_state, + **kwlgb ) - objective = lgbpars["objective"] - # These are necessary for building model in mice. - logger.set_start_time() + time_key = dataset, iteration, variable, 'Prepare XY' + logger.set_start_time(time_key) ( candidate_features, candidate_values, - feature_cat_index, ) = self._make_features_label( variable=variable, - subset_count=data_subset, - random_seed=lgbpars["seed"], + seed=lgbpars['seed'] ) - if ( - self.original_data_class == "pd_DataFrame" - or len(feature_cat_index) == 0 - ): - feature_cat_index = "auto" # lightgbm requires integers for label. Categories won't work. if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes + label = candidate_values.cat.codes + else: + label = candidate_values num_iterations = lgbpars.pop("num_iterations") train_pointer = Dataset( data=candidate_features, - label=candidate_values, - categorical_feature=feature_cat_index, + label=label, ) - logger.record_time(timed_event="prepare_xy", **log_context) - logger.set_start_time() + logger.record_time(time_key) + + time_key = dataset, iteration, variable, 'Training' + logger.set_start_time(time_key) current_model = train( params=lgbpars, train_set=train_pointer, num_boost_round=num_iterations, - categorical_feature=feature_cat_index, + keep_training_booster=True, ) - logger.record_time(timed_event="training", **log_context) - - if save_model: - self.models[ds, variable, iter_abs] = current_model + logger.record_time(time_key) # Only perform mean matching and insertion # if variable is being imputed. if variable in self.imputation_order: - mean_match_args = self.mean_match_scheme.get_mean_match_args( - objective - ) - - # Start creating kwargs for mean matching function - mm_kwargs = {} - - if "lgb_booster" in mean_match_args: - mm_kwargs["lgb_booster"] = current_model - - if {"bachelor_preds", "bachelor_features"}.intersection( - mean_match_args - ): - logger.set_start_time() - bachelor_features = _subset_data( - self.working_data, - row_ind=nawhere, - col_ind=predictor_variables, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - if "bachelor_features" in mean_match_args: - mm_kwargs["bachelor_features"] = bachelor_features - - if "bachelor_preds" in mean_match_args: - logger.set_start_time() - bachelor_preds = self.mean_match_scheme.model_predict( - current_model, bachelor_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["bachelor_preds"] = bachelor_preds - - if "candidate_values" in mean_match_args: - mm_kwargs["candidate_values"] = candidate_values - - if "candidate_features" in mean_match_args: - mm_kwargs["candidate_features"] = candidate_features - - # Calculate the candidate predictions if - # the mean matching function calls for it - if "candidate_preds" in mean_match_args: - logger.set_start_time() - candidate_preds = self.mean_match_scheme.model_predict( - current_model, candidate_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["candidate_preds"] = candidate_preds - - if compile_candidates and save_model: - self.candidate_preds[ - ds, variable, iter_abs - ] = candidate_preds - - if "random_state" in mean_match_args: - mm_kwargs["random_state"] = self._random_state - - # Hashed seeds are only to ensure record reproducibility - # for impute_new_data(). - if "hashed_seeds" in mean_match_args: - mm_kwargs["hashed_seeds"] = None - - logger.set_start_time() - imp_values = self.mean_match_scheme._mean_match( - variable, objective, **mm_kwargs + time_key = dataset, iteration, variable, 'Mean Matching' + logger.set_start_time(time_key) + bachelor_features = self.get_bachelor_features(variable=variable) + imputation_values = self.mean_match( + variable=variable, + lgbmodel=current_model, + bachelor_features=bachelor_features, + candidate_features=candidate_features, + candidate_values=candidate_values, + dataset=dataset, + iteration=iteration, + mice=True, + hashed_seeds=None, ) - logger.record_time(timed_event="mean_matching", **log_context) + imputation_values.index = self.na_where[variable] + logger.record_time(time_key) - assert imp_values.shape == ( + assert imputation_values.shape == ( self.na_counts[variable], ), f"{variable} mean matching returned malformed array" - # Updates our working data and saves the imputations. - self._insert_new_data( - dataset=ds, variable_index=variable, new_data=imp_values - ) + # Insert the imputation_values we obtained + self[variable, iteration, dataset] = imputation_values + + if not self.save_all_iterations_data: + del self[variable, iteration - 1, dataset] + + else: + + - self.iterations[ - ds, self.variable_training_order.index(variable) - ] += 1 + # Save the model, if we should be + if self.save_all_iterations_data: + self.models[variable, iteration, dataset] = current_model.free_dataset() logger.log("\n", end="") self._ampute_original_data() - if self.save_loggers: - self.loggers.append(logger) + self.loggers.append(logger) + + def get_model( + self, + variable: str, + dataset: int, + iteration: Optional[int] = None, + ): + # Allow passing -1 to get the latest iteration's model + if (iteration is None) or (iteration == -1): + iteration = self.iteration_count(dataset=dataset, variable=variable) + try: + model = self.models[variable, iteration, dataset] + except KeyError: + raise ValueError('Model was not saved.') + return model def transform(self, X, y=None): """ @@ -1124,6 +1293,8 @@ def tune_parameters( ): """ Perform hyperparameter tuning on models at the current iteration. + This method is not meant to be robust, but to get a decent set of + parameters to help with imputation. .. code-block:: text @@ -1283,7 +1454,7 @@ def tune_parameters( for var in variables: default_tuning_space = make_default_tuning_space( self.category_counts[var] if var in self.categorical_variables else 1, - int((self.data_shape[0] - len(self.na_where[var])) / 10), + int((self.shape[0] - len(self.na_where[var])) / 10), ) variable_parameter_space[var] = self._get_lgb_params( @@ -1371,15 +1542,15 @@ def tune_parameters( def impute_new_data( self, - new_data: _t_dat, + new_data: DataFrame, datasets: Optional[List[int]] = None, iterations: Optional[int] = None, - save_all_iterations: bool = True, + save_all_iterations_data: bool = True, copy_data: bool = True, random_state: Optional[Union[int, np.random.RandomState]] = None, random_seed_array: Optional[np.ndarray] = None, verbose: bool = False, - ) -> ImputedPandasDataFrame: + ) -> ImputedData: """ Impute a new dataset @@ -1466,41 +1637,41 @@ def impute_new_data( """ - datasets = list(range(self.dataset_count())) if datasets is None else datasets + assert self.save_all_iterations_data, ( + 'Cannot recreate imputation procedure, data was not saved during MICE. ' + 'To save this data, set save_all_iterations_data to True when making kernel.' + ) + + datasets = list(range(self.num_datasets)) if datasets is None else datasets kernel_iterations = self.iteration_count() iterations = kernel_iterations if iterations is None else iterations - iter_pairs = self._iter_pairs(iterations) - __IND_TIMED_EVENTS = ["prepare_xy", "predict", "mean_matching"] logger = Logger( - name=f"ind {str(iter_pairs[0][1])}-{str(iter_pairs[-1][1])}", + name=f"Impute New Data {0}-{iterations}", + timed_levels=_IMPUTE_NEW_DATA_TIMED_LEVELS, verbose=verbose, ) - if isinstance(self.working_data, DataFrame): - assert isinstance(new_data, DataFrame) - assert set(self.working_data.columns) == set( - new_data.columns - ), "Different columns from original dataset." - assert all( - [ - self.working_data[col].dtype == new_data[col].dtype - for col in self.working_data.columns - ] - ), "Column types are not the same as the original data. Check categorical columns." - - if self.save_models < 1: - raise ValueError("No models were saved.") + assert isinstance(new_data, DataFrame) + assert self.working_data.columns.equals(new_data.columns), ( + "Different columns from original dataset." + ) + assert np.all([ + self.working_data[col].dtype == new_data[col].dtype + for col in self.column_names + ]), "Column types are not the same as the original data. Check categorical columns." imputed_data = ImputedData( impute_data=new_data, - datasets=len(datasets), + num_datasets=len(datasets), variable_schema=self.variable_schema.copy(), - imputation_order=self.variable_training_order.copy(), - train_nonmissing=False, - categorical_feature=self.categorical_feature, - save_all_iterations=save_all_iterations, + save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, + random_seed_array=random_seed_array ) + new_imputation_order = [ + col for col in self.model_training_order + if col in imputed_data.vars_with_any_missing + ] ### Manage Randomness. if random_state is None: @@ -1510,195 +1681,70 @@ def impute_new_data( random_state = self._random_state else: random_state = ensure_rng(random_state) - # use_seed_array = random_seed_array is not None - random_seed_array = self._initialize_random_seed_array( - random_seed_array=random_seed_array, - expected_shape=imputed_data.data_shape[0], - ) + self._initialize_dataset( - imputed_data, random_state=random_state, random_seed_array=random_seed_array + imputed_data, + random_state=random_state, + random_seed_array=random_seed_array, ) - for ds_kern in datasets: - logger.log("Dataset " + str(ds_kern)) - self.complete_data(dataset=ds_kern, inplace=True) - ds_new = datasets.index(ds_kern) - imputed_data.complete_data(dataset=ds_new, inplace=True) - - for iter_abs, iter_rel in iter_pairs: - logger.log(str(iter_rel) + " ", end="") - - # Determine which model iteration to grab - if self.save_models == 1 or iter_abs > kernel_iterations: - iter_model = kernel_iterations - else: - iter_model = iter_abs - - for var in imputed_data.imputation_order: - var_name = self._get_var_name_from_scalar(var) - logger.log(" | " + var_name, end="") - log_context = { - "dataset": ds_kern, - "variable_name": var_name, - "iteration": iter_rel, - } - nawhere = imputed_data.na_where[var] - predictor_variables = self.variable_schema[var] + for iteration in range(1, iterations + 1): + logger.log(str(iteration) + " ", end="") + + for dataset in datasets: + logger.log("Dataset " + str(dataset)) + self.complete_data(dataset=dataset, inplace=True) + ds_new = datasets.index(dataset) + imputed_data.complete_data(dataset=ds_new, inplace=True) + + for variable in new_imputation_order: + logger.log(" | " + variable, end="") # Select our model. current_model = self.get_model( - variable=var, dataset=ds_kern, iteration=iter_model - ) - objective = current_model.params["objective"] - model_seed = current_model.params["seed"] - - # Start building mean matching kwargs - mean_match_args = self.mean_match_scheme.get_mean_match_args( - objective + variable=variable, + dataset=dataset, + iteration=iteration ) - mm_kwargs = {} - - if "lgb_booster" in mean_match_args: - mm_kwargs["lgb_booster"] = current_model - - # Procure bachelor information - if {"bachelor_preds", "bachelor_features"}.intersection( - mean_match_args - ): - logger.set_start_time() - bachelor_features = _subset_data( - imputed_data.working_data, - row_ind=imputed_data.na_where[var], - col_ind=predictor_variables, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - if "bachelor_features" in mean_match_args: - mm_kwargs["bachelor_features"] = bachelor_features - - if "bachelor_preds" in mean_match_args: - logger.set_start_time() - bachelor_preds = self.mean_match_scheme.model_predict( - current_model, bachelor_features - ) - logger.record_time(timed_event="predict", **log_context) - mm_kwargs["bachelor_preds"] = bachelor_preds - - # Procure candidate information - if { - "candidate_values", - "candidate_features", - "candidate_preds", - }.intersection(mean_match_args): - # Need to return candidate features if we need to calculate - # candidate_preds or candidate_features is needed by mean matching function - calculate_candidate_preds = ( - ds_kern, - var, - iter_model, - ) not in self.candidate_preds.keys() and "candidate_preds" in mean_match_args - return_features = ( - "candidate_features" in mean_match_args - ) or calculate_candidate_preds - # Set up like this so we only have to subset once - logger.set_start_time() - if return_features: - ( - candidate_features, - candidate_values, - _, - ) = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model_seed, - ) - else: - candidate_values = self._make_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model_seed, - ) - logger.record_time(timed_event="prepare_xy", **log_context) - - if "candidate_values" in mean_match_args: - # lightgbm requires integers for label. Categories won't work. - if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes - mm_kwargs["candidate_values"] = candidate_values - - if "candidate_features" in mean_match_args: - mm_kwargs["candidate_features"] = candidate_features - - # Calculate the candidate predictions if - # the mean matching function calls for it - if "candidate_preds" in mean_match_args: - if calculate_candidate_preds: - logger.set_start_time() - candidate_preds = self.mean_match_scheme.model_predict( - current_model, candidate_features - ) - logger.record_time(timed_event="predict", **log_context) - else: - candidate_preds = self.candidate_preds[ - ds_kern, var, iter_model - ] - mm_kwargs["candidate_preds"] = candidate_preds - - if "random_state" in mean_match_args: - mm_kwargs["random_state"] = random_state - - if "hashed_seeds" in mean_match_args: - if isinstance(random_seed_array, np.ndarray): - seeds = random_seed_array[nawhere] - rehash_seeds = True - else: - seeds = None - rehash_seeds = False + time_key = dataset, iteration, variable, 'Getting Bachelor Features' + logger.set_start_time(time_key) + bachelor_features = imputed_data.get_bachelor_features(variable) + logger.record_time(time_key) - mm_kwargs["hashed_seeds"] = seeds + time_key = dataset, iteration, variable, 'Mean Matching' + logger.set_start_time(time_key) + imputation_values = self.mean_match( + variable=variable, + lgbmodel=current_model, + bachelor_features=bachelor_features, + candidate_features=None, + candidate_values=None, + dataset=dataset, + iteration=iteration, + mice=False, + hashed_seeds=None + ) + imputation_values.index = imputed_data.na_where[variable] + logger.record_time(time_key) - else: - rehash_seeds = False + assert imputation_values.shape == ( + imputed_data.na_counts[variable], + ), f"{variable} mean matching returned malformed array" - logger.set_start_time() - imp_values = self.mean_match_scheme._mean_match( - var, objective, **mm_kwargs - ) - logger.record_time(timed_event="mean_matching", **log_context) - imputed_data._insert_new_data( - dataset=ds_new, variable_index=var, new_data=imp_values - ) - # Refresh our seeds. - if rehash_seeds: - assert isinstance(random_seed_array, np.ndarray) - random_seed_array[nawhere] = hash_int32(seeds) + # Insert the imputation_values we obtained + imputed_data[variable, iteration, dataset] = imputation_values - imputed_data.iterations[ - ds_new, imputed_data.imputation_order.index(var) - ] += 1 + if not imputed_data.save_all_iterations_data: + del imputed_data[variable, iteration - 1, dataset] logger.log("\n", end="") imputed_data._ampute_original_data() - if self.save_loggers: - self.loggers.append(logger) + self.loggers.append(logger) return imputed_data - def start_logging(self): - """ - Start saving loggers to self.loggers - """ - - self.save_loggers = True - - def stop_logging(self): - """ - Stop saving loggers to self.loggers - """ - - self.save_loggers = False - def save_kernel( self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True ): @@ -1781,7 +1827,7 @@ def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: """ if iteration is None: - iteration = self.iteration_count(datasets=dataset) + iteration = self.iteration_count(dataset=dataset) importance_matrix = np.full( shape=(len(self.imputation_order), len(self.predictor_vars)), diff --git a/miceforest/imputed_data.py b/miceforest/imputed_data.py new file mode 100644 index 0000000..0ef057a --- /dev/null +++ b/miceforest/imputed_data.py @@ -0,0 +1,567 @@ +import numpy as np +from pandas import DataFrame, MultiIndex, RangeIndex, read_parquet +from .utils import ( + get_best_int_downcast, + hash_numpy_int_array, +) +from io import BytesIO +from itertools import combinations +from typing import Dict, List, Union, Any, Optional +from warnings import warn + + +class ImputedData: + def __init__( + self, + impute_data: DataFrame, + num_datasets: int = 5, + variable_schema: Union[List[str], Dict[str, str]] = None, + save_all_iterations_data: bool = True, + copy_data: bool = True, + random_seed_array: Optional[np.ndarray] = None, + ): + # All references to the data should be through self. + self.working_data = impute_data.copy() if copy_data else impute_data + self.shape = self.working_data.shape + self.save_all_iterations_data = save_all_iterations_data + + assert isinstance(self.working_data.index, RangeIndex), ( + 'Please reset the index on the dataframe' + ) + + column_names = [] + pd_dtypes_orig = {} + for col, series in self.working_data.items(): + assert isinstance(col, str), 'column names must be strings' + assert series.dtype.name != 'object', 'convert object dtypes to something else' + column_names.append(col) + pd_dtypes_orig[col] = series.dtype.name + + column_names: List[str] = [str(x) for x in self.working_data.columns] + self.column_names = column_names + pd_dtypes_orig = self.working_data.dtypes + + # Collect info about what data is missing. + na_where = {} + for col in column_names: + nas = np.where(self.working_data[col].isnull())[0] + if len(nas) == 0: + best_downcast = 'uint8' + else: + best_downcast = get_best_int_downcast(int(nas.max())) + na_where[col] = nas.astype(best_downcast) + na_counts = {col: len(nw) for col, nw in na_where.items()} + self.vars_with_any_missing = [ + col for col, count in na_counts.items() if count > 0 + ] + + # If variable_schema was passed, use that as the + # list of variables that should have models trained. + # Otherwise, only train models on variables that have + # missing values. + if variable_schema is None: + modeled_variables = self.vars_with_any_missing.copy() + variable_schema = { + target: [ + regressor + for regressor in self.column_names + if regressor != target + ] + for target in modeled_variables + } + elif isinstance(variable_schema, list): + variable_schema = { + target: [ + regressor + for regressor in self.column_names + if regressor != target + ] + for target in variable_schema + } + elif isinstance(variable_schema, dict): + # Don't alter the original dict out of scope + variable_schema = variable_schema.copy() + for target, regressors in variable_schema.items(): + if target in regressors: + raise ValueError(f'{target} being used to impute itself') + + self.variable_schema = variable_schema + + self.modeled_variables = list(self.variable_schema) + self.imputed_variables = [ + col for col in self.modeled_variables + if col in self.vars_with_any_missing + ] + + self.using_random_seed_array = not random_seed_array is None + if self.using_random_seed_array: + assert isinstance(random_seed_array, np.ndarray) + assert ( + random_seed_array.shape[0] == self.shape[0] + ), "random_seed_array must be the same length as data." + self.random_seed_array = hash_numpy_int_array(random_seed_array + 1) + else: + self.random_seed_array = None + + self.na_counts = na_counts + self.na_where = na_where + self.num_datasets = num_datasets + self.initialized = False + self.imputed_variable_count = len(self.imputed_variables) + self.modeled_variable_count = len(self.modeled_variables) + self.iterations = np.zeros( + shape=(num_datasets, self.modeled_variable_count) + ).astype(int) + + iv_multiindex = MultiIndex.from_product([[0], np.arange(num_datasets)], names=('iteration', 'dataset')) + self.imputation_values = { + var: DataFrame(index=na_where[var], columns=iv_multiindex).astype(pd_dtypes_orig[var]) + for var in self.imputed_variables + } + + # Subsetting allows us to get to the imputation values: + def __getitem__(self, tup): + variable, iteration, dataset = tup + return self.imputation_values[variable].loc[:, (iteration, dataset)] + + def __setitem__(self, tup, newitem): + variable, iteration, dataset = tup + imputation_iteration = self.iteration_count(dataset=dataset, variable=variable) + + # Don't throw this warning on initialization + if (iteration <= imputation_iteration) and (iteration > 0): + warn(f'Overwriting Variable: {variable} Dataset: {dataset} Iteration: iteration') + + self.imputation_values[variable].loc[:, (iteration, dataset)] = newitem + + def __delitem__(self, tup): + variable, iteration, dataset = tup + self.imputation_values[variable].drop([(iteration, dataset)], axis=1, inplace=True) + + def __getstate__(self): + """ + For pickling + """ + # Copy the entire object, minus the big stuff + state = { + key: value + for key, value in self.__dict__.items() + if key not in ['imputation_values'] + }.copy() + + state['imputation_values'] = {} + + for col, df in self.imputation_values.items(): + byte_stream = BytesIO() + df.to_parquet(byte_stream) + state['imputation_values'][col] = byte_stream + + return state + + def __setstate__(self, state): + """ + For unpickling + """ + self.__dict__ = state + + for col, bytes in self.imputation_values.items(): + self.imputation_values[col] = read_parquet(bytes) + + def __repr__(self): + summary_string = f'\n{" " * 14}Class: ImputedData\n{self.__ids_info()}' + return summary_string + + def __ids_info(self): + summary_string = f"""\ + Datasets: {self.num_datasets} + Iterations: {self.iteration_count()} + Data Samples: {self.shape[0]} + Data Columns: {self.shape[1]} + Imputed Variables: {self.imputed_variable_count} + Modeled Variables: {self.modeled_variable_count} +All Iterations Saved: {self.save_all_iterations_data} + """ + return summary_string + + def _get_nonmissing_index(self, variable): + na_where = self.na_where[variable] + dtype = na_where.dtype + non_missing_ind = np.setdiff1d( + np.arange(self.shape[0], dtype=dtype), + na_where, + assume_unique=True + ) + return non_missing_ind + + def _get_nonmissing_values(self, variable): + ind = self._get_nonmissing_index(variable) + return self.working_data.loc[ind, variable] + + def get_bachelor_features(self, variable): + na_where = self.na_where[variable] + predictors = self.variable_schema[variable] + bachelor_features = self.working_data.loc[na_where, predictors] + return bachelor_features + + def _ampute_original_data(self): + """Need to put self.working_data back in its original form""" + for variable in self.imputed_variables: + na_where = self.na_where[variable] + self.working_data.loc[na_where, variable] = np.nan + + def _prep_multi_plot( + self, + variables, + ): + plots = len(variables) + plotrows, plotcols = int(np.ceil(np.sqrt(plots))), int( + np.ceil(plots / np.ceil(np.sqrt(plots))) + ) + return plots, plotrows, plotcols + + def iteration_count( + self, + dataset: Optional[int] = None, + variable: Optional[str] = None + ): + """ + Grabs the iteration count for specified variables, datasets. + If the iteration count is not consistent across the provided + datasets/variables, an error will be thrown. Providing None + will use all datasets/variables. + + This is to ensure the process is in a consistent state when + the iteration count is needed. + + Parameters + ---------- + datasets: int or None + The datasets to check the iteration count for. + If None, all datasets are assumed (and assured) + to have the same iteration count, otherwise error. + variables: str or None + The variable to check the iteration count for. + If None, all variables are assumed (and assured) + to have the same iteration count, otherwise error. + + Returns + ------- + An integer representing the iteration count. + """ + + ds_slice = slice(None) if dataset is None else dataset + # Check all variables if None specified + check_vars = self.imputed_variables if variable is None else [variable] + assert len(check_vars) > 0, 'No variables to get iteration count for.' + variable_dataset_iterations = {} + for var in check_vars: + var_ds_iter = ( + self.imputation_values[var] + .columns + .to_frame() + .loc[(slice(None), ds_slice), :] + .reset_index(drop=True) + .groupby('dataset') + .iteration + .max() + ) + assert var_ds_iter.nunique() == 1, ( + f'{var} has different iteration counts between datasets:\n' + f'{var_ds_iter}' + ) + variable_dataset_iterations[var] = var_ds_iter.iloc[0] + + distinct_variable_iteration_counts = set(variable_dataset_iterations.values()) + assert len(distinct_variable_iteration_counts) == 1, ( + 'Variables have different iteration counts:\n' + f'{variable_dataset_iterations}' + ) + + return distinct_variable_iteration_counts.pop() + + + def complete_data( + self, + dataset: int = 0, + iteration: Optional[int] = None, + inplace: bool = False, + variables: Optional[List[str]] = None, + ): + """ + Return dataset with missing values imputed. + + Parameters + ---------- + dataset: int + The dataset to complete. + iteration: int + Impute data with values obtained at this iteration. + If None, returns the most up-to-date iterations, + even if different between variables. If not none, + iteration must have been saved in imputed values. + inplace: bool + Should the data be completed in place? If True, + self.working_data is imputed,and nothing is returned. + This is useful if the dataset is very large. If + False, a copy of the data is returned, with missing + values imputed. + + Returns + ------- + The completed data, with values imputed for specified variables. + + """ + + # Return a copy if not inplace. + impute_data = self.working_data if inplace else self.working_data.copy() + + # Figure out which variables we need to impute. + # Never impute variables that are not in imputed_variables. + imp_vars = self.imputed_variables if variables is None else variables + assert set(imp_vars).issubset(set(self.imputed_variables)), ( + 'Not all variables specified were imputed.' + ) + + for variable in imp_vars: + if iteration is None: + iteration = self.iteration_count(dataset=dataset, variable=variable) + na_where = self.na_where[variable] + impute_data.loc[na_where, variable] = self[variable, iteration, dataset] + + if not inplace: + return impute_data + + # def get_means(self, datasets, variables=None): + # """ + # Return a dict containing the average imputation value + # for specified variables at each iteration. + # """ + # num_vars = self._get_num_vars(variables) + + # # For every variable, get the correlations between every dataset combination + # # at each iteration + # curr_iteration = self.iteration_count(datasets=datasets) + # if self.save_all_iterations: + # iter_range = list(range(curr_iteration + 1)) + # else: + # iter_range = [curr_iteration] + # mean_dict = { + # ds: { + # var: {itr: np.mean(self[ds, var, itr]) for itr in iter_range} + # for var in num_vars + # } + # for ds in datasets + # } + + # return mean_dict + + # def plot_mean_convergence(self, datasets=None, variables=None, **adj_args): + # """ + # Plots the average value of imputations over each iteration. + + # Parameters + # ---------- + # variables: None or list + # The variables to plot. Must be numeric. + # adj_args + # Passed to matplotlib.pyplot.subplots_adjust() + + # """ + + # # Move this to .compat at some point. + # try: + # import matplotlib.pyplot as plt + # from matplotlib import gridspec + # except ImportError: + # raise ImportError("matplotlib must be installed to plot mean convergence") + + # if self.iteration_count() < 2 or not self.save_all_iterations: + # raise ValueError("There is only one iteration.") + + # if datasets is None: + # datasets = list(range(self.dataset_count())) + # else: + # datasets = _ensure_iterable(datasets) + # num_vars = self._get_num_vars(variables) + # mean_dict = self.get_means(datasets=datasets, variables=variables) + # plots, plotrows, plotcols = self._prep_multi_plot(num_vars) + # gs = gridspec.GridSpec(plotrows, plotcols) + # fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) + + # for v in range(plots): + # axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) + # var = num_vars[v] + # for d in mean_dict.values(): + # ax[axr, axc].plot(list(d[var].values()), color="black") + # ax[axr, axc].set_title(var) + # ax[axr, axc].set_xlabel("Iteration") + # ax[axr, axc].set_ylabel("mean") + # plt.subplots_adjust(**adj_args) + + # def plot_imputed_distributions( + # self, datasets=None, variables=None, iteration=None, **adj_args + # ): + # """ + # Plot the imputed value distributions. + # Red lines are the distribution of original data + # Black lines are the distribution of the imputed values. + + # Parameters + # ---------- + # datasets: None, int, list[int] + # variables: None, str, int, list[str], or list[int] + # The variables to plot. If None, all numeric variables + # are plotted. + # iteration: None, int + # The iteration to plot the distribution for. + # If None, the latest iteration is plotted. + # save_all_iterations must be True if specifying + # an iteration. + # adj_args + # Additional arguments passed to plt.subplots_adjust() + + # """ + # # Move this to .compat at some point. + # try: + # import seaborn as sns + # import matplotlib.pyplot as plt + # from matplotlib import gridspec + # except ImportError: + # raise ImportError( + # "matplotlib and seaborn must be installed to plot distributions." + # ) + + # if datasets is None: + # datasets = list(range(self.dataset_count())) + # else: + # datasets = _ensure_iterable(datasets) + # if iteration is None: + # iteration = self.iteration_count(datasets=datasets, variables=variables) + # num_vars = self._get_num_vars(variables) + # plots, plotrows, plotcols = self._prep_multi_plot(num_vars) + # gs = gridspec.GridSpec(plotrows, plotcols) + # fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) + + # for v in range(plots): + # var = num_vars[v] + # axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) + # iteration_level_imputations = { + # ds: self[ds, var, iteration] for ds in datasets + # } + # plt.sca(ax[axr, axc]) + # non_missing_ind = self._get_nonmissing_index(var) + # nonmissing_values = _subset_data( + # self.working_data, row_ind=non_missing_ind, col_ind=var, return_1d=True + # ) + # ax[axr, axc] = sns.kdeplot(nonmissing_values, color="red", linewidth=2) + # for imparray in iteration_level_imputations.values(): + # ax[axr, axc] = sns.kdeplot( + # imparray, color="black", linewidth=1, warn_singular=False + # ) + # ax[axr, axc].set(xlabel=self._get_var_name_from_scalar(var)) + + # plt.subplots_adjust(**adj_args) + + # def get_correlations( + # self, datasets: List[int], variables: Union[List[int], List[str]] + # ): + # """ + # Return the correlations between datasets for + # the specified variables. + + # Parameters + # ---------- + # variables: list[str], list[int] + # The variables to return the correlations for. + + # Returns + # ------- + # dict + # The correlations at each iteration for the specified + # variables. + + # """ + + # if self.dataset_count() < 3: + # raise ValueError( + # "Not enough datasets to calculate correlations between them" + # ) + # curr_iteration = self.iteration_count() + # var_indx = self._get_var_ind_from_list(variables) + + # # For every variable, get the correlations between every dataset combination + # # at each iteration + # correlation_dict = {} + # if self.save_all_iterations: + # iter_range = list(range(1, curr_iteration + 1)) + # else: + # # Make this iterable for code tidyness + # iter_range = [curr_iteration] + + # for var in var_indx: + # # Get a dict of variables and imputations for all datasets for this iteration + # iteration_level_imputations = { + # iteration: {ds: self[ds, var, iteration] for ds in datasets} + # for iteration in iter_range + # } + + # combination_correlations = { + # iteration: [ + # round(np.corrcoef(impcomb)[0, 1], 3) + # for impcomb in list(combinations(varimps.values(), 2)) + # ] + # for iteration, varimps in iteration_level_imputations.items() + # } + + # correlation_dict[var] = combination_correlations + + # return correlation_dict + + # def plot_correlations(self, datasets=None, variables=None, **adj_args): + # """ + # Plot the correlations between datasets. + # See get_correlations() for more details. + + # Parameters + # ---------- + # datasets: None or list[int] + # The datasets to plot. + # variables: None,list + # The variables to plot. + # adj_args + # Additional arguments passed to plt.subplots_adjust() + + # """ + + # # Move this to .compat at some point. + # try: + # import matplotlib.pyplot as plt + # from matplotlib import gridspec + # except ImportError: + # raise ImportError("matplotlib must be installed to plot importance") + + # if self.dataset_count() < 4: + # raise ValueError("Not enough datasets to make box plot") + # if datasets is None: + # datasets = list(range(self.dataset_count())) + # else: + # datasets = _ensure_iterable(datasets) + # var_indx = self._get_var_ind_from_list(variables) + # num_vars = self._get_num_vars(var_indx) + # plots, plotrows, plotcols = self._prep_multi_plot(num_vars) + # correlation_dict = self.get_correlations(datasets=datasets, variables=num_vars) + # gs = gridspec.GridSpec(plotrows, plotcols) + # fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) + + # for v in range(plots): + # axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) + # var = list(correlation_dict)[v] + # ax[axr, axc].boxplot( + # list(correlation_dict[var].values()), + # labels=range(len(correlation_dict[var])), + # ) + # ax[axr, axc].set_title(self._get_var_name_from_scalar(var)) + # ax[axr, axc].set_xlabel("Iteration") + # ax[axr, axc].set_ylabel("Correlations") + # ax[axr, axc].set_ylim([-1, 1]) + # plt.subplots_adjust(**adj_args) diff --git a/miceforest/logger.py b/miceforest/logger.py index 8163090..a32bc0c 100644 --- a/miceforest/logger.py +++ b/miceforest/logger.py @@ -1,15 +1,15 @@ -from .compat import pd_Series, pd_DataFrame, PANDAS_INSTALLED +from pandas import Series from datetime import datetime, timedelta -from typing import Dict, Any, List, Tuple, Optional +from typing import Dict, Any, List, Tuple, Optional, Union class Logger: def __init__( - self, - name: str, - recording_levels: Tuple, - verbose: bool = False, - ) -> None: + self, + name: str, + timed_levels: List[str], + verbose: bool = False, + ): """ miceforest logger. @@ -29,13 +29,13 @@ def __init__( Should information be printed. """ self.name = name - self.recording_levels = recording_levels self.verbose = verbose self.initialization_time = datetime.now() - self._start_time: Optional[datetime] = None + self.timed_levels = timed_levels + self.started_timers = {} if self.verbose: - print(f"Initialized logger with name {name}") + print(f"Initialized logger with name {name} and {len(timed_levels)} levels") self.time_seconds: Dict[Any, float] = {} @@ -47,38 +47,29 @@ def log(self, *args, **kwargs): if self.verbose: print(*args, **kwargs) - def set_start_time(self): - assert self._start_time is None, 'Recording has already started' - self._start_time = datetime.now() + def set_start_time(self, time_key: Tuple): + assert len(time_key) == len(self.timed_levels) + assert time_key not in list(self.started_timers), f'Timer {time_key} already started' + self.started_timers[time_key] = datetime.now() - def record_time( - self, - level_items: Dict[str, str], - ): + def record_time(self, time_key: Tuple): """ Compares the current time with the start time, and records the time difference in our time log in the appropriate register. Times can stack for a context. """ - seconds = (datetime.now() - self._start_time).total_seconds() - self._start_time = None - time_key = (dataset, variable_name, iteration, timed_event) + assert time_key in list(self.started_timers), f'Timer {time_key} never started' + seconds = (datetime.now() - self.started_timers[time_key]).total_seconds() + del self.started_timers[time_key] if time_key in self.time_seconds: self.time_seconds[time_key] += seconds else: self.time_seconds[time_key] = seconds - def get_time_df_summary(self): + def get_time_spend_summary(self): """ Returns a frame of the total time taken per variable, event. Returns a pandas dataframe if pandas is installed. Otherwise, np.array. """ - - if PANDAS_INSTALLED: - dat = pd_Series(self.time_seconds.values(), index=self.time_seconds.keys()) - agg = dat.groupby(level=[1, 3]).sum() - df = pd_DataFrame(agg).reset_index() - df.columns = ["Variable", "Event", "Seconds"] - piv = df.pivot_table(values="Seconds", index="Variable", columns="Event") - return piv - else: - raise ValueError("Returning times as a frame requires pandas") \ No newline at end of file + summary = Series(self.time_seconds) + summary.index.names = self.timed_levels + return summary diff --git a/miceforest/mean_match.py b/miceforest/mean_match.py index 45f9480..b79617d 100644 --- a/miceforest/mean_match.py +++ b/miceforest/mean_match.py @@ -1,11 +1,11 @@ -from pandas import Series +from pandas import Series, DataFrame import inspect from copy import deepcopy from lightgbm import Booster from typing import Callable, Union, Dict, Set, Optional import numpy as np -from scipy.spatial import KDTree + from .utils import logodds @@ -34,183 +34,6 @@ ] -def _to_2d(x): - if x.ndim == 1: - x.shape = (-1, 1) - - -def mean_match_reg( - mean_match_candidates: int, - bachelor_preds: np.ndarray, - candidate_preds: np.ndarray, - candidate_values: np.ndarray, - random_state: np.random.RandomState, - hashed_seeds: Optional[np.ndarray], -): - """ - Determines the values of candidates which will be used to impute the bachelors - """ - - if mean_match_candidates == 0: - imp_values = bachelor_preds - - else: - _to_2d(bachelor_preds) - _to_2d(candidate_preds) - - num_bachelors = bachelor_preds.shape[0] - - # balanced_tree = False fixes a recursion issue for some reason. - # https://github.com/scipy/scipy/issues/14799 - kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False) - _, knn_indices = kd_tree.query( - bachelor_preds, k=mean_match_candidates, workers=-1 - ) - - # We can skip the random selection process if mean_match_candidates == 1 - if mean_match_candidates == 1: - index_choice = knn_indices - - else: - # Use the random_state if seed_array was not passed. Faster - if hashed_seeds is None: - ind = random_state.randint(mean_match_candidates, size=(num_bachelors)) - # Use the random_seed_array if it was passed. Deterministic. - else: - ind = hashed_seeds % mean_match_candidates - - index_choice = knn_indices[np.arange(num_bachelors), ind] - - imp_values = np.array(candidate_values)[index_choice] - - return imp_values - - -def mean_match_binary_accurate( - mean_match_candidates: int, - bachelor_preds: np.ndarray, - candidate_preds: np.ndarray, - candidate_values: np.ndarray, - random_state: np.random.RandomState, - hashed_seeds: Optional[np.ndarray], -): - """ - Determines the values of candidates which will be used to impute the bachelors. - This function works just like the regression version - chooses candidates with - close probabilities to the bachelor prediction. - """ - - return mean_match_reg( - mean_match_candidates, - bachelor_preds, - candidate_preds, - candidate_values, - random_state, - hashed_seeds, - ) - - -def mean_match_binary_fast( - mean_match_candidates: int, - bachelor_preds: np.ndarray, - random_state: np.random.RandomState, - hashed_seeds: Optional[np.ndarray], -): - """ - Chooses 0/1 randomly weighted by probability obtained from prediction. - If mean_match_candidates is 0, choose class with highest probability. - """ - if mean_match_candidates == 0: - imp_values = np.floor(bachelor_preds + 0.5) - - else: - num_bachelors = bachelor_preds.shape[0] - if hashed_seeds is None: - imp_values = random_state.binomial(n=1, p=bachelor_preds) - else: - imp_values = [] - for i in range(num_bachelors): - np.random.seed(seed=hashed_seeds[i]) - imp_values.append(np.random.binomial(n=1, p=bachelor_preds[i])) - - imp_values = np.array(imp_values) - - return imp_values - - -def mean_match_multiclass_fast( - mean_match_candidates: int, - bachelor_preds: np.ndarray, - random_state: np.random.RandomState, - hashed_seeds: Optional[np.ndarray], -): - """ - If mean_match_candidates is 0, choose class with highest probability. - Otherwise, randomly choose class weighted by class probabilities. - """ - if mean_match_candidates == 0: - imp_values = np.argmax(bachelor_preds, axis=1) - - else: - num_bachelors = bachelor_preds.shape[0] - - # Turn bachelor_preds into discrete cdf: - bachelor_preds = bachelor_preds.cumsum(axis=1) - - # Randomly choose uniform numbers 0-1 - if hashed_seeds is None: - # This is the fastest way to adjust for numeric - # imprecision of float16 dtype. Actually ends up - # barely taking any time at all. - bp_dtype = bachelor_preds.dtype - unif = np.minimum( - random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype), - bachelor_preds[:, -1], - ) - else: - unif = [] - for i in range(num_bachelors): - np.random.seed(seed=hashed_seeds[i]) - unif.append(np.random.uniform(0, 1, size=1)[0]) - unif = np.array(unif) - - # Choose classes according to their cdf. - # Distribution will match probabilities - imp_values = np.array( - [ - np.searchsorted(bachelor_preds[i, :], unif[i]) - for i in range(num_bachelors) - ] - ) - - return imp_values - - -def mean_match_multiclass_accurate( - mean_match_candidates: int, - bachelor_preds: np.ndarray, - candidate_preds: np.ndarray, - candidate_values: np.ndarray, - random_state: np.random.RandomState, - hashed_seeds: Optional[np.ndarray], -): - """ - Performs nearest neighbors search on class probabilities. - """ - if mean_match_candidates == 0: - return np.argmax(bachelor_preds, axis=1) - - else: - return mean_match_reg( - mean_match_candidates, - bachelor_preds, - candidate_preds, - candidate_values, - random_state, - hashed_seeds, - ) - - def adjust_shap_for_rf(model, sv): if model.params["boosting"] in ["random_forest", "rf"]: sv /= model.current_iteration() @@ -244,7 +67,7 @@ def predict_multiclass_logodds(model: Booster, data): return preds -def predict_multiclass_shap(model: Booster, data): +def predict_multiclass_shap(model: Booster, data: DataFrame): """ Returns a 3d array of shape (samples, columns, classes) It is faster to copy into a new array than delete from diff --git a/miceforest/utils.py b/miceforest/utils.py index 7c9bec3..52fc8f2 100644 --- a/miceforest/utils.py +++ b/miceforest/utils.py @@ -7,11 +7,26 @@ from typing import Union, List, Dict, Optional +def _to_2d(x): + """ + Ensures an array is 2 dimensional, in place. + """ + if x.ndim == 1: + x.shape = (-1, 1) + +def _to_1d(x): + """ + Ensures an array is 1 dimensional, in place. + """ + if x.ndim == 2: + assert x.shape[1] == 1 + x.shape = (-1) + def get_best_int_downcast(x: int): assert isinstance(x, int) int_dtypes = ['uint8', 'uint16', 'uint32', 'uint64'] np_iinfo_max = { - np.iinfo(dtype).max + dtype: np.iinfo(dtype).max for dtype in int_dtypes } for dtype, max in np_iinfo_max.items(): @@ -54,12 +69,13 @@ def ampute_data( """ amputed_data = data.copy() num_rows = amputed_data.shape[0] - amp_rows = int(perc * num_rows[0]) + amp_rows = int(perc * num_rows) random_state = ensure_rng(random_state) + variables = list(data.columns) if variables is None else variables - for col in ampute_data.columns: + for col in variables: ind = random_state.choice(amputed_data.index, size=amp_rows, replace=False) - ampute_data.loc[ind, col] = np.nan + amputed_data.loc[ind, col] = np.nan return amputed_data @@ -207,19 +223,39 @@ def stratified_categorical_folds(y: Series, nfold: int): # We don't really need to worry that much about diffusion # since we take % n at the end, and n (mmc) is usually # very small. This hash performs well enough in testing. -def hash_int32(x): +def hash_int32(x: np.ndarray): """ A hash function which generates random uniform (enough) int32 integers. Used in mean matching and initialization. """ assert isinstance(x, np.ndarray) - assert x.dtype == "int32", "x must be int32" + assert x.dtype in ["uint32", "int32"], "x must be int32" x = ((x >> 16) ^ x) * 0x45D9F3B x = ((x >> 16) ^ x) * 0x45D9F3B x = (x >> 16) ^ x return x +def hash_uint64(x: np.ndarray): + assert isinstance(x, np.ndarray) + assert x.dtype == "uint64", "x must be int32" + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9 + x = (x ^ (x >> 27)) * 0x94d049bb133111eb + x = x ^ (x >> 31) + return x + +def hash_numpy_int_array(x: np.ndarray, ind: Optional[np.ndarray] = None): + if ind is None: + ind = slice(None) + assert isinstance(x, np.ndarray) + if x.dtype in ["uint32", "int32"]: + x[ind] = hash_int32(x[ind]) + elif x.dtype == 'uint64': + x[ind] = hash_uint64(x[ind]) + else: + raise ValueError('random_seed_array must be uint32, int32, or uint64 datatype') + return x + def _draw_random_int32(random_state, size): nums = random_state.randint( low=0, high=np.iinfo("int32").max, size=size, dtype="int32" @@ -276,7 +312,7 @@ def _expand_value_to_dict(default, value, keys): } else: assert default.__class__ == value.__class__ - ret = {key: default for key in keys} + ret = {key: value for key in keys} return ret diff --git a/poetry.lock b/poetry.lock index f659e20..f1a69fa 100644 --- a/poetry.lock +++ b/poetry.lock @@ -277,13 +277,13 @@ files = [ [[package]] name = "ipython" -version = "8.23.0" +version = "8.24.0" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.10" files = [ - {file = "ipython-8.23.0-py3-none-any.whl", hash = "sha256:07232af52a5ba146dc3372c7bf52a0f890a23edf38d77caef8d53f9cdc2584c1"}, - {file = "ipython-8.23.0.tar.gz", hash = "sha256:7468edaf4f6de3e1b912e57f66c241e6fd3c7099f2ec2136e239e142e800274d"}, + {file = "ipython-8.24.0-py3-none-any.whl", hash = "sha256:d7bf2f6c4314984e3e02393213bab8703cf163ede39672ce5918c51fe253a2a3"}, + {file = "ipython-8.24.0.tar.gz", hash = "sha256:010db3f8a728a578bb641fdd06c063b9fb8e96a9464c63aec6310fbcb5e80501"}, ] [package.dependencies] @@ -297,7 +297,7 @@ prompt-toolkit = ">=3.0.41,<3.1.0" pygments = ">=2.4.0" stack-data = "*" traitlets = ">=5.13.0" -typing-extensions = {version = "*", markers = "python_version < \"3.12\""} +typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} [package.extras] all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] @@ -310,7 +310,7 @@ nbformat = ["nbformat"] notebook = ["ipywidgets", "notebook"] parallel = ["ipyparallel"] qtconsole = ["qtconsole"] -test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] +test = ["pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] [[package]] @@ -334,13 +334,13 @@ testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] [[package]] name = "joblib" -version = "1.4.0" +version = "1.4.2" description = "Lightweight pipelining with Python functions" optional = false python-versions = ">=3.8" files = [ - {file = "joblib-1.4.0-py3-none-any.whl", hash = "sha256:42942470d4062537be4d54c83511186da1fc14ba354961a2114da91efa9a4ed7"}, - {file = "joblib-1.4.0.tar.gz", hash = "sha256:1eb0dc091919cd384490de890cb5dfd538410a6d4b3b54eef09fb8c50b409b1c"}, + {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, + {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, ] [[package]] @@ -720,48 +720,49 @@ files = [ [[package]] name = "pandas" -version = "2.2.2" +version = "2.2.0" description = "Powerful data structures for data analysis, time series, and statistics" optional = false python-versions = ">=3.9" files = [ - {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"}, - {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"}, - {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08"}, - {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0"}, - {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51"}, - {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e5a0b00e1e56a842f922e7fae8ae4077aee4af0acb5ae3622bd4b4c30aedf99"}, - {file = "pandas-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ddf818e4e6c7c6f4f7c8a12709696d193976b591cc7dc50588d3d1a6b5dc8772"}, - {file = "pandas-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:696039430f7a562b74fa45f540aca068ea85fa34c244d0deee539cb6d70aa288"}, - {file = "pandas-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8e90497254aacacbc4ea6ae5e7a8cd75629d6ad2b30025a4a8b09aa4faf55151"}, - {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58b84b91b0b9f4bafac2a0ac55002280c094dfc6402402332c0913a59654ab2b"}, - {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2123dc9ad6a814bcdea0f099885276b31b24f7edf40f6cdbc0912672e22eee"}, - {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2925720037f06e89af896c70bca73459d7e6a4be96f9de79e2d440bd499fe0db"}, - {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1"}, - {file = "pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24"}, - {file = "pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef"}, - {file = "pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce"}, - {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad"}, - {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad"}, - {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76"}, - {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32"}, - {file = "pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23"}, - {file = "pandas-2.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0ca6377b8fca51815f382bd0b697a0814c8bda55115678cbc94c30aacbb6eff2"}, - {file = "pandas-2.2.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9057e6aa78a584bc93a13f0a9bf7e753a5e9770a30b4d758b8d5f2a62a9433cd"}, - {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:001910ad31abc7bf06f49dcc903755d2f7f3a9186c0c040b827e522e9cef0863"}, - {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66b479b0bd07204e37583c191535505410daa8df638fd8e75ae1b383851fe921"}, - {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a77e9d1c386196879aa5eb712e77461aaee433e54c68cf253053a73b7e49c33a"}, - {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:92fd6b027924a7e178ac202cfbe25e53368db90d56872d20ffae94b96c7acc57"}, - {file = "pandas-2.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:640cef9aa381b60e296db324337a554aeeb883ead99dc8f6c18e81a93942f5f4"}, - {file = "pandas-2.2.2.tar.gz", hash = "sha256:9e79019aba43cb4fda9e4d983f8e88ca0373adbb697ae9c6c43093218de28b54"}, + {file = "pandas-2.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8108ee1712bb4fa2c16981fba7e68b3f6ea330277f5ca34fa8d557e986a11670"}, + {file = "pandas-2.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:736da9ad4033aeab51d067fc3bd69a0ba36f5a60f66a527b3d72e2030e63280a"}, + {file = "pandas-2.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38e0b4fc3ddceb56ec8a287313bc22abe17ab0eb184069f08fc6a9352a769b18"}, + {file = "pandas-2.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20404d2adefe92aed3b38da41d0847a143a09be982a31b85bc7dd565bdba0f4e"}, + {file = "pandas-2.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7ea3ee3f125032bfcade3a4cf85131ed064b4f8dd23e5ce6fa16473e48ebcaf5"}, + {file = "pandas-2.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f9670b3ac00a387620489dfc1bca66db47a787f4e55911f1293063a78b108df1"}, + {file = "pandas-2.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:5a946f210383c7e6d16312d30b238fd508d80d927014f3b33fb5b15c2f895430"}, + {file = "pandas-2.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a1b438fa26b208005c997e78672f1aa8138f67002e833312e6230f3e57fa87d5"}, + {file = "pandas-2.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8ce2fbc8d9bf303ce54a476116165220a1fedf15985b09656b4b4275300e920b"}, + {file = "pandas-2.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2707514a7bec41a4ab81f2ccce8b382961a29fbe9492eab1305bb075b2b1ff4f"}, + {file = "pandas-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85793cbdc2d5bc32620dc8ffa715423f0c680dacacf55056ba13454a5be5de88"}, + {file = "pandas-2.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:cfd6c2491dc821b10c716ad6776e7ab311f7df5d16038d0b7458bc0b67dc10f3"}, + {file = "pandas-2.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a146b9dcacc3123aa2b399df1a284de5f46287a4ab4fbfc237eac98a92ebcb71"}, + {file = "pandas-2.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbc1b53c0e1fdf16388c33c3cca160f798d38aea2978004dd3f4d3dec56454c9"}, + {file = "pandas-2.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a41d06f308a024981dcaa6c41f2f2be46a6b186b902c94c2674e8cb5c42985bc"}, + {file = "pandas-2.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:159205c99d7a5ce89ecfc37cb08ed179de7783737cea403b295b5eda8e9c56d1"}, + {file = "pandas-2.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb1e1f3861ea9132b32f2133788f3b14911b68102d562715d71bd0013bc45440"}, + {file = "pandas-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:761cb99b42a69005dec2b08854fb1d4888fdf7b05db23a8c5a099e4b886a2106"}, + {file = "pandas-2.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a20628faaf444da122b2a64b1e5360cde100ee6283ae8effa0d8745153809a2e"}, + {file = "pandas-2.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f5be5d03ea2073627e7111f61b9f1f0d9625dc3c4d8dda72cc827b0c58a1d042"}, + {file = "pandas-2.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:a626795722d893ed6aacb64d2401d017ddc8a2341b49e0384ab9bf7112bdec30"}, + {file = "pandas-2.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9f66419d4a41132eb7e9a73dcec9486cf5019f52d90dd35547af11bc58f8637d"}, + {file = "pandas-2.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:57abcaeda83fb80d447f28ab0cc7b32b13978f6f733875ebd1ed14f8fbc0f4ab"}, + {file = "pandas-2.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e60f1f7dba3c2d5ca159e18c46a34e7ca7247a73b5dd1a22b6d59707ed6b899a"}, + {file = "pandas-2.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb61dc8567b798b969bcc1fc964788f5a68214d333cade8319c7ab33e2b5d88a"}, + {file = "pandas-2.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:52826b5f4ed658fa2b729264d63f6732b8b29949c7fd234510d57c61dbeadfcd"}, + {file = "pandas-2.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bde2bc699dbd80d7bc7f9cab1e23a95c4375de615860ca089f34e7c64f4a8de7"}, + {file = "pandas-2.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:3de918a754bbf2da2381e8a3dcc45eede8cd7775b047b923f9006d5f876802ae"}, + {file = "pandas-2.2.0.tar.gz", hash = "sha256:30b83f7c3eb217fb4d1b494a57a2fda5444f17834f5df2de6b2ffff68dc3c8e2"}, ] [package.dependencies] numpy = [ - {version = ">=1.22.4", markers = "python_version < \"3.11\""}, - {version = ">=1.23.2", markers = "python_version == \"3.11\""}, - {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, + {version = ">=1.22.4,<2", markers = "python_version < \"3.11\""}, + {version = ">=1.23.2,<2", markers = "python_version == \"3.11\""}, + {version = ">=1.26.0,<2", markers = "python_version >= \"3.12\""}, ] +pyarrow = {version = ">=10.0.1", optional = true, markers = "extra == \"parquet\""} python-dateutil = ">=2.8.2" pytz = ">=2020.1" tzdata = ">=2022.7" @@ -785,7 +786,6 @@ parquet = ["pyarrow (>=10.0.1)"] performance = ["bottleneck (>=1.3.6)", "numba (>=0.56.4)", "numexpr (>=2.8.4)"] plot = ["matplotlib (>=3.6.3)"] postgresql = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "psycopg2 (>=2.9.6)"] -pyarrow = ["pyarrow (>=10.0.1)"] spss = ["pyreadstat (>=1.2.0)"] sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)"] test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] @@ -971,6 +971,54 @@ files = [ {file = "py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5"}, ] +[[package]] +name = "pyarrow" +version = "16.0.0" +description = "Python library for Apache Arrow" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pyarrow-16.0.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:22a1fdb1254e5095d629e29cd1ea98ed04b4bbfd8e42cc670a6b639ccc208b60"}, + {file = "pyarrow-16.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:574a00260a4ed9d118a14770edbd440b848fcae5a3024128be9d0274dbcaf858"}, + {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0815d0ddb733b8c1b53a05827a91f1b8bde6240f3b20bf9ba5d650eb9b89cdf"}, + {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:df0080339387b5d30de31e0a149c0c11a827a10c82f0c67d9afae3981d1aabb7"}, + {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:edf38cce0bf0dcf726e074159c60516447e4474904c0033f018c1f33d7dac6c5"}, + {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:91d28f9a40f1264eab2af7905a4d95320ac2f287891e9c8b0035f264fe3c3a4b"}, + {file = "pyarrow-16.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:99af421ee451a78884d7faea23816c429e263bd3618b22d38e7992c9ce2a7ad9"}, + {file = "pyarrow-16.0.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:d22d0941e6c7bafddf5f4c0662e46f2075850f1c044bf1a03150dd9e189427ce"}, + {file = "pyarrow-16.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:266ddb7e823f03733c15adc8b5078db2df6980f9aa93d6bb57ece615df4e0ba7"}, + {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cc23090224b6594f5a92d26ad47465af47c1d9c079dd4a0061ae39551889efe"}, + {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56850a0afe9ef37249d5387355449c0f94d12ff7994af88f16803a26d38f2016"}, + {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:705db70d3e2293c2f6f8e84874b5b775f690465798f66e94bb2c07bab0a6bb55"}, + {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:5448564754c154997bc09e95a44b81b9e31ae918a86c0fcb35c4aa4922756f55"}, + {file = "pyarrow-16.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:729f7b262aa620c9df8b9967db96c1575e4cfc8c25d078a06968e527b8d6ec05"}, + {file = "pyarrow-16.0.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:fb8065dbc0d051bf2ae2453af0484d99a43135cadabacf0af588a3be81fbbb9b"}, + {file = "pyarrow-16.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:20ce707d9aa390593ea93218b19d0eadab56390311cb87aad32c9a869b0e958c"}, + {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5823275c8addbbb50cd4e6a6839952682a33255b447277e37a6f518d6972f4e1"}, + {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ab8b9050752b16a8b53fcd9853bf07d8daf19093533e990085168f40c64d978"}, + {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:42e56557bc7c5c10d3e42c3b32f6cff649a29d637e8f4e8b311d334cc4326730"}, + {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2a7abdee4a4a7cfa239e2e8d721224c4b34ffe69a0ca7981354fe03c1328789b"}, + {file = "pyarrow-16.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:ef2f309b68396bcc5a354106741d333494d6a0d3e1951271849787109f0229a6"}, + {file = "pyarrow-16.0.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:ed66e5217b4526fa3585b5e39b0b82f501b88a10d36bd0d2a4d8aa7b5a48e2df"}, + {file = "pyarrow-16.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cc8814310486f2a73c661ba8354540f17eef51e1b6dd090b93e3419d3a097b3a"}, + {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c2f5e239db7ed43e0ad2baf46a6465f89c824cc703f38ef0fde927d8e0955f7"}, + {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f293e92d1db251447cb028ae12f7bc47526e4649c3a9924c8376cab4ad6b98bd"}, + {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:dd9334a07b6dc21afe0857aa31842365a62eca664e415a3f9536e3a8bb832c07"}, + {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:d91073d1e2fef2c121154680e2ba7e35ecf8d4969cc0af1fa6f14a8675858159"}, + {file = "pyarrow-16.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:71d52561cd7aefd22cf52538f262850b0cc9e4ec50af2aaa601da3a16ef48877"}, + {file = "pyarrow-16.0.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:b93c9a50b965ee0bf4fef65e53b758a7e8dcc0c2d86cebcc037aaaf1b306ecc0"}, + {file = "pyarrow-16.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d831690844706e374c455fba2fb8cfcb7b797bfe53ceda4b54334316e1ac4fa4"}, + {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35692ce8ad0b8c666aa60f83950957096d92f2a9d8d7deda93fb835e6053307e"}, + {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9dd3151d098e56f16a8389c1247137f9e4c22720b01c6f3aa6dec29a99b74d80"}, + {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:bd40467bdb3cbaf2044ed7a6f7f251c8f941c8b31275aaaf88e746c4f3ca4a7a"}, + {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:00a1dcb22ad4ceb8af87f7bd30cc3354788776c417f493089e0a0af981bc8d80"}, + {file = "pyarrow-16.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:fda9a7cebd1b1d46c97b511f60f73a5b766a6de4c5236f144f41a5d5afec1f35"}, + {file = "pyarrow-16.0.0.tar.gz", hash = "sha256:59bb1f1edbbf4114c72415f039f1359f1a57d166a331c3229788ccbfbb31689a"}, +] + +[package.dependencies] +numpy = ">=1.16.6" + [[package]] name = "pygments" version = "2.17.2" @@ -1002,13 +1050,13 @@ diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" -version = "8.1.1" +version = "8.2.0" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ - {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"}, - {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"}, + {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"}, + {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"}, ] [package.dependencies] @@ -1016,11 +1064,11 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" -pluggy = ">=1.4,<2.0" +pluggy = ">=1.5,<2.0" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] -testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] +dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] [[package]] name = "python-dateutil" @@ -1133,20 +1181,24 @@ test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "po [[package]] name = "seaborn" -version = "0.11.2" -description = "seaborn: statistical data visualization" +version = "0.13.2" +description = "Statistical data visualization" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" files = [ - {file = "seaborn-0.11.2-py3-none-any.whl", hash = "sha256:85a6baa9b55f81a0623abddc4a26b334653ff4c6b18c418361de19dbba0ef283"}, - {file = "seaborn-0.11.2.tar.gz", hash = "sha256:cf45e9286d40826864be0e3c066f98536982baf701a7caa386511792d61ff4f6"}, + {file = "seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987"}, + {file = "seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7"}, ] [package.dependencies] -matplotlib = ">=2.2" -numpy = ">=1.15" -pandas = ">=0.23" -scipy = ">=1.0" +matplotlib = ">=3.4,<3.6.1 || >3.6.1" +numpy = ">=1.20,<1.24.0 || >1.24.0" +pandas = ">=1.2" + +[package.extras] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"] [[package]] name = "six" @@ -1180,13 +1232,13 @@ tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] [[package]] name = "threadpoolctl" -version = "3.4.0" +version = "3.5.0" description = "threadpoolctl" optional = false python-versions = ">=3.8" files = [ - {file = "threadpoolctl-3.4.0-py3-none-any.whl", hash = "sha256:8f4c689a65b23e5ed825c8436a92b818aac005e0f3715f6a1664d7c7ee29d262"}, - {file = "threadpoolctl-3.4.0.tar.gz", hash = "sha256:f11b491a03661d6dd7ef692dd422ab34185d982466c49c8f98c8f716b5c93196"}, + {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"}, + {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"}, ] [[package]] @@ -1251,4 +1303,4 @@ files = [ [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "d7271a2e0d7c785a57363c2d11ef8dc542a2288659c8e017dda71b9e98f975ae" +content-hash = "be1ba227f52493dafaf01193766cc1be90a3d52fe361bb8e93a9b2e91fa83c09" diff --git a/pyproject.toml b/pyproject.toml index 907b71b..6996dbc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,12 +11,12 @@ package-mode = true python = "^3.10" lightgbm = "^4.0.0" -pandas = "^2.2.0" +pandas = {extras = ["parquet"], version = "2.2.0"} numpy = "^1.26.0" blosc2 = "^2.6.0" dill = "^0.3.7" scipy = "^1.11.1" -seaborn = "^0.11.0" +seaborn = "^0.13.0" matplotlib = "^3.3.0" scikit-learn = "^1.4.0" diff --git a/tests/test_ImputationKernel.py b/tests/test_ImputationKernel.py index c9fe86e..2913cae 100644 --- a/tests/test_ImputationKernel.py +++ b/tests/test_ImputationKernel.py @@ -6,12 +6,14 @@ from datetime import datetime from matplotlib.pyplot import close from tempfile import mkstemp +import dill # Make random state and load data # Define data random_state = np.random.RandomState(1991) iris = pd.concat(load_iris(as_frame=True, return_X_y=True), axis=1) -iris['sp'] = iris['target'].astype('category') +# iris = iris.sample(100000, replace=True) +iris['sp'] = iris['target'].map({0: 'Category1', 1: 'Category2', 2: 'Category3'}).astype('category') del iris['target'] iris.rename({ 'sepal length (cm)': 'sl', @@ -19,115 +21,222 @@ 'petal length (cm)': 'pl', 'petal width (cm)': 'pw', }, axis=1, inplace=True) -iris['bc'] = pd.Series(np.random.binomial(n=1, p=0.5, size=150)).astype('category') -iris_amp = mf.ampute_data(iris, perc=0.25, random_state=random_state) +iris['bi'] = pd.Series(np.random.binomial(n=1, p=0.5, size=iris.shape[0])).map({0: 'FOO', 1: 'BAR'}).astype('category') +iris['ui8'] = iris['sl'].round(0).astype('UInt8') +iris['ws'] = iris['ws'].astype('float32') +iris.reset_index(drop=True, inplace=True) +amputed_variables = ['sl', 'ws', 'pl', 'sp', 'bi', 'ui8'] +iris_amp = mf.ampute_data( + iris, + variables=amputed_variables, + perc=0.25, + random_state=random_state +) + +new_amputed_data = iris_amp.loc[range(20), :].reset_index(drop=True).copy() +new_nonmissing_data = iris.loc[range(20), :].reset_index(drop=True).copy() + +# Make special datasets that have weird edge cases +# Multiple columns with all missing values +# sp is categorical, and pw had no missing +# values in the original kernel data +new_amputed_data_special_1 = iris_amp.loc[range(20), :].reset_index(drop=True).copy() +for col in ['sp', 'pw']: + new_amputed_data_special_1[col] = np.nan + dtype = iris[col].dtype + new_amputed_data_special_1[col] = new_amputed_data_special_1[col].astype(dtype) + +# Some columns with no missing values +new_amputed_data_special_2 = iris_amp.loc[range(20), :].reset_index(drop=True).copy() +new_amputed_data_special_2[['sp', 'ui8']] = iris.loc[range(20), ['sp', 'ui8']] + + +def make_and_test_kernel(**kwargs): + + kwargs = { + 'data':iris_amp, + 'num_datasets':2, + 'variable_schema':vs, + 'mean_match_candidates':mmc, + 'data_subset':ds, + 'mean_match_strategy':'normal', + 'save_all_iterations_data':True, + } + # Build a normal kernel, run mice, save, load, and run mice again + kernel = mf.ImputationKernel(**kwargs) + assert kernel.iteration_count() == 0 + kernel.mice(iterations=2, verbose=True) + assert kernel.iteration_count() == 2 + new_file, filename = mkstemp() + with open(filename, 'wb') as file: + dill.dump(kernel, file) + del kernel + with open(filename, 'rb') as file: + kernel = dill.load(file) + kernel.mice(iterations=1, verbose=True) + assert kernel.iteration_count() == 3 -def test_defaults_pandas(): + modeled_variables = kernel.model_training_order + imputed_variables = kernel.imputed_variables - new_data = iris_amp.loc[range(10), :].copy() + # pw has no missing values. + assert 'pw' not in imputed_variables + + # Make a completed dataset + completed_data = kernel.complete_data(dataset=0, inplace=False) - kernel = mf.ImputationKernel( - data=iris_amp, - datasets=2, - save_models=1 - ) - kernel.mice(iterations=2, compile_candidates=True, verbose=True) + # Make sure the data was imputed + assert all(completed_data[imputed_variables].isnull().sum() == 0) - kernel2 = mf.ImputationKernel( - data=iris_amp, - datasets=1, - save_models=1 - ) - kernel2.mice(iterations=2) + # Make sure the dtypes didn't change + for col, series in iris_amp.items(): + dtype = series.dtype + assert completed_data[col].dtype == dtype - # Test appending and then test kernel. - kernel.append(kernel2) - kernel.compile_candidate_preds() + # Make sure the working data wasn't imputed + assert all(kernel.working_data[imputed_variables].isnull().sum() > 0) + # Impute the data in place now + kernel.complete_data(0, inplace=True) - # Test mice after appendage - kernel.mice(1, verbose=True) + # Assert we actually imputed the working data + assert all(kernel.working_data[imputed_variables].isnull().sum() == 0) - kernel.complete_data(0, inplace=True) - assert all(kernel.working_data.isnull().sum() == 0) - assert kernel.get_model(0, 0, 3).params['objective'] == 'regression' - assert kernel.get_model(0, 'bc', 3).params['objective'] == 'binary' - assert kernel.get_model(0, 'sp', 3).params['objective'] == 'multiclass' + # Assert the original data was not touched + assert all(iris_amp[imputed_variables].isnull().sum() > 0) - # Make sure we didn't touch the original data - assert all(iris_amp.isnull().sum() > 0) + # Make sure the models were trained the way we expect + for variable in modeled_variables: + if variable == 'sp': + objective = 'multiclass' + elif variable == 'bi': + objective = 'binary' + else: + objective = 'regression' + assert kernel.get_model(variable=variable, dataset=0, iteration=1).params['objective'] == objective + assert kernel.get_model(variable=variable, dataset=0, iteration=2).params['objective'] == objective + assert kernel.get_model(variable=variable, dataset=1, iteration=1).params['objective'] == objective + assert kernel.get_model(variable=variable, dataset=1, iteration=2).params['objective'] == objective - imp_ds = kernel.impute_new_data(new_data, verbose=True) - imp_ds.complete_data(2,inplace=True) - assert all(imp_ds.working_data.isnull().sum(0) == 0) - assert new_data.isnull().sum().sum() > 0 + # Impute a new dataset, and complete the data + imputed_new_data = kernel.impute_new_data(new_amputed_data, verbose=True) + imputed_dataset_0 = imputed_new_data.complete_data(dataset=0, iteration=2, inplace=False) + imputed_dataset_1 = imputed_new_data.complete_data(dataset=1, iteration=2, inplace=False) - # Make sure fully-recognized data can be passed through with no changes - imp_fr = kernel.impute_new_data(iris) - comp_fr = imp_fr.complete_data(0) - assert np.all(comp_fr == iris), "values of fully-recognized data were modified" - assert imp_fr.iteration_count() == -1 + # Assert we didn't just impute the same thing for all values + assert not np.all(imputed_dataset_0 == imputed_dataset_1) - # Make sure single rows can be imputed - single_row = new_data.iloc[[0], :] - imp_sr = kernel.impute_new_data(single_row) - assert np.all(imp_sr.complete_data(0).dtypes == single_row.dtypes) + # Make sure we can impute the special cases + imputed_data_special_1 = kernel.impute_new_data(new_amputed_data_special_1) + imputed_data_special_2 = kernel.impute_new_data(new_amputed_data_special_2) + imputed_dataset_special_1 = imputed_data_special_1.complete_data(0) + imputed_dataset_special_2 = imputed_data_special_2.complete_data(0) + assert not np.any(imputed_dataset_special_1[modeled_variables].isnull()) + assert not np.any(imputed_dataset_special_2[modeled_variables].isnull()) + return kernel -def test_complex_pandas(): - - working_set = iris_amp.copy() - new_data = working_set.loc[range(10), :].copy() +def test_defaults(): + + kernel_normal = make_and_test_kernel( + data=iris_amp, + num_datasets=2, + mean_match_strategy='normal', + save_all_iterations_data=True, + ) + kernel_fast = make_and_test_kernel( + data=iris_amp, + num_datasets=2, + mean_match_strategy='fast', + save_all_iterations_data=True, + ) + kernel_shap = make_and_test_kernel( + data=iris_amp, + num_datasets=2, + mean_match_strategy='shap', + save_all_iterations_data=True, + ) + + +def test_complex(): + # Customize everything. vs = { - 'sl': ['ws', 'pl', 'pw', 'sp', 'bc'], + 'sl': ['ws', 'pl', 'pw', 'sp', 'bi'], 'ws': ['sl'], - 'pl': ['sp', 'bc'], - 'sp': ['sl', 'ws', 'pl', 'pw', 'bc'], - 'pw': ['sl', 'ws', 'pl', 'sp', 'bc'], + 'pl': ['sp', 'bi'], + # 'sp': ['sl', 'ws', 'pl', 'pw', 'bc'], # Purposely don't train a variable that does have missing values + 'pw': ['sl', 'ws', 'pl', 'sp', 'bi'], + 'bi': ['ws', 'pl', 'sp'], + 'ui8': ['sp', 'ws'], } - mmc = {"sl": 4, 'ws': 0.01, "pl": 0} - ds = {"sl": 100, "ws": 0.5} - io = ['pw', 'pl', 'ws', 'sl'] + mmc = {"sl": 4, 'ws': 0, "bi": 5} + ds = {"sl": int(iris_amp.shape[0] / 2), "ws": 50} - imputed_var_names = io + imputed_var_names = list(vs) non_imputed_var_names = [c for c in iris_amp if c not in imputed_var_names] - from miceforest.builtin_mean_match_schemes import mean_match_shap - mean_match_custom = mean_match_shap.copy() - mean_match_custom.set_mean_match_candidates(mmc) - - kernel = mf.ImputationKernel( - data=working_set, - datasets=2, + # Build a normal kernel, run mice, save, load, and run mice again + kernel = make_and_test_kernel( + data=iris_amp, + num_datasets=2, variable_schema=vs, - mean_match_scheme=mean_match_shap, - imputation_order=io, - train_nonmissing=True, + mean_match_candidates=mmc, data_subset=ds, - categorical_feature='auto', - copy_data=False + mean_match_strategy='normal', + save_all_iterations_data=True, ) - kernel2 = mf.ImputationKernel( - data=working_set, - datasets=1, + normal_ind = kernel_normal.impute_new_data(new_data) + + kernel_fast = mf.ImputationKernel( + data=iris_amp, + num_datasets=2, variable_schema=vs, - mean_match_scheme=mean_match_shap, - imputation_order=io, - train_nonmissing=True, + mean_match_candidates=mmc, data_subset=ds, - categorical_feature='auto', - copy_data=False + mean_match_strategy='fast', + save_all_iterations_data=True, ) + kernel_fast.mice(iterations=2, verbose=True) new_file, filename = mkstemp() - kernel2.save_kernel(filename) - kernel2 = mf.utils.load_kernel(filename) + with open(filename, 'wb') as file: + dill.dump(kernel_fast, file) + del kernel_fast + with open(filename, 'rb') as file: + kernel_fast = dill.load(file) + kernel_fast.mice(iterations=1, verbose=True) + fast_ind = kernel_fast.impute_new_data(new_data) + + kernel_shap = mf.ImputationKernel( + data=iris_amp, + num_datasets=2, + variable_schema=vs, + mean_match_candidates=mmc, + data_subset=ds, + mean_match_strategy={'sl': 'shap', 'ws': 'fast', 'ui8': 'fast', 'bi': 'normal'}, + save_all_iterations_data=True, + ) + kernel_shap.mice(iterations=2, verbose=True) + new_file, filename = mkstemp() + with open(filename, 'wb') as file: + dill.dump(kernel_shap, file) + del kernel_shap + with open(filename, 'rb') as file: + kernel_shap = dill.load(file) + kernel_shap.mice(iterations=1, verbose=True) + shap_ind = kernel_shap.impute_new_data(new_data) + + kernel_normal.data_subset + kernel_normal.model_training_order + kernel_normal.mean_match_candidates + kernel_normal.modeled_but_not_imputed_variables + assert kernel.data_subset == {0: 100, 1: 56, 3: 113, 2: 113, 4: 113}, "mean_match_subset initialization failed" assert kernel.iteration_count() == 0, "iteration initialization failed" - assert kernel.categorical_variables == [4, 5], "categorical recognition failed." + # This section tests many things: # After saving / loading a kernel, and appending 2 kernels together: diff --git a/tests/test_imputed_accuracy.py b/tests/test_imputed_accuracy.py index b59fb23..d33d649 100644 --- a/tests/test_imputed_accuracy.py +++ b/tests/test_imputed_accuracy.py @@ -6,11 +6,6 @@ import miceforest as mf from miceforest.utils import logistic_function from sklearn.metrics import roc_auc_score -from miceforest import ( - mean_match_fast_cat, - mean_match_default, - mean_match_shap -) random_state = np.random.RandomState(5) iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) @@ -23,25 +18,26 @@ iris_new = iris.iloc[random_state.choice(iris.index, iris.shape[0], replace=False)].reset_index(drop=True) iris_new_amp = mf.utils.ampute_data(iris_new, perc=0.20) - def mse(x, y): return np.mean((x-y) ** 2) iterations = 2 + kernel_sm2 = mf.ImputationKernel( iris_amp, - datasets=1, - data_subset=0.75, - mean_match_scheme=mean_match_fast_cat, - save_models=2, - random_state=1 + num_datasets=1, + data_subset=0, + mean_match_candidates=0, + random_state=1, ) kernel_sm2.mice( iterations, boosting='random_forest', - num_iterations=100, - num_leaves=31 + learning_rate=0.02, + num_iterations=50, + num_leaves=31, + verbose=True ) kernel_sm1 = mf.ImputationKernel( @@ -78,23 +74,34 @@ def mse(x, y): def test_sm2_mice_cat(): # Binary - col = 5 + col = 'binary' ind = kernel_sm2.na_where[col] - orig = iris.values[ind, col] - imps = kernel_sm2[0, col, iterations] - preds = logistic_function(kernel_sm2.get_raw_prediction(col, dtype="float32")) - roc = roc_auc_score(orig, preds[ind]) + orig = iris.loc[ind, col] + imps = kernel_sm2[col, 0, iterations] + model = kernel_sm2.get_model(col, 0, -1) + bf = kernel_sm2.get_bachelor_features(col) + preds = model.predict(bf) + roc = roc_auc_score(orig, preds) acc = (imps == orig).mean() assert roc > 0.6 assert acc > 0.6 + pd.Series(preds).groupby(imps).mean() + dat = pd.DataFrame({'preds': preds, 'orig': orig, 'imps': imps}) + import seaborn as sb + fig = sb.displot(data=dat, x='preds', hue='orig') + fig.savefig('temp.png') + + iris_amp.columns[4] # Multiclass - col = 4 + col = 'target' ind = kernel_sm2.na_where[col] - orig = iris.values[ind, col] - imps = kernel_sm2[0, col, iterations] - preds = kernel_sm2.get_raw_prediction(col, dtype="float32") - roc = roc_auc_score(orig, preds[ind,:], multi_class='ovr', average='macro') + orig = iris.loc[ind, col] + imps = kernel_sm2[col, 0, iterations] + model = kernel_sm2.get_model(col, 0, -1) + bf = kernel_sm2.get_bachelor_features(col) + preds = model.predict(bf) + roc = roc_auc_score(orig, preds, multi_class='ovr', average='macro') acc = (imps == orig).mean() assert roc > 0.7 assert acc > 0.7 @@ -105,18 +112,21 @@ def test_sm2_mice_reg(): imputed_errors = {} modeled_errors = {} random_sample_error = {} - for col in [0,1,2,3]: + for col in ['sepallength(cm)', 'sepalwidth(cm)', 'petallength(cm)','petalwidth(cm)']: ind = kernel_sm2.na_where[col] nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris.iloc[ind, col] - preds = kernel_sm2.get_raw_prediction(col) - imps = kernel_sm2[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) + ind = kernel_sm2.na_where[col] + orig = iris.loc[ind, col] + imps = kernel_sm2[col, 0, iterations] + random_sample_error[col] = mse(orig, np.mean(iris.loc[nonmissind, col])) + modeled_errors[col] = mse(orig, preds[ind]) imputed_errors[col] = mse(orig, imps) assert random_sample_error[col] > modeled_errors[col] assert random_sample_error[col] > imputed_errors[col] + iris_amp.columns + def test_sm1_mice_cat(): From a0a15d39b8c17d4b2b4dca32c6efa099c63de47d Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sat, 20 Jul 2024 14:10:18 -0400 Subject: [PATCH 03/44] updated .gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 78b6de7..841899f 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,6 @@ miceforest.Rproj benchmarks/* requirements.txt .venv +poetry.lock +pyproject.toml +*.DS_Store* From baf22ad10f25ec890ce838d159a9363bee024c28 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sat, 20 Jul 2024 14:13:35 -0400 Subject: [PATCH 04/44] Tests are passing, Still need to work on docs --- miceforest/__init__.py | 1 - miceforest/builtin_pred_funcs.py | 13 +- miceforest/compat.py | 1 + miceforest/default_lightgbm_parameters.py | 5 +- miceforest/imputation_kernel.py | 902 +++++++++++----------- miceforest/imputed_data.py | 150 ++-- miceforest/logger.py | 8 +- miceforest/mean_match.py | 13 +- miceforest/utils.py | 62 +- poetry.lock | 100 ++- pyproject.toml | 1 + tests/test_ImputationKernel.py | 378 ++------- tests/test_imputed_accuracy.py | 466 ++++------- tests/test_reproducibility.py | 38 +- tests/test_sklearn_pipeline.py | 35 +- tests/test_utils.py | 31 +- 16 files changed, 979 insertions(+), 1225 deletions(-) diff --git a/miceforest/__init__.py b/miceforest/__init__.py index 9615b61..0f8e337 100644 --- a/miceforest/__init__.py +++ b/miceforest/__init__.py @@ -8,7 +8,6 @@ https://github.com/AnotherSamWilson/miceforest """ - from .utils import ampute_data, load_kernel from .imputed_data import ImputedData from .imputation_kernel import ImputationKernel diff --git a/miceforest/builtin_pred_funcs.py b/miceforest/builtin_pred_funcs.py index d1c627e..40641f8 100644 --- a/miceforest/builtin_pred_funcs.py +++ b/miceforest/builtin_pred_funcs.py @@ -1,6 +1,7 @@ """ Default prediction functions that come with miceforest. """ + from .utils import logodds from lightgbm import Booster import numpy as np @@ -22,14 +23,14 @@ def predict_normal(model: Booster, data): def predict_normal_shap(model: Booster, data): - preds = model.predict(data, pred_contrib=True)[:, :-1] # type: ignore + preds = model.predict(data, pred_contrib=True)[:, :-1] # type: ignore _adjust_shap_for_rf(model, preds) return preds def predict_binary_logodds(model: Booster, data): preds = logodds( - model.predict(data).clip( # type: ignore + model.predict(data).clip( # type: ignore _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD ) ) @@ -37,7 +38,7 @@ def predict_binary_logodds(model: Booster, data): def predict_multiclass_logodds(model: Booster, data): - preds = model.predict(data).clip( # type: ignore + preds = model.predict(data).clip( # type: ignore _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD ) preds = logodds(preds) @@ -52,12 +53,12 @@ def predict_multiclass_shap(model: Booster, data): """ preds = model.predict(data, pred_contrib=True) samples, cols = data.shape - classes = model._Booster__num_class # type: ignore - p = np.empty(shape=(samples, cols * classes), dtype=preds.dtype) # type: ignore + classes = model._Booster__num_class # type: ignore + p = np.empty(shape=(samples, cols * classes), dtype=preds.dtype) # type: ignore for c in range(classes): s1 = slice(c * cols, (c + 1) * cols) s2 = slice(c * (cols + 1), (c + 1) * (cols + 1) - 1) - p[:, s1] = preds[:, s2] # type: ignore + p[:, s1] = preds[:, s2] # type: ignore # If objective is random forest, the shap values are summed # without ever taking an average, so we divide by the iters diff --git a/miceforest/compat.py b/miceforest/compat.py index bf5d13e..31f828d 100644 --- a/miceforest/compat.py +++ b/miceforest/compat.py @@ -1,4 +1,5 @@ """Compatibility library.""" + """Stolen from lightgbm""" """pandas""" diff --git a/miceforest/default_lightgbm_parameters.py b/miceforest/default_lightgbm_parameters.py index eb0491c..f7b8393 100644 --- a/miceforest/default_lightgbm_parameters.py +++ b/miceforest/default_lightgbm_parameters.py @@ -11,9 +11,8 @@ "min_sum_hessian_in_leaf": 0.00001, "min_gain_to_split": 0.0, "bagging_fraction": 0.632, - # "feature_fraction": 1.0, - "feature_fraction": 0.632, - # "feature_fraction_bynode": 0.632, + # "feature_fraction": 0.632, + "feature_fraction_bynode": 0.632, "bagging_freq": 1, "verbosity": -1, } diff --git a/miceforest/imputation_kernel.py b/miceforest/imputation_kernel.py index 1e2d38e..7a214d4 100644 --- a/miceforest/imputation_kernel.py +++ b/miceforest/imputation_kernel.py @@ -1,5 +1,7 @@ - -from miceforest.default_lightgbm_parameters import default_parameters, make_default_tuning_space +from miceforest.default_lightgbm_parameters import ( + default_parameters, + make_default_tuning_space, +) from miceforest.logger import Logger from miceforest.imputed_data import ImputedData from miceforest.utils import ( @@ -8,35 +10,34 @@ _list_union, _draw_random_int32, ensure_rng, - hash_numpy_int_array, stratified_categorical_folds, stratified_continuous_folds, - stratified_subset, _to_2d, - _to_1d + _to_1d, ) import numpy as np from warnings import warn from lightgbm import train, Dataset, cv, log_evaluation, early_stopping, Booster from lightgbm.basic import _ConfigAliases from io import BytesIO -import blosc2 from scipy.spatial import KDTree -import dill from copy import copy from typing import Union, List, Dict, Any, Optional, Tuple from pandas import Series, DataFrame, MultiIndex, read_parquet, Categorical +from pandas.api.types import is_integer_dtype _DEFAULT_DATA_SUBSET = 0 _DEFAULT_MEANMATCH_CANDIDATES = 5 -_DEFAULT_MEANMATCH_STRATEGY = 'normal' -_MICE_TIMED_LEVELS = ['Dataset', 'Iteration', 'Variable', 'Event'] -_IMPUTE_NEW_DATA_TIMED_LEVELS = ['Dataset', 'Iteration', 'Variable', 'Event'] +_DEFAULT_MEANMATCH_STRATEGY = "normal" +_MICE_TIMED_LEVELS = ["Dataset", "Iteration", "Variable", "Event"] +_IMPUTE_NEW_DATA_TIMED_LEVELS = ["Dataset", "Iteration", "Variable", "Event"] +_PRE_LINK_DATATYPE = "float16" # These can inherently be 2D, Series cannot. _MEAN_MATCH_PRED_TYPE = Union[np.ndarray, DataFrame] + class ImputationKernel(ImputedData): """ Creates a kernel dataset. This dataset can perform MICE on itself, @@ -44,7 +45,7 @@ class ImputationKernel(ImputedData): Parameters ---------- - data : np.ndarray or pandas DataFrame. + data : pandas DataFrame. .. code-block:: text @@ -56,13 +57,12 @@ class ImputationKernel(ImputedData): Specifies the feature - target relationships used to train models. This parameter also controls which models are built. Models can be built - even if a variable contains no missing values, or is not being imputed - (train_nonmissing must be set to True). + even if a variable contains no missing values, or is not being imputed. - - If None, all columns will be used as features in the training of each model. + - If None, all columns with missing values will have models trained, and all + columns will be used as features in these models. - If list, all columns in data are used to impute the variables in the list - - If dict the values will be used to impute the keys. Can be either column - indices or names (if data is a pd.DataFrame). + - If dict the values will be used to impute the keys. No models will be trained for variables not specified by variable_schema (either by None, a list, or in dict keys). @@ -71,22 +71,13 @@ class ImputationKernel(ImputedData): .. code-block:: text - The order the imputations should occur in. If a string from the - items below, all variables specified by variable_schema with - missing data are imputed: - ascending: variables are imputed from least to most missing - descending: most to least missing - roman: from left to right in the dataset - arabic: from right to left in the dataset. - If a list is provided: - - the variables will be imputed in that order. - - only variables with missing values should be included in the list. - - must be a subset of variables specified by variable_schema. - If a variable with missing values is in variable_schema, but not in - imputation_order, then models to impute that variable will be trained, - but the actual values will not be imputed. See examples for details. - - data_subset: None or int or float or dict. + The order the imputations should occur in. + - ascending: variables are imputed from least to most missing + - descending: most to least missing + - roman: from left to right in the dataset + - arabic: from right to left in the dataset. + + data_subset: None or int or dict. .. code-block:: text @@ -97,7 +88,6 @@ class ImputationKernel(ImputedData): The number of rows used for each variable is (# rows in raw data) - (# missing variable values) for each variable. data_subset takes a random sample of this. - If float, must be 0.0 < data_subset <= 1.0. Interpreted as a percentage of available candidates If int must be data_subset >= 0. Interpreted as the number of candidates. If 0, no subsetting is done. If dict, keys must be variable names, and values must follow two above rules. @@ -117,7 +107,7 @@ class ImputationKernel(ImputedData): is selected at random weighted by the class probabilities. - "shap" - Similar to "normal" but more robust. A K-nearest-neighbors search is performed on the shap values of the candidate predictions - and the bachelor predictions. A value from the top MMC closest candidate + and the bachelor predictions. A value from the top MMC closest candidate values is chosen at random. A dict of strategies by variable can be passed as well. Any unmentioned variables @@ -147,16 +137,14 @@ class ImputationKernel(ImputedData): .. code-block:: text If True, missing data is not filled in randomly before model training starts. - LightGBM is capable of learning from missing data - this might result in - faster convergence, or data leakage, depending on the data passed in. - save_all_iterations: boolean, optional(default=True) + save_all_iterations_data: boolean, optional(default=True) .. code-block:: text - Save all the imputation values from all iterations, or just - the latest. Saving all iterations allows for additional - plotting, but may take more memory + Setting to False will cause the process to not store the models and + candidate values obtained at each iteration. This can save significant + amounts of memory, but it means `impute_new_data()` will not be callable. copy_data: boolean (default = False) @@ -165,23 +153,7 @@ class ImputationKernel(ImputedData): Should the dataset be referenced directly? If False, this will cause the dataset to be altered in place. If a copy is created, it is saved in self.working_data. There are different ways in which the dataset - can be altered: - - 1) complete_data() will fill in missing values - 2) To save space, mice() references and manipulates self.working_data directly. - If self.working_data is a reference to the original dataset, the original - dataset will undergo these manipulations during the mice process. - At the end of the mice process, missing values will be set back to np.NaN - where they were originally missing. - - save_loggers: boolean (default = False) - - .. code-block:: text - - A logger is created each time mice() or impute_new_data() is called. - If True, the loggers are stored in a list ImputationKernel.loggers. - If you wish to start saving logs, call ImputationKernel.start_logging(). - If you wish to stop saving logs, call ImputationKernel.stop_logging(). + can be altered. random_state: None,int, or numpy.random.RandomState @@ -201,8 +173,12 @@ def __init__( num_datasets: int = 1, variable_schema: Union[List[str], Dict[str, str]] = None, imputation_order: str = "ascending", - mean_match_candidates: Union[int, Dict[str, int]] = _DEFAULT_MEANMATCH_CANDIDATES, - mean_match_strategy: Optional[Union[str, Dict[str, str]]] = _DEFAULT_MEANMATCH_STRATEGY, + mean_match_candidates: Union[ + int, Dict[str, int] + ] = _DEFAULT_MEANMATCH_CANDIDATES, + mean_match_strategy: Optional[ + Union[str, Dict[str, str]] + ] = _DEFAULT_MEANMATCH_STRATEGY, data_subset: Union[int, Dict[str, int]] = _DEFAULT_DATA_SUBSET, initialize_empty: bool = False, save_all_iterations_data: bool = True, @@ -216,20 +192,22 @@ def __init__( variable_schema=variable_schema, save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, - random_seed_array=None + random_seed_array=None, ) # Model Training / Imputation Order: - # Variables with missing data are always trained - # first, according to imputation_order. Afterwards, - # variables with no missing values have models trained. + # Variables with missing data are always trained + # first, according to imputation_order. Afterwards, + # variables with no missing values have models trained. if imputation_order in ["ascending", "descending"]: _na_counts = { - key: value + key: value for key, value in self.na_counts.items() if key in self.imputed_variables } - self.imputation_order = list(Series(_na_counts).sort_values(ascending=False).index) + self.imputation_order = list( + Series(_na_counts).sort_values(ascending=False).index + ) if imputation_order == "decending": self.imputation_order.reverse() elif imputation_order == "roman": @@ -239,10 +217,9 @@ def __init__( self.imputation_order.reverse() else: raise ValueError("imputation_order not recognized.") - + modeled_but_not_imputed_variables = [ - col for col in self.modeled_variables - if col not in self.imputed_variables + col for col in self.modeled_variables if col not in self.imputed_variables ] model_training_order = self.imputation_order + modeled_but_not_imputed_variables self.model_training_order = model_training_order @@ -261,24 +238,22 @@ def __init__( # Determine available candidates and interpret data subset. available_candidates = { - v: (self.shape[0] - self.na_counts[v]) - for v in self.model_training_order + v: (self.shape[0] - self.na_counts[v]) for v in self.model_training_order } data_subset = _expand_value_to_dict( - _DEFAULT_DATA_SUBSET, - data_subset, - keys=self.model_training_order + _DEFAULT_DATA_SUBSET, data_subset, keys=self.model_training_order ) for col in self.model_training_order: - assert data_subset[col] <= available_candidates[col], ( - f'data_subset is more than available candidates for {col}' - ) + assert ( + data_subset[col] <= available_candidates[col] + ), f"data_subset is more than available candidates for {col}" self.available_candidates = available_candidates self.data_subset = data_subset # Collect category information. categorical_columns: List[str] = [ - var for var, dtype in self.working_data.dtypes.items() + var + for var, dtype in self.working_data.dtypes.items() if dtype.name == "category" ] category_counts = { @@ -286,8 +261,7 @@ def __init__( for col in categorical_columns } numeric_columns = [ - col for col in self.working_data.columns - if col not in categorical_columns + col for col in self.working_data.columns if col not in categorical_columns ] binary_columns = [] for col, count in category_counts.items(): @@ -301,9 +275,15 @@ def __init__( assert set(binary_columns).isdisjoint(set(numeric_columns)) self.category_counts = category_counts - self.modeled_categorical_columns = _list_union(categorical_columns, self.model_training_order) - self.modeled_numeric_columns = _list_union(numeric_columns, self.model_training_order) - self.modeled_binary_columns = _list_union(binary_columns, self.model_training_order) + self.modeled_categorical_columns = _list_union( + categorical_columns, self.model_training_order + ) + self.modeled_numeric_columns = _list_union( + numeric_columns, self.model_training_order + ) + self.modeled_binary_columns = _list_union( + binary_columns, self.model_training_order + ) # Make sure all pandas categorical levels are used. rare_level_cols = [] @@ -321,30 +301,27 @@ def __init__( self.mean_match_candidates = _expand_value_to_dict( _DEFAULT_MEANMATCH_CANDIDATES, mean_match_candidates, - self.model_training_order + self.model_training_order, ) self.mean_match_strategy = _expand_value_to_dict( - _DEFAULT_MEANMATCH_STRATEGY, - mean_match_strategy, - self.model_training_order + _DEFAULT_MEANMATCH_STRATEGY, mean_match_strategy, self.model_training_order ) for col in self.model_training_order: mmc = self.mean_match_candidates[col] mms = self.mean_match_strategy[col] assert not ((mmc == 0) and (mms == "shap")), ( - f'Failing because {col} mean_match_candidates == 0 and ' - 'mean_match_strategy == shap. This implies an unintentional setup.' + f"Failing because {col} mean_match_candidates == 0 and " + "mean_match_strategy == shap. This implies an unintentional setup." ) - # Determine if the mean matching scheme will + # Determine if the mean matching scheme will # require candidate information for each variable self.mean_matching_requires_candidates = [] for variable in self.model_training_order: mean_match_strategy = self.mean_match_strategy[variable] - if ( - (mean_match_strategy in ['normal', 'shap']) or - (variable in self.modeled_numeric_columns) + if (mean_match_strategy in ["normal", "shap"]) or ( + variable in self.modeled_numeric_columns ): self.mean_matching_requires_candidates.append(variable) @@ -356,7 +333,7 @@ def __init__( # Set initial imputations (iteration 0). self._initialize_dataset( - self, random_state=self._random_state, random_seed_array=None + self, random_state=self._random_state ) def __getstate__(self): @@ -365,9 +342,9 @@ def __getstate__(self): """ # Copy the entire object, minus the big stuff - special_handling = ['imputation_values'] + special_handling = ["imputation_values"] if self.save_all_iterations_data: - special_handling.append('candidate_preds') + special_handling.append("candidate_preds") state = { key: value @@ -375,20 +352,20 @@ def __getstate__(self): if key not in special_handling }.copy() - state['imputation_values'] = {} - state['candidate_preds'] = {} + state["imputation_values"] = {} + state["candidate_preds"] = {} for col, df in self.imputation_values.items(): byte_stream = BytesIO() df.to_parquet(byte_stream) - state['imputation_values'][col] = byte_stream + state["imputation_values"][col] = byte_stream for col, df in self.candidate_preds.items(): byte_stream = BytesIO() df.to_parquet(byte_stream) - state['candidate_preds'][col] = byte_stream + state["candidate_preds"][col] = byte_stream return state - + def __setstate__(self, state): """ For unpickling @@ -406,7 +383,7 @@ def __repr__(self): summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self.__ids_info()}' return summary_string - def _initialize_dataset(self, imputed_data, random_state, random_seed_array): + def _initialize_dataset(self, imputed_data, random_state): """ Sets initial imputation values for iteration 0. If "random", draw values from the working data at random. @@ -416,7 +393,7 @@ def _initialize_dataset(self, imputed_data, random_state, random_seed_array): assert not imputed_data.initialized, "dataset has already been initialized" - if self.initialize_empty : + if self.initialize_empty: # The default value when initialized is np.nan, nothing to do here pass else: @@ -431,35 +408,25 @@ def _initialize_dataset(self, imputed_data, random_state, random_seed_array): for dataset in range(imputed_data.num_datasets): # Initialize using the random_state if no record seeds were passed. - if random_seed_array is None: - imputation_values = ( - candidate_values - .sample(n=missing_num, replace=True, random_state=random_state) + if imputed_data.random_seed_array is None: + imputation_values = candidate_values.sample( + n=missing_num, replace=True, random_state=random_state ) imputation_values.index = missing_ind imputed_data[variable, 0, dataset] = imputation_values else: assert ( - len(random_seed_array) == imputed_data.shape[0] + len(imputed_data.random_seed_array) == imputed_data.shape[0] ), "The random_seed_array did not match the number of rows being imputed." - selection_ind = random_seed_array[missing_ind] % candidate_num + hashed_seeds = imputed_data._get_hashed_seeds(variable=variable) + selection_ind = hashed_seeds % candidate_num imputation_values = candidate_values.iloc[selection_ind] imputation_values.index = missing_ind imputed_data[variable, 0, dataset] = imputation_values - random_seed_array = hash_numpy_int_array( - x=random_seed_array, - ind=missing_ind - ) imputed_data.initialized = True - def _get_lgb_params( - self, - variable, - variable_parameters, - random_state, - **kwlgb - ): + def _get_lgb_params(self, variable, variable_parameters, random_state, **kwlgb): """ Builds the parameters for a lightgbm model. Infers objective based on datatype of the response variable, assigns a random seed, finds @@ -493,7 +460,7 @@ def _get_lgb_params( lgb_params = default_parameters.copy() lgb_params.update(obj) - lgb_params['seed'] = seed + lgb_params["seed"] = seed # Priority is [variable specific] > [global in kwargs] > [defaults] lgb_params.update(kwlgb) @@ -577,18 +544,14 @@ def _get_nonmissing_subset_index(self, variable: str, seed: int): data_subset = self.data_subset[variable] available_candidates = self.available_candidates[variable] + nonmissing_ind = self._get_nonmissing_index(variable=variable) if (data_subset == 0) or (data_subset >= available_candidates): - subset_index = slice(None) + subset_index = nonmissing_ind else: - nonmissing_ind = self._get_nonmissing_index(variable=variable) rs = np.random.RandomState(seed) - subset_index = rs.choice( - nonmissing_ind, - size=data_subset, - replace=False - ) + subset_index = rs.choice(nonmissing_ind, size=data_subset, replace=False) return subset_index - + def _make_label(self, variable: str, seed: int): """ Returns a reproducible subset of the non-missing values of a variable. @@ -606,7 +569,9 @@ def _make_features_label(self, variable: str, seed: int): """ subset_index = self._get_nonmissing_subset_index(variable=variable, seed=seed) predictor_columns = self.variable_schema[variable] - features = self.working_data.loc[subset_index, predictor_columns + [variable]].copy() + features = self.working_data.loc[ + subset_index, predictor_columns + [variable] + ].copy() label = features.pop(variable) return features, label @@ -651,15 +616,17 @@ def fit(self, X, y, **fit_params): """ assert self.num_datasets == 1, ( "miceforest kernel should be initialized with datasets=1 if " - + "being used in a sklearn pipeline." + "being used in a sklearn pipeline." ) assert X.equals(self.working_data), ( - 'Data passed was not the same as original ' - 'data used to train ImputationKernel.' + "It looks like this kernel is being used in a sklearn pipeline. " + "The data passed in fit() should be the same as the data that " + "was originally passed to the kernel. If this kernel is not being " + "used in an sklearn pipeline, please just use the mice() method." ) self.mice(**fit_params) return self - + @staticmethod def _mean_match_nearest_neighbors( mean_match_candidates: int, @@ -673,7 +640,7 @@ def _mean_match_nearest_neighbors( Determines the values of candidates which will be used to impute the bachelors """ - assert mean_match_candidates > 0, 'Do not use nearest_neighbors with 0 mmc.' + assert mean_match_candidates > 0, "Do not use nearest_neighbors with 0 mmc." _to_2d(bachelor_preds) _to_2d(candidate_preds) @@ -705,7 +672,6 @@ def _mean_match_nearest_neighbors( return imp_values - @staticmethod def _mean_match_binary_fast( mean_match_candidates: int, @@ -751,123 +717,128 @@ def _mean_match_multiclass_fast( else: num_bachelors = bachelor_preds.shape[0] - # Turn bachelor_preds into discrete cdf: - bachelor_preds = bachelor_preds.cumsum(axis=1) - - # Randomly choose uniform numbers 0-1 if hashed_seeds is None: - # This is the fastest way to adjust for numeric - # imprecision of float16 dtype. Actually ends up - # barely taking any time at all. - bp_dtype = bachelor_preds.dtype - unif = np.minimum( - random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype), - bachelor_preds[:, -1], - ) + # Turn bachelor_preds into discrete cdf, and choose + bachelor_preds = bachelor_preds.cumsum(axis=1) + compare = random_state.uniform(0, 1, size=(num_bachelors, 1)) + imp_values = (bachelor_preds < compare).sum(1) + else: - unif = [] - for i in range(num_bachelors): - np.random.seed(seed=hashed_seeds[i]) - unif.append(np.random.uniform(0, 1, size=1)[0]) - unif = np.array(unif) - - # Choose classes according to their cdf. - # Distribution will match probabilities - imp_values = np.array( - [ - np.searchsorted(bachelor_preds[i, :], unif[i]) - for i in range(num_bachelors) - ] - ) + dtype = hashed_seeds.dtype + dtype_max = np.iinfo(dtype).max + compare = np.abs(hashed_seeds / dtype_max) + imp_values = (bachelor_preds < compare).sum(1) return imp_values - - def _impute_with_predictions( + + def _mean_match_fast( self, variable: str, - bachelor_preds: _MEAN_MATCH_PRED_TYPE, + mean_match_candidates: int, + bachelor_preds: np.ndarray, + random_state: np.random.RandomState, + hashed_seeds: Optional[np.ndarray], ): + """ + Dispatcher and formatter for the fast mean matching functions + """ + if variable in self.modeled_categorical_columns: + imputation_values = self._mean_match_multiclass_fast( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=random_state, + hashed_seeds=hashed_seeds, + ) + elif variable in self.modeled_binary_columns: + imputation_values = self._mean_match_binary_fast( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=random_state, + hashed_seeds=hashed_seeds, + ) + else: + raise ValueError("Shouldnt be able to get here") + _to_1d(imputation_values) + dtype = self.working_data[variable].dtype + imputation_values = Categorical.from_codes(codes=imputation_values, dtype=dtype) + + return imputation_values + + def _impute_with_predictions( + self, + variable: str, + lgbmodel: Booster, + bachelor_features: DataFrame, + ): + bachelor_preds = lgbmodel.predict( + bachelor_features, + pred_contrib=False, + raw_score=False, + ) dtype = self.working_data[variable].dtype if variable in self.modeled_numeric_columns: + if is_integer_dtype(dtype): + bachelor_preds = bachelor_preds.round(0) return Series(bachelor_preds, dtype=dtype) else: if variable in self.modeled_binary_columns: - selection_ind = np.floor(bachelor_preds + 0.5) + selection_ind = (bachelor_preds > 0.5).astype("uint8") else: - assert variable in self.modeled_categorical_columns, ( - f'{variable} is not in numeric, binary or categorical columns' - ) + assert ( + variable in self.modeled_categorical_columns + ), f"{variable} is not in numeric, binary or categorical columns" selection_ind = np.argmax(bachelor_preds, axis=1) values = dtype.categories[selection_ind] return Series(values, dtype=dtype) - - def _get_candidate_preds( + + def _get_candidate_preds_mice( self, variable: str, lgbmodel: Booster, - candidate_features: Optional[DataFrame], - pred_contrib: bool, - is_logistic_link: bool, + candidate_features: DataFrame, dataset: int, iteration: int, - mice: bool, ): - - if mice: - assert hasattr(lgbmodel, 'train_set'), ( - 'Model was passed that does not have training data.' - ) - if pred_contrib: - print(f'Getting {variable} preds from pred_contrib') - candidate_preds = lgbmodel.predict( - candidate_features, - pred_contrib=True, - ) - else: - print(f'Getting {variable} preds from inner predict') - candidate_preds = lgbmodel._Booster__inner_predict(0) - if is_logistic_link and not pred_contrib: - candidate_preds = logodds(candidate_preds) - - candidate_preds = self._prepare_prediction_multiindex( - variable=variable, - preds=candidate_preds, - pred_contrib=pred_contrib, - dataset=dataset, - iteration=iteration, - ) - - if self.save_all_iterations_data: - self._record_candidate_preds( - variable=variable, - candidate_preds=candidate_preds, - ) - + """ + This function also records the candidate predictions + """ + shap = self.mean_match_strategy[variable] == "shap" + fast = self.mean_match_strategy[variable] == "fast" + logistic = variable not in self.modeled_numeric_columns + + assert hasattr( + lgbmodel, "train_set" + ), "Model was passed that does not have training data." + if shap: + candidate_preds = lgbmodel.predict( + candidate_features, + pred_contrib=True, + ).astype(_PRE_LINK_DATATYPE) else: + candidate_preds = lgbmodel._Booster__inner_predict(0) + if logistic and not (shap or fast): + candidate_preds = logodds(candidate_preds).astype(_PRE_LINK_DATATYPE) + + candidate_preds = self._prepare_prediction_multiindex( + variable=variable, + preds=candidate_preds, + shap=shap, + dataset=dataset, + iteration=iteration, + ) - # Candidate predictions are only stored - # for imputed variables during mice - if variable in self.imputed_variables: - print(f'Getting {variable} preds from store') - candidate_preds = self._get_candidate_preds_from_store( - variable=variable, - iteration=iteration, - dataset=dataset, - ) - # We need to make the features and get the - # predictions if they weren't saved during mice - else: - print(f'Getting {variable} preds from features') - seed = lgbmodel.params['seed'] - candidate_features, _ = self._make_features_label(variable=variable, seed=seed) - candidate_preds = lgbmodel.predict(candidate_features) + if self.save_all_iterations_data: + self._record_candidate_preds( + variable=variable, + candidate_preds=candidate_preds, + ) return candidate_preds def _get_candidate_preds_from_store( - self, - variable: str, + self, + variable: str, dataset: int, iteration: int, ) -> DataFrame: @@ -878,8 +849,44 @@ def _get_candidate_preds_from_store( assert isinstance(ret, DataFrame) return ret - def mean_match( - self, + def _get_bachelor_preds( + self, + variable: str, + lgbmodel: Booster, + bachelor_features: DataFrame, + dataset: int, + iteration: int, + ) -> np.ndarray: + + shap = self.mean_match_strategy[variable] == "shap" + fast = self.mean_match_strategy[variable] == "fast" + logistic = variable not in self.modeled_numeric_columns + + bachelor_preds = lgbmodel.predict( + bachelor_features, + pred_contrib=shap, + ) + + if shap: + bachelor_preds = bachelor_preds.astype(_PRE_LINK_DATATYPE) + + # We want the logods if running k-nearest + # neighbors on logistic-link predictions + if logistic and not (shap or fast): + bachelor_preds = logodds(bachelor_preds).astype(_PRE_LINK_DATATYPE) + + bachelor_preds = self._prepare_prediction_multiindex( + variable=variable, + preds=bachelor_preds, + shap=shap, + dataset=dataset, + iteration=iteration, + ) + + return bachelor_preds + + def mean_match_mice( + self, variable: str, lgbmodel: Booster, bachelor_features: DataFrame, @@ -887,79 +894,104 @@ def mean_match( candidate_values: Series, dataset: int, iteration: int, - mice: bool, - hashed_seeds: Optional[np.ndarray] = None, ): - """ - Efficient mean matching called during MICE. - """ - mean_match_strategy = self.mean_match_strategy[variable] mean_match_candidates = self.mean_match_candidates[variable] using_candidate_data = variable in self.mean_matching_requires_candidates - use_mean_matching = mean_match_candidates > 0 - pred_contrib = mean_match_strategy == 'shap' - is_logistic_link = variable in (self.modeled_binary_columns + self.modeled_categorical_columns) - # Special handling for imputing with predictions. - # Takes priority over other mean match settings. + use_mean_matching = mean_match_candidates > 0 if not use_mean_matching: - assert mean_match_strategy != 'shap', ( - 'Should have failed before this, please open an issue on github. ' - 'mean_match_strategy == shap and mean_match_candidates == 0. ' - 'This implies an unintentional setup.' - ) - - print(f'Imputing {variable} with Predictions') - - # Get bachelor predictions - bachelor_preds = lgbmodel.predict( - bachelor_features, - pred_contrib=False, - raw_score=False, - ) - imputation_values = self._impute_with_predictions( variable=variable, - bachelor_preds=bachelor_preds, + lgbmodel=lgbmodel, + bachelor_features=bachelor_features, ) return imputation_values - if using_candidate_data: + # Get bachelor predictions + bachelor_preds = self._get_bachelor_preds( + variable=variable, + lgbmodel=lgbmodel, + bachelor_features=bachelor_features, + dataset=dataset, + iteration=iteration, + ) - print(f'Mean matching {variable} using nearest neighbor') + if using_candidate_data: - # Get bachelor predictions - bachelor_preds = lgbmodel.predict( - bachelor_features, - pred_contrib=pred_contrib, - ) - if is_logistic_link and not pred_contrib: - bachelor_preds = logodds(bachelor_preds) - _to_2d(bachelor_preds) - bachelor_preds = self._prepare_prediction_multiindex( + candidate_preds = self._get_candidate_preds_mice( variable=variable, - preds=bachelor_preds, - pred_contrib=pred_contrib, + lgbmodel=lgbmodel, + candidate_features=candidate_features, dataset=dataset, iteration=iteration, ) - candidate_preds = self._get_candidate_preds( + # By now, a numeric variable will be post-link, and + # categorical / binary variables will be pre-link. + imputation_values = self._mean_match_nearest_neighbors( + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + candidate_preds=candidate_preds, + candidate_values=candidate_values, + random_state=self._random_state, + hashed_seeds=None, + ) + + else: + + imputation_values = self._mean_match_fast( + variable=variable, + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=self._random_state, + hashed_seeds=None, + ) + + return imputation_values + + def mean_match_ind( + self, + variable: str, + lgbmodel: Booster, + bachelor_features: DataFrame, + dataset: int, + iteration: int, + hashed_seeds: Optional[np.ndarray] = None, + ): + mean_match_candidates = self.mean_match_candidates[variable] + using_candidate_data = variable in self.mean_matching_requires_candidates + use_mean_matching = mean_match_candidates > 0 + + if not use_mean_matching: + imputation_values = self._impute_with_predictions( variable=variable, lgbmodel=lgbmodel, - candidate_features=candidate_features, - pred_contrib=pred_contrib, - is_logistic_link=is_logistic_link, + bachelor_features=bachelor_features, + ) + return imputation_values + + # Get bachelor predictions + bachelor_preds = self._get_bachelor_preds( + variable=variable, + lgbmodel=lgbmodel, + bachelor_features=bachelor_features, + dataset=dataset, + iteration=iteration, + ) + + if using_candidate_data: + + print(f"Mean matching {variable} using nearest neighbor") + + candidate_preds = self._get_candidate_preds_from_store( + variable=variable, dataset=dataset, iteration=iteration, - mice=mice, ) - if candidate_values is None: - candidate_values = self._make_label( - variable=variable, - seed = lgbmodel.params['seed'] - ) + candidate_values = self._make_label( + variable=variable, seed=lgbmodel.params["seed"] + ) # By now, a numeric variable will be post-link, and # categorical / binary variables will be pre-link. @@ -974,47 +1006,16 @@ def mean_match( else: - # Get bachelor predictions - bachelor_preds = lgbmodel.predict( - bachelor_features, - pred_contrib=False, - raw_score=False, + imputation_values = self._mean_match_fast( + variable=variable, + mean_match_candidates=mean_match_candidates, + bachelor_preds=bachelor_preds, + random_state=self._random_state, + hashed_seeds=hashed_seeds, ) - _to_2d(bachelor_preds) - - if variable in self.modeled_categorical_columns: - print(f'Mean matching {variable} using fast multiclass') - imputation_values = self._mean_match_multiclass_fast( - mean_match_candidates=mean_match_candidates, - bachelor_preds=bachelor_preds, - random_state=self._random_state, - hashed_seeds=hashed_seeds - ) - _to_1d(imputation_values) - dtype = self.working_data[variable].dtype - imputation_values = Categorical.from_codes( - codes=imputation_values, - dtype=dtype - ) - elif variable in self.modeled_binary_columns: - print(f'Mean matching {variable} using fast binary') - imputation_values = self._mean_match_binary_fast( - mean_match_candidates=mean_match_candidates, - bachelor_preds=bachelor_preds, - random_state=self._random_state, - hashed_seeds=hashed_seeds - ) - _to_1d(imputation_values) - dtype = self.working_data[variable].dtype - imputation_values = Categorical.from_codes( - codes=imputation_values, - dtype=dtype - ) - else: - raise ValueError('Shouldnt be able to get here') return imputation_values - + def _record_candidate_preds( self, variable: str, @@ -1024,48 +1025,52 @@ def _record_candidate_preds( assign_col_index = candidate_preds.columns if variable not in self.candidate_preds.keys(): - inferred_iteration = assign_col_index.get_level_values('iteration').unique() - assert len(inferred_iteration) == 1, f'Malformed iteration multiindex for {variable}: {print(assign_col_index)}' + inferred_iteration = assign_col_index.get_level_values("iteration").unique() + assert ( + len(inferred_iteration) == 1 + ), f"Malformed iteration multiindex for {variable}: {print(assign_col_index)}" inferred_iteration = inferred_iteration[0] - assert inferred_iteration == 1, 'Adding initial candidate preds after iteration 1.' + assert ( + inferred_iteration == 1 + ), "Adding initial candidate preds after iteration 1." self.candidate_preds[variable] = candidate_preds else: self.candidate_preds[variable][assign_col_index] = candidate_preds def _prepare_prediction_multiindex( - self, - variable: str, - preds: np.ndarray, - pred_contrib: bool, - dataset: int, - iteration: int, + self, + variable: str, + preds: np.ndarray, + shap: bool, + dataset: int, + iteration: int, ) -> DataFrame: multiclass = variable in self.modeled_categorical_columns - cols = self.variable_schema[variable] + ['Intercept'] + cols = self.variable_schema[variable] + ["Intercept"] - if pred_contrib: + if shap: if multiclass: categories = self.working_data[variable].dtype.categories cat_count = self.category_counts[variable] preds = DataFrame(preds, columns=cols * cat_count) - del preds['Intercept'] - cols.remove('Intercept') + del preds["Intercept"] + cols.remove("Intercept") assign_col_index = MultiIndex.from_product( [[iteration], [dataset], categories, cols], - names=('iteration', 'dataset', 'categories', 'predictor') + names=("iteration", "dataset", "categories", "predictor"), ) preds.columns = assign_col_index else: preds = DataFrame(preds, columns=cols) - del preds['Intercept'] - cols.remove('Intercept') + del preds["Intercept"] + cols.remove("Intercept") assign_col_index = MultiIndex.from_product( [[iteration], [dataset], cols], - names=('iteration', 'dataset', 'predictor') + names=("iteration", "dataset", "predictor"), ) preds.columns = assign_col_index @@ -1077,7 +1082,7 @@ def _prepare_prediction_multiindex( preds = DataFrame(preds, columns=categories) assign_col_index = MultiIndex.from_product( [[iteration], [dataset], categories], - names=('iteration', 'dataset', 'categories') + names=("iteration", "dataset", "categories"), ) preds.columns = assign_col_index @@ -1085,14 +1090,12 @@ def _prepare_prediction_multiindex( preds = DataFrame(preds, columns=[variable]) assign_col_index = MultiIndex.from_product( - [[iteration], [dataset]], - names=('iteration', 'dataset') + [[iteration], [dataset]], names=("iteration", "dataset") ) preds.columns = assign_col_index return preds - def mice( self, iterations: int, @@ -1143,8 +1146,6 @@ def mice( current_iterations = self.iteration_count() start_iter = current_iterations + 1 end_iter = current_iterations + iterations + 1 - - # Delete models and candidate_preds if we shouldn't be saving every iteration logger = Logger( name=f"MICE Iterations {current_iterations + 1} - {current_iterations + iterations}", timed_levels=_MICE_TIMED_LEVELS, @@ -1152,10 +1153,12 @@ def mice( ) if len(variable_parameters) > 0: - assert isinstance(variable_parameters, dict), 'variable_parameters should be a dict.' + assert isinstance( + variable_parameters, dict + ), "variable_parameters should be a dict." assert set(variable_parameters).issubset(self.model_training_order), ( - 'Variables in variable_parameters will not have models trained. ' - 'Check kernel.model_training_order' + "Variables in variable_parameters will not have models trained. " + "Check kernel.model_training_order" ) for iteration in range(start_iter, end_iter, 1): @@ -1174,19 +1177,18 @@ def mice( # Define the lightgbm parameters lgbpars = self._get_lgb_params( variable, - variable_parameters.get(variable, {}), - self._random_state, - **kwlgb + variable_parameters.get(variable, {}), + self._random_state, + **kwlgb, ) - time_key = dataset, iteration, variable, 'Prepare XY' + time_key = dataset, iteration, variable, "Prepare XY" logger.set_start_time(time_key) ( candidate_features, candidate_values, ) = self._make_features_label( - variable=variable, - seed=lgbpars['seed'] + variable=variable, seed=lgbpars["seed"] ) # lightgbm requires integers for label. Categories won't work. @@ -1202,7 +1204,7 @@ def mice( ) logger.record_time(time_key) - time_key = dataset, iteration, variable, 'Training' + time_key = dataset, iteration, variable, "Training" logger.set_start_time(time_key) current_model = train( params=lgbpars, @@ -1215,10 +1217,12 @@ def mice( # Only perform mean matching and insertion # if variable is being imputed. if variable in self.imputation_order: - time_key = dataset, iteration, variable, 'Mean Matching' + time_key = dataset, iteration, variable, "Mean Matching" logger.set_start_time(time_key) - bachelor_features = self.get_bachelor_features(variable=variable) - imputation_values = self.mean_match( + bachelor_features = self.get_bachelor_features( + variable=variable + ) + imputation_values = self.mean_match_mice( variable=variable, lgbmodel=current_model, bachelor_features=bachelor_features, @@ -1226,8 +1230,6 @@ def mice( candidate_values=candidate_values, dataset=dataset, iteration=iteration, - mice=True, - hashed_seeds=None, ) imputation_values.index = self.na_where[variable] logger.record_time(time_key) @@ -1238,17 +1240,29 @@ def mice( # Insert the imputation_values we obtained self[variable, iteration, dataset] = imputation_values - + if not self.save_all_iterations_data: del self[variable, iteration - 1, dataset] else: - + # This is called to save the candidate predictions + _ = self._get_candidate_preds_mice( + variable=variable, + lgbmodel=current_model, + candidate_features=candidate_features, + dataset=dataset, + iteration=iteration, + ) + del _ # Save the model, if we should be if self.save_all_iterations_data: - self.models[variable, iteration, dataset] = current_model.free_dataset() + self.models[variable, iteration, dataset] = ( + current_model.free_dataset() + ) + + self.iteration_tab[variable, dataset] += 1 logger.log("\n", end="") @@ -1256,18 +1270,18 @@ def mice( self.loggers.append(logger) def get_model( - self, - variable: str, - dataset: int, - iteration: Optional[int] = None, - ): + self, + variable: str, + dataset: int, + iteration: Optional[int] = None, + ): # Allow passing -1 to get the latest iteration's model if (iteration is None) or (iteration == -1): iteration = self.iteration_count(dataset=dataset, variable=variable) try: model = self.models[variable, iteration, dataset] except KeyError: - raise ValueError('Model was not saved.') + raise ValueError("Model was not saved.") return model def transform(self, X, y=None): @@ -1282,8 +1296,8 @@ def transform(self, X, y=None): def tune_parameters( self, dataset: int, - variables: Union[List[int], List[str], None] = None, - variable_parameters: Optional[Dict[Any, Any]] = None, + variables: Optional[List[str]] = None, + variable_parameters: Optional[Dict[str, Any]] = None, parameter_sampling_method: str = "random", nfold: int = 10, optimization_steps: int = 5, @@ -1638,8 +1652,8 @@ def impute_new_data( """ assert self.save_all_iterations_data, ( - 'Cannot recreate imputation procedure, data was not saved during MICE. ' - 'To save this data, set save_all_iterations_data to True when making kernel.' + "Cannot recreate imputation procedure, data was not saved during MICE. " + "To save this data, set save_all_iterations_data to True when making kernel." ) datasets = list(range(self.num_datasets)) if datasets is None else datasets @@ -1652,13 +1666,15 @@ def impute_new_data( ) assert isinstance(new_data, DataFrame) - assert self.working_data.columns.equals(new_data.columns), ( - "Different columns from original dataset." - ) - assert np.all([ - self.working_data[col].dtype == new_data[col].dtype - for col in self.column_names - ]), "Column types are not the same as the original data. Check categorical columns." + assert self.working_data.columns.equals( + new_data.columns + ), "Different columns from original dataset." + assert np.all( + [ + self.working_data[col].dtype == new_data[col].dtype + for col in self.column_names + ] + ), "Column types are not the same as the original data. Check categorical columns." imputed_data = ImputedData( impute_data=new_data, @@ -1666,10 +1682,11 @@ def impute_new_data( variable_schema=self.variable_schema.copy(), save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, - random_seed_array=random_seed_array + random_seed_array=random_seed_array, ) new_imputation_order = [ - col for col in self.model_training_order + col + for col in self.model_training_order if col in imputed_data.vars_with_any_missing ] @@ -1683,9 +1700,8 @@ def impute_new_data( random_state = ensure_rng(random_state) self._initialize_dataset( - imputed_data, - random_state=random_state, - random_seed_array=random_seed_array, + imputed_data, + random_state=random_state, ) for iteration in range(1, iterations + 1): @@ -1702,30 +1718,28 @@ def impute_new_data( # Select our model. current_model = self.get_model( - variable=variable, - dataset=dataset, - iteration=iteration + variable=variable, dataset=dataset, iteration=iteration ) - time_key = dataset, iteration, variable, 'Getting Bachelor Features' + time_key = dataset, iteration, variable, "Getting Bachelor Features" logger.set_start_time(time_key) bachelor_features = imputed_data.get_bachelor_features(variable) + hashed_seeds = imputed_data._get_hashed_seeds(variable) logger.record_time(time_key) - time_key = dataset, iteration, variable, 'Mean Matching' + time_key = dataset, iteration, variable, "Mean Matching" logger.set_start_time(time_key) - imputation_values = self.mean_match( + na_where = imputed_data.na_where[variable] + imputation_values = self.mean_match_ind( variable=variable, lgbmodel=current_model, bachelor_features=bachelor_features, - candidate_features=None, - candidate_values=None, dataset=dataset, iteration=iteration, - mice=False, - hashed_seeds=None + hashed_seeds=hashed_seeds, ) - imputation_values.index = imputed_data.na_where[variable] + # self.cycle_random_seed_array(variable) + imputation_values.index = na_where logger.record_time(time_key) assert imputation_values.shape == ( @@ -1745,63 +1759,63 @@ def impute_new_data( return imputed_data - def save_kernel( - self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True - ): - """ - Compresses and saves the kernel to a file. - - Parameters - ---------- - filepath: str - The file to save to. - - clevel: int - The compression level, sent to clevel argument in blosc.compress() - - cname: str - The compression algorithm used. - Sent to cname argument in blosc.compress. - If None is specified, the default is lz4hc. - - n_threads: int - The number of threads to use for compression. - By default, all threads are used. - - copy_while_saving: boolean - Should the kernel be copied while saving? Copying is safer, but - may take more memory. - - """ - - clevel = 9 if clevel is None else clevel - cname = "lz4hc" if cname is None else cname - n_threads = blosc2.detect_number_of_cores() if n_threads is None else n_threads - - if copy_while_saving: - kernel = copy(self) - else: - kernel = self - - # convert working data to parquet bytes object - if kernel.original_data_class == "pd_DataFrame": - working_data_bytes = BytesIO() - kernel.working_data.to_parquet(working_data_bytes) - kernel.working_data = working_data_bytes - - blosc2.set_nthreads(n_threads) - - with open(filepath, "wb") as f: - dill.dump( - blosc2.compress( - dill.dumps(kernel), - clevel=clevel, - typesize=8, - shuffle=blosc2.NOSHUFFLE, - cname=cname, - ), - f, - ) + # def save_kernel( + # self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True + # ): + # """ + # Compresses and saves the kernel to a file. + + # Parameters + # ---------- + # filepath: str + # The file to save to. + + # clevel: int + # The compression level, sent to clevel argument in blosc.compress() + + # cname: str + # The compression algorithm used. + # Sent to cname argument in blosc.compress. + # If None is specified, the default is lz4hc. + + # n_threads: int + # The number of threads to use for compression. + # By default, all threads are used. + + # copy_while_saving: boolean + # Should the kernel be copied while saving? Copying is safer, but + # may take more memory. + + # """ + + # clevel = 9 if clevel is None else clevel + # cname = "lz4hc" if cname is None else cname + # n_threads = blosc2.detect_number_of_cores() if n_threads is None else n_threads + + # if copy_while_saving: + # kernel = copy(self) + # else: + # kernel = self + + # # convert working data to parquet bytes object + # if kernel.original_data_class == "pd_DataFrame": + # working_data_bytes = BytesIO() + # kernel.working_data.to_parquet(working_data_bytes) + # kernel.working_data = working_data_bytes + + # blosc2.set_nthreads(n_threads) + + # with open(filepath, "wb") as f: + # dill.dump( + # blosc2.compress( + # dill.dumps(kernel), + # clevel=clevel, + # typesize=8, + # shuffle=blosc2.NOSHUFFLE, + # cname=cname, + # ), + # f, + # ) def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: """ diff --git a/miceforest/imputed_data.py b/miceforest/imputed_data.py index 0ef057a..2c7bd7e 100644 --- a/miceforest/imputed_data.py +++ b/miceforest/imputed_data.py @@ -1,5 +1,5 @@ import numpy as np -from pandas import DataFrame, MultiIndex, RangeIndex, read_parquet +from pandas import DataFrame, MultiIndex, RangeIndex, read_parquet, Series from .utils import ( get_best_int_downcast, hash_numpy_int_array, @@ -25,15 +25,17 @@ def __init__( self.shape = self.working_data.shape self.save_all_iterations_data = save_all_iterations_data - assert isinstance(self.working_data.index, RangeIndex), ( - 'Please reset the index on the dataframe' - ) + assert isinstance( + self.working_data.index, RangeIndex + ), "Please reset the index on the dataframe" column_names = [] pd_dtypes_orig = {} for col, series in self.working_data.items(): - assert isinstance(col, str), 'column names must be strings' - assert series.dtype.name != 'object', 'convert object dtypes to something else' + assert isinstance(col, str), "column names must be strings" + assert ( + series.dtype.name != "object" + ), "convert object dtypes to something else" column_names.append(col) pd_dtypes_orig[col] = series.dtype.name @@ -46,7 +48,7 @@ def __init__( for col in column_names: nas = np.where(self.working_data[col].isnull())[0] if len(nas) == 0: - best_downcast = 'uint8' + best_downcast = "uint8" else: best_downcast = get_best_int_downcast(int(nas.max())) na_where[col] = nas.astype(best_downcast) @@ -55,7 +57,7 @@ def __init__( col for col, count in na_counts.items() if count > 0 ] - # If variable_schema was passed, use that as the + # If variable_schema was passed, use that as the # list of variables that should have models trained. # Otherwise, only train models on variables that have # missing values. @@ -63,18 +65,14 @@ def __init__( modeled_variables = self.vars_with_any_missing.copy() variable_schema = { target: [ - regressor - for regressor in self.column_names - if regressor != target + regressor for regressor in self.column_names if regressor != target ] for target in modeled_variables } elif isinstance(variable_schema, list): variable_schema = { target: [ - regressor - for regressor in self.column_names - if regressor != target + regressor for regressor in self.column_names if regressor != target ] for target in variable_schema } @@ -83,23 +81,27 @@ def __init__( variable_schema = variable_schema.copy() for target, regressors in variable_schema.items(): if target in regressors: - raise ValueError(f'{target} being used to impute itself') - + raise ValueError(f"{target} being used to impute itself") + self.variable_schema = variable_schema self.modeled_variables = list(self.variable_schema) self.imputed_variables = [ - col for col in self.modeled_variables - if col in self.vars_with_any_missing + col for col in self.modeled_variables if col in self.vars_with_any_missing ] - self.using_random_seed_array = not random_seed_array is None - if self.using_random_seed_array: + if random_seed_array is not None: assert isinstance(random_seed_array, np.ndarray) assert ( random_seed_array.shape[0] == self.shape[0] ), "random_seed_array must be the same length as data." - self.random_seed_array = hash_numpy_int_array(random_seed_array + 1) + # Our hashing scheme doesn't work for specifically the value 0. + # Set any values == 0 to the value 1. + random_seed_array = random_seed_array.copy() + zero_value_seeds = random_seed_array == 0 + random_seed_array[zero_value_seeds] = 1 + hash_numpy_int_array(random_seed_array) + self.random_seed_array = random_seed_array else: self.random_seed_array = None @@ -113,12 +115,23 @@ def __init__( shape=(num_datasets, self.modeled_variable_count) ).astype(int) - iv_multiindex = MultiIndex.from_product([[0], np.arange(num_datasets)], names=('iteration', 'dataset')) + # Create a multiindexed dataframe to store our imputation values + iv_multiindex = MultiIndex.from_product( + [[0], np.arange(num_datasets)], names=("iteration", "dataset") + ) self.imputation_values = { - var: DataFrame(index=na_where[var], columns=iv_multiindex).astype(pd_dtypes_orig[var]) + var: DataFrame(index=na_where[var], columns=iv_multiindex).astype( + pd_dtypes_orig[var] + ) for var in self.imputed_variables } + # Create an iteration counter + self.iteration_tab = {} + for variable in self.modeled_variables: + for dataset in range(num_datasets): + self.iteration_tab[variable, dataset] = 0 + # Subsetting allows us to get to the imputation values: def __getitem__(self, tup): variable, iteration, dataset = tup @@ -130,13 +143,17 @@ def __setitem__(self, tup, newitem): # Don't throw this warning on initialization if (iteration <= imputation_iteration) and (iteration > 0): - warn(f'Overwriting Variable: {variable} Dataset: {dataset} Iteration: iteration') + warn( + f"Overwriting Variable: {variable} Dataset: {dataset} Iteration: iteration" + ) self.imputation_values[variable].loc[:, (iteration, dataset)] = newitem def __delitem__(self, tup): variable, iteration, dataset = tup - self.imputation_values[variable].drop([(iteration, dataset)], axis=1, inplace=True) + self.imputation_values[variable].drop( + [(iteration, dataset)], axis=1, inplace=True + ) def __getstate__(self): """ @@ -146,18 +163,18 @@ def __getstate__(self): state = { key: value for key, value in self.__dict__.items() - if key not in ['imputation_values'] + if key not in ["imputation_values"] }.copy() - state['imputation_values'] = {} + state["imputation_values"] = {} for col, df in self.imputation_values.items(): byte_stream = BytesIO() df.to_parquet(byte_stream) - state['imputation_values'][col] = byte_stream + state["imputation_values"][col] = byte_stream return state - + def __setstate__(self, state): """ For unpickling @@ -187,16 +204,14 @@ def _get_nonmissing_index(self, variable): na_where = self.na_where[variable] dtype = na_where.dtype non_missing_ind = np.setdiff1d( - np.arange(self.shape[0], dtype=dtype), - na_where, - assume_unique=True + np.arange(self.shape[0], dtype=dtype), na_where, assume_unique=True ) return non_missing_ind - + def _get_nonmissing_values(self, variable): ind = self._get_nonmissing_index(variable) return self.working_data.loc[ind, variable] - + def get_bachelor_features(self, variable): na_where = self.na_where[variable] predictors = self.variable_schema[variable] @@ -209,6 +224,22 @@ def _ampute_original_data(self): na_where = self.na_where[variable] self.working_data.loc[na_where, variable] = np.nan + def _get_hashed_seeds(self, variable: str): + if self.random_seed_array is not None: + na_where = self.na_where[variable] + hashed_seeds = self.random_seed_array[na_where].copy() + hash_numpy_int_array(self.random_seed_array, ind=na_where) + return hashed_seeds + else: + return None + + # def _cycle_random_seed_array(self, variable: str): + # if self.random_seed_array is not None: + # na_where = self.na_where[variable] + # hash_numpy_int_array(self.random_seed_array, ind=na_where) + # else: + # pass + def _prep_multi_plot( self, variables, @@ -220,10 +251,8 @@ def _prep_multi_plot( return plots, plotrows, plotcols def iteration_count( - self, - dataset: Optional[int] = None, - variable: Optional[str] = None - ): + self, dataset: Optional[int] = None, variable: Optional[str] = None + ): """ Grabs the iteration count for specified variables, datasets. If the iteration count is not consistent across the provided @@ -249,36 +278,19 @@ def iteration_count( An integer representing the iteration count. """ - ds_slice = slice(None) if dataset is None else dataset - # Check all variables if None specified - check_vars = self.imputed_variables if variable is None else [variable] - assert len(check_vars) > 0, 'No variables to get iteration count for.' - variable_dataset_iterations = {} - for var in check_vars: - var_ds_iter = ( - self.imputation_values[var] - .columns - .to_frame() - .loc[(slice(None), ds_slice), :] - .reset_index(drop=True) - .groupby('dataset') - .iteration - .max() - ) - assert var_ds_iter.nunique() == 1, ( - f'{var} has different iteration counts between datasets:\n' - f'{var_ds_iter}' - ) - variable_dataset_iterations[var] = var_ds_iter.iloc[0] + iteration_tab = Series(self.iteration_tab) + iteration_tab.index.names = ["variable", "dataset"] - distinct_variable_iteration_counts = set(variable_dataset_iterations.values()) - assert len(distinct_variable_iteration_counts) == 1, ( - 'Variables have different iteration counts:\n' - f'{variable_dataset_iterations}' - ) + if variable is None: + variable = slice(None) + if dataset is None: + dataset = slice(None) - return distinct_variable_iteration_counts.pop() - + iterations = np.unique(iteration_tab.loc[variable, dataset]) + if iterations.shape[0] > 1: + raise ValueError("Multiple iteration counts found") + else: + return iterations[0] def complete_data( self, @@ -318,9 +330,9 @@ def complete_data( # Figure out which variables we need to impute. # Never impute variables that are not in imputed_variables. imp_vars = self.imputed_variables if variables is None else variables - assert set(imp_vars).issubset(set(self.imputed_variables)), ( - 'Not all variables specified were imputed.' - ) + assert set(imp_vars).issubset( + set(self.imputed_variables) + ), "Not all variables specified were imputed." for variable in imp_vars: if iteration is None: diff --git a/miceforest/logger.py b/miceforest/logger.py index a32bc0c..ec4778f 100644 --- a/miceforest/logger.py +++ b/miceforest/logger.py @@ -5,7 +5,7 @@ class Logger: def __init__( - self, + self, name: str, timed_levels: List[str], verbose: bool = False, @@ -49,7 +49,9 @@ def log(self, *args, **kwargs): def set_start_time(self, time_key: Tuple): assert len(time_key) == len(self.timed_levels) - assert time_key not in list(self.started_timers), f'Timer {time_key} already started' + assert time_key not in list( + self.started_timers + ), f"Timer {time_key} already started" self.started_timers[time_key] = datetime.now() def record_time(self, time_key: Tuple): @@ -57,7 +59,7 @@ def record_time(self, time_key: Tuple): Compares the current time with the start time, and records the time difference in our time log in the appropriate register. Times can stack for a context. """ - assert time_key in list(self.started_timers), f'Timer {time_key} never started' + assert time_key in list(self.started_timers), f"Timer {time_key} never started" seconds = (datetime.now() - self.started_timers[time_key]).total_seconds() del self.started_timers[time_key] if time_key in self.time_seconds: diff --git a/miceforest/mean_match.py b/miceforest/mean_match.py index b79617d..a37e4a2 100644 --- a/miceforest/mean_match.py +++ b/miceforest/mean_match.py @@ -1,4 +1,3 @@ - from pandas import Series, DataFrame import inspect from copy import deepcopy @@ -45,14 +44,14 @@ def predict_normal(model: Booster, data): def predict_normal_shap(model: Booster, data): - preds = model.predict(data, pred_contrib=True)[:, :-1] # type: ignore + preds = model.predict(data, pred_contrib=True)[:, :-1] # type: ignore adjust_shap_for_rf(model, preds) return preds def predict_binary_logodds(model: Booster, data): preds = logodds( - model.predict(data).clip( # type: ignore + model.predict(data).clip( # type: ignore _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD ) ) @@ -60,7 +59,7 @@ def predict_binary_logodds(model: Booster, data): def predict_multiclass_logodds(model: Booster, data): - preds = model.predict(data).clip( # type: ignore + preds = model.predict(data).clip( # type: ignore _LIGHTGBM_PROB_THRESHOLD, 1.0 - _LIGHTGBM_PROB_THRESHOLD ) preds = logodds(preds) @@ -75,12 +74,12 @@ def predict_multiclass_shap(model: Booster, data: DataFrame): """ preds = model.predict(data, pred_contrib=True) samples, cols = data.shape - classes = model._Booster__num_class # type: ignore - p = np.empty(shape=(samples, cols * classes), dtype=preds.dtype) # type: ignore + classes = model._Booster__num_class # type: ignore + p = np.empty(shape=(samples, cols * classes), dtype=preds.dtype) # type: ignore for c in range(classes): s1 = slice(c * cols, (c + 1) * cols) s2 = slice(c * (cols + 1), (c + 1) * (cols + 1) - 1) - p[:, s1] = preds[:, s2] # type: ignore + p[:, s1] = preds[:, s2] # type: ignore # If objective is random forest, the shap values are summed # without ever taking an average, so we divide by the iters diff --git a/miceforest/utils.py b/miceforest/utils.py index 52fc8f2..0e78eb9 100644 --- a/miceforest/utils.py +++ b/miceforest/utils.py @@ -1,4 +1,3 @@ - import numpy as np from numpy.random import RandomState import blosc2 @@ -14,26 +13,25 @@ def _to_2d(x): if x.ndim == 1: x.shape = (-1, 1) + def _to_1d(x): """ Ensures an array is 1 dimensional, in place. """ if x.ndim == 2: assert x.shape[1] == 1 - x.shape = (-1) + x.shape = -1 + def get_best_int_downcast(x: int): assert isinstance(x, int) - int_dtypes = ['uint8', 'uint16', 'uint32', 'uint64'] - np_iinfo_max = { - dtype: np.iinfo(dtype).max - for dtype in int_dtypes - } + int_dtypes = ["uint8", "uint16", "uint32", "uint64"] + np_iinfo_max = {dtype: np.iinfo(dtype).max for dtype in int_dtypes} for dtype, max in np_iinfo_max.items(): if x <= max: break - if dtype == 'uint64': - raise ValueError('Number too large to downcast') + if dtype == "uint64": + raise ValueError("Number too large to downcast") return dtype @@ -112,11 +110,11 @@ def load_kernel(filepath: str, n_threads: Optional[int] = None): def stratified_subset( - y: Series, - size: int, - groups: int, - random_state: Optional[Union[int, np.random.RandomState]], - ): + y: Series, + size: int, + groups: int, + random_state: Optional[Union[int, np.random.RandomState]], +): """ Subsample y using stratification. y is divided into quantiles, and then elements are randomly chosen from each quantile to @@ -142,6 +140,8 @@ def stratified_subset( """ + random_state = ensure_rng(random_state=random_state) + cat = False if y.dtype.name == "category": cat = True @@ -161,7 +161,9 @@ def stratified_subset( digits_s = (digits_p * size).round(0).astype("int32") diff = size - digits_s.sum() if diff != 0: - digits_fix = random_state.choice(digits_i, size=abs(diff), p=digits_p, replace=False) + digits_fix = random_state.choice( + digits_i, size=abs(diff), p=digits_p, replace=False + ) if diff < 0: for d in digits_fix: digits_s[d] -= 1 @@ -220,9 +222,7 @@ def stratified_categorical_folds(y: Series, nfold: int): # https://stackoverflow.com/questions/664014/what-integer-hash-function-are-good-that-accepts-an-integer-hash-key -# We don't really need to worry that much about diffusion -# since we take % n at the end, and n (mmc) is usually -# very small. This hash performs well enough in testing. +# This hash performs well enough in testing. def hash_int32(x: np.ndarray): """ A hash function which generates random uniform (enough) @@ -238,23 +238,31 @@ def hash_int32(x: np.ndarray): def hash_uint64(x: np.ndarray): assert isinstance(x, np.ndarray) - assert x.dtype == "uint64", "x must be int32" - x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9 - x = (x ^ (x >> 27)) * 0x94d049bb133111eb + assert x.dtype == "uint64", "x must be uint64" + x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9 + x = (x ^ (x >> 27)) * 0x94D049BB133111EB x = x ^ (x >> 31) return x + def hash_numpy_int_array(x: np.ndarray, ind: Optional[np.ndarray] = None): + """ + Deterministically set the values of the elements in x + at the locations ind to some uniformly distributed number + within the range of the datatype of x. + + This function acts on x in place + """ if ind is None: ind = slice(None) assert isinstance(x, np.ndarray) if x.dtype in ["uint32", "int32"]: x[ind] = hash_int32(x[ind]) - elif x.dtype == 'uint64': + elif x.dtype == "uint64": x[ind] = hash_uint64(x[ind]) else: - raise ValueError('random_seed_array must be uint32, int32, or uint64 datatype') - return x + raise ValueError("random_seed_array must be uint32, int32, or uint64 datatype") + def _draw_random_int32(random_state, size): nums = random_state.randint( @@ -306,10 +314,7 @@ def ensure_rng(random_state) -> RandomState: def _expand_value_to_dict(default, value, keys): if isinstance(value, dict): - ret = { - key: value.get(key, default) - for key in keys - } + ret = {key: value.get(key, default) for key in keys} else: assert default.__class__ == value.__class__ ret = {key: value for key in keys} @@ -320,6 +325,7 @@ def _expand_value_to_dict(default, value, keys): def _list_union(x: List, y: List): return [z for z in x if z in y] + def logodds(probability): try: odds_ratio = probability / (1 - probability) diff --git a/poetry.lock b/poetry.lock index f1a69fa..e75e230 100644 --- a/poetry.lock +++ b/poetry.lock @@ -18,6 +18,52 @@ six = ">=1.12.0" astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] +[[package]] +name = "black" +version = "24.4.2" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.8" +files = [ + {file = "black-24.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dd1b5a14e417189db4c7b64a6540f31730713d173f0b63e55fabd52d61d8fdce"}, + {file = "black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e537d281831ad0e71007dcdcbe50a71470b978c453fa41ce77186bbe0ed6021"}, + {file = "black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaea3008c281f1038edb473c1aa8ed8143a5535ff18f978a318f10302b254063"}, + {file = "black-24.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:7768a0dbf16a39aa5e9a3ded568bb545c8c2727396d063bbaf847df05b08cd96"}, + {file = "black-24.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:257d724c2c9b1660f353b36c802ccece186a30accc7742c176d29c146df6e474"}, + {file = "black-24.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bdde6f877a18f24844e381d45e9947a49e97933573ac9d4345399be37621e26c"}, + {file = "black-24.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e151054aa00bad1f4e1f04919542885f89f5f7d086b8a59e5000e6c616896ffb"}, + {file = "black-24.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:7e122b1c4fb252fd85df3ca93578732b4749d9be076593076ef4d07a0233c3e1"}, + {file = "black-24.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:accf49e151c8ed2c0cdc528691838afd217c50412534e876a19270fea1e28e2d"}, + {file = "black-24.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:88c57dc656038f1ab9f92b3eb5335ee9b021412feaa46330d5eba4e51fe49b04"}, + {file = "black-24.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be8bef99eb46d5021bf053114442914baeb3649a89dc5f3a555c88737e5e98fc"}, + {file = "black-24.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:415e686e87dbbe6f4cd5ef0fbf764af7b89f9057b97c908742b6008cc554b9c0"}, + {file = "black-24.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bf10f7310db693bb62692609b397e8d67257c55f949abde4c67f9cc574492cc7"}, + {file = "black-24.4.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:98e123f1d5cfd42f886624d84464f7756f60ff6eab89ae845210631714f6db94"}, + {file = "black-24.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48a85f2cb5e6799a9ef05347b476cce6c182d6c71ee36925a6c194d074336ef8"}, + {file = "black-24.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:b1530ae42e9d6d5b670a34db49a94115a64596bc77710b1d05e9801e62ca0a7c"}, + {file = "black-24.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:37aae07b029fa0174d39daf02748b379399b909652a806e5708199bd93899da1"}, + {file = "black-24.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da33a1a5e49c4122ccdfd56cd021ff1ebc4a1ec4e2d01594fef9b6f267a9e741"}, + {file = "black-24.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef703f83fc32e131e9bcc0a5094cfe85599e7109f896fe8bc96cc402f3eb4b6e"}, + {file = "black-24.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:b9176b9832e84308818a99a561e90aa479e73c523b3f77afd07913380ae2eab7"}, + {file = "black-24.4.2-py3-none-any.whl", hash = "sha256:d36ed1124bb81b32f8614555b34cc4259c3fbc7eec17870e8ff8ded335b58d8c"}, + {file = "black-24.4.2.tar.gz", hash = "sha256:c872b53057f000085da66a19c55d68f6f8ddcac2642392ad3a355878406fbd4d"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +packaging = ">=22.0" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + [[package]] name = "blosc2" version = "2.6.2" @@ -56,6 +102,20 @@ numexpr = "*" numpy = ">=1.20.3" py-cpuinfo = "*" +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + [[package]] name = "colorama" version = "0.4.6" @@ -607,6 +667,17 @@ files = [ {file = "msgpack-1.0.8.tar.gz", hash = "sha256:95c02b0e27e706e48d0e5426d1710ca78e0f0628d6e89d5b5a5b91a5f12274f3"}, ] +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + [[package]] name = "ndindex" version = "1.8" @@ -806,6 +877,17 @@ files = [ qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] testing = ["docopt", "pytest"] +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + [[package]] name = "pexpect" version = "4.9.0" @@ -906,6 +988,22 @@ tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "pa typing = ["typing-extensions"] xmp = ["defusedxml"] +[[package]] +name = "platformdirs" +version = "4.2.2" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +optional = false +python-versions = ">=3.8" +files = [ + {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"}, + {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] +type = ["mypy (>=1.8)"] + [[package]] name = "pluggy" version = "1.5.0" @@ -1303,4 +1401,4 @@ files = [ [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "be1ba227f52493dafaf01193766cc1be90a3d52fe361bb8e93a9b2e91fa83c09" +content-hash = "0ac7b43d1158129dbdeb439be5d650c0f16283babdeb5d3ddab037eee69eca1d" diff --git a/pyproject.toml b/pyproject.toml index 6996dbc..b819642 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,6 +19,7 @@ scipy = "^1.11.1" seaborn = "^0.13.0" matplotlib = "^3.3.0" scikit-learn = "^1.4.0" +black = "^24.4.2" [tool.poetry.group.dev.dependencies] ipython = "^8.17.2" diff --git a/tests/test_ImputationKernel.py b/tests/test_ImputationKernel.py index 2913cae..4d3d88d 100644 --- a/tests/test_ImputationKernel.py +++ b/tests/test_ImputationKernel.py @@ -8,6 +8,7 @@ from tempfile import mkstemp import dill + # Make random state and load data # Define data random_state = np.random.RandomState(1991) @@ -32,6 +33,14 @@ perc=0.25, random_state=random_state ) +na_where = { + var: np.where(iris_amp[var].isnull())[0] + for var in iris_amp.columns +} +notnan_where = { + var: np.setdiff1d(np.arange(iris_amp.shape[0]), na_where[var], assume_unique=True)[0] + for var in iris_amp.columns +} new_amputed_data = iris_amp.loc[range(20), :].reset_index(drop=True).copy() new_nonmissing_data = iris.loc[range(20), :].reset_index(drop=True).copy() @@ -53,15 +62,15 @@ def make_and_test_kernel(**kwargs): - kwargs = { - 'data':iris_amp, - 'num_datasets':2, - 'variable_schema':vs, - 'mean_match_candidates':mmc, - 'data_subset':ds, - 'mean_match_strategy':'normal', - 'save_all_iterations_data':True, - } + # kwargs = { + # 'data':iris_amp, + # 'num_datasets':2, + # 'variable_schema':vs, + # 'mean_match_candidates':mmc, + # 'data_subset':ds, + # 'mean_match_strategy':'normal', + # 'save_all_iterations_data':True, + # } # Build a normal kernel, run mice, save, load, and run mice again kernel = mf.ImputationKernel(**kwargs) @@ -95,7 +104,13 @@ def make_and_test_kernel(**kwargs): assert completed_data[col].dtype == dtype # Make sure the working data wasn't imputed - assert all(kernel.working_data[imputed_variables].isnull().sum() > 0) + for var, naw in na_where.items(): + if len(naw) > 0: + assert kernel.working_data.loc[naw, var].isnull().mean() == 1.0 + + # Make sure the original nonmissing data wasn't changed + for var, naw in notnan_where.items(): + assert completed_data.loc[naw, var] == iris_amp.loc[naw, var] # Impute the data in place now kernel.complete_data(0, inplace=True) @@ -138,6 +153,8 @@ def make_and_test_kernel(**kwargs): return kernel + + def test_defaults(): kernel_normal = make_and_test_kernel( @@ -158,6 +175,12 @@ def test_defaults(): mean_match_strategy='shap', save_all_iterations_data=True, ) + kernel_iwp = make_and_test_kernel( + data=iris_amp, + num_datasets=2, + mean_match_candidates=0, + save_all_iterations_data=True, + ) def test_complex(): @@ -188,9 +211,16 @@ def test_complex(): mean_match_strategy='normal', save_all_iterations_data=True, ) - normal_ind = kernel_normal.impute_new_data(new_data) + assert kernel.data_subset == { + 'sl': 75, + 'ws': 50, + 'pl': 0, + 'bi': 0, + 'ui8': 0, + 'pw': 0 + }, "mean_match_subset initialization failed" - kernel_fast = mf.ImputationKernel( + kernel_fast = make_and_test_kernel( data=iris_amp, num_datasets=2, variable_schema=vs, @@ -199,326 +229,28 @@ def test_complex(): mean_match_strategy='fast', save_all_iterations_data=True, ) - kernel_fast.mice(iterations=2, verbose=True) - new_file, filename = mkstemp() - with open(filename, 'wb') as file: - dill.dump(kernel_fast, file) - del kernel_fast - with open(filename, 'rb') as file: - kernel_fast = dill.load(file) - kernel_fast.mice(iterations=1, verbose=True) - fast_ind = kernel_fast.impute_new_data(new_data) - kernel_shap = mf.ImputationKernel( + mmc_shap = mmc.copy() + mmc_shap['ws'] = 1 + kernel_shap = make_and_test_kernel( data=iris_amp, num_datasets=2, variable_schema=vs, - mean_match_candidates=mmc, + mean_match_candidates=mmc_shap, data_subset=ds, - mean_match_strategy={'sl': 'shap', 'ws': 'fast', 'ui8': 'fast', 'bi': 'normal'}, + mean_match_strategy='shap', save_all_iterations_data=True, ) - kernel_shap.mice(iterations=2, verbose=True) - new_file, filename = mkstemp() - with open(filename, 'wb') as file: - dill.dump(kernel_shap, file) - del kernel_shap - with open(filename, 'rb') as file: - kernel_shap = dill.load(file) - kernel_shap.mice(iterations=1, verbose=True) - shap_ind = kernel_shap.impute_new_data(new_data) - - kernel_normal.data_subset - kernel_normal.model_training_order - kernel_normal.mean_match_candidates - kernel_normal.modeled_but_not_imputed_variables - - - assert kernel.data_subset == {0: 100, 1: 56, 3: 113, 2: 113, 4: 113}, "mean_match_subset initialization failed" - assert kernel.iteration_count() == 0, "iteration initialization failed" - - - # This section tests many things: - # After saving / loading a kernel, and appending 2 kernels together: - # mice can continue - # Aliases are fixed, even when different aliases are passed - # variable specific parameters supercede globally specified parameters - # The parameters come through the actual model - nround = 2 - kernel.mice( - nround - 1, - compile_candidates=True, - variable_parameters={"sl": {"n_iter": 15}}, - num_trees=10, - verbose=True - ) - kernel.compile_candidate_preds() - kernel2.mice(nround - 1, variable_parameters={"sl": {"n_estimators": 15}}, n_estimators=10, verbose=True) - kernel.append(kernel2) - kernel.compile_candidate_preds() - assert kernel.get_model(0, 0, nround - 1).num_trees() == 15 - assert kernel.get_model(0, 1, nround - 1).num_trees() == 10 - kernel.mice(1, variable_parameters={1: {"n_iter": 15}}, num_trees=10, verbose=True) - assert kernel.iteration_count() == nround, "iteration counting is incorrect." - assert kernel.get_model(0, 1, nround).num_trees() == 15 - assert kernel.get_model(0, 2, nround).num_trees() == 10 - - # Make sure we only impute variables in variable_schema - compdat = kernel.complete_data(0) - assert all(compdat[imputed_var_names].isnull().sum() == 0) - assert all(compdat[non_imputed_var_names].isnull().sum() > 0) - - # Test the ability to tune parameters with custom setup - optimization_steps = 2 - op, ol = kernel.tune_parameters( - dataset=0, - optimization_steps=optimization_steps, - variable_parameters={1: {"bagging_fraction": 0.9, "feature_fraction_bynode": (0.85, 0.9)}}, - bagging_fraction=0.8, - feature_fraction_bynode=(0.70,0.75), - verbose=True - ) - assert op[1]["bagging_fraction"] == 0.9 - assert op[2]["bagging_fraction"] == 0.8 - assert (op[1]["feature_fraction_bynode"] >= 0.85) and (op[1]["feature_fraction_bynode"] <= 0.9) - assert (op[2]["feature_fraction_bynode"] >= 0.70) and (op[2]["feature_fraction_bynode"] <= 0.75) - kernel.mice(1, variable_parameters=op, verbose=True) - model_2_params = kernel.get_model(0, 2, nround + 1).params - model_1_params = kernel.get_model(0, 1, nround + 1).params - assert model_2_params["bagging_fraction"] == 0.8 - assert model_1_params["bagging_fraction"] == 0.9 - assert (model_2_params["feature_fraction_bynode"] >= 0.70) and (model_2_params["feature_fraction_bynode"] <= 0.75) - assert (model_1_params["feature_fraction_bynode"] >= 0.85) and (model_1_params["feature_fraction_bynode"] <= 0.9) - - new_imp_dat = kernel.impute_new_data(new_data=new_data, verbose=True) - new_imp_complete = new_imp_dat.complete_data(0) - assert all(new_imp_complete[imputed_var_names].isnull().sum() == 0) - - # Plotting on multiple imputed dataset - new_imp_dat.plot_mean_convergence() - close() - new_imp_dat.plot_imputed_distributions() - close() - - # Plotting on Multiple Imputed Kernel - kernel.plot_feature_importance(0) - close() - kernel.plot_mean_convergence() - close() - kernel.plot_imputed_distributions() - close() - - - -def test_defaults_numpy(): - - iris_np = iris.copy() - iris_np["sp"] = iris_np["sp"].cat.codes - iris_np = iris_np.values - iris_np_amp = mf.ampute_data(iris_np, perc=0.25) - new_data = iris_np_amp[range(10), :].copy() - - s = datetime.now() - kernel = mf.ImputationKernel( - data=iris_np_amp, - datasets=3, - categorical_feature=[4], - mean_match_scheme=mean_match_fast_cat - ) - kernel.mice(iterations=1, verbose=True) - kernel.compile_candidate_preds() - # Complete data with copy. - comp_dat = kernel.complete_data(0, inplace=False) - - # We didn't complete data in place. Make sure we created - # a copy, and did not affect internal data or original data. - assert all(np.isnan(comp_dat).sum(0) == 0) - assert all(np.isnan(kernel.working_data).sum(0) > 0) - assert all(np.isnan(iris_np_amp).sum(0) > 0) - - # Complete data in place - kernel.complete_data(0, inplace=True) - - # We completed data in place. Make sure we only affected - # the kernel.working_data and not the original data. - assert all(np.isnan(kernel.working_data).sum(0) == 0) - assert all(np.isnan(iris_np_amp).sum(0) > 0) - - imp_ds = kernel.impute_new_data(new_data) - imp_ds.complete_data(0,inplace=True) - assert all(np.isnan(imp_ds.working_data).sum(0) == 0) - assert np.isnan(new_data).sum() > 0 - - # Make sure fully-recognized data can be passed through with no changes - imp_fr = kernel.impute_new_data(iris_np) - comp_fr = imp_fr.complete_data(0) - assert np.all(comp_fr == iris_np), "values of fully-recognized data were modified" - assert imp_fr.iteration_count() == -1 - - -def test_complex_numpy(): - - iris_np = iris.copy() - iris_np["sp"] = iris_np["sp"].cat.codes - iris_np = iris_np.values - iris_np_amp = mf.ampute_data(iris_np, perc=0.25) - new_data = iris_np_amp[range(25), :].copy() - - # Specify that models should be built for variables 1, 2, 3, 4 - # Customize everything. - vs = { - 0: [1, 2, 3, 4, 5], - 1: [0], - 2: [4, 5], - 3: [0, 1, 2, 4, 5], - 4: [0, 1, 2, 3, 5], + mixed_mms = { + 'sl': 'shap', 'ws': 'fast', 'ui8': 'fast', 'bi': 'normal' } - mmc = {0: 4, 1: 0.1, 2: 0} - ds = {0: 100, 1: 0.5} - io = [0, 1, 2, 3, 4] - niv = [v for v in range(iris_amp.shape[1]) if v not in list(vs)] - - mmfc = mean_match_fast_cat.copy() - mmfc.set_mean_match_candidates(mean_match_candidates=mmc) - kernel = mf.ImputationKernel( - data=iris_np_amp, - datasets=2, - variable_schema=vs, - imputation_order=io, - train_nonmissing=True, - data_subset=ds, - mean_match_scheme=mmfc, - categorical_feature=[4], - copy_data=False, - save_loggers=True - ) - - kernel2 = mf.ImputationKernel( - data=iris_np_amp, - datasets=1, + kernel_mixed = make_and_test_kernel( + data=iris_amp, + num_datasets=2, variable_schema=vs, - imputation_order=io, - train_nonmissing=True, + mean_match_candidates=mmc, data_subset=ds, - mean_match_scheme=mmfc.copy(), - categorical_feature=[4], - copy_data=False, - save_loggers=True - ) - new_file, filename = mkstemp() - kernel2.save_kernel(filename) - kernel2 = mf.utils.load_kernel(filename) - - assert kernel.data_subset == {0: 100, 1: 56, 2: 113, 3: 113, 4: 113}, "mean_match_subset initialization failed" - assert kernel.iteration_count() == 0, "iteration initialization failed" - assert kernel.categorical_variables == [4], "categorical recognition failed." - - nround = 2 - kernel.mice(nround - 1, variable_parameters={1: {"n_iter": 15}}, num_trees=10, verbose=True) - kernel.compile_candidate_preds() - kernel2.mice(nround - 1, variable_parameters={1: {"n_iter": 15}}, num_trees=10, verbose=True) - kernel.append(kernel2) - kernel.compile_candidate_preds() - assert kernel.get_model(0, 1, nround - 1).num_trees() == 15 - assert kernel.get_model(0, 2, nround - 1).num_trees() == 10 - kernel.mice(1, variable_parameters={1: {"n_estimators": 15}}, n_estimators=10, verbose=True) - assert kernel.iteration_count() == nround, "iteration counting is incorrect." - assert kernel.get_model(0, 1, nround).num_trees() == 15 - assert kernel.get_model(0, 2, nround).num_trees() == 10 - - # Complete data with copy. Make sure only correct datasets and variables were affected. - compdat = kernel.complete_data(0, inplace=False) - assert all(np.isnan(compdat[:,io]).sum(0) == 0) - assert all(np.isnan(compdat[:,niv]).sum(0) > 0) - - # Should have no affect on working_data - assert all(np.isnan(kernel.working_data).sum(0) > 0) - - # Should have no affect on working_set - assert all(np.isnan(iris_np_amp).sum(0) > 0) - - # Now complete the data in place - kernel.complete_data(0, inplace=True) - - # Should have affect on working_data and original data - assert all(np.isnan(kernel.working_data[:, io]).sum(0) == 0) - assert all(np.isnan(iris_np_amp[:, io]).sum(0) == 0) - assert all(np.isnan(kernel.working_data[:, niv]).sum(0) > 0) - assert all(np.isnan(iris_np_amp[:, niv]).sum(0) > 0) - - # Test the ability to tune parameters with custom setup - optimization_steps = 2 - op, ol = kernel.tune_parameters( - dataset=0, - optimization_steps=optimization_steps, - variable_parameters={1: {"bagging_fraction": 0.9, "feature_fraction_bynode": (0.85, 0.9)}}, - bagging_fraction=0.8, - feature_fraction_bynode=(0.70,0.75), - verbose=True + mean_match_strategy=mixed_mms, + save_all_iterations_data=True, ) - - assert op[1]["bagging_fraction"] == 0.9 - assert op[2]["bagging_fraction"] == 0.8 - assert (op[1]["feature_fraction_bynode"] >= 0.85) and (op[1]["feature_fraction_bynode"] <= 0.9) - assert (op[2]["feature_fraction_bynode"] >= 0.70) and (op[2]["feature_fraction_bynode"] <= 0.75) - kernel.mice(1, variable_parameters=op, verbose=True) - model_2_params = kernel.get_model(0, 2, nround + 1).params - model_1_params = kernel.get_model(0, 1, nround + 1).params - assert model_2_params["bagging_fraction"] == 0.8 - assert model_1_params["bagging_fraction"] == 0.9 - assert (model_2_params["feature_fraction_bynode"] >= 0.70) and (model_2_params["feature_fraction_bynode"] <= 0.75) - assert (model_1_params["feature_fraction_bynode"] >= 0.85) and (model_1_params["feature_fraction_bynode"] <= 0.9) - - new_imp_dat = kernel.impute_new_data(new_data=new_data, copy_data=True, verbose=True) - - # Not in place - new_imp_complete = new_imp_dat.complete_data(0, inplace=False) - assert all(np.isnan(new_imp_complete[:, list(vs)]).sum(0) == 0) - assert all(np.isnan(new_imp_complete[:, niv]).sum(0) > 0) - - - # Should have no affect on working_data or original data - assert all(np.isnan(new_imp_dat.working_data).sum(0) > 0) - assert all(np.isnan(new_data[:, list(vs)]).sum(0) > 0) - - # complete data in place - new_imp_dat.complete_data(0, inplace=True) - assert all(np.isnan(new_imp_dat.working_data[:, list(vs)]).sum(0) == 0) - assert all(np.isnan(new_data[:, niv]).sum(0) > 0) - - # Alter in place - new_imp_dat = kernel.impute_new_data(new_data=new_data, copy_data=False, verbose=True) - - # Before completion, nan's should still exist in data: - assert all(np.isnan(new_data).sum(0) > 0) - assert all(np.isnan(new_imp_dat.working_data).sum(0) > 0) - - # Complete data not in place - new_imp_complete = new_imp_dat.complete_data(0, inplace=False) - assert all(np.isnan(new_imp_complete[:, niv]).sum(0) > 0) - assert all(np.isnan(new_imp_complete[:, list(vs)]).sum(0) == 0) - assert all(np.isnan(new_data).sum(0) > 0) - assert all(np.isnan(new_imp_dat.working_data).sum(0) > 0) - - # Complete data in place - new_imp_dat.complete_data(0, inplace=True) - assert all(np.isnan(new_data[:, niv]).sum(0) > 0) - assert all(np.isnan(new_data[:, list(vs)]).sum(0) == 0) - assert all(np.isnan(new_imp_dat.working_data[:, niv]).sum(0) > 0) - assert all(np.isnan(new_imp_dat.working_data[:, list(vs)]).sum(0) == 0) - - - # Plotting on multiple imputed dataset - new_imp_dat.plot_mean_convergence() - close() - new_imp_dat.plot_imputed_distributions() - close() - - # Plotting on Multiple Imputed Kernel - kernel.plot_feature_importance(0) - close() - kernel.plot_mean_convergence() - close() - kernel.plot_imputed_distributions() - close() diff --git a/tests/test_imputed_accuracy.py b/tests/test_imputed_accuracy.py index d33d649..39110f0 100644 --- a/tests/test_imputed_accuracy.py +++ b/tests/test_imputed_accuracy.py @@ -1,5 +1,4 @@ - from sklearn.datasets import load_iris import pandas as pd import numpy as np @@ -7,315 +6,176 @@ from miceforest.utils import logistic_function from sklearn.metrics import roc_auc_score -random_state = np.random.RandomState(5) -iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) -iris["binary"] = random_state.binomial(1,(iris["target"] + 0.2) / 2.5, size=150) -iris["target"] = iris["target"].astype("category") -iris["binary"] = iris["binary"].astype("category") -iris.columns = [c.replace(" ", "") for c in iris.columns] -iris = pd.concat([iris] * 2, axis=0, ignore_index=True) -iris_amp = mf.utils.ampute_data(iris, perc=0.20) -iris_new = iris.iloc[random_state.choice(iris.index, iris.shape[0], replace=False)].reset_index(drop=True) -iris_new_amp = mf.utils.ampute_data(iris_new, perc=0.20) - -def mse(x, y): - return np.mean((x-y) ** 2) - -iterations = 2 - - -kernel_sm2 = mf.ImputationKernel( - iris_amp, - num_datasets=1, - data_subset=0, - mean_match_candidates=0, - random_state=1, -) -kernel_sm2.mice( - iterations, - boosting='random_forest', - learning_rate=0.02, - num_iterations=50, - num_leaves=31, - verbose=True -) -kernel_sm1 = mf.ImputationKernel( - iris_amp, - datasets=1, - data_subset=0.75, - mean_match_scheme=mean_match_default, - save_models=1, - random_state=1 -) -kernel_sm1.mice( - iterations, - boosting='random_forest', - num_iterations=100, - num_leaves=31 -) +def make_dataset(seed): -kernel_shap = mf.ImputationKernel( - iris_amp, - datasets=1, - data_subset=0.75, - mean_match_scheme=mean_match_shap, - save_models=1, - random_state=1 -) -kernel_shap.mice( - iterations, - boosting='random_forest', - num_iterations=100, - num_leaves=31, -) + random_state = np.random.RandomState(seed) + iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) + iris["bi"] = random_state.binomial(1,(iris["target"] == 0).map({True: 0.85, False: 0.15}), size=150) + iris["bi"] = iris["bi"].astype('category') + iris['sp'] = iris['target'].map({0: 'A', 1: 'B', 2: 'C'}).astype('category') + del iris['target'] + iris.rename({ + 'sepal length (cm)': 'sl', + 'sepal width (cm)': 'sw', + 'petal length (cm)': 'pl', + 'petal width (cm)': 'pw', + }, axis=1, inplace=True) + iris_amp = mf.utils.ampute_data(iris, perc=0.20) + return iris, iris_amp -def test_sm2_mice_cat(): - # Binary - col = 'binary' - ind = kernel_sm2.na_where[col] - orig = iris.loc[ind, col] - imps = kernel_sm2[col, 0, iterations] - model = kernel_sm2.get_model(col, 0, -1) - bf = kernel_sm2.get_bachelor_features(col) - preds = model.predict(bf) - roc = roc_auc_score(orig, preds) - acc = (imps == orig).mean() - assert roc > 0.6 - assert acc > 0.6 - - pd.Series(preds).groupby(imps).mean() - dat = pd.DataFrame({'preds': preds, 'orig': orig, 'imps': imps}) - import seaborn as sb - fig = sb.displot(data=dat, x='preds', hue='orig') - fig.savefig('temp.png') - - iris_amp.columns[4] - # Multiclass - col = 'target' - ind = kernel_sm2.na_where[col] - orig = iris.loc[ind, col] - imps = kernel_sm2[col, 0, iterations] - model = kernel_sm2.get_model(col, 0, -1) - bf = kernel_sm2.get_bachelor_features(col) - preds = model.predict(bf) - roc = roc_auc_score(orig, preds, multi_class='ovr', average='macro') - acc = (imps == orig).mean() - assert roc > 0.7 - assert acc > 0.7 - -def test_sm2_mice_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - modeled_errors = {} - random_sample_error = {} - for col in ['sepallength(cm)', 'sepalwidth(cm)', 'petallength(cm)','petalwidth(cm)']: - ind = kernel_sm2.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - ind = kernel_sm2.na_where[col] +def get_numeric_performance(kernel, variables, iris): + r_squares = {} + iterations = kernel.iteration_count() + for col in variables: + ind = kernel.na_where[col] orig = iris.loc[ind, col] - imps = kernel_sm2[col, 0, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.loc[nonmissind, col])) - - modeled_errors[col] = mse(orig, preds[ind]) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > modeled_errors[col] - assert random_sample_error[col] > imputed_errors[col] - - iris_amp.columns - - -def test_sm1_mice_cat(): - - # Binary - col = 5 - ind = kernel_sm1.na_where[col] - orig = iris.values[ind, col] - imps = kernel_sm1[0, col, iterations] - preds = logistic_function(kernel_sm1.get_raw_prediction(col, dtype="float32")) - roc = roc_auc_score(orig, preds[ind]) - acc = (imps == orig).mean() - assert roc > 0.6 - assert acc > 0.6 - - # Multiclass - col = 4 - ind = kernel_sm1.na_where[col] - orig = iris.values[ind, col] - imps = kernel_sm1[0, col, iterations] - preds = logistic_function(kernel_sm1.get_raw_prediction(col, dtype="float32")) - roc = roc_auc_score(orig, preds[ind,:], multi_class='ovr', average='macro') - acc = (imps == orig).mean() - assert roc > 0.7 - assert acc > 0.7 - - -def test_sm1_mice_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - modeled_errors = {} - random_sample_error = {} - for col in [0,1,2,3]: - ind = kernel_sm1.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris.iloc[ind, col] - preds = kernel_sm1.get_raw_prediction(col) - imps = kernel_sm1[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) - modeled_errors[col] = mse(orig, preds[ind]) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > modeled_errors[col] - assert random_sample_error[col] > imputed_errors[col] - - -def test_shap_mice_cat(): - - # Binary - col = 5 - ind = kernel_shap.na_where[col] - orig = iris.values[ind, col] - imps = kernel_shap[0, col, iterations] - preds = kernel_shap.get_raw_prediction(col, dtype="float32") - roc = roc_auc_score(orig, logistic_function(preds[ind, :].sum(1))) - acc = (imps == orig).mean() - assert roc > 0.6 - assert acc > 0.6 + imps = kernel[col, iterations, 0] + r_squares[col] = np.corrcoef(orig, imps)[0, 1] ** 2 + r_squares = pd.Series(r_squares) + return r_squares - # Multiclass - col = 4 - ind = kernel_shap.na_where[col] - orig = iris.values[ind, col] - imps = kernel_shap[0, col, iterations] - # preds = logistic_function(kernel_shap.get_raw_prediction(col, dtype="float32")) - # roc = roc_auc_score(orig, preds[ind,:], multi_class='ovr', average='macro') - acc = (imps == orig).mean() - # assert roc > 0.7 - assert acc > 0.7 +def get_imp_mse(kernel, variables, iris): + mses = {} + iterations = kernel.iteration_count() + for col in variables: + ind = kernel.na_where[col] + orig = iris.loc[ind, col] + imps = kernel[col, iterations, 0] + mses[col] = ((orig - imps) ** 2).sum() + mses = pd.Series(mses) + return mses -def test_shap_mice_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - modeled_errors = {} - random_sample_error = {} - for col in [0,1,2,3]: - ind = kernel_shap.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris.iloc[ind, col] - preds = kernel_shap.get_raw_prediction(col).sum(1) + orig.mean() - imps = kernel_shap[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) - modeled_errors[col] = mse(orig, preds[ind]) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > modeled_errors[col] - assert random_sample_error[col] > imputed_errors[col] - - -################################ -### IMPUTE NEW DATA TESTING - -new_imp_sm2 = kernel_sm2.impute_new_data(iris_new_amp) -new_imp_sm1 = kernel_sm1.impute_new_data(iris_new_amp) -new_imp_shap = kernel_shap.impute_new_data(iris_new_amp) - - -def test_sm2_ind_cat(): - - # Binary - col = 5 - ind = new_imp_sm2.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_sm2[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.6 - - # Multiclass - col = 4 - ind = new_imp_sm2.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_sm2[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.7 - -def test_sm2_ind_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - random_sample_error = {} - for col in [0,1,2,3]: - ind = new_imp_sm2.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris_new.iloc[ind, col] - imps = new_imp_sm2[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > imputed_errors[col] - -def test_sm1_ind_cat(): - - # Binary - col = 5 - ind = new_imp_sm1.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_sm1[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.6 - - # Multiclass - col = 4 - ind = new_imp_sm1.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_sm1[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.7 - -def test_sm1_ind_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - random_sample_error = {} - for col in [0,1,2,3]: - ind = new_imp_sm1.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris_new.iloc[ind, col] - imps = new_imp_sm1[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > imputed_errors[col] - -def test_shap_ind_cat(): - - # Binary - col = 5 - ind = new_imp_shap.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_shap[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.6 - - # Multiclass - col = 4 - ind = new_imp_shap.na_where[col] - orig = iris_new.values[ind, col] - imps = new_imp_shap[0, col, iterations] - acc = (imps == orig).mean() - assert acc > 0.7 -def test_shap_ind_reg(): - # Square error of the model predictions should be less than - # if we just predicted the mean every time. - imputed_errors = {} - random_sample_error = {} - for col in [0,1,2,3]: - ind = new_imp_shap.na_where[col] - nonmissind = np.delete(range(iris.shape[0]), ind) - orig = iris_new.iloc[ind, col] - imps = new_imp_shap[0, col, iterations] - random_sample_error[col] = mse(orig, np.mean(iris.iloc[nonmissind, col])) - imputed_errors[col] = mse(orig, imps) - assert random_sample_error[col] > imputed_errors[col] +def get_mean_pred_mse(kernel: mf.ImputationKernel, variables, iris): + mses = {} + iterations = kernel.iteration_count() + for col in variables: + ind = kernel.na_where[col] + orig = iris.loc[ind, col] + target = kernel._get_nonmissing_values(col) + pred = target.mean() + mses[col] = ((orig - pred) ** 2).sum() + mses = pd.Series(mses) + return mses + + +def get_categorical_performance(kernel: mf.ImputationKernel, variables, iris): + + rocs = {} + accs = {} + rand_accs = {} + iterations = kernel.iteration_count() + for col in variables: + ind = kernel.na_where[col] + model = kernel.get_model(col, 0, -1) + cand = kernel._make_label(col, seed=model.params['seed']) + orig = iris.loc[ind, col] + imps = kernel[col, iterations, 0] + bf = kernel.get_bachelor_features(col) + preds = model.predict(bf) + rocs[col] = roc_auc_score(orig, preds, multi_class='ovr', average='macro') + accs[col] = (imps == orig).mean() + rand_accs[col] = np.sum(cand.value_counts(normalize=True) * imps.value_counts(normalize=True)) + rocs = pd.Series(rocs) + accs = pd.Series(accs) + rand_accs = pd.Series(rand_accs) + return rocs, accs, rand_accs + + +def test_defaults(): + + for i in range(10): + # i = 0 + iris, iris_amp = make_dataset(i) + kernel_1 = mf.ImputationKernel( + iris_amp, + num_datasets=1, + data_subset=0, + mean_match_candidates=3, + initialize_empty=True, + random_state=i, + ) + kernel_1.mice(4, verbose=False) + kernel_1.complete_data(0, inplace=True) + + rocs, accs, rand_accs = get_categorical_performance(kernel_1, ['bi', 'sp'], iris) + assert np.all(accs > rand_accs) + assert np.all(rocs > 0.6) + + # sw Just doesn't have the information density to pass this test reliably. + # It's definitely the hardest variable to model. + mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) + mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + assert np.all(mpses > mses) + + +def test_no_mean_match(): + + for i in range(10): + # i = 0 + iris, iris_amp = make_dataset(i) + kernel_1 = mf.ImputationKernel( + iris_amp, + num_datasets=1, + data_subset=0, + mean_match_candidates=0, + initialize_empty=True, + random_state=i, + ) + kernel_1.mice(4, verbose=False) + kernel_1.complete_data(0, inplace=True) + + rocs, accs, rand_accs = get_categorical_performance( + kernel=kernel_1, + variables=['bi', 'sp'], + iris=iris + ) + assert np.all(accs > rand_accs) + assert np.all(rocs > 0.5) + + # sw Just doesn't have the information density to pass this test reliably. + # It's definitely the hardest variable to model. + mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) + mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + assert np.all(mpses > mses) + + +def test_custom_params(): + + for i in range(10): + # i = 0 + iris, iris_amp = make_dataset(i) + kernel_1 = mf.ImputationKernel( + iris_amp, + num_datasets=1, + data_subset=0, + mean_match_candidates=1, + initialize_empty=True, + random_state=i, + ) + kernel_1.mice( + iterations=4, + verbose=False, + boosting='random_forest', + num_iterations=500, + min_data_in_leaf=15, + ) + kernel_1.complete_data(0, inplace=True) + + rocs, accs, rand_accs = get_categorical_performance( + kernel=kernel_1, + variables=['bi', 'sp'], + iris=iris + ) + assert np.all(accs > rand_accs) + assert np.all(rocs > 0.5) + + # sw Just doesn't have the information density to pass this test reliably. + # It's definitely the hardest variable to model. + mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) + mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + assert np.all(mpses > mses) diff --git a/tests/test_reproducibility.py b/tests/test_reproducibility.py index 14b526e..6abbc5a 100644 --- a/tests/test_reproducibility.py +++ b/tests/test_reproducibility.py @@ -32,23 +32,24 @@ def test_pandas_reproducibility(): datasets = 2 kernel = mf.ImputationKernel( data=iris_amp, - datasets=datasets, - initialization="random", - save_models=2, + num_datasets=datasets, + initialize_empty=False, random_state=2 ) kernel2 = mf.ImputationKernel( data=iris_amp, - datasets=datasets, - initialization="random", - save_models=2, + num_datasets=datasets, + initialize_empty=False, random_state=2 ) assert kernel.complete_data(0).equals(kernel2.complete_data(0)), ( "random_state initialization failed to be deterministic" ) + assert kernel.complete_data(1).equals(kernel2.complete_data(1)), ( + "random_state initialization failed to be deterministic" + ) # Run mice for 2 iterations kernel.mice(2) @@ -57,6 +58,9 @@ def test_pandas_reproducibility(): assert kernel.complete_data(0).equals(kernel2.complete_data(0)), ( "random_state after mice() failed to be deterministic" ) + assert kernel.complete_data(1).equals(kernel2.complete_data(1)), ( + "random_state after mice() failed to be deterministic" + ) kernel_imputed_as_new = kernel.impute_new_data( iris_amp, @@ -67,7 +71,7 @@ def test_pandas_reproducibility(): # Generate and impute new data as a reordering of original new_order = np.arange(rows) random_state.shuffle(new_order) - new_data = iris_amp.loc[new_order] + new_data = iris_amp.loc[new_order].reset_index(drop=True) new_seeds = random_seed_array[new_order] new_imputed = kernel.impute_new_data( new_data, @@ -77,7 +81,12 @@ def test_pandas_reproducibility(): # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): - reordered_kernel_completed = kernel_imputed_as_new.complete_data(dataset=0).loc[new_order] + reordered_kernel_completed = ( + kernel_imputed_as_new + .complete_data(dataset=0) + .loc[new_order] + .reset_index(drop=True) + ) new_data_completed = new_imputed.complete_data(dataset=0) assert (reordered_kernel_completed == new_data_completed).all().all(), ( @@ -86,7 +95,7 @@ def test_pandas_reproducibility(): # Generate and impute new data as a subset of original new_ind = [0,1,4,7,8,10] - new_data = iris_amp.loc[new_ind] + new_data = iris_amp.loc[new_ind].reset_index(drop=True) new_seeds = random_seed_array[new_ind] new_imputed = kernel.impute_new_data( new_data, @@ -96,7 +105,7 @@ def test_pandas_reproducibility(): # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): - reordered_kernel_completed = kernel_imputed_as_new.complete_data(dataset=0).loc[new_ind] + reordered_kernel_completed = kernel_imputed_as_new.complete_data(dataset=0).loc[new_ind].reset_index(drop=True) new_data_completed = new_imputed.complete_data(dataset=0) assert (reordered_kernel_completed == new_data_completed).all().all(), ( @@ -106,7 +115,7 @@ def test_pandas_reproducibility(): # Generate and impute new data as a reordering of original new_order = np.arange(rows) random_state.shuffle(new_order) - new_data = iris_amp.loc[new_order] + new_data = iris_amp.loc[new_order].reset_index(drop=True) new_imputed = kernel.impute_new_data( new_data, random_state=4, @@ -115,7 +124,12 @@ def test_pandas_reproducibility(): # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): - reordered_kernel_completed = kernel_imputed_as_new.complete_data(dataset=0).loc[new_order] + reordered_kernel_completed = ( + kernel_imputed_as_new + .complete_data(dataset=0) + .loc[new_order] + .reset_index(drop=True) + ) new_data_completed = new_imputed.complete_data(dataset=0) assert not (reordered_kernel_completed == new_data_completed).all().all(), ( diff --git a/tests/test_sklearn_pipeline.py b/tests/test_sklearn_pipeline.py index 1bcdffd..f47d5e8 100644 --- a/tests/test_sklearn_pipeline.py +++ b/tests/test_sklearn_pipeline.py @@ -1,17 +1,34 @@ import numpy as np from sklearn.preprocessing import StandardScaler -from sklearn.datasets import make_classification -from sklearn.model_selection import train_test_split +from sklearn.datasets import load_iris from sklearn.pipeline import Pipeline import miceforest as mf -X, y = make_classification(random_state=0) -X = mf.utils.ampute_data(X) -X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) +import pandas as pd + + +def make_dataset(seed): + + random_state = np.random.RandomState(seed) + iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) + del iris['target'] + iris.rename({ + 'sepal length (cm)': 'sl', + 'sepal width (cm)': 'sw', + 'petal length (cm)': 'pl', + 'petal width (cm)': 'pw', + }, axis=1, inplace=True) + iris_amp = mf.utils.ampute_data(iris, perc=0.20) + + return iris_amp def test_pipeline(): - kernel = mf.ImputationKernel(X_train, datasets=1) + + iris_amp_train = make_dataset(1) + iris_amp_test = make_dataset(2) + + kernel = mf.ImputationKernel(iris_amp_train, num_datasets=1) pipe = Pipeline([ ('impute', kernel), @@ -21,11 +38,11 @@ def test_pipeline(): # The pipeline can be used as any other estimator # and avoids leaking the test set into the train set X_train_t = pipe.fit_transform( - X_train, - y_train, + X=iris_amp_train, + y=None, impute__iterations=2 ) - X_test_t = pipe.transform(X_test) + X_test_t = pipe.transform(iris_amp_test) assert not np.any(np.isnan(X_train_t)) assert not np.any(np.isnan(X_test_t)) \ No newline at end of file diff --git a/tests/test_utils.py b/tests/test_utils.py index f1136d5..f15e362 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -3,23 +3,22 @@ stratified_subset ) import numpy as np +import pandas as pd def test_subset(): strat_std_closer = [] strat_mean_closer = [] for i in range(1000): - y = np.random.normal(size=1000) + y = pd.Series(np.random.normal(size=1000)) size = 100 - y_strat_sub = y[ - stratified_subset( - y, - size, - groups=10, - cat=False, - seed=i - ) - ] + ss_ind = stratified_subset( + y, + size, + groups=10, + random_state=i + ) + y_strat_sub = y[ss_ind] y_rand_sub = np.random.choice(y, size, replace=False) # See which random sample has a closer stdev @@ -42,11 +41,11 @@ def test_subset(): def test_subset_continuous_reproduce(): # Tests for reproducibility in numeric stratified subsetting for i in range(100): - y = np.random.normal(size=1000) + y = pd.Series(np.random.normal(size=1000)) size = 100 - ss1 = stratified_subset(y, size, groups=10, cat=False, seed=i) - ss2 = stratified_subset(y, size, groups=10, cat=False, seed=i) + ss1 = stratified_subset(y, size, groups=10, random_state=i) + ss2 = stratified_subset(y, size, groups=10, random_state=i) assert np.all(ss1 == ss2) @@ -54,10 +53,10 @@ def test_subset_continuous_reproduce(): def test_subset_categorical_reproduce(): # Tests for reproducibility in categorical stratified subsetting for i in range(100): - y = np.random.randint(low=1, high=10, size=1000) + y = pd.Series(np.random.randint(low=1, high=10, size=1000)).astype('category') size = 100 - ss1 = stratified_subset(y, size, groups=10, cat=True, seed=i) - ss2 = stratified_subset(y, size, groups=10, cat=True, seed=i) + ss1 = stratified_subset(y, size, groups=10, random_state=i) + ss2 = stratified_subset(y, size, groups=10, random_state=i) assert np.all(ss1 == ss2) \ No newline at end of file From efcaabaea5b10cf7bc2d2f0954d8dd535dd08b01 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sat, 20 Jul 2024 20:33:38 -0400 Subject: [PATCH 05/44] Now readme --- README.Rmd | 797 ------------------------------------- README.ipynb | 236 +++++++++++ README.md | 1073 -------------------------------------------------- 3 files changed, 236 insertions(+), 1870 deletions(-) delete mode 100644 README.Rmd create mode 100644 README.ipynb delete mode 100644 README.md diff --git a/README.Rmd b/README.Rmd deleted file mode 100644 index 11ab09e..0000000 --- a/README.Rmd +++ /dev/null @@ -1,797 +0,0 @@ ---- -output: github_document -always_allow_html: true ---- -```{r EDITPATH,include=FALSE} -library(knitr) -opts_chunk$set(engine.path = "C:/Users/swilson/virtual_environments/3.9.6/Scripts/python.exe") -initlines = readLines(file("miceforest/__init__.py")) -initlines = initlines[grep("__version__", initlines)] -vrzn = gsub("\"","",gsub("__version__ = ","",initlines)) -``` - -[![DOI](https://zenodo.org/badge/289387436.svg)](https://zenodo.org/badge/latestdoi/289387436) -[![Downloads](https://static.pepy.tech/badge/miceforest)](https://pepy.tech/project/miceforest) -[![Pypi](https://img.shields.io/pypi/v/miceforest.svg)](https://pypi.python.org/pypi/miceforest) -[![Conda Version](https://img.shields.io/conda/vn/conda-forge/miceforest.svg)](https://anaconda.org/conda-forge/miceforest) -[![PyVersions](https://img.shields.io/pypi/pyversions/miceforest.svg?logo=python&logoColor=white)](https://pypi.org/project/miceforest/) -[![tests + mypy](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml) -[![Documentation Status](https://readthedocs.org/projects/miceforest/badge/?version=latest)](https://miceforest.readthedocs.io/en/latest/?badge=latest) -[![CodeCov](https://codecov.io/gh/AnotherSamWilson/miceforest/branch/master/graphs/badge.svg?branch=master&service=github)](https://codecov.io/gh/AnotherSamWilson/miceforest) - - - - - - -## miceforest: Fast, Memory Efficient Imputation with LightGBM - - - -Fast, memory efficient Multiple Imputation by Chained Equations (MICE) with lightgbm. The R version of this package may be found [here](https://github.com/FarrellDay/miceRanger). - -`miceforest` was designed to be: - -* **Fast** - * Uses lightgbm as a backend - * Has efficient mean matching solutions. - * Can utilize GPU training -* **Flexible** - * Can impute pandas dataframes and numpy arrays - * Handles categorical data automatically - * Fits into a sklearn pipeline - * User can customize every aspect of the imputation process -* **Production Ready** - * Can impute new, unseen datasets quickly - * Kernels are efficiently compressed during saving and loading - * Data can be imputed in place to save memory - * Can build models on non-missing data - - - -This document contains a thorough walkthrough of the package, benchmarks, and an introduction to multiple imputation. More information on MICE can be found in Stef van Buuren's excellent online book, which you can find [here](https://stefvanbuuren.name/fimd/ch-introduction.html). - - - - -#### Table of Contents: -* [Package Meta](https://github.com/AnotherSamWilson/miceforest#Package-Meta) -* [The Basics](https://github.com/AnotherSamWilson/miceforest#The-Basics) - + [Basic Examples](https://github.com/AnotherSamWilson/miceforest#Basic-Examples) - + [Customizing LightGBM Parameters](https://github.com/AnotherSamWilson/miceforest#Customizing-LightGBM-Parameters) - + [Available Mean Match Schemes](https://github.com/AnotherSamWilson/miceforest#Controlling-Tree-Growth) - + [Imputing New Data with Existing Models](https://github.com/AnotherSamWilson/miceforest#Imputing-New-Data-with-Existing-Models) - + [Saving and Loading Kernels](https://github.com/AnotherSamWilson/miceforest#Saving-and-Loading-Kernels) - + [Implementing sklearn Pipelines](https://github.com/AnotherSamWilson/miceforest#Implementing-sklearn-Pipelines) -* [Advanced Features](https://github.com/AnotherSamWilson/miceforest#Advanced-Features) - + [Customizing the Imputation Process](https://github.com/AnotherSamWilson/miceforest#Customizing-the-Imputation-Process) - + [Building Models on Nonmissing Data](https://github.com/AnotherSamWilson/miceforest#Building-Models-on-Nonmissing-Data) - + [Tuning Parameters](https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters) - + [On Reproducibility](https://github.com/AnotherSamWilson/miceforest#On-Reproducibility) - + [How to Make the Process Faster](https://github.com/AnotherSamWilson/miceforest#How-to-Make-the-Process-Faster) - + [Imputing Data In Place](https://github.com/AnotherSamWilson/miceforest#Imputing-Data-In-Place) -* [Diagnostic Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting) - + [Imputed Distributions](https://github.com/AnotherSamWilson/miceforest#Distribution-of-Imputed-Values) - + [Correlation Convergence](https://github.com/AnotherSamWilson/miceforest#Convergence-of-Correlation) - + [Variable Importance](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) - + [Mean Convergence](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) -* [Benchmarks](https://github.com/AnotherSamWilson/miceforest#Benchmarks) -* [Using the Imputed Data](https://github.com/AnotherSamWilson/miceforest#Using-the-Imputed-Data) -* [The MICE Algorithm](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) - + [Introduction](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) - + [Common Use Cases](https://github.com/AnotherSamWilson/miceforest#Common-Use-Cases) - + [Predictive Mean Matching](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) - + [Effects of Mean Matching](https://github.com/AnotherSamWilson/miceforest#Effects-of-Mean-Matching) - - -## Package Meta - - -### Installation -This package can be installed using either pip or conda, through conda-forge: - -``` {bash INSTALL1,eval=FALSE} -# Using pip -$ pip install miceforest --no-cache-dir - -# Using conda -$ conda install -c conda-forge miceforest -``` - -You can also download the latest development version from this -repository. If you want to install from github with conda, you -must first run ```conda install pip git```. - -``` {bash INSTALL2,eval=FALSE} -$ pip install git+https://github.com/AnotherSamWilson/miceforest.git -``` - -### Classes -miceforest has 3 main classes which the user will interact with: - -* [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) - This class contains the raw data off of which the `mice` algorithm is performed. During this process, models will be trained, and the imputed (predicted) values will be stored. These values can be used to fill in the missing values of the raw data. The raw data can be copied, or referenced directly. Models can be saved, and used to impute new datasets. -* [`ImputedData`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputedData.html#miceforest.ImputedData) - The result of `ImputationKernel.impute_new_data(new_data)`. This contains the raw data in `new_data` as well as the imputed values. -* [`MeanMatchScheme`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.MeanMatchScheme.html#miceforest.MeanMatchScheme) - Determines how mean matching should be carried out. There are 3 built-in mean match schemes available in miceforest, discussed below. - -## The Basics - -We will be looking at a few simple examples of -imputation. We need to load the packages, and define the data: - -``` {python SETUP} -import miceforest as mf -from sklearn.datasets import load_iris -import pandas as pd -import numpy as np - -# Load data and introduce missing values -iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1) -iris.rename({"target": "species"}, inplace=True, axis=1) -iris['species'] = iris['species'].astype('category') -iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991) -``` - - -### Basic Examples -If you only want to create a single imputed dataset, you can use [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) with some default settings: -``` {python SIMPLESINGLE} -# Create kernel. -kds = mf.ImputationKernel( - iris_amp, - save_all_iterations=True, - random_state=1991 -) - -# Run the MICE algorithm for 2 iterations -kds.mice(2) - -# Return the completed dataset. -iris_complete = kds.complete_data() -``` -There are also an array of plotting functions available, these are discussed below in the section [Diagnostic Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting). - - -We usually don't want to impute just a single dataset. In statistics, multiple imputation is a process by which the uncertainty/other effects caused by missing values can be examined by creating multiple different imputed datasets. [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) can contain an arbitrary number of different datasets, all of which have gone through mutually exclusive imputation processes: -``` {python SIMPLEMULTI} -# Create kernel. -kernel = mf.ImputationKernel( - iris_amp, - datasets=4, - save_all_iterations=True, - random_state=1 -) - -# Run the MICE algorithm for 2 iterations on each of the datasets -kernel.mice(2) - -# Printing the kernel will show you some high level information. -print(kernel) -``` - -After we have run mice, we can obtain our completed dataset directly from the kernel: -``` {python COMPLETE_NOCOPY} -completed_dataset = kernel.complete_data(dataset=2) -print(completed_dataset.isnull().sum(0)) -``` - -### Customizing LightGBM Parameters -Parameters can be passed directly to lightgbm in several different ways. Parameters you wish to apply globally to every model can simply be passed as kwargs to `mice`: -``` {python TREEGROWTH} -# Run the MICE algorithm for 1 more iteration on the kernel with new parameters -kernel.mice(iterations=1,n_estimators=50) -``` - -You can also pass pass variable-specific arguments to `variable_parameters` in mice. For instance, let's say you noticed the imputation of the `[species]` column was taking a little longer, because it is multiclass. You could decrease the n_estimators specifically for that column with: -``` {python TREEGROWTH2} -# Run the MICE algorithm for 2 more iterations on the kernel -kernel.mice( - iterations=1, - variable_parameters={'species': {'n_estimators': 25}}, - n_estimators=50 -) - -# Let's get the actual models for these variables: -species_model = kernel.get_model(dataset=0,variable="species") -sepalwidth_model = kernel.get_model(dataset=0,variable="sepal width (cm)") - -print( -f"""Species used {str(species_model.params["num_iterations"])} iterations -Sepal Width used {str(sepalwidth_model.params["num_iterations"])} iterations -""" -) -``` - -In this scenario, any parameters specified in `variable_parameters` takes presidence over the kwargs. - -Since we can pass any parameters we want to LightGBM, we can completely customize how our models are built. That includes how the data should be modeled. If your data contains count data, or any other data which can be parameterized by lightgbm, you can simply specify that variable to be modeled with the corresponding objective function. - -For example, let's pretend `sepal width (cm)` is a count field which can be parameterized by a Poisson distribution. Let's also change our boosting method to gradient boosted trees: -``` {python DIFFOBJECTIVE} -# Create kernel. -cust_kernel = mf.ImputationKernel( - iris_amp, - datasets=1, - random_state=1 -) - -cust_kernel.mice( - iterations=1, - variable_parameters={'sepal width (cm)': {'objective': 'poisson'}}, - boosting = 'gbdt', - min_sum_hessian_in_leaf=0.01 -) -``` - -Other nice parameters like `monotone_constraints` can also be passed. Setting the parameter `device: 'gpu'` will utilize GPU learning, if LightGBM is set up to do this on your machine. - - -### Available Mean Match Schemes - -Note: It is probably a good idea to read [this section](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) first, to get some context on how mean matching works. - -The class `miceforest.MeanMatchScheme` contains information about how mean matching should be performed, such as: - -1) Mean matching functions -2) Mean matching candidates -3) How to get predictions from a lightgbm model -4) The datatypes predictions are stored as - -There are three pre-built mean matching schemes that come with `miceforest`: -``` {python MMS} -from miceforest import ( - mean_match_default, - mean_match_fast_cat, - mean_match_shap -) - -# To get information for each, use help() -# help(mean_match_default) -``` - -These schemes mostly differ in their strategy for performing mean matching - -* **mean_match_default** - medium speed, medium imputation quality - * Categorical: perform a K Nearest Neighbors search on the candidate class probabilities, where K = mmc. Select 1 at random, and choose the associated candidate value as the imputation value. - * Numeric: Perform a K Nearest Neighbors search on the candidate predictions, where K = mmc. Select 1 at random, and choose the associated candidate value as the imputation value. -* **mean_match_fast_cat** - fastest speed, lowest imputation quality - * Categorical: return class based on random draw weighted by class probability for each sample. - * Numeric: perform a K Nearest Neighbors search on the candidate class probabilities, where K = mmc. Select 1 at random, and choose the associated candidate value as the imputation value. -* **mean_match_shap** - slowest speed, highest imputation quality for large datasets - * Categorical: perform a K Nearest Neighbors search on the candidate prediction shap values, where K = mmc. Select 1 at random, and choose the associated candidate value as the imputation value. - * Numeric: perform a K Nearest Neighbors search on the candidate prediction shap values, where K = mmc. Select 1 at random, and choose the associated candidate value as the imputation value. - -As a special case, if the mean_match_candidates is set to 0, the following behavior is observed for all schemes: - -* Categorical: the class with the highest probability is chosen. -* Numeric: the predicted value is used - -These mean matching schemes can be updated and customized, we show an example below in the advanced section. - -### Imputing New Data with Existing Models - -Multiple Imputation can take a long time. If you wish to impute a -dataset using the MICE algorithm, but don’t have time to train new -models, it is possible to impute new datasets using a `ImputationKernel` object. -The `impute_new_data()` function uses the models collected by `ImputationKernel` -to perform multiple imputation without updating the models at -each iteration: - -``` {python IMPUTENEWDATA} -# Our 'new data' is just the first 15 rows of iris_amp -from datetime import datetime - -# Define our new data as the first 15 rows -new_data = iris_amp.iloc[range(15)] - -# Imputing new data can often be made faster by -# first compiling candidate predictions -kernel.compile_candidate_preds() - -start_t = datetime.now() -new_data_imputed = kernel.impute_new_data(new_data=new_data) -print(f"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds") -``` - -All of the imputation parameters (variable_schema, mean_match_candidates, etc) will be -carried over from the original `ImputationKernel` object. When mean matching, -the candidate values are pulled from the original kernel dataset. To impute new data, -the ```save_models``` parameter in ```ImputationKernel``` must be > 0. If -```save_models == 1```, the model from the latest iteration is saved for each variable. -If ```save_models > 1```, the model from each iteration is saved. This allows for new -data to be imputed in a more similar fashion to the original mice procedure. - - -### Saving and Loading Kernels - -Kernels can be saved using the `.save_kernel()` method, and then loaded again using the `utils.load_kernel()` function. Internally, this procedure uses `blosc2` and `dill` packages to do the following: - -1. Convert working data to parquet bytes (if it is a pandas dataframe) -2. Serialize the kernel -3. Compress this serialization -4. Save to a file - -### Implementing sklearn Pipelines - -kernels can be fit into sklearn pipelines to impute training and scoring datasets: - -``` {python PIPELINE} -import numpy as np -from sklearn.preprocessing import StandardScaler -from sklearn.datasets import make_classification -from sklearn.model_selection import train_test_split -from sklearn.pipeline import Pipeline -import miceforest as mf - -# Define our data -X, y = make_classification(random_state=0) - -# Ampute and split the training data -X = mf.utils.ampute_data(X) -X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) - -# Initialize our miceforest kernel. datasets parameter should be 1, -# we don't want to return multiple datasets. -pipe_kernel = mf.ImputationKernel(X_train, datasets=1) - -# Define our pipeline -pipe = Pipeline([ - ('impute', pipe_kernel), - ('scaler', StandardScaler()), -]) - -# Fit on and transform our training data. -# Only use 2 iterations of mice. -X_train_t = pipe.fit_transform( - X_train, - y_train, - impute__iterations=2 -) - -# Transform the test data as well -X_test_t = pipe.transform(X_test) - -# Show that neither now have missing values. -assert not np.any(np.isnan(X_train_t)) -assert not np.any(np.isnan(X_test_t)) -``` - - -## Advanced Features -Multiple imputation is a complex process. However, `miceforest` allows all of the major components to be switched out and customized by the user. - -### Customizing the Imputation Process - -It is possible to heavily customize our imputation procedure by variable. By -passing a named list to `variable_schema`, you can specify the predictor -variables for each imputed variable. You can also specify `mean_match_candidates` -and `data_subset` by variable by passing a dict of valid values, with variable -names as keys. You can even replace the entire default mean matching function -for certain objectives if desired. Below is an _extremely_ convoluted setup, -which you would probably never want to use. It simply shows what is possible: - -``` {python CUSTOMSCHEMA} -# Use the default mean match schema as our base -from miceforest import mean_match_default -mean_match_custom = mean_match_default.copy() - -# Define a mean matching function that -# just randomly shuffles the predictions -def custom_mmf(bachelor_preds): - np.random.shuffle(bachelor_preds) - return bachelor_preds - -# Specify that our custom function should be -# used to perform mean matching on any variable -# that was modeled with a poisson objective: -mean_match_custom.set_mean_match_function( - {"poisson": custom_mmf} -) - -# Set the mean match candidates by variable -mean_match_custom.set_mean_match_candidates( - { - 'sepal width (cm)': 3, - 'petal width (cm)': 0 - } -) - -# Define which variables should be used to model others -variable_schema = { - 'sepal width (cm)': ['species','petal width (cm)'], - 'petal width (cm)': ['species','sepal length (cm)'] -} - -# Subset the candidate data to 50 rows for sepal width (cm). -variable_subset = { - 'sepal width (cm)': 50 -} - -# Specify that petal width (cm) should be modeled by the -# poisson objective. Our custom mean matching function -# above will be used for this variable. -variable_parameters = { - 'petal width (cm)': {"objective": "poisson"} -} - -cust_kernel = mf.ImputationKernel( - iris_amp, - datasets=3, - mean_match_scheme=mean_match_custom, - variable_schema=variable_schema, - data_subset=variable_subset -) -cust_kernel.mice(iterations=1, variable_parameters=variable_parameters) -``` - -The mean matching function can take any number of the following arguments. If a function does not take one of these arguments, then the process will not prepare that data for mean matching. -```{python MEANMATCHARGS} -from miceforest.MeanMatchScheme import AVAILABLE_MEAN_MATCH_ARGS -print("\n".join(AVAILABLE_MEAN_MATCH_ARGS)) -``` - -### Building Models on Nonmissing Data -The MICE process itself is used to impute missing data in a dataset. However, sometimes a variable can be fully recognized in the training data, but needs to be imputed later on in a different dataset. It is possible to train models to impute variables even if they have no missing values by setting `train_nonmissing=True`. In this case, `variable_schema` is treated as the list of variables to train models on. `imputation_order` only affects which variables actually have their values imputed, it does not affect which variables have models trained: -``` {python TRAIN_NONMISSING} -orig_missing_cols = ["sepal length (cm)", "sepal width (cm)"] -new_missing_cols = ["sepal length (cm)", "sepal width (cm)", "species"] - -# Training data only contains 2 columns with missing data -iris_amp2 = iris.copy() -iris_amp2[orig_missing_cols] = mf.ampute_data( - iris_amp2[orig_missing_cols], - perc=0.25, - random_state=1991 -) - -# Specify that models should also be trained for species column -var_sch = new_missing_cols - -cust_kernel = mf.ImputationKernel( - iris_amp2, - datasets=1, - variable_schema=var_sch, - train_nonmissing=True -) -cust_kernel.mice(1) - -# New data has missing values in species column -iris_amp2_new = iris.iloc[range(10),:].copy() -iris_amp2_new[new_missing_cols] = mf.ampute_data( - iris_amp2_new[new_missing_cols], - perc=0.25, - random_state=1991 -) - -# Species column can still be imputed -iris_amp2_new_imp = cust_kernel.impute_new_data(iris_amp2_new) -iris_amp2_new_imp.complete_data(0).isnull().sum() -``` - -Here, we knew that the species column in our new data would need to be imputed. Therefore, we specified that a model should be built for all 3 variables in the `variable_schema` (passing a dict of target - feature pairs would also have worked). - - -### Tuning Parameters -`miceforest` allows you to tune the parameters on a kernel dataset. These parameters can then be used to build the models in future iterations of mice. In its most simple invocation, you can just call the function with the desired optimization steps: -``` {python TUNEPARAMETERS} -# Using the first ImputationKernel in kernel to tune parameters -# with the default settings. -optimal_parameters, losses = kernel.tune_parameters( - dataset=0, - optimization_steps=5 -) - -# Run mice with our newly tuned parameters. -kernel.mice(1, variable_parameters=optimal_parameters) - -# The optimal parameters are kept in ImputationKernel.optimal_parameters: -print(optimal_parameters) -``` -This will perform 10 fold cross validation on random samples of parameters. By default, all variables models are tuned. If you are curious about the default parameter space that is searched within, check out the `miceforest.default_lightgbm_parameters` module. - -The parameter tuning is pretty flexible. If you wish to set some model parameters static, or to change the bounds that are searched in, you can simply pass this information to either the `variable_parameters` parameter, `**kwbounds`, or both: -``` {python TUNEPARAMETERS2} -# Using a complicated setup: -optimal_parameters, losses = kernel.tune_parameters( - dataset=0, - variables = ['sepal width (cm)','species','petal width (cm)'], - variable_parameters = { - 'sepal width (cm)': {'bagging_fraction': 0.5}, - 'species': {'bagging_freq': (5,10)} - }, - optimization_steps=5, - extra_trees = [True, False] -) - -kernel.mice(1, variable_parameters=optimal_parameters) - -``` -In this example, we did a few things - we specified that only `sepal width (cm)`, `species`, and `petal width (cm)` should be tuned. We also specified some specific parameters in `variable_parameters.` Notice that `bagging_fraction` was passed as a scalar, `0.5`. This means that, for the variable `sepal width (cm)`, the parameter `bagging_fraction` will be set as that number and not be tuned. We did the opposite for `bagging_freq`. We specified bounds that the process should search in. We also passed the argument `extra_trees` as a list. Since it was passed to **kwbounds, this parameter will apply to all variables that are being tuned. Passing values as a list tells the process that it should randomly sample values from the list, instead of treating them as set of counts to search within. - -The tuning process follows these rules for different parameter values it finds: - -* Scalar: That value is used, and not tuned. -* Tuple: Should be length 2. Treated as the lower and upper bound to search in. -* List: Treated as a distinct list of values to try randomly. - -### On Reproducibility -`miceforest` allows for different "levels" of reproducibility, global and record-level. - -##### **Global Reproducibility** -Global reproducibility ensures that the same values will be imputed if the same code is run multiple times. To ensure global reproducibility, all the user needs to do is set a `random_state` when the kernel is initialized. - -##### **Record-Level Reproducibility** -Sometimes we want to obtain reproducible imputations at the record level, without having to pass the same dataset. This is possible by passing a list of record-specific seeds to the `random_seed_array` parameter. This is useful if imputing new data multiple times, and you would like imputations for each row to match each time it is imputed. -``` {python REPRODUCE_SEEDS} -# Define seeds for the data, and impute iris -random_seed_array = np.random.randint(9999, size=150) -iris_imputed = kernel.impute_new_data( - iris_amp, - random_state=4, - random_seed_array=random_seed_array -) - -# Select a random sample -new_inds = np.random.choice(150, size=15) -new_data = iris_amp.loc[new_inds] -new_seeds = random_seed_array[new_inds] -new_imputed = kernel.impute_new_data( - new_data, - random_state=4, - random_seed_array=new_seeds -) - -# We imputed the same values for the 15 values each time, -# because each record was associated with the same seed. -assert new_imputed.complete_data(0).equals(iris_imputed.complete_data(0).loc[new_inds]) - -``` - -Note that record-level reproducibility is only possible in the `impute_new_data` function, there are no guarantees of record-level reproducibility in imputations between the kernel and new data. - -### How to Make the Process Faster -Multiple Imputation is one of the most robust ways to handle missing data - but it can take a long time. There are several strategies you can use to decrease the time a process takes to run: - -* Decrease `data_subset`. By default all non-missing datapoints for each variable are used to train the model and perform mean matching. This can cause the model training nearest-neighbors search to take a long time for large data. A subset of these points can be searched instead by using `data_subset`. -* If categorical columns are taking a long time, you can use the `mean_match_fast_cat` scheme. You can also set different parameters specifically for categorical columns, like smaller `bagging_fraction` or `num_iterations`. -* If you need to impute new data faster, compile the predictions with the `compile_candidate_preds` method. This stores the predictions for each model, so it does not need to be re-calculated at each iteration. -* Convert your data to a numpy array. Numpy arrays are much faster to index. While indexing overhead is avoided as much as possible, there is no getting around it. Consider comverting to `float32` datatype as well, as it will cause the resulting object to take up much less memory. -* Decrease `mean_match_candidates`. The maximum number of neighbors that are considered with the default parameters is 10. However, for large datasets, this can still be an expensive operation. Consider explicitly setting `mean_match_candidates` lower. -* Use different lightgbm parameters. lightgbm is usually not the problem, however if a certain variable has a large number of classes, then the max number of trees actually grown is (# classes) * (n_estimators). You can specifically decrease the bagging fraction or n_estimators for large multi-class variables, or grow less trees in general. -* Use a faster mean matching function. The default mean matching function uses the scipy.Spatial.KDtree algorithm. There are faster alternatives out there, if you think mean matching is the holdup. - - -### Imputing Data In Place -It is possible to run the entire process without copying the dataset. If `copy_data=False`, then the data is referenced directly: -```{python IMPUTE_NOCOPY} -kernel_inplace = mf.ImputationKernel( - iris_amp, - datasets=1, - copy_data=False -) -kernel_inplace.mice(2) -``` -Note, that this probably won't (but could) change the original dataset in undesirable ways. Throughout the `mice` procedure, imputed values are stored directly in the original data. At the end, the missing values are put back as `np.NaN`. - -We can also complete our original data in place: -```{python COMPLETE_REFERENCE} -kernel_inplace.complete_data(dataset=0, inplace=True) -print(iris_amp.isnull().sum(0)) -``` -This is useful if the dataset is large, and copies can't be made in memory. - -## Diagnostic Plotting - -As of now, miceforest has four diagnostic plots available. - -### Distribution of Imputed-Values -We probably want to know how the imputed values are distributed. We can -plot the original distribution beside the imputed distributions in each -dataset by using the `plot_imputed_distributions` method of an -`ImputationKernel` object: -``` {python PLOT_DIST,eval=FALSE} -kernel.plot_imputed_distributions(wspace=0.3,hspace=0.3) -``` -```{r,eval=TRUE,echo=FALSE,out.width="600px"} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/distributions.png") -``` - -The red line is the original data, and each black line are the imputed -values of each dataset. - -### Convergence of Correlation - -We are probably interested in knowing how our values between datasets -converged over the iterations. The `plot_correlations` method shows you -a boxplot of the correlations between imputed values in every -combination of datasets, at each iteration. This allows you to see how -correlated the imputations are between datasets, as well as the convergence -over iterations: - -``` {python PLOT_CORRCONVERGENCE,eval=FALSE} -kernel.plot_correlations() -``` -```{r,eval=TRUE,echo=FALSE,out.width="600px"} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/plot_corr.png") -``` - -### Variable Importance -We also may be interested in which variables were used to impute each variable. We can -plot this information by using the `plot_feature_importance` method. -``` {python PLOT_FEATIMP,eval=FALSE} -kernel.plot_feature_importance(dataset=0, annot=True,cmap="YlGnBu",vmin=0, vmax=1) -``` -```{r,eval=TRUE,echo=FALSE,out.width="600px"} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/var_imp.png") -``` - -The numbers shown are returned from the `lightgbm.Booster.feature_importance()` function. Each square represents the importance of the column variable in imputing the row variable. - -### Mean Convergence -If our data is not missing completely at random, we may see that it takes a few iterations for our models to get the distribution of imputations right. -We can plot the average value of our imputations to see if this is occurring: -``` {python PLOT_MEANCON,eval=FALSE} -kernel.plot_mean_convergence(wspace=0.3, hspace=0.4) -``` -```{r,eval=TRUE,echo=FALSE,out.width="600px"} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/mean_convergence.png") -``` - -Our data was missing completely at random, so we don't see any convergence occurring here. - -## Using the Imputed Data - -To return the imputed data simply use the `complete_data` method: -```{python completeData} -dataset_1 = kernel.complete_data(0) -``` -This will return a single specified dataset. Multiple datasets are typically created so that -some measure of confidence around each prediction can be created. - -Since we know what the original data looked like, we can cheat and see how well the imputations -compare to the original data: -```{python IMP_PERFORMANCE} -acclist = [] -for iteration in range(kernel.iteration_count()+1): - species_na_count = kernel.na_counts[4] - compdat = kernel.complete_data(dataset=0,iteration=iteration) - - # Record the accuract of the imputations of species. - acclist.append( - round(1-sum(compdat['species'] != iris['species'])/species_na_count,2) - ) - -# acclist shows the accuracy of the imputations -# over the iterations. -print(acclist) -``` -In this instance, we went from a low accuracy (what is expected with random sampling) to a much higher accuracy. - - -## The MICE Algorithm -Multiple Imputation by Chained Equations 'fills in' (imputes) missing data in a dataset through an iterative series of predictive models. In each iteration, each specified variable in the dataset is imputed using the other variables in the dataset. These iterations should be run until it appears that convergence has been met. - - -```{r eval=TRUE,echo=FALSE,fig.align='center'} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/MICEalgorithm.png") -``` - -This process is continued until all specified variables have been imputed. Additional iterations can be run if it appears that the average imputed values have not converged, although no more than 5 iterations are usually necessary. - - -### Common Use Cases -##### **Data Leakage:** -MICE is particularly useful if missing values are associated with the target variable in a way that introduces leakage. For instance, let's say you wanted to model customer retention at the time of sign up. A certain variable is collected at sign up or 1 month after sign up. The absence of that variable is a data leak, since it tells you that the customer did not retain for 1 month. - -##### **Funnel Analysis:** -Information is often collected at different stages of a 'funnel'. MICE can be used to make educated guesses about the characteristics of entities at different points in a funnel. - -##### **Confidence Intervals:** -MICE can be used to impute missing values, however it is important to keep in mind that these imputed values are a prediction. Creating multiple datasets with different imputed values allows you to do two types of inference: - -* Imputed Value Distribution: A profile can be built for each imputed value, allowing you to make statements about the likely distribution of that value. -* Model Prediction Distribution: With multiple datasets, you can build multiple models and create a distribution of predictions for each sample. Those samples with imputed values which were not able to be imputed with much confidence would have a larger variance in their predictions. - - -### Predictive Mean Matching -```miceforest``` can make use of a procedure called predictive mean matching (PMM) to select which values are imputed. PMM involves selecting a datapoint from the original, nonmissing data (candidates) which has a predicted value close to the predicted value of the missing sample (bachelors). The closest N (```mean_match_candidates``` parameter) values are selected, from which a value is chosen at random. This can be specified on a column-by-column basis. Going into more detail from our example above, we see how this works in practice: - - -```{r eval=TRUE,echo=FALSE,fig.align='center'} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/PMM.png") -``` - - -This method is very useful if you have a variable which needs imputing which has any of the following characteristics: - -* Multimodal -* Integer -* Skewed - -### Effects of Mean Matching -As an example, let's construct a dataset with some of the above characteristics: -```{python FAKEDATA, fig.height = 8, fig.width = 8,eval=FALSE} -randst = np.random.RandomState(1991) -# random uniform variable -nrws = 1000 -uniform_vec = randst.uniform(size=nrws) - -def make_bimodal(mean1,mean2,size): - bimodal_1 = randst.normal(size=nrws, loc=mean1) - bimodal_2 = randst.normal(size=nrws, loc=mean2) - bimdvec = [] - for i in range(size): - bimdvec.append(randst.choice([bimodal_1[i], bimodal_2[i]])) - return np.array(bimdvec) - -# Make 2 Bimodal Variables -close_bimodal_vec = make_bimodal(2,-2,nrws) -far_bimodal_vec = make_bimodal(3,-3,nrws) - - -# Highly skewed variable correlated with Uniform_Variable -skewed_vec = np.exp(uniform_vec*randst.uniform(size=nrws)*3) + randst.uniform(size=nrws)*3 - -# Integer variable correlated with Close_Bimodal_Variable and Uniform_Variable -integer_vec = np.round(uniform_vec + close_bimodal_vec/3 + randst.uniform(size=nrws)*2) - -# Make a DataFrame -dat = pd.DataFrame( - { - 'uniform_var':uniform_vec, - 'close_bimodal_var':close_bimodal_vec, - 'far_bimodal_var':far_bimodal_vec, - 'skewed_var':skewed_vec, - 'integer_var':integer_vec - } -) - -# Ampute the data. -ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst) - -# Plot the original data -import seaborn as sns -import matplotlib.pyplot as plt -g = sns.PairGrid(dat) -g.map(plt.scatter,s=5) -``` -```{r eval=TRUE,echo=FALSE,fig.align='center',out.width='600px'} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/dataset.png") -``` -We can see how our variables are distributed and correlated in the graph above. Now let's run our imputation process twice, once using mean matching, and once using the model prediction. -```{python, eval=FALSE} -from miceforest import mean_match_default -scheme_mmc_0 = mean_match_default.copy() -scheme_mmc_5 = mean_match_default.copy() - -scheme_mmc_0.set_mean_match_candidates(0) -scheme_mmc_5.set_mean_match_candidates(5) - -kernelmeanmatch = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_5, datasets=1) -kernelmodeloutput = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_0, datasets=1) - -kernelmeanmatch.mice(2) -kernelmodeloutput.mice(2) -``` - -Let's look at the effect on the different variables. - -##### With Mean Matching -```{python,eval=FALSE} -kernelmeanmatch.plot_imputed_distributions(wspace=0.2,hspace=0.4) -``` -```{r eval=TRUE,echo=FALSE,fig.align='center',out.width='600px'} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/meanmatcheffects.png") -``` - -##### Without Mean Matching -``` {python,eval=FALSE} -kernelmodeloutput.plot_imputed_distributions(wspace=0.2,hspace=0.4) -``` -```{r eval=TRUE,echo=FALSE,fig.align='center',out.width='600px'} -knitr::include_graphics("https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/nomeanmatching.png") -``` - -You can see the effects that mean matching has, depending on the distribution of the data. -Simply returning the value from the model prediction, while it may provide a better 'fit', -will not provide imputations with a similair distribution to the original. This may be -beneficial, depending on your goal. \ No newline at end of file diff --git a/README.ipynb b/README.ipynb new file mode 100644 index 0000000..f16e471 --- /dev/null +++ b/README.ipynb @@ -0,0 +1,236 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![DOI](https://zenodo.org/badge/289387436.svg)](https://zenodo.org/badge/latestdoi/289387436)\n", + "[![Downloads](https://static.pepy.tech/badge/miceforest)](https://pepy.tech/project/miceforest)\n", + "[![Pypi](https://img.shields.io/pypi/v/miceforest.svg)](https://pypi.python.org/pypi/miceforest)\n", + "[![Conda\n", + "Version](https://img.shields.io/conda/vn/conda-forge/miceforest.svg)](https://anaconda.org/conda-forge/miceforest)\n", + "[![PyVersions](https://img.shields.io/pypi/pyversions/miceforest.svg?logo=python&logoColor=white)](https://pypi.org/project/miceforest/) \n", + "[![tests +\n", + "mypy](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml)\n", + "[![Documentation\n", + "Status](https://readthedocs.org/projects/miceforest/badge/?version=latest)](https://miceforest.readthedocs.io/en/latest/?badge=latest)\n", + "[![CodeCov](https://codecov.io/gh/AnotherSamWilson/miceforest/branch/master/graphs/badge.svg?branch=master&service=github)](https://codecov.io/gh/AnotherSamWilson/miceforest)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# miceforest: Fast, Memory Efficient Imputation with LightGBM" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Fast, memory efficient Multiple Imputation by Chained Equations (MICE)\n", + "with lightgbm. The R version of this package may be found\n", + "[here](https://github.com/FarrellDay/miceRanger).\n", + "\n", + "`miceforest` was designed to be:\n", + "\n", + " - **Fast**\n", + " - Uses lightgbm as a backend\n", + " - Has efficient mean matching solutions.\n", + " - Can utilize GPU training\n", + " - **Flexible**\n", + " - Can impute pandas dataframes and numpy arrays\n", + " - Handles categorical data automatically\n", + " - Fits into a sklearn pipeline\n", + " - User can customize every aspect of the imputation process\n", + " - **Production Ready**\n", + " - Can impute new, unseen datasets quickly\n", + " - Kernels are efficiently compressed during saving and loading\n", + " - Data can be imputed in place to save memory\n", + " - Can build models on non-missing data\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This document contains a thorough walkthrough of the package,\n", + "benchmarks, and an introduction to multiple imputation. More information\n", + "on MICE can be found in Stef van Buuren’s excellent online book, which\n", + "you can find\n", + "[here](https://stefvanbuuren.name/fimd/ch-introduction.html).\n", + "\n", + "#### Table of Contents:\n", + "\n", + " - [Package\n", + " Meta](https://github.com/AnotherSamWilson/miceforest#Package-Meta)\n", + " - [The\n", + " Basics](https://github.com/AnotherSamWilson/miceforest#The-Basics)\n", + " - [Basic\n", + " Examples](https://github.com/AnotherSamWilson/miceforest#Basic-Examples)\n", + " - [Customizing LightGBM\n", + " Parameters](https://github.com/AnotherSamWilson/miceforest#Customizing-LightGBM-Parameters)\n", + " - [Available Mean Match\n", + " Schemes](https://github.com/AnotherSamWilson/miceforest#Controlling-Tree-Growth)\n", + " - [Imputing New Data with Existing\n", + " Models](https://github.com/AnotherSamWilson/miceforest#Imputing-New-Data-with-Existing-Models)\n", + " - [Saving and Loading\n", + " Kernels](https://github.com/AnotherSamWilson/miceforest#Saving-and-Loading-Kernels)\n", + " - [Implementing sklearn\n", + " Pipelines](https://github.com/AnotherSamWilson/miceforest#Implementing-sklearn-Pipelines)\n", + " - [Advanced\n", + " Features](https://github.com/AnotherSamWilson/miceforest#Advanced-Features)\n", + " - [Customizing the Imputation\n", + " Process](https://github.com/AnotherSamWilson/miceforest#Customizing-the-Imputation-Process)\n", + " - [Building Models on Nonmissing\n", + " Data](https://github.com/AnotherSamWilson/miceforest#Building-Models-on-Nonmissing-Data)\n", + " - [Tuning\n", + " Parameters](https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters)\n", + " - [On\n", + " Reproducibility](https://github.com/AnotherSamWilson/miceforest#On-Reproducibility)\n", + " - [How to Make the Process\n", + " Faster](https://github.com/AnotherSamWilson/miceforest#How-to-Make-the-Process-Faster)\n", + " - [Imputing Data In\n", + " Place](https://github.com/AnotherSamWilson/miceforest#Imputing-Data-In-Place)\n", + " - [Diagnostic\n", + " Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting)\n", + " - [Imputed\n", + " Distributions](https://github.com/AnotherSamWilson/miceforest#Distribution-of-Imputed-Values)\n", + " - [Correlation\n", + " Convergence](https://github.com/AnotherSamWilson/miceforest#Convergence-of-Correlation)\n", + " - [Variable\n", + " Importance](https://github.com/AnotherSamWilson/miceforest#Variable-Importance)\n", + " - [Mean\n", + " Convergence](https://github.com/AnotherSamWilson/miceforest#Variable-Importance)\n", + " - [Benchmarks](https://github.com/AnotherSamWilson/miceforest#Benchmarks)\n", + " - [Using the Imputed\n", + " Data](https://github.com/AnotherSamWilson/miceforest#Using-the-Imputed-Data)\n", + " - [The MICE\n", + " Algorithm](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm)\n", + " - [Introduction](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm)\n", + " - [Common Use\n", + " Cases](https://github.com/AnotherSamWilson/miceforest#Common-Use-Cases)\n", + " - [Predictive Mean\n", + " Matching](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching)\n", + " - [Effects of Mean\n", + " Matching](https://github.com/AnotherSamWilson/miceforest#Effects-of-Mean-Matching)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation\n", + "\n", + "This package can be installed using either pip or conda, through\n", + "conda-forge:\n", + "\n", + "``` bash\n", + "# Using pip\n", + "$ pip install miceforest --no-cache-dir\n", + "\n", + "# Using conda\n", + "$ conda install -c conda-forge miceforest\n", + "```\n", + "\n", + "You can also download the latest development version from this\n", + "repository. If you want to install from github with conda, you must\n", + "first run `conda install pip git`.\n", + "\n", + "``` bash\n", + "$ pip install git+https://github.com/AnotherSamWilson/miceforest.git\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classes\n", + "\n", + "miceforest has 3 main classes which the user will interact with:\n", + "\n", + " - [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)\n", + " - This class contains the raw data off of which the `mice` algorithm\n", + " is performed. During this process, models will be trained, and the\n", + " imputed (predicted) values will be stored. These values can be used\n", + " to fill in the missing values of the raw data. The raw data can be\n", + " copied, or referenced directly. Models can be saved, and used to\n", + " impute new datasets.\n", + " - [`ImputedData`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputedData.html#miceforest.ImputedData)\n", + " - The result of `ImputationKernel.impute_new_data(new_data)`. This\n", + " contains the raw data in `new_data` as well as the imputed values. \n", + " - [`MeanMatchScheme`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.MeanMatchScheme.html#miceforest.MeanMatchScheme)\n", + " - Determines how mean matching should be carried out. There are 3\n", + " built-in mean match schemes available in miceforest, discussed\n", + " below.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Usage\n", + "\n", + "We will be looking at a few simple examples of imputation. We need to\n", + "load the packages, and define the data:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "import miceforest as mf\n", + "from sklearn.datasets import load_iris\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# Load data and introduce missing values\n", + "iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1)\n", + "iris.rename({\"target\": \"species\"}, inplace=True, axis=1)\n", + "iris['species'] = iris['species'].astype('category')\n", + "iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md deleted file mode 100644 index b3f4914..0000000 --- a/README.md +++ /dev/null @@ -1,1073 +0,0 @@ - -[![DOI](https://zenodo.org/badge/289387436.svg)](https://zenodo.org/badge/latestdoi/289387436) -[![Downloads](https://static.pepy.tech/badge/miceforest)](https://pepy.tech/project/miceforest) -[![Pypi](https://img.shields.io/pypi/v/miceforest.svg)](https://pypi.python.org/pypi/miceforest) -[![Conda -Version](https://img.shields.io/conda/vn/conda-forge/miceforest.svg)](https://anaconda.org/conda-forge/miceforest) -[![PyVersions](https://img.shields.io/pypi/pyversions/miceforest.svg?logo=python&logoColor=white)](https://pypi.org/project/miceforest/) -[![tests + -mypy](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml) -[![Documentation -Status](https://readthedocs.org/projects/miceforest/badge/?version=latest)](https://miceforest.readthedocs.io/en/latest/?badge=latest) -[![CodeCov](https://codecov.io/gh/AnotherSamWilson/miceforest/branch/master/graphs/badge.svg?branch=master&service=github)](https://codecov.io/gh/AnotherSamWilson/miceforest) - - - - -## miceforest: Fast, Memory Efficient Imputation with LightGBM - - - -Fast, memory efficient Multiple Imputation by Chained Equations (MICE) -with lightgbm. The R version of this package may be found -[here](https://github.com/FarrellDay/miceRanger). - -`miceforest` was designed to be: - - - **Fast** - - Uses lightgbm as a backend - - Has efficient mean matching solutions. - - Can utilize GPU training - - **Flexible** - - Can impute pandas dataframes and numpy arrays - - Handles categorical data automatically - - Fits into a sklearn pipeline - - User can customize every aspect of the imputation process - - **Production Ready** - - Can impute new, unseen datasets quickly - - Kernels are efficiently compressed during saving and loading - - Data can be imputed in place to save memory - - Can build models on non-missing data - -This document contains a thorough walkthrough of the package, -benchmarks, and an introduction to multiple imputation. More information -on MICE can be found in Stef van Buuren’s excellent online book, which -you can find -[here](https://stefvanbuuren.name/fimd/ch-introduction.html). - -#### Table of Contents: - - - [Package - Meta](https://github.com/AnotherSamWilson/miceforest#Package-Meta) - - [The - Basics](https://github.com/AnotherSamWilson/miceforest#The-Basics) - - [Basic - Examples](https://github.com/AnotherSamWilson/miceforest#Basic-Examples) - - [Customizing LightGBM - Parameters](https://github.com/AnotherSamWilson/miceforest#Customizing-LightGBM-Parameters) - - [Available Mean Match - Schemes](https://github.com/AnotherSamWilson/miceforest#Controlling-Tree-Growth) - - [Imputing New Data with Existing - Models](https://github.com/AnotherSamWilson/miceforest#Imputing-New-Data-with-Existing-Models) - - [Saving and Loading - Kernels](https://github.com/AnotherSamWilson/miceforest#Saving-and-Loading-Kernels) - - [Implementing sklearn - Pipelines](https://github.com/AnotherSamWilson/miceforest#Implementing-sklearn-Pipelines) - - [Advanced - Features](https://github.com/AnotherSamWilson/miceforest#Advanced-Features) - - [Customizing the Imputation - Process](https://github.com/AnotherSamWilson/miceforest#Customizing-the-Imputation-Process) - - [Building Models on Nonmissing - Data](https://github.com/AnotherSamWilson/miceforest#Building-Models-on-Nonmissing-Data) - - [Tuning - Parameters](https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters) - - [On - Reproducibility](https://github.com/AnotherSamWilson/miceforest#On-Reproducibility) - - [How to Make the Process - Faster](https://github.com/AnotherSamWilson/miceforest#How-to-Make-the-Process-Faster) - - [Imputing Data In - Place](https://github.com/AnotherSamWilson/miceforest#Imputing-Data-In-Place) - - [Diagnostic - Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting) - - [Imputed - Distributions](https://github.com/AnotherSamWilson/miceforest#Distribution-of-Imputed-Values) - - [Correlation - Convergence](https://github.com/AnotherSamWilson/miceforest#Convergence-of-Correlation) - - [Variable - Importance](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) - - [Mean - Convergence](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) - - [Benchmarks](https://github.com/AnotherSamWilson/miceforest#Benchmarks) - - [Using the Imputed - Data](https://github.com/AnotherSamWilson/miceforest#Using-the-Imputed-Data) - - [The MICE - Algorithm](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) - - [Introduction](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) - - [Common Use - Cases](https://github.com/AnotherSamWilson/miceforest#Common-Use-Cases) - - [Predictive Mean - Matching](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) - - [Effects of Mean - Matching](https://github.com/AnotherSamWilson/miceforest#Effects-of-Mean-Matching) - -## Package Meta - -### Installation - -This package can be installed using either pip or conda, through -conda-forge: - -``` bash -# Using pip -$ pip install miceforest --no-cache-dir - -# Using conda -$ conda install -c conda-forge miceforest -``` - -You can also download the latest development version from this -repository. If you want to install from github with conda, you must -first run `conda install pip git`. - -``` bash -$ pip install git+https://github.com/AnotherSamWilson/miceforest.git -``` - -### Classes - -miceforest has 3 main classes which the user will interact with: - - - [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) - - This class contains the raw data off of which the `mice` algorithm - is performed. During this process, models will be trained, and the - imputed (predicted) values will be stored. These values can be used - to fill in the missing values of the raw data. The raw data can be - copied, or referenced directly. Models can be saved, and used to - impute new datasets. - - [`ImputedData`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputedData.html#miceforest.ImputedData) - - The result of `ImputationKernel.impute_new_data(new_data)`. This - contains the raw data in `new_data` as well as the imputed values. - - [`MeanMatchScheme`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.MeanMatchScheme.html#miceforest.MeanMatchScheme) - - Determines how mean matching should be carried out. There are 3 - built-in mean match schemes available in miceforest, discussed - below. - -## The Basics - -We will be looking at a few simple examples of imputation. We need to -load the packages, and define the data: - -``` python -import miceforest as mf -from sklearn.datasets import load_iris -import pandas as pd -import numpy as np - -# Load data and introduce missing values -iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1) -iris.rename({"target": "species"}, inplace=True, axis=1) -iris['species'] = iris['species'].astype('category') -iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991) -``` - -### Basic Examples - -If you only want to create a single imputed dataset, you can use -[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) -with some default settings: - -``` python -# Create kernel. -kds = mf.ImputationKernel( - iris_amp, - save_all_iterations=True, - random_state=1991 -) - -# Run the MICE algorithm for 2 iterations -kds.mice(2) - -# Return the completed dataset. -iris_complete = kds.complete_data() -``` - -There are also an array of plotting functions available, these are -discussed below in the section [Diagnostic -Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting). - -We usually don’t want to impute just a single dataset. In statistics, -multiple imputation is a process by which the uncertainty/other effects -caused by missing values can be examined by creating multiple different -imputed datasets. -[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) -can contain an arbitrary number of different datasets, all of which have -gone through mutually exclusive imputation processes: - -``` python -# Create kernel. -kernel = mf.ImputationKernel( - iris_amp, - datasets=4, - save_all_iterations=True, - random_state=1 -) - -# Run the MICE algorithm for 2 iterations on each of the datasets -kernel.mice(2) - -# Printing the kernel will show you some high level information. -print(kernel) -``` - - ## - ## Class: ImputationKernel - ## Datasets: 4 - ## Iterations: 2 - ## Data Samples: 150 - ## Data Columns: 5 - ## Imputed Variables: 5 - ## save_all_iterations: True - -After we have run mice, we can obtain our completed dataset directly -from the kernel: - -``` python -completed_dataset = kernel.complete_data(dataset=2) -print(completed_dataset.isnull().sum(0)) -``` - - ## sepal length (cm) 0 - ## sepal width (cm) 0 - ## petal length (cm) 0 - ## petal width (cm) 0 - ## species 0 - ## dtype: int64 - -### Customizing LightGBM Parameters - -Parameters can be passed directly to lightgbm in several different ways. -Parameters you wish to apply globally to every model can simply be -passed as kwargs to `mice`: - -``` python -# Run the MICE algorithm for 1 more iteration on the kernel with new parameters -kernel.mice(iterations=1,n_estimators=50) -``` - -You can also pass pass variable-specific arguments to -`variable_parameters` in mice. For instance, let’s say you noticed the -imputation of the `[species]` column was taking a little longer, because -it is multiclass. You could decrease the n\_estimators specifically for -that column with: - -``` python -# Run the MICE algorithm for 2 more iterations on the kernel -kernel.mice( - iterations=1, - variable_parameters={'species': {'n_estimators': 25}}, - n_estimators=50 -) - -# Let's get the actual models for these variables: -species_model = kernel.get_model(dataset=0,variable="species") -sepalwidth_model = kernel.get_model(dataset=0,variable="sepal width (cm)") - -print( -f"""Species used {str(species_model.params["num_iterations"])} iterations -Sepal Width used {str(sepalwidth_model.params["num_iterations"])} iterations -""" -) -``` - - ## Species used 25 iterations - ## Sepal Width used 50 iterations - -In this scenario, any parameters specified in `variable_parameters` -takes presidence over the kwargs. - -Since we can pass any parameters we want to LightGBM, we can completely -customize how our models are built. That includes how the data should be -modeled. If your data contains count data, or any other data which can -be parameterized by lightgbm, you can simply specify that variable to be -modeled with the corresponding objective function. - -For example, let’s pretend `sepal width (cm)` is a count field which can -be parameterized by a Poisson distribution. Let’s also change our -boosting method to gradient boosted trees: - -``` python -# Create kernel. -cust_kernel = mf.ImputationKernel( - iris_amp, - datasets=1, - random_state=1 -) - -cust_kernel.mice( - iterations=1, - variable_parameters={'sepal width (cm)': {'objective': 'poisson'}}, - boosting = 'gbdt', - min_sum_hessian_in_leaf=0.01 -) -``` - -Other nice parameters like `monotone_constraints` can also be passed. -Setting the parameter `device: 'gpu'` will utilize GPU learning, if -LightGBM is set up to do this on your machine. - -### Available Mean Match Schemes - -Note: It is probably a good idea to read [this -section](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) -first, to get some context on how mean matching works. - -The class `miceforest.MeanMatchScheme` contains information about how -mean matching should be performed, such as: - -1) Mean matching functions -2) Mean matching candidates -3) How to get predictions from a lightgbm model -4) The datatypes predictions are stored as - -There are three pre-built mean matching schemes that come with -`miceforest`: - -``` python -from miceforest import ( - mean_match_default, - mean_match_fast_cat, - mean_match_shap -) - -# To get information for each, use help() -# help(mean_match_default) -``` - -These schemes mostly differ in their strategy for performing mean -matching - - - **mean\_match\_default** - medium speed, medium imputation quality - - Categorical: perform a K Nearest Neighbors search on the - candidate class probabilities, where K = mmc. Select 1 at - random, and choose the associated candidate value as the - imputation value. - - Numeric: Perform a K Nearest Neighbors search on the candidate - predictions, where K = mmc. Select 1 at random, and choose the - associated candidate value as the imputation value. - - **mean\_match\_fast\_cat** - fastest speed, lowest imputation - quality - - Categorical: return class based on random draw weighted by class - probability for each sample. - - Numeric: perform a K Nearest Neighbors search on the candidate - class probabilities, where K = mmc. Select 1 at random, and - choose the associated candidate value as the imputation value. - - **mean\_match\_shap** - slowest speed, highest imputation quality - for large datasets - - Categorical: perform a K Nearest Neighbors search on the - candidate prediction shap values, where K = mmc. Select 1 at - random, and choose the associated candidate value as the - imputation value. - - Numeric: perform a K Nearest Neighbors search on the candidate - prediction shap values, where K = mmc. Select 1 at random, and - choose the associated candidate value as the imputation value. - -As a special case, if the mean\_match\_candidates is set to 0, the -following behavior is observed for all schemes: - - - Categorical: the class with the highest probability is chosen. - - Numeric: the predicted value is used - -These mean matching schemes can be updated and customized, we show an -example below in the advanced section. - -### Imputing New Data with Existing Models - -Multiple Imputation can take a long time. If you wish to impute a -dataset using the MICE algorithm, but don’t have time to train new -models, it is possible to impute new datasets using a `ImputationKernel` -object. The `impute_new_data()` function uses the models collected by -`ImputationKernel` to perform multiple imputation without updating the -models at each iteration: - -``` python -# Our 'new data' is just the first 15 rows of iris_amp -from datetime import datetime - -# Define our new data as the first 15 rows -new_data = iris_amp.iloc[range(15)] - -# Imputing new data can often be made faster by -# first compiling candidate predictions -kernel.compile_candidate_preds() - -start_t = datetime.now() -new_data_imputed = kernel.impute_new_data(new_data=new_data) -print(f"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds") -``` - - ## New Data imputed in 0.507115 seconds - -All of the imputation parameters (variable\_schema, -mean\_match\_candidates, etc) will be carried over from the original -`ImputationKernel` object. When mean matching, the candidate values are -pulled from the original kernel dataset. To impute new data, the -`save_models` parameter in `ImputationKernel` must be \> 0. If -`save_models == 1`, the model from the latest iteration is saved for -each variable. If `save_models > 1`, the model from each iteration is -saved. This allows for new data to be imputed in a more similar fashion -to the original mice procedure. - -### Saving and Loading Kernels - -Kernels can be saved using the `.save_kernel()` method, and then loaded -again using the `utils.load_kernel()` function. Internally, this -procedure uses `blosc2` and `dill` packages to do the following: - -1. Convert working data to parquet bytes (if it is a pandas dataframe) -2. Serialize the kernel -3. Compress this serialization -4. Save to a file - -### Implementing sklearn Pipelines - -kernels can be fit into sklearn pipelines to impute training and scoring -datasets: - -``` python -import numpy as np -from sklearn.preprocessing import StandardScaler -from sklearn.datasets import make_classification -from sklearn.model_selection import train_test_split -from sklearn.pipeline import Pipeline -import miceforest as mf - -# Define our data -X, y = make_classification(random_state=0) - -# Ampute and split the training data -X = mf.utils.ampute_data(X) -X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) - -# Initialize our miceforest kernel. datasets parameter should be 1, -# we don't want to return multiple datasets. -pipe_kernel = mf.ImputationKernel(X_train, datasets=1) - -# Define our pipeline -pipe = Pipeline([ - ('impute', pipe_kernel), - ('scaler', StandardScaler()), -]) - -# Fit on and transform our training data. -# Only use 2 iterations of mice. -X_train_t = pipe.fit_transform( - X_train, - y_train, - impute__iterations=2 -) - -# Transform the test data as well -X_test_t = pipe.transform(X_test) - -# Show that neither now have missing values. -assert not np.any(np.isnan(X_train_t)) -assert not np.any(np.isnan(X_test_t)) -``` - -## Advanced Features - -Multiple imputation is a complex process. However, `miceforest` allows -all of the major components to be switched out and customized by the -user. - -### Customizing the Imputation Process - -It is possible to heavily customize our imputation procedure by -variable. By passing a named list to `variable_schema`, you can specify -the predictor variables for each imputed variable. You can also specify -`mean_match_candidates` and `data_subset` by variable by passing a dict -of valid values, with variable names as keys. You can even replace the -entire default mean matching function for certain objectives if desired. -Below is an *extremely* convoluted setup, which you would probably never -want to use. It simply shows what is possible: - -``` python -# Use the default mean match schema as our base -from miceforest import mean_match_default -mean_match_custom = mean_match_default.copy() - -# Define a mean matching function that -# just randomly shuffles the predictions -def custom_mmf(bachelor_preds): - np.random.shuffle(bachelor_preds) - return bachelor_preds - -# Specify that our custom function should be -# used to perform mean matching on any variable -# that was modeled with a poisson objective: -mean_match_custom.set_mean_match_function( - {"poisson": custom_mmf} -) - -# Set the mean match candidates by variable -mean_match_custom.set_mean_match_candidates( - { - 'sepal width (cm)': 3, - 'petal width (cm)': 0 - } -) - -# Define which variables should be used to model others -variable_schema = { - 'sepal width (cm)': ['species','petal width (cm)'], - 'petal width (cm)': ['species','sepal length (cm)'] -} - -# Subset the candidate data to 50 rows for sepal width (cm). -variable_subset = { - 'sepal width (cm)': 50 -} - -# Specify that petal width (cm) should be modeled by the -# poisson objective. Our custom mean matching function -# above will be used for this variable. -variable_parameters = { - 'petal width (cm)': {"objective": "poisson"} -} - -cust_kernel = mf.ImputationKernel( - iris_amp, - datasets=3, - mean_match_scheme=mean_match_custom, - variable_schema=variable_schema, - data_subset=variable_subset -) -cust_kernel.mice(iterations=1, variable_parameters=variable_parameters) -``` - -The mean matching function can take any number of the following -arguments. If a function does not take one of these arguments, then the -process will not prepare that data for mean matching. - -``` python -from miceforest.MeanMatchScheme import AVAILABLE_MEAN_MATCH_ARGS -print("\n".join(AVAILABLE_MEAN_MATCH_ARGS)) -``` - - ## mean_match_candidates - ## lgb_booster - ## bachelor_preds - ## bachelor_features - ## candidate_values - ## candidate_features - ## candidate_preds - ## random_state - ## hashed_seeds - -### Building Models on Nonmissing Data - -The MICE process itself is used to impute missing data in a dataset. -However, sometimes a variable can be fully recognized in the training -data, but needs to be imputed later on in a different dataset. It is -possible to train models to impute variables even if they have no -missing values by setting `train_nonmissing=True`. In this case, -`variable_schema` is treated as the list of variables to train models -on. `imputation_order` only affects which variables actually have their -values imputed, it does not affect which variables have models trained: - -``` python -orig_missing_cols = ["sepal length (cm)", "sepal width (cm)"] -new_missing_cols = ["sepal length (cm)", "sepal width (cm)", "species"] - -# Training data only contains 2 columns with missing data -iris_amp2 = iris.copy() -iris_amp2[orig_missing_cols] = mf.ampute_data( - iris_amp2[orig_missing_cols], - perc=0.25, - random_state=1991 -) - -# Specify that models should also be trained for species column -var_sch = new_missing_cols - -cust_kernel = mf.ImputationKernel( - iris_amp2, - datasets=1, - variable_schema=var_sch, - train_nonmissing=True -) -cust_kernel.mice(1) - -# New data has missing values in species column -iris_amp2_new = iris.iloc[range(10),:].copy() -iris_amp2_new[new_missing_cols] = mf.ampute_data( - iris_amp2_new[new_missing_cols], - perc=0.25, - random_state=1991 -) - -# Species column can still be imputed -iris_amp2_new_imp = cust_kernel.impute_new_data(iris_amp2_new) -iris_amp2_new_imp.complete_data(0).isnull().sum() -``` - - ## sepal length (cm) 0 - ## sepal width (cm) 0 - ## petal length (cm) 0 - ## petal width (cm) 0 - ## species 0 - ## dtype: int64 - -Here, we knew that the species column in our new data would need to be -imputed. Therefore, we specified that a model should be built for all 3 -variables in the `variable_schema` (passing a dict of target - feature -pairs would also have worked). - -### Tuning Parameters - -`miceforest` allows you to tune the parameters on a kernel dataset. -These parameters can then be used to build the models in future -iterations of mice. In its most simple invocation, you can just call the -function with the desired optimization steps: - -``` python -# Using the first ImputationKernel in kernel to tune parameters -# with the default settings. -optimal_parameters, losses = kernel.tune_parameters( - dataset=0, - optimization_steps=5 -) - -# Run mice with our newly tuned parameters. -kernel.mice(1, variable_parameters=optimal_parameters) - -# The optimal parameters are kept in ImputationKernel.optimal_parameters: -print(optimal_parameters) -``` - - ## {0: {'boosting': 'gbdt', 'num_iterations': 165, 'max_depth': 8, 'num_leaves': 20, 'min_data_in_leaf': 1, 'min_sum_hessian_in_leaf': 0.1, 'min_gain_to_split': 0.0, 'bagging_fraction': 0.2498838792503861, 'feature_fraction': 1.0, 'feature_fraction_bynode': 0.6020460898858531, 'bagging_freq': 1, 'verbosity': -1, 'objective': 'regression', 'learning_rate': 0.02, 'cat_smooth': 17.807024990062555}, 1: {'boosting': 'gbdt', 'num_iterations': 94, 'max_depth': 8, 'num_leaves': 14, 'min_data_in_leaf': 4, 'min_sum_hessian_in_leaf': 0.1, 'min_gain_to_split': 0.0, 'bagging_fraction': 0.7802435334180599, 'feature_fraction': 1.0, 'feature_fraction_bynode': 0.6856668707631843, 'bagging_freq': 1, 'verbosity': -1, 'objective': 'regression', 'learning_rate': 0.02, 'cat_smooth': 4.802568893662679}, 2: {'boosting': 'gbdt', 'num_iterations': 229, 'max_depth': 8, 'num_leaves': 4, 'min_data_in_leaf': 8, 'min_sum_hessian_in_leaf': 0.1, 'min_gain_to_split': 0.0, 'bagging_fraction': 0.9565982004313843, 'feature_fraction': 1.0, 'feature_fraction_bynode': 0.6065024947204825, 'bagging_freq': 1, 'verbosity': -1, 'objective': 'regression', 'learning_rate': 0.02, 'cat_smooth': 17.2138799939537}, 3: {'boosting': 'gbdt', 'num_iterations': 182, 'max_depth': 8, 'num_leaves': 20, 'min_data_in_leaf': 4, 'min_sum_hessian_in_leaf': 0.1, 'min_gain_to_split': 0.0, 'bagging_fraction': 0.7251674145835884, 'feature_fraction': 1.0, 'feature_fraction_bynode': 0.9262368919526676, 'bagging_freq': 1, 'verbosity': -1, 'objective': 'regression', 'learning_rate': 0.02, 'cat_smooth': 5.780326477879999}, 4: {'boosting': 'gbdt', 'num_iterations': 208, 'max_depth': 8, 'num_leaves': 4, 'min_data_in_leaf': 7, 'min_sum_hessian_in_leaf': 0.1, 'min_gain_to_split': 0.0, 'bagging_fraction': 0.6746301598613926, 'feature_fraction': 1.0, 'feature_fraction_bynode': 0.20999114041328495, 'bagging_freq': 1, 'verbosity': -1, 'objective': 'multiclass', 'num_class': 3, 'learning_rate': 0.02, 'cat_smooth': 8.604908973256704}} - -This will perform 10 fold cross validation on random samples of -parameters. By default, all variables models are tuned. If you are -curious about the default parameter space that is searched within, check -out the `miceforest.default_lightgbm_parameters` module. - -The parameter tuning is pretty flexible. If you wish to set some model -parameters static, or to change the bounds that are searched in, you can -simply pass this information to either the `variable_parameters` -parameter, `**kwbounds`, or both: - -``` python -# Using a complicated setup: -optimal_parameters, losses = kernel.tune_parameters( - dataset=0, - variables = ['sepal width (cm)','species','petal width (cm)'], - variable_parameters = { - 'sepal width (cm)': {'bagging_fraction': 0.5}, - 'species': {'bagging_freq': (5,10)} - }, - optimization_steps=5, - extra_trees = [True, False] -) - -kernel.mice(1, variable_parameters=optimal_parameters) -``` - -In this example, we did a few things - we specified that only `sepal -width (cm)`, `species`, and `petal width (cm)` should be tuned. We also -specified some specific parameters in `variable_parameters.` Notice that -`bagging_fraction` was passed as a scalar, `0.5`. This means that, for -the variable `sepal width (cm)`, the parameter `bagging_fraction` will -be set as that number and not be tuned. We did the opposite for -`bagging_freq`. We specified bounds that the process should search in. -We also passed the argument `extra_trees` as a list. Since it was passed -to \*\*kwbounds, this parameter will apply to all variables that are -being tuned. Passing values as a list tells the process that it should -randomly sample values from the list, instead of treating them as set of -counts to search within. - -The tuning process follows these rules for different parameter values it -finds: - - - Scalar: That value is used, and not tuned. - - Tuple: Should be length 2. Treated as the lower and upper bound to - search in. - - List: Treated as a distinct list of values to try randomly. - -### On Reproducibility - -`miceforest` allows for different “levels” of reproducibility, global -and record-level. - -##### **Global Reproducibility** - -Global reproducibility ensures that the same values will be imputed if -the same code is run multiple times. To ensure global reproducibility, -all the user needs to do is set a `random_state` when the kernel is -initialized. - -##### **Record-Level Reproducibility** - -Sometimes we want to obtain reproducible imputations at the record -level, without having to pass the same dataset. This is possible by -passing a list of record-specific seeds to the `random_seed_array` -parameter. This is useful if imputing new data multiple times, and you -would like imputations for each row to match each time it is imputed. - -``` python -# Define seeds for the data, and impute iris -random_seed_array = np.random.randint(9999, size=150) -iris_imputed = kernel.impute_new_data( - iris_amp, - random_state=4, - random_seed_array=random_seed_array -) - -# Select a random sample -new_inds = np.random.choice(150, size=15) -new_data = iris_amp.loc[new_inds] -new_seeds = random_seed_array[new_inds] -new_imputed = kernel.impute_new_data( - new_data, - random_state=4, - random_seed_array=new_seeds -) - -# We imputed the same values for the 15 values each time, -# because each record was associated with the same seed. -assert new_imputed.complete_data(0).equals(iris_imputed.complete_data(0).loc[new_inds]) -``` - -Note that record-level reproducibility is only possible in the -`impute_new_data` function, there are no guarantees of record-level -reproducibility in imputations between the kernel and new data. - -### How to Make the Process Faster - -Multiple Imputation is one of the most robust ways to handle missing -data - but it can take a long time. There are several strategies you can -use to decrease the time a process takes to run: - - - Decrease `data_subset`. By default all non-missing datapoints for - each variable are used to train the model and perform mean matching. - This can cause the model training nearest-neighbors search to take a - long time for large data. A subset of these points can be searched - instead by using `data_subset`. - - If categorical columns are taking a long time, you can use the - `mean_match_fast_cat` scheme. You can also set different parameters - specifically for categorical columns, like smaller - `bagging_fraction` or `num_iterations`. - - If you need to impute new data faster, compile the predictions with - the `compile_candidate_preds` method. This stores the predictions - for each model, so it does not need to be re-calculated at each - iteration. - - Convert your data to a numpy array. Numpy arrays are much faster to - index. While indexing overhead is avoided as much as possible, there - is no getting around it. Consider comverting to `float32` datatype - as well, as it will cause the resulting object to take up much less - memory. - - Decrease `mean_match_candidates`. The maximum number of neighbors - that are considered with the default parameters is 10. However, for - large datasets, this can still be an expensive operation. Consider - explicitly setting `mean_match_candidates` lower. - - Use different lightgbm parameters. lightgbm is usually not the - problem, however if a certain variable has a large number of - classes, then the max number of trees actually grown is (\# classes) - \* (n\_estimators). You can specifically decrease the bagging - fraction or n\_estimators for large multi-class variables, or grow - less trees in general. - - Use a faster mean matching function. The default mean matching - function uses the scipy.Spatial.KDtree algorithm. There are faster - alternatives out there, if you think mean matching is the holdup. - -### Imputing Data In Place - -It is possible to run the entire process without copying the dataset. If -`copy_data=False`, then the data is referenced directly: - -``` python -kernel_inplace = mf.ImputationKernel( - iris_amp, - datasets=1, - copy_data=False -) -kernel_inplace.mice(2) -``` - -Note, that this probably won’t (but could) change the original dataset -in undesirable ways. Throughout the `mice` procedure, imputed values are -stored directly in the original data. At the end, the missing values are -put back as `np.NaN`. - -We can also complete our original data in place: - -``` python -kernel_inplace.complete_data(dataset=0, inplace=True) -print(iris_amp.isnull().sum(0)) -``` - - ## sepal length (cm) 0 - ## sepal width (cm) 0 - ## petal length (cm) 0 - ## petal width (cm) 0 - ## species 0 - ## dtype: int64 - -This is useful if the dataset is large, and copies can’t be made in -memory. - -## Diagnostic Plotting - -As of now, miceforest has four diagnostic plots available. - -### Distribution of Imputed-Values - -We probably want to know how the imputed values are distributed. We can -plot the original distribution beside the imputed distributions in each -dataset by using the `plot_imputed_distributions` method of an -`ImputationKernel` object: - -``` python -kernel.plot_imputed_distributions(wspace=0.3,hspace=0.3) -``` - - - -The red line is the original data, and each black line are the imputed -values of each dataset. - -### Convergence of Correlation - -We are probably interested in knowing how our values between datasets -converged over the iterations. The `plot_correlations` method shows you -a boxplot of the correlations between imputed values in every -combination of datasets, at each iteration. This allows you to see how -correlated the imputations are between datasets, as well as the -convergence over iterations: - -``` python -kernel.plot_correlations() -``` - - - -### Variable Importance - -We also may be interested in which variables were used to impute each -variable. We can plot this information by using the -`plot_feature_importance` method. - -``` python -kernel.plot_feature_importance(dataset=0, annot=True,cmap="YlGnBu",vmin=0, vmax=1) -``` - - - -The numbers shown are returned from the -`lightgbm.Booster.feature_importance()` function. Each square represents -the importance of the column variable in imputing the row variable. - -### Mean Convergence - -If our data is not missing completely at random, we may see that it -takes a few iterations for our models to get the distribution of -imputations right. We can plot the average value of our imputations to -see if this is occurring: - -``` python -kernel.plot_mean_convergence(wspace=0.3, hspace=0.4) -``` - - - -Our data was missing completely at random, so we don’t see any -convergence occurring here. - -## Using the Imputed Data - -To return the imputed data simply use the `complete_data` method: - -``` python -dataset_1 = kernel.complete_data(0) -``` - -This will return a single specified dataset. Multiple datasets are -typically created so that some measure of confidence around each -prediction can be created. - -Since we know what the original data looked like, we can cheat and see -how well the imputations compare to the original data: - -``` python -acclist = [] -for iteration in range(kernel.iteration_count()+1): - species_na_count = kernel.na_counts[4] - compdat = kernel.complete_data(dataset=0,iteration=iteration) - - # Record the accuract of the imputations of species. - acclist.append( - round(1-sum(compdat['species'] != iris['species'])/species_na_count,2) - ) - -# acclist shows the accuracy of the imputations -# over the iterations. -print(acclist) -``` - - ## [0.35, 0.81, 0.84, 0.84, 0.89, 0.92, 0.89] - -In this instance, we went from a low accuracy (what is expected with -random sampling) to a much higher accuracy. - -## The MICE Algorithm - -Multiple Imputation by Chained Equations ‘fills in’ (imputes) missing -data in a dataset through an iterative series of predictive models. In -each iteration, each specified variable in the dataset is imputed using -the other variables in the dataset. These iterations should be run until -it appears that convergence has been met. - - - -This process is continued until all specified variables have been -imputed. Additional iterations can be run if it appears that the average -imputed values have not converged, although no more than 5 iterations -are usually necessary. - -### Common Use Cases - -##### **Data Leakage:** - -MICE is particularly useful if missing values are associated with the -target variable in a way that introduces leakage. For instance, let’s -say you wanted to model customer retention at the time of sign up. A -certain variable is collected at sign up or 1 month after sign up. The -absence of that variable is a data leak, since it tells you that the -customer did not retain for 1 month. - -##### **Funnel Analysis:** - -Information is often collected at different stages of a ‘funnel’. MICE -can be used to make educated guesses about the characteristics of -entities at different points in a funnel. - -##### **Confidence Intervals:** - -MICE can be used to impute missing values, however it is important to -keep in mind that these imputed values are a prediction. Creating -multiple datasets with different imputed values allows you to do two -types of inference: - - - Imputed Value Distribution: A profile can be built for each imputed - value, allowing you to make statements about the likely distribution - of that value. - - Model Prediction Distribution: With multiple datasets, you can build - multiple models and create a distribution of predictions for each - sample. Those samples with imputed values which were not able to be - imputed with much confidence would have a larger variance in their - predictions. - -### Predictive Mean Matching - -`miceforest` can make use of a procedure called predictive mean matching -(PMM) to select which values are imputed. PMM involves selecting a -datapoint from the original, nonmissing data (candidates) which has a -predicted value close to the predicted value of the missing sample -(bachelors). The closest N (`mean_match_candidates` parameter) values -are selected, from which a value is chosen at random. This can be -specified on a column-by-column basis. Going into more detail from our -example above, we see how this works in practice: - - - -This method is very useful if you have a variable which needs imputing -which has any of the following characteristics: - - - Multimodal - - Integer - - Skewed - -### Effects of Mean Matching - -As an example, let’s construct a dataset with some of the above -characteristics: - -``` python -randst = np.random.RandomState(1991) -# random uniform variable -nrws = 1000 -uniform_vec = randst.uniform(size=nrws) - -def make_bimodal(mean1,mean2,size): - bimodal_1 = randst.normal(size=nrws, loc=mean1) - bimodal_2 = randst.normal(size=nrws, loc=mean2) - bimdvec = [] - for i in range(size): - bimdvec.append(randst.choice([bimodal_1[i], bimodal_2[i]])) - return np.array(bimdvec) - -# Make 2 Bimodal Variables -close_bimodal_vec = make_bimodal(2,-2,nrws) -far_bimodal_vec = make_bimodal(3,-3,nrws) - - -# Highly skewed variable correlated with Uniform_Variable -skewed_vec = np.exp(uniform_vec*randst.uniform(size=nrws)*3) + randst.uniform(size=nrws)*3 - -# Integer variable correlated with Close_Bimodal_Variable and Uniform_Variable -integer_vec = np.round(uniform_vec + close_bimodal_vec/3 + randst.uniform(size=nrws)*2) - -# Make a DataFrame -dat = pd.DataFrame( - { - 'uniform_var':uniform_vec, - 'close_bimodal_var':close_bimodal_vec, - 'far_bimodal_var':far_bimodal_vec, - 'skewed_var':skewed_vec, - 'integer_var':integer_vec - } -) - -# Ampute the data. -ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst) - -# Plot the original data -import seaborn as sns -import matplotlib.pyplot as plt -g = sns.PairGrid(dat) -g.map(plt.scatter,s=5) -``` - - -We can see how our variables are distributed and correlated in the graph -above. Now let’s run our imputation process twice, once using mean -matching, and once using the model prediction. - -``` python -from miceforest import mean_match_default -scheme_mmc_0 = mean_match_default.copy() -scheme_mmc_5 = mean_match_default.copy() - -scheme_mmc_0.set_mean_match_candidates(0) -scheme_mmc_5.set_mean_match_candidates(5) - -kernelmeanmatch = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_5, datasets=1) -kernelmodeloutput = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_0, datasets=1) - -kernelmeanmatch.mice(2) -kernelmodeloutput.mice(2) -``` - -Let’s look at the effect on the different variables. - -##### With Mean Matching - -``` python -kernelmeanmatch.plot_imputed_distributions(wspace=0.2,hspace=0.4) -``` - - - -##### Without Mean Matching - -``` python -kernelmodeloutput.plot_imputed_distributions(wspace=0.2,hspace=0.4) -``` - - - -You can see the effects that mean matching has, depending on the -distribution of the data. Simply returning the value from the model -prediction, while it may provide a better ‘fit’, will not provide -imputations with a similair distribution to the original. This may be -beneficial, depending on your goal. From 2b25447b90636a67169b7839c40da464480e66dd Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sat, 20 Jul 2024 20:34:27 -0400 Subject: [PATCH 06/44] Updated dev environment --- .gitignore | 2 + poetry.lock | 2553 +++++++++++++++++++++++++++++++++++++++++------- pyproject.toml | 1 + 3 files changed, 2218 insertions(+), 338 deletions(-) diff --git a/.gitignore b/.gitignore index 841899f..0a3decf 100644 --- a/.gitignore +++ b/.gitignore @@ -27,3 +27,5 @@ requirements.txt poetry.lock pyproject.toml *.DS_Store* +.devcontainer +Dockerfile diff --git a/poetry.lock b/poetry.lock index e75e230..3dcdad1 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,142 @@ -# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. + +[[package]] +name = "aiofiles" +version = "22.1.0" +description = "File support for asyncio." +optional = false +python-versions = ">=3.7,<4.0" +files = [ + {file = "aiofiles-22.1.0-py3-none-any.whl", hash = "sha256:1142fa8e80dbae46bb6339573ad4c8c0841358f79c6eb50a493dceca14621bad"}, + {file = "aiofiles-22.1.0.tar.gz", hash = "sha256:9107f1ca0b2a5553987a94a3c9959fe5b491fdf731389aa5b7b1bd0733e32de6"}, +] + +[[package]] +name = "aiosqlite" +version = "0.20.0" +description = "asyncio bridge to the standard sqlite3 module" +optional = false +python-versions = ">=3.8" +files = [ + {file = "aiosqlite-0.20.0-py3-none-any.whl", hash = "sha256:36a1deaca0cac40ebe32aac9977a6e2bbc7f5189f23f4a54d5908986729e5bd6"}, + {file = "aiosqlite-0.20.0.tar.gz", hash = "sha256:6d35c8c256637f4672f843c31021464090805bf925385ac39473fb16eaaca3d7"}, +] + +[package.dependencies] +typing_extensions = ">=4.0" + +[package.extras] +dev = ["attribution (==1.7.0)", "black (==24.2.0)", "coverage[toml] (==7.4.1)", "flake8 (==7.0.0)", "flake8-bugbear (==24.2.6)", "flit (==3.9.0)", "mypy (==1.8.0)", "ufmt (==2.3.0)", "usort (==1.0.8.post1)"] +docs = ["sphinx (==7.2.6)", "sphinx-mdinclude (==0.5.3)"] + +[[package]] +name = "anyio" +version = "4.4.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +optional = false +python-versions = ">=3.8" +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[package.dependencies] +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} +idna = ">=2.8" +sniffio = ">=1.1" +typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""} + +[package.extras] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] +trio = ["trio (>=0.23)"] + +[[package]] +name = "appnope" +version = "0.1.4" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = ">=3.6" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +description = "Argon2 for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +optional = false +python-versions = ">=3.6" +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["cogapp", "pre-commit", "pytest", "wheel"] +tests = ["pytest"] + +[[package]] +name = "arrow" +version = "1.3.0" +description = "Better dates & times for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[package.dependencies] +python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] [[package]] name = "asttokens" @@ -18,6 +156,60 @@ six = ">=1.12.0" astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "babel" +version = "2.15.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"}, + {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"}, +] + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +cchardet = ["cchardet"] +chardet = ["chardet"] +charset-normalizer = ["charset-normalizer"] +html5lib = ["html5lib"] +lxml = ["lxml"] + [[package]] name = "black" version = "24.4.2" @@ -64,35 +256,53 @@ d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"] jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] uvloop = ["uvloop (>=0.15.2)"] +[[package]] +name = "bleach" +version = "6.1.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.8" +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.3)"] + [[package]] name = "blosc2" -version = "2.6.2" +version = "2.7.0" description = "Python wrapper for the C-Blosc2 library" optional = false python-versions = "<4,>=3.10" files = [ - {file = "blosc2-2.6.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:00db67006601f534553a7948213595f384eac0e3afa41a4f5600fbb3ba580ae2"}, - {file = "blosc2-2.6.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:407627050d116d1cce85b197616350d3f2852f7e036a4f59a97d5cc07f345ead"}, - {file = "blosc2-2.6.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8aeb8eb12c60522bf0eb6d49687aba925e710ba4f9976cdde519d7af3bc547df"}, - {file = "blosc2-2.6.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:072a8753d627499893129d480042a61ee47845ce99106fa0e7d8ea4f0ced37a1"}, - {file = "blosc2-2.6.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:afb962aef4f2b3b5cd20a3ae2d92311bb829836ae283b5ac595fa14dd2fad47c"}, - {file = "blosc2-2.6.2-cp310-cp310-win32.whl", hash = "sha256:abc87b8bda70290a33b0d5631121d189f90046b86f7992865428672471cccba0"}, - {file = "blosc2-2.6.2-cp310-cp310-win_amd64.whl", hash = "sha256:8291cd97f3730873c498df610acb0177ff11901e09771197e1eace5c3e1b9669"}, - {file = "blosc2-2.6.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:15d91ba9fd24391a67dcb1051b82490b0cbde3a1d473209fa578e7a96d801bf7"}, - {file = "blosc2-2.6.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cbe8e97f0bc94a45456f186c374e5fb91d35123ebe80e530d849d1da95cf6770"}, - {file = "blosc2-2.6.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50661d5e9147b8f50a86c7d86ec2be907ac33418c5ec82963f4487d851e9c88c"}, - {file = "blosc2-2.6.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81b0d7cf029b097fd130817ddae66e67a92253136812a5dddba3d9504bce15ed"}, - {file = "blosc2-2.6.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:be1925fbf1ce37d384f47d3f02710abe79cc7722d09c2d50044845947e85d2fa"}, - {file = "blosc2-2.6.2-cp311-cp311-win32.whl", hash = "sha256:6c5b861a8c51af1cd7eabf59c3bdd944f873ea5de8497602af9c5617cabe4f7e"}, - {file = "blosc2-2.6.2-cp311-cp311-win_amd64.whl", hash = "sha256:db38cc7aed6547f0855ef5dbb13853f653a91174bf5e79841dd00ff1914a83d3"}, - {file = "blosc2-2.6.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bb8fc5c0420eab9c4c0c7eddf1b8747b817f7aae5145e3e99607918af3f42588"}, - {file = "blosc2-2.6.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f4c2272915e0f28cd10258393506cc31616317d94fed77b61617c98734588016"}, - {file = "blosc2-2.6.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ca4c24cb1f64dba1b900fbfc165649bbfd9c890d76e356a682a9cff4c34f967"}, - {file = "blosc2-2.6.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c4fec36f58267fa0b5b1ed7f688469313e5af83ed1cc70ba01001d3fe4b824f"}, - {file = "blosc2-2.6.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8a63ad8ae52af974d4ffa1490aa7715cfe0d6408363686fb141ff6f7513bb0ad"}, - {file = "blosc2-2.6.2-cp312-cp312-win32.whl", hash = "sha256:3025e4d0bdab498853e0cf971ece10ac5709c875f0b6b4272fe069326b69ef42"}, - {file = "blosc2-2.6.2-cp312-cp312-win_amd64.whl", hash = "sha256:b99157758b5d3ba11c46db26602750555053aee2b917ba3209eaf37ee266ccb4"}, - {file = "blosc2-2.6.2.tar.gz", hash = "sha256:8ca29d9aa988b85318bd8a9b707a7a06c8d6604ae1304cae059170437ae4f53a"}, + {file = "blosc2-2.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:aa71042277956199676169335eb64aa76e33adac5a22289eccdb7d10edf402b6"}, + {file = "blosc2-2.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:18e3c4c95fe40ea9cda88c784d96e4efc8ddf53f94074cf46daa2e91c9ae5137"}, + {file = "blosc2-2.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1ac66ce25214b0b2e53beda9bc6f333dba16f2667649b1026ae041511b5a07d"}, + {file = "blosc2-2.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:928a89851b8528ce9c233048d832be5b2fef47645d5a389c021f3f58333fa3f8"}, + {file = "blosc2-2.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a9518b7bbaa0f9903a5a921abe6abb0faa56b0e0ad2da0416ff3a486a4b2e0aa"}, + {file = "blosc2-2.7.0-cp310-cp310-win32.whl", hash = "sha256:488dc4be3b6894967a7189952634644f8da46c4bab7734719d379cdf5b440dc0"}, + {file = "blosc2-2.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:17dd39f62f1686a170232ac8bcba40358ef67e919a91fe840ac71a45d067df30"}, + {file = "blosc2-2.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:565701ad336946a7ef12250def97aae2257de1da34ac8cd570be91b664a03d30"}, + {file = "blosc2-2.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5b640fe2d1d39af2dccffe5e100ef94d21940bfb7f0af44ba17fef718671b267"}, + {file = "blosc2-2.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:634bc22f17ae47a166b8201c77ba11bc160d9997ace51fc820cb3cbd285d47f8"}, + {file = "blosc2-2.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d4b208d5f5947d3062d3353717c43e0ea8e6ccdecdcd30737d5305628e0062b"}, + {file = "blosc2-2.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:fd3ca9a61bce4e4dc8006b613fa9dd8982f71e01fa9f593d6cc44d9fdbb56174"}, + {file = "blosc2-2.7.0-cp311-cp311-win32.whl", hash = "sha256:4518944374880d822f9ca90d4473bfa9f4d884b462f78365e224c2b291962e44"}, + {file = "blosc2-2.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:05d40ede9cf0ecb25500cfe9bebe190e75f246eb1fcd7bd358ac1acfef44ee7a"}, + {file = "blosc2-2.7.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:729305b06e76b0c95b0ea5090aa7ec87eff72ca43e194283e0cccee92bbdd1e6"}, + {file = "blosc2-2.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:64a26c9f7a4a5ddc5721a75b37f913f9e21c0dab96d8c152a64f8faf8659e9ee"}, + {file = "blosc2-2.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:770733ce68d82674d1f80961fe56f3c2d914d8ea4de036af3888a22479add97d"}, + {file = "blosc2-2.7.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6a700f9324b37e814c5633c43b081c60962f4dd59c0340cefe5f61f9f0411fd"}, + {file = "blosc2-2.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1546c04d25ce793fa0fd7a83999bbb576ff84ef474fb45801f0b6dd76b84803c"}, + {file = "blosc2-2.7.0-cp312-cp312-win32.whl", hash = "sha256:407896867032a760dcce6c25d5e5a56b6fe5235245e065e2549697f69b5117c6"}, + {file = "blosc2-2.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:62d2a6eaf1be1858993a4d7b2b8efd2ede5c4eaabe030c611cd075d907aa5400"}, + {file = "blosc2-2.7.0.tar.gz", hash = "sha256:9b982c1d40560eefb4a01d67c57e786d39a5ee9696f3deadd32ebf5f8885eb2a"}, ] [package.dependencies] @@ -102,6 +312,180 @@ numexpr = "*" numpy = ">=1.20.3" py-cpuinfo = "*" +[[package]] +name = "certifi" +version = "2024.7.4" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"}, + {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + [[package]] name = "click" version = "8.1.7" @@ -127,6 +511,23 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +[[package]] +name = "comm" +version = "0.2.2" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.8" +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +test = ["pytest"] + [[package]] name = "contourpy" version = "1.2.1" @@ -205,6 +606,37 @@ files = [ docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] tests = ["pytest", "pytest-cov", "pytest-xdist"] +[[package]] +name = "debugpy" +version = "1.8.2" +description = "An implementation of the Debug Adapter Protocol for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "debugpy-1.8.2-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7ee2e1afbf44b138c005e4380097d92532e1001580853a7cb40ed84e0ef1c3d2"}, + {file = "debugpy-1.8.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f8c3f7c53130a070f0fc845a0f2cee8ed88d220d6b04595897b66605df1edd6"}, + {file = "debugpy-1.8.2-cp310-cp310-win32.whl", hash = "sha256:f179af1e1bd4c88b0b9f0fa153569b24f6b6f3de33f94703336363ae62f4bf47"}, + {file = "debugpy-1.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:0600faef1d0b8d0e85c816b8bb0cb90ed94fc611f308d5fde28cb8b3d2ff0fe3"}, + {file = "debugpy-1.8.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8a13417ccd5978a642e91fb79b871baded925d4fadd4dfafec1928196292aa0a"}, + {file = "debugpy-1.8.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdf39855f65c48ac9667b2801234fc64d46778021efac2de7e50907ab90c634"}, + {file = "debugpy-1.8.2-cp311-cp311-win32.whl", hash = "sha256:2cbd4d9a2fc5e7f583ff9bf11f3b7d78dfda8401e8bb6856ad1ed190be4281ad"}, + {file = "debugpy-1.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:d3408fddd76414034c02880e891ea434e9a9cf3a69842098ef92f6e809d09afa"}, + {file = "debugpy-1.8.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:5d3ccd39e4021f2eb86b8d748a96c766058b39443c1f18b2dc52c10ac2757835"}, + {file = "debugpy-1.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62658aefe289598680193ff655ff3940e2a601765259b123dc7f89c0239b8cd3"}, + {file = "debugpy-1.8.2-cp312-cp312-win32.whl", hash = "sha256:bd11fe35d6fd3431f1546d94121322c0ac572e1bfb1f6be0e9b8655fb4ea941e"}, + {file = "debugpy-1.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:15bc2f4b0f5e99bf86c162c91a74c0631dbd9cef3c6a1d1329c946586255e859"}, + {file = "debugpy-1.8.2-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:5a019d4574afedc6ead1daa22736c530712465c0c4cd44f820d803d937531b2d"}, + {file = "debugpy-1.8.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40f062d6877d2e45b112c0bbade9a17aac507445fd638922b1a5434df34aed02"}, + {file = "debugpy-1.8.2-cp38-cp38-win32.whl", hash = "sha256:c78ba1680f1015c0ca7115671fe347b28b446081dada3fedf54138f44e4ba031"}, + {file = "debugpy-1.8.2-cp38-cp38-win_amd64.whl", hash = "sha256:cf327316ae0c0e7dd81eb92d24ba8b5e88bb4d1b585b5c0d32929274a66a5210"}, + {file = "debugpy-1.8.2-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:1523bc551e28e15147815d1397afc150ac99dbd3a8e64641d53425dba57b0ff9"}, + {file = "debugpy-1.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e24ccb0cd6f8bfaec68d577cb49e9c680621c336f347479b3fce060ba7c09ec1"}, + {file = "debugpy-1.8.2-cp39-cp39-win32.whl", hash = "sha256:7f8d57a98c5a486c5c7824bc0b9f2f11189d08d73635c326abef268f83950326"}, + {file = "debugpy-1.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:16c8dcab02617b75697a0a925a62943e26a0330da076e2a10437edd9f0bf3755"}, + {file = "debugpy-1.8.2-py2.py3-none-any.whl", hash = "sha256:16e16df3a98a35c63c3ab1e4d19be4cbc7fdda92d9ddc059294f18910928e0ca"}, + {file = "debugpy-1.8.2.zip", hash = "sha256:95378ed08ed2089221896b9b3a8d021e642c24edc8fef20e5d4342ca8be65c00"}, +] + [[package]] name = "decorator" version = "5.1.1" @@ -216,6 +648,17 @@ files = [ {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, ] +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + [[package]] name = "dill" version = "0.3.8" @@ -231,15 +674,26 @@ files = [ graph = ["objgraph (>=1.7.2)"] profile = ["gprof2dot (>=2022.7.29)"] +[[package]] +name = "entrypoints" +version = "0.4" +description = "Discover and load entry points from installed packages." +optional = false +python-versions = ">=3.6" +files = [ + {file = "entrypoints-0.4-py3-none-any.whl", hash = "sha256:f174b5ff827504fd3cd97cc3f8649f3693f51538c7e4bdf3ef002c8429d42f9f"}, + {file = "entrypoints-0.4.tar.gz", hash = "sha256:b706eddaa9218a19ebcd67b56818f05bb27589b1ca9e8d797b74affad4ccacd4"}, +] + [[package]] name = "exceptiongroup" -version = "1.2.1" +version = "1.2.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, - {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, ] [package.extras] @@ -259,55 +713,69 @@ files = [ [package.extras] tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] +[[package]] +name = "fastjsonschema" +version = "2.20.0" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + [[package]] name = "fonttools" -version = "4.51.0" +version = "4.53.1" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" files = [ - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, - {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, - {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, - {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, - {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, - {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, - {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, - {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, - {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, - {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, - {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, - {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, - {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0679a30b59d74b6242909945429dbddb08496935b82f91ea9bf6ad240ec23397"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8bf06b94694251861ba7fdeea15c8ec0967f84c3d4143ae9daf42bbc7717fe3"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b96cd370a61f4d083c9c0053bf634279b094308d52fdc2dd9a22d8372fdd590d"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1c7c5aa18dd3b17995898b4a9b5929d69ef6ae2af5b96d585ff4005033d82f0"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e013aae589c1c12505da64a7d8d023e584987e51e62006e1bb30d72f26522c41"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9efd176f874cb6402e607e4cc9b4a9cd584d82fc34a4b0c811970b32ba62501f"}, + {file = "fonttools-4.53.1-cp310-cp310-win32.whl", hash = "sha256:c8696544c964500aa9439efb6761947393b70b17ef4e82d73277413f291260a4"}, + {file = "fonttools-4.53.1-cp310-cp310-win_amd64.whl", hash = "sha256:8959a59de5af6d2bec27489e98ef25a397cfa1774b375d5787509c06659b3671"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da33440b1413bad53a8674393c5d29ce64d8c1a15ef8a77c642ffd900d07bfe1"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ff7e5e9bad94e3a70c5cd2fa27f20b9bb9385e10cddab567b85ce5d306ea923"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6e7170d675d12eac12ad1a981d90f118c06cf680b42a2d74c6c931e54b50719"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee32ea8765e859670c4447b0817514ca79054463b6b79784b08a8df3a4d78e3"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6e08f572625a1ee682115223eabebc4c6a2035a6917eac6f60350aba297ccadb"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b21952c092ffd827504de7e66b62aba26fdb5f9d1e435c52477e6486e9d128b2"}, + {file = "fonttools-4.53.1-cp311-cp311-win32.whl", hash = "sha256:9dfdae43b7996af46ff9da520998a32b105c7f098aeea06b2226b30e74fbba88"}, + {file = "fonttools-4.53.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4d0096cb1ac7a77b3b41cd78c9b6bc4a400550e21dc7a92f2b5ab53ed74eb02"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d92d3c2a1b39631a6131c2fa25b5406855f97969b068e7e08413325bc0afba58"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3b3c8ebafbee8d9002bd8f1195d09ed2bd9ff134ddec37ee8f6a6375e6a4f0e8"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32f029c095ad66c425b0ee85553d0dc326d45d7059dbc227330fc29b43e8ba60"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f5e6c3510b79ea27bb1ebfcc67048cde9ec67afa87c7dd7efa5c700491ac7f"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f677ce218976496a587ab17140da141557beb91d2a5c1a14212c994093f2eae2"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9e6ceba2a01b448e36754983d376064730690401da1dd104ddb543519470a15f"}, + {file = "fonttools-4.53.1-cp312-cp312-win32.whl", hash = "sha256:791b31ebbc05197d7aa096bbc7bd76d591f05905d2fd908bf103af4488e60670"}, + {file = "fonttools-4.53.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ed170b5e17da0264b9f6fae86073be3db15fa1bd74061c8331022bca6d09bab"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c818c058404eb2bba05e728d38049438afd649e3c409796723dfc17cd3f08749"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:651390c3b26b0c7d1f4407cad281ee7a5a85a31a110cbac5269de72a51551ba2"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54f1bba2f655924c1138bbc7fa91abd61f45c68bd65ab5ed985942712864bbb"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9cd19cf4fe0595ebdd1d4915882b9440c3a6d30b008f3cc7587c1da7b95be5f"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:2af40ae9cdcb204fc1d8f26b190aa16534fcd4f0df756268df674a270eab575d"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:35250099b0cfb32d799fb5d6c651220a642fe2e3c7d2560490e6f1d3f9ae9169"}, + {file = "fonttools-4.53.1-cp38-cp38-win32.whl", hash = "sha256:f08df60fbd8d289152079a65da4e66a447efc1d5d5a4d3f299cdd39e3b2e4a7d"}, + {file = "fonttools-4.53.1-cp38-cp38-win_amd64.whl", hash = "sha256:7b6b35e52ddc8fb0db562133894e6ef5b4e54e1283dff606fda3eed938c36fc8"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a157d8d26c06e64ace9df037ee93a4938a4606a38cb7ffaf6635e60e253b7a"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4824c198f714ab5559c5be10fd1adf876712aa7989882a4ec887bf1ef3e00e31"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:becc5d7cb89c7b7afa8321b6bb3dbee0eec2b57855c90b3e9bf5fb816671fa7c"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ec3fb43befb54be490147b4a922b5314e16372a643004f182babee9f9c3407"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:73379d3ffdeecb376640cd8ed03e9d2d0e568c9d1a4e9b16504a834ebadc2dfb"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:02569e9a810f9d11f4ae82c391ebc6fb5730d95a0657d24d754ed7763fb2d122"}, + {file = "fonttools-4.53.1-cp39-cp39-win32.whl", hash = "sha256:aae7bd54187e8bf7fd69f8ab87b2885253d3575163ad4d669a262fe97f0136cb"}, + {file = "fonttools-4.53.1-cp39-cp39-win_amd64.whl", hash = "sha256:e5b708073ea3d684235648786f5f6153a48dc8762cdfe5563c57e80787c29fbb"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, ] [package.extras] @@ -324,6 +792,28 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=15.1.0)"] woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] +[[package]] +name = "fqdn" +version = "1.5.1" +description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +optional = false +python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "idna" +version = "3.7" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, + {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, +] + [[package]] name = "iniconfig" version = "2.0.0" @@ -335,15 +825,48 @@ files = [ {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] +[[package]] +name = "ipykernel" +version = "6.29.5" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=24" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"] + [[package]] name = "ipython" -version = "8.24.0" +version = "8.26.0" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.10" files = [ - {file = "ipython-8.24.0-py3-none-any.whl", hash = "sha256:d7bf2f6c4314984e3e02393213bab8703cf163ede39672ce5918c51fe253a2a3"}, - {file = "ipython-8.24.0.tar.gz", hash = "sha256:010db3f8a728a578bb641fdd06c063b9fb8e96a9464c63aec6310fbcb5e80501"}, + {file = "ipython-8.26.0-py3-none-any.whl", hash = "sha256:e6b347c27bdf9c32ee9d31ae85defc525755a1869f14057e900675b9e8d6e6ff"}, + {file = "ipython-8.26.0.tar.gz", hash = "sha256:1cec0fbba8404af13facebe83d04436a7434c7400e59f47acf467c64abd0956c"}, ] [package.dependencies] @@ -362,7 +885,7 @@ typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} [package.extras] all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] black = ["black"] -doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] +doc = ["docrepr", "exceptiongroup", "intersphinx-registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing-extensions"] kernel = ["ipykernel"] matplotlib = ["matplotlib"] nbconvert = ["nbconvert"] @@ -370,9 +893,34 @@ nbformat = ["nbformat"] notebook = ["ipywidgets", "notebook"] parallel = ["ipyparallel"] qtconsole = ["qtconsole"] -test = ["pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test = ["packaging", "pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] +[[package]] +name = "ipython-genutils" +version = "0.2.0" +description = "Vestigial utilities from IPython" +optional = false +python-versions = "*" +files = [ + {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"}, + {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +description = "Operations with ISO 8601 durations" +optional = false +python-versions = ">=3.7" +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[package.dependencies] +arrow = ">=0.15.0" + [[package]] name = "jedi" version = "0.19.1" @@ -392,6 +940,23 @@ docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alab qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] +[[package]] +name = "jinja2" +version = "3.1.4" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"}, + {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + [[package]] name = "joblib" version = "1.4.2" @@ -403,6 +968,316 @@ files = [ {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, ] +[[package]] +name = "json5" +version = "0.9.25" +description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = ">=3.8" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +description = "Identify specific nodes in a JSON document (RFC 6901)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} +rpds-py = ">=0.7.1" +uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +webcolors = {version = ">=24.6.0", optional = true, markers = "extra == \"format-nongpl\""} + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=24.6.0)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +referencing = ">=0.31.0" + +[[package]] +name = "jupyter-client" +version = "7.4.9" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_client-7.4.9-py3-none-any.whl", hash = "sha256:214668aaea208195f4c13d28eb272ba79f945fc0cf3f11c7092c20b2ca1980e7"}, + {file = "jupyter_client-7.4.9.tar.gz", hash = "sha256:52be28e04171f07aed8f20e1616a5a552ab9fee9cbbe6c1896ae170c3880d392"}, +] + +[package.dependencies] +entrypoints = "*" +jupyter-core = ">=4.9.2" +nest-asyncio = ">=1.5.4" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = "*" + +[package.extras] +doc = ["ipykernel", "myst-parser", "sphinx (>=1.3.6)", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] +test = ["codecov", "coverage", "ipykernel (>=6.12)", "ipython", "mypy", "pre-commit", "pytest", "pytest-asyncio (>=0.18)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +description = "Jupyter Event System library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[package.dependencies] +jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} +python-json-logger = ">=2.0.4" +pyyaml = ">=5.3" +referencing = "*" +rfc3339-validator = "*" +rfc3986-validator = ">=0.1.1" +traitlets = ">=5.3" + +[package.extras] +cli = ["click", "rich"] +docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] +test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] + +[[package]] +name = "jupyter-server" +version = "2.14.2" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server-2.14.2-py3-none-any.whl", hash = "sha256:47ff506127c2f7851a17bf4713434208fc490955d0e8632e95014a9a9afbeefd"}, + {file = "jupyter_server-2.14.2.tar.gz", hash = "sha256:66095021aa9638ced276c248b1d81862e4c50f292d575920bbe960de1c56b12b"}, +] + +[package.dependencies] +anyio = ">=3.1.0" +argon2-cffi = ">=21.1" +jinja2 = ">=3.0.3" +jupyter-client = ">=7.4.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +jupyter-events = ">=0.9.0" +jupyter-server-terminals = ">=0.4.4" +nbconvert = ">=6.4.4" +nbformat = ">=5.3.0" +overrides = ">=5.0" +packaging = ">=22.0" +prometheus-client = ">=0.9" +pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} +pyzmq = ">=24" +send2trash = ">=1.8.2" +terminado = ">=0.8.3" +tornado = ">=6.2.0" +traitlets = ">=5.6.0" +websocket-client = ">=1.7" + +[package.extras] +docs = ["ipykernel", "jinja2", "jupyter-client", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] +test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0,<9)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"] + +[[package]] +name = "jupyter-server-fileid" +version = "0.9.2" +description = "Jupyter Server extension providing an implementation of the File ID service." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_server_fileid-0.9.2-py3-none-any.whl", hash = "sha256:76a2fbcea6950968485dcd509c2d6ac417ca11e61ab1ad447a475f0878ca808f"}, + {file = "jupyter_server_fileid-0.9.2.tar.gz", hash = "sha256:ffb11460ca5f8567644f6120b25613fca8e3f3048b38d14c6e3fe1902f314a9b"}, +] + +[package.dependencies] +jupyter-events = ">=0.5.0" +jupyter-server = ">=1.15,<3" + +[package.extras] +cli = ["click"] +test = ["jupyter-server[test] (>=1.15,<3)", "pytest", "pytest-cov", "pytest-jupyter"] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +description = "A Jupyter Server Extension Providing Terminals." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[package.dependencies] +pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} +terminado = ">=0.8.3" + +[package.extras] +docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] +test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] + +[[package]] +name = "jupyter-server-ydoc" +version = "0.8.0" +description = "A Jupyter Server Extension Providing Y Documents." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_server_ydoc-0.8.0-py3-none-any.whl", hash = "sha256:969a3a1a77ed4e99487d60a74048dc9fa7d3b0dcd32e60885d835bbf7ba7be11"}, + {file = "jupyter_server_ydoc-0.8.0.tar.gz", hash = "sha256:a6fe125091792d16c962cc3720c950c2b87fcc8c3ecf0c54c84e9a20b814526c"}, +] + +[package.dependencies] +jupyter-server-fileid = ">=0.6.0,<1" +jupyter-ydoc = ">=0.2.0,<0.4.0" +ypy-websocket = ">=0.8.2,<0.9.0" + +[package.extras] +test = ["coverage", "jupyter-server[test] (>=2.0.0a0)", "pytest (>=7.0)", "pytest-cov", "pytest-timeout", "pytest-tornasync"] + +[[package]] +name = "jupyter-ydoc" +version = "0.2.5" +description = "Document structures for collaborative editing using Ypy" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_ydoc-0.2.5-py3-none-any.whl", hash = "sha256:5759170f112c70320a84217dd98d287699076ae65a7f88d458d57940a9f2b882"}, + {file = "jupyter_ydoc-0.2.5.tar.gz", hash = "sha256:5a02ca7449f0d875f73e8cb8efdf695dddef15a8e71378b1f4eda6b7c90f5382"}, +] + +[package.dependencies] +y-py = ">=0.6.0,<0.7.0" + +[package.extras] +dev = ["click", "jupyter-releaser"] +test = ["pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)", "ypy-websocket (>=0.8.4,<0.9.0)"] + +[[package]] +name = "jupyterlab" +version = "3.6.7" +description = "JupyterLab computational environment" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab-3.6.7-py3-none-any.whl", hash = "sha256:d92d57d402f53922bca5090654843aa08e511290dff29fdb0809eafbbeb6df98"}, + {file = "jupyterlab-3.6.7.tar.gz", hash = "sha256:2fadeaec161b0d1aec19f17721d8b803aef1d267f89c8b636b703be14f435c8f"}, +] + +[package.dependencies] +ipython = "*" +jinja2 = ">=2.1" +jupyter-core = "*" +jupyter-server = ">=1.16.0,<3" +jupyter-server-ydoc = ">=0.8.0,<0.9.0" +jupyter-ydoc = ">=0.2.4,<0.3.0" +jupyterlab-server = ">=2.19,<3.0" +nbclassic = "*" +notebook = "<7" +packaging = "*" +tomli = {version = "*", markers = "python_version < \"3.11\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["jsx-lexer", "myst-parser", "pytest", "pytest-check-links", "pytest-tornasync", "sphinx (>=1.8)", "sphinx-copybutton", "sphinx-rtd-theme"] +test = ["check-manifest", "coverage", "jupyterlab-server[test]", "pre-commit", "pytest (>=6.0)", "pytest-check-links (>=0.5)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "requests", "requests-cache", "virtualenv"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +description = "A set of server components for JupyterLab and JupyterLab like applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[package.dependencies] +babel = ">=2.10" +jinja2 = ">=3.0.3" +json5 = ">=0.9.0" +jsonschema = ">=4.18.0" +jupyter-server = ">=1.21,<3" +packaging = ">=21.3" +requests = ">=2.31" + +[package.extras] +docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0,<8)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] + [[package]] name = "kiwisolver" version = "1.4.5" @@ -518,20 +1393,21 @@ files = [ [[package]] name = "lightgbm" -version = "4.3.0" +version = "4.4.0" description = "LightGBM Python Package" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "lightgbm-4.3.0-py3-none-macosx_10_15_x86_64.macosx_11_6_x86_64.macosx_12_5_x86_64.whl", hash = "sha256:7e7c84e30607d043cc07ab7c0ffe3109120bde8e7e126f6a6151ca010c40fe3f"}, - {file = "lightgbm-4.3.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:25eb3dd661d75ccf8a46de686b07def3a2e06eacab7da5937d82543732183688"}, - {file = "lightgbm-4.3.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:104496a3404cb2452d3412cbddcfbfadbef9c372ea91e3a9b8794bcc5183bf07"}, - {file = "lightgbm-4.3.0-py3-none-win_amd64.whl", hash = "sha256:89bc9ef2b97552bfa07523416513d27cf3344bedf9bcb1f286e636ebe169ed51"}, - {file = "lightgbm-4.3.0.tar.gz", hash = "sha256:006f5784a9bcee43e5a7e943dc4f02de1ba2ee7a7af1ee5f190d383f3b6c9ebe"}, + {file = "lightgbm-4.4.0-py3-none-macosx_10_15_x86_64.macosx_11_6_x86_64.macosx_12_5_x86_64.whl", hash = "sha256:f51f17a10ef9b4669b9c95a2297213b57debbc9deadfe5c1489a7f3c9e2617c5"}, + {file = "lightgbm-4.4.0-py3-none-macosx_14_0_arm64.whl", hash = "sha256:d96b06c85f0840da95bbbf31a095b207186bb0e584cee0fe2f2e7f24fb07c70f"}, + {file = "lightgbm-4.4.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:a04875e4c0ffda7c67a0ab5bd8892f154a491833f4f5b39c4acf5b3add099699"}, + {file = "lightgbm-4.4.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:8700b41f637717d36763a282d280b8d4722a87103030b7f0f373b96da0225022"}, + {file = "lightgbm-4.4.0-py3-none-win_amd64.whl", hash = "sha256:460dd78586dccfc0ed756571690fcfcd3d61770ed7972746c655c3b11cce8a93"}, + {file = "lightgbm-4.4.0.tar.gz", hash = "sha256:9e8a7640911481134e60987d5d1e1cd157f430c3b4b38de8d36fc55c302bc299"}, ] [package.dependencies] -numpy = "*" +numpy = ">=1.17.0" scipy = "*" [package.extras] @@ -540,41 +1416,111 @@ dask = ["dask[array,dataframe,distributed] (>=2.0.0)", "pandas (>=0.24.0)"] pandas = ["pandas (>=0.24.0)"] scikit-learn = ["scikit-learn (!=0.22.0)"] +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + [[package]] name = "matplotlib" -version = "3.8.4" +version = "3.9.1" description = "Python plotting package" optional = false python-versions = ">=3.9" files = [ - {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"}, - {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"}, - {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"}, - {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"}, - {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"}, - {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"}, - {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"}, - {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"}, - {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"}, - {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"}, - {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"}, - {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"}, - {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"}, - {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"}, - {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"}, - {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"}, - {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"}, - {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"}, - {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"}, - {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"}, - {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"}, - {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"}, - {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"}, - {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"}, - {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"}, + {file = "matplotlib-3.9.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7ccd6270066feb9a9d8e0705aa027f1ff39f354c72a87efe8fa07632f30fc6bb"}, + {file = "matplotlib-3.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:591d3a88903a30a6d23b040c1e44d1afdd0d778758d07110eb7596f811f31842"}, + {file = "matplotlib-3.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd2a59ff4b83d33bca3b5ec58203cc65985367812cb8c257f3e101632be86d92"}, + {file = "matplotlib-3.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc001516ffcf1a221beb51198b194d9230199d6842c540108e4ce109ac05cc0"}, + {file = "matplotlib-3.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:83c6a792f1465d174c86d06f3ae85a8fe36e6f5964633ae8106312ec0921fdf5"}, + {file = "matplotlib-3.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:421851f4f57350bcf0811edd754a708d2275533e84f52f6760b740766c6747a7"}, + {file = "matplotlib-3.9.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b3fce58971b465e01b5c538f9d44915640c20ec5ff31346e963c9e1cd66fa812"}, + {file = "matplotlib-3.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a973c53ad0668c53e0ed76b27d2eeeae8799836fd0d0caaa4ecc66bf4e6676c0"}, + {file = "matplotlib-3.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82cd5acf8f3ef43f7532c2f230249720f5dc5dd40ecafaf1c60ac8200d46d7eb"}, + {file = "matplotlib-3.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab38a4f3772523179b2f772103d8030215b318fef6360cb40558f585bf3d017f"}, + {file = "matplotlib-3.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2315837485ca6188a4b632c5199900e28d33b481eb083663f6a44cfc8987ded3"}, + {file = "matplotlib-3.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:a0c977c5c382f6696caf0bd277ef4f936da7e2aa202ff66cad5f0ac1428ee15b"}, + {file = "matplotlib-3.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:565d572efea2b94f264dd86ef27919515aa6d629252a169b42ce5f570db7f37b"}, + {file = "matplotlib-3.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d397fd8ccc64af2ec0af1f0efc3bacd745ebfb9d507f3f552e8adb689ed730a"}, + {file = "matplotlib-3.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26040c8f5121cd1ad712abffcd4b5222a8aec3a0fe40bc8542c94331deb8780d"}, + {file = "matplotlib-3.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d12cb1837cffaac087ad6b44399d5e22b78c729de3cdae4629e252067b705e2b"}, + {file = "matplotlib-3.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0e835c6988edc3d2d08794f73c323cc62483e13df0194719ecb0723b564e0b5c"}, + {file = "matplotlib-3.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:44a21d922f78ce40435cb35b43dd7d573cf2a30138d5c4b709d19f00e3907fd7"}, + {file = "matplotlib-3.9.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:0c584210c755ae921283d21d01f03a49ef46d1afa184134dd0f95b0202ee6f03"}, + {file = "matplotlib-3.9.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:11fed08f34fa682c2b792942f8902e7aefeed400da71f9e5816bea40a7ce28fe"}, + {file = "matplotlib-3.9.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0000354e32efcfd86bda75729716b92f5c2edd5b947200be9881f0a671565c33"}, + {file = "matplotlib-3.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4db17fea0ae3aceb8e9ac69c7e3051bae0b3d083bfec932240f9bf5d0197a049"}, + {file = "matplotlib-3.9.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:208cbce658b72bf6a8e675058fbbf59f67814057ae78165d8a2f87c45b48d0ff"}, + {file = "matplotlib-3.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:dc23f48ab630474264276be156d0d7710ac6c5a09648ccdf49fef9200d8cbe80"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3fda72d4d472e2ccd1be0e9ccb6bf0d2eaf635e7f8f51d737ed7e465ac020cb3"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:84b3ba8429935a444f1fdc80ed930babbe06725bcf09fbeb5c8757a2cd74af04"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b918770bf3e07845408716e5bbda17eadfc3fcbd9307dc67f37d6cf834bb3d98"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f1f2e5d29e9435c97ad4c36fb6668e89aee13d48c75893e25cef064675038ac9"}, + {file = "matplotlib-3.9.1.tar.gz", hash = "sha256:de06b19b8db95dd33d0dc17c926c7c9ebed9f572074b6fac4f65068a6814d010"}, ] [package.dependencies] @@ -582,12 +1528,15 @@ contourpy = ">=1.0.1" cycler = ">=0.10" fonttools = ">=4.22.0" kiwisolver = ">=1.3.1" -numpy = ">=1.21" +numpy = ">=1.23" packaging = ">=20.0" pillow = ">=8" pyparsing = ">=2.3.1" python-dateutil = ">=2.7" +[package.extras] +dev = ["meson-python (>=0.13.1)", "numpy (>=1.25)", "pybind11 (>=2.6)", "setuptools (>=64)", "setuptools_scm (>=7)"] + [[package]] name = "matplotlib-inline" version = "0.1.7" @@ -602,6 +1551,17 @@ files = [ [package.dependencies] traitlets = "*" +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + [[package]] name = "msgpack" version = "1.0.8" @@ -668,16 +1628,118 @@ files = [ ] [[package]] -name = "mypy-extensions" -version = "1.0.0" -description = "Type system extensions for programs checked with the mypy type checker." +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "nbclassic" +version = "1.1.0" +description = "Jupyter Notebook as a Jupyter Server extension." +optional = false +python-versions = ">=3.7" +files = [ + {file = "nbclassic-1.1.0-py3-none-any.whl", hash = "sha256:8c0fd6e36e320a18657ff44ed96c3a400f17a903a3744fc322303a515778f2ba"}, + {file = "nbclassic-1.1.0.tar.gz", hash = "sha256:77b77ba85f9e988f9bad85df345b514e9e64c7f0e822992ab1df4a78ac64fc1e"}, +] + +[package.dependencies] +ipykernel = "*" +ipython-genutils = "*" +nest-asyncio = ">=1.5" +notebook-shim = ">=0.2.3" + +[package.extras] +docs = ["myst-parser", "nbsphinx", "sphinx", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] +json-logging = ["json-logging"] +test = ["coverage", "nbval", "pytest", "pytest-cov", "pytest-jupyter", "pytest-playwright", "pytest-tornasync", "requests", "requests-unixsocket", "testpath"] + +[[package]] +name = "nbclient" +version = "0.10.0" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +nbformat = ">=5.1" +traitlets = ">=5.4" + +[package.extras] +dev = ["pre-commit"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.16.4" +description = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.16.4-py3-none-any.whl", hash = "sha256:05873c620fe520b6322bf8a5ad562692343fe3452abda5765c7a34b7d1aa3eb3"}, + {file = "nbconvert-7.16.4.tar.gz", hash = "sha256:86ca91ba266b0a448dc96fa6c5b9d98affabde2867b363258703536807f9f7f4"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["flaky", "ipykernel", "ipython", "ipywidgets (>=7.5)", "myst-parser", "nbsphinx (>=0.2.12)", "playwright", "pydata-sphinx-theme", "pyqtwebengine (>=5.15)", "pytest (>=7)", "sphinx (==5.0.2)", "sphinxcontrib-spelling", "tornado (>=6.1)"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["pyqtwebengine (>=5.15)"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest (>=7)"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.10.4" +description = "The Jupyter Notebook format" optional = false -python-versions = ">=3.5" +python-versions = ">=3.8" files = [ - {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, - {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, ] +[package.dependencies] +fastjsonschema = ">=2.15" +jsonschema = ">=2.6" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + [[package]] name = "ndindex" version = "1.8" @@ -692,46 +1754,108 @@ files = [ [package.extras] arrays = ["numpy"] +[[package]] +name = "nest-asyncio" +version = "1.6.0" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "notebook" +version = "6.5.7" +description = "A web-based notebook environment for interactive computing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook-6.5.7-py3-none-any.whl", hash = "sha256:a6afa9a4ff4d149a0771ff8b8c881a7a73b3835f9add0606696d6e9d98ac1cd0"}, + {file = "notebook-6.5.7.tar.gz", hash = "sha256:04eb9011dfac634fbd4442adaf0a8c27cd26beef831fe1d19faf930c327768e4"}, +] + +[package.dependencies] +argon2-cffi = "*" +ipykernel = "*" +ipython-genutils = "*" +jinja2 = "*" +jupyter-client = ">=5.3.4,<8" +jupyter-core = ">=4.6.1" +nbclassic = ">=0.4.7" +nbconvert = ">=5" +nbformat = "*" +nest-asyncio = ">=1.5" +prometheus-client = "*" +pyzmq = ">=17" +Send2Trash = ">=1.8.0" +terminado = ">=0.8.3" +tornado = ">=6.1" +traitlets = ">=4.2.1" + +[package.extras] +docs = ["myst-parser", "nbsphinx", "sphinx", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] +json-logging = ["json-logging"] +test = ["coverage", "nbval", "pytest", "pytest-cov", "requests", "requests-unixsocket", "selenium (==4.1.5)", "testpath"] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +description = "A shim layer for notebook traits and config" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[package.dependencies] +jupyter-server = ">=1.8,<3" + +[package.extras] +test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] + [[package]] name = "numexpr" -version = "2.10.0" +version = "2.10.1" description = "Fast numerical expression evaluator for NumPy" optional = false python-versions = ">=3.9" files = [ - {file = "numexpr-2.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1af6dc6b3bd2e11a802337b352bf58f30df0b70be16c4f863b70a3af3a8ef95e"}, - {file = "numexpr-2.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c66dc0188358cdcc9465b6ee54fd5eef2e83ac64b1d4ba9117c41df59bf6fca"}, - {file = "numexpr-2.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83f1e7a7f7ee741b8dcd20c56c3f862a3a3ec26fa8b9fcadb7dcd819876d2f35"}, - {file = "numexpr-2.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f0b045e1831953a47cc9fabae76a6794c69cbb60921751a5cf2d555034c55bf"}, - {file = "numexpr-2.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1d8eb88b0ae3d3c609d732a17e71096779b2bf47b3a084320ffa93d9f9132786"}, - {file = "numexpr-2.10.0-cp310-cp310-win32.whl", hash = "sha256:629b66cc1b750671e7fb396506b3f9410612e5bd8bc1dd55b5a0a0041d839f95"}, - {file = "numexpr-2.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:78e0a8bc4417c3dedcbae3c473505b69080535246edc977c7dccf3ec8454a685"}, - {file = "numexpr-2.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a602692cd52ce923ce8a0a90fb1d6cf186ebe8706eed83eee0de685e634b9aa9"}, - {file = "numexpr-2.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:745b46a1fb76920a3eebfaf26e50bc94a9c13b5aee34b256ab4b2d792dbaa9ca"}, - {file = "numexpr-2.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10789450032357afaeda4ac4d06da9542d1535c13151e8d32b49ae1a488d1358"}, - {file = "numexpr-2.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4feafc65ea3044b8bf8f305b757a928e59167a310630c22b97a57dff07a56490"}, - {file = "numexpr-2.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:937d36c6d3cf15601f26f84f0f706649f976491e9e0892d16cd7c876d77fa7dc"}, - {file = "numexpr-2.10.0-cp311-cp311-win32.whl", hash = "sha256:03d0ba492e484a5a1aeb24b300c4213ed168f2c246177be5733abb4e18cbb043"}, - {file = "numexpr-2.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:6b5f8242c075477156d26b3a6b8e0cd0a06d4c8eb68d907bde56dd3c9c683e92"}, - {file = "numexpr-2.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b276e2ba3e87ace9a30fd49078ad5dcdc6a1674d030b1ec132599c55465c0346"}, - {file = "numexpr-2.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb5e12787101f1216f2cdabedc3417748f2e1f472442e16bbfabf0bab2336300"}, - {file = "numexpr-2.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05278bad96b5846d712eba58b44e5cec743bdb3e19ca624916c921d049fdbcf6"}, - {file = "numexpr-2.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6cdf9e64c5b3dbb61729edb505ea75ee212fa02b85c5b1d851331381ae3b0e1"}, - {file = "numexpr-2.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e3a973265591b0a875fd1151c4549e468959c7192821aac0bb86937694a08efa"}, - {file = "numexpr-2.10.0-cp312-cp312-win32.whl", hash = "sha256:416e0e9f0fc4cced67767585e44cb6b301728bdb9edbb7c534a853222ec62cac"}, - {file = "numexpr-2.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:748e8d4cde22d9a5603165293fb293a4de1a4623513299416c64fdab557118c2"}, - {file = "numexpr-2.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dc3506c30c03b082da2cadef43747d474e5170c1f58a6dcdf882b3dc88b1e849"}, - {file = "numexpr-2.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:efa63ecdc9fcaf582045639ddcf56e9bdc1f4d9a01729be528f62df4db86c9d6"}, - {file = "numexpr-2.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96a64d0dd8f8e694da3f8582d73d7da8446ff375f6dd239b546010efea371ac3"}, - {file = "numexpr-2.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d47bb567e330ebe86781864219a36cbccb3a47aec893bd509f0139c6b23e8104"}, - {file = "numexpr-2.10.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c7517b774d309b1f0896c89bdd1ddd33c4418a92ecfbe5e1df3ac698698f6fcf"}, - {file = "numexpr-2.10.0-cp39-cp39-win32.whl", hash = "sha256:04e8620e7e676504201d4082e7b3ee2d9b561d1cb9470b47a6104e10c1e2870e"}, - {file = "numexpr-2.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:56d0d96b130f7cd4d78d0017030d6a0e9d9fc2a717ac51d4cf4860b39637e86a"}, - {file = "numexpr-2.10.0.tar.gz", hash = "sha256:c89e930752639df040539160326d8f99a84159bbea41943ab8e960591edaaef0"}, + {file = "numexpr-2.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bbd35f17f6efc00ebd4a480192af1ee30996094a0d5343b131b0e90e61e8b554"}, + {file = "numexpr-2.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fecdf4bf3c1250e56583db0a4a80382a259ba4c2e1efa13e04ed43f0938071f5"}, + {file = "numexpr-2.10.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2efa499f460124538a5b4f1bf2e77b28eb443ee244cc5573ed0f6a069ebc635"}, + {file = "numexpr-2.10.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac23a72eff10f928f23b147bdeb0f1b774e862abe332fc9bf4837e9f1bc0bbf9"}, + {file = "numexpr-2.10.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b28eaf45f1cc1048aad9e90e3a8ada1aef58c5f8155a85267dc781b37998c046"}, + {file = "numexpr-2.10.1-cp310-cp310-win32.whl", hash = "sha256:4f0985bd1c493b23b5aad7d81fa174798f3812efb78d14844194834c9fee38b8"}, + {file = "numexpr-2.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:44f6d12a8c44be90199bbb10d3abf467f88951f48a3d1fbbd3c219d121f39c9d"}, + {file = "numexpr-2.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a3c0b0bf165b2d886eb981afa4e77873ca076f5d51c491c4d7b8fc10f17c876f"}, + {file = "numexpr-2.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:56648a04679063175681195670ad53e5c8ca19668166ed13875199b5600089c7"}, + {file = "numexpr-2.10.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce04ae6efe2a9d0be1a0e114115c3ae70c68b8b8fbc615c5c55c15704b01e6a4"}, + {file = "numexpr-2.10.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:45f598182b4f5c153222e47d5163c3bee8d5ebcaee7e56dd2a5898d4d97e4473"}, + {file = "numexpr-2.10.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6a50370bea77ba94c3734a44781c716751354c6bfda2d369af3aed3d67d42871"}, + {file = "numexpr-2.10.1-cp311-cp311-win32.whl", hash = "sha256:fa4009d84a8e6e21790e718a80a22d57fe7f215283576ef2adc4183f7247f3c7"}, + {file = "numexpr-2.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:fcbf013bb8494e8ef1d11fa3457827c1571c6a3153982d709e5d17594999d4dd"}, + {file = "numexpr-2.10.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:82fc95c301b15ff4823f98989ee363a2d5555d16a7cfd3710e98ddee726eaaaa"}, + {file = "numexpr-2.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cbf79fef834f88607f977ab9867061dcd9b40ccb08bb28547c6dc6c73e560895"}, + {file = "numexpr-2.10.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:552c8d4b2e3b87cdb2abb40a781b9a61a9090a9f66ac7357fc5a0b93aff76be3"}, + {file = "numexpr-2.10.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22cc65e9121aeb3187a2b50827715b2b087ea70e8ab21416ea52662322087b43"}, + {file = "numexpr-2.10.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:00204e5853713b5eba5f3d0bc586a5d8d07f76011b597c8b4087592cc2ec2928"}, + {file = "numexpr-2.10.1-cp312-cp312-win32.whl", hash = "sha256:82bf04a1495ac475de4ab49fbe0a3a2710ed3fd1a00bc03847316b5d7602402d"}, + {file = "numexpr-2.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:300e577b3c006dd7a8270f1bb2e8a00ee15bf235b1650fe2a6febec2954bc2c3"}, + {file = "numexpr-2.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fb704620657a1c99d64933e8a982148d8bfb2b738a1943e107a2bfdee887ce56"}, + {file = "numexpr-2.10.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:368a1972c3186355160f6ee330a7eea146d8443da75a38a30083289ae251ef5a"}, + {file = "numexpr-2.10.1-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ca8ae46481d0b0689ca0d00a8670bc464ce375e349599fe674a6d4957e7b7eb6"}, + {file = "numexpr-2.10.1-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a4db4456e0779d5e024220b7b6a7477ac900679bfa74836b06fa526aaed4e3c"}, + {file = "numexpr-2.10.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:926dd426c68f1d927412a2ad843831c1eb9a95871e7bb0bd8b20d547c12238d2"}, + {file = "numexpr-2.10.1-cp39-cp39-win32.whl", hash = "sha256:37598cca41f8f50dc889b0b72be1616a288758c16ab7d48c9ac8719e1a39d835"}, + {file = "numexpr-2.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:78b14c19c403df7498954468385768c86b0d2c52ad03dffb74e45d44ae5a9c77"}, + {file = "numexpr-2.10.1.tar.gz", hash = "sha256:9bba99d354a65f1a008ab8b87f07d84404c668e66bab624df5b6b5373403cf81"}, ] [package.dependencies] -numpy = ">=1.19.3" +numpy = ">=1.23.0" [[package]] name = "numpy" @@ -778,15 +1902,26 @@ files = [ {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, ] +[[package]] +name = "overrides" +version = "7.7.0" +description = "A decorator to automatically detect mismatch when overriding a method." +optional = false +python-versions = ">=3.6" +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + [[package]] name = "packaging" -version = "24.0" +version = "24.1" description = "Core utilities for Python packages" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, - {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, + {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, + {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, ] [[package]] @@ -862,6 +1997,17 @@ sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-d test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] xml = ["lxml (>=4.9.2)"] +[[package]] +name = "pandocfilters" +version = "1.5.1" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + [[package]] name = "parso" version = "0.8.4" @@ -904,84 +2050,95 @@ ptyprocess = ">=0.5" [[package]] name = "pillow" -version = "10.3.0" +version = "10.4.0" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.8" files = [ - {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, - {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, - {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, - {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, - {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, - {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, - {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, - {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, - {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, - {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, - {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, - {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, - {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, - {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, - {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, - {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, - {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, -] - -[package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] + {file = "pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e"}, + {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46"}, + {file = "pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984"}, + {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"}, + {file = "pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696"}, + {file = "pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496"}, + {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"}, + {file = "pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9"}, + {file = "pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42"}, + {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"}, + {file = "pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309"}, + {file = "pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060"}, + {file = "pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea"}, + {file = "pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0"}, + {file = "pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e"}, + {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df"}, + {file = "pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef"}, + {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"}, + {file = "pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=7.3)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"] fpx = ["olefile"] mic = ["olefile"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] @@ -1019,20 +2176,63 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "prometheus-client" +version = "0.20.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[package.extras] +twisted = ["twisted"] + [[package]] name = "prompt-toolkit" -version = "3.0.43" +version = "3.0.47" description = "Library for building powerful interactive command lines in Python" optional = false python-versions = ">=3.7.0" files = [ - {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, - {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, ] [package.dependencies] wcwidth = "*" +[[package]] +name = "psutil" +version = "6.0.0" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"}, + {file = "psutil-6.0.0-cp27-none-win32.whl", hash = "sha256:02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"}, + {file = "psutil-6.0.0-cp27-none-win_amd64.whl", hash = "sha256:21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"}, + {file = "psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"}, + {file = "psutil-6.0.0-cp36-cp36m-win32.whl", hash = "sha256:fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"}, + {file = "psutil-6.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"}, + {file = "psutil-6.0.0-cp37-abi3-win32.whl", hash = "sha256:a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"}, + {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"}, + {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + [[package]] name = "ptyprocess" version = "0.7.0" @@ -1071,65 +2271,78 @@ files = [ [[package]] name = "pyarrow" -version = "16.0.0" +version = "17.0.0" description = "Python library for Apache Arrow" optional = false python-versions = ">=3.8" files = [ - {file = "pyarrow-16.0.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:22a1fdb1254e5095d629e29cd1ea98ed04b4bbfd8e42cc670a6b639ccc208b60"}, - {file = "pyarrow-16.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:574a00260a4ed9d118a14770edbd440b848fcae5a3024128be9d0274dbcaf858"}, - {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0815d0ddb733b8c1b53a05827a91f1b8bde6240f3b20bf9ba5d650eb9b89cdf"}, - {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:df0080339387b5d30de31e0a149c0c11a827a10c82f0c67d9afae3981d1aabb7"}, - {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:edf38cce0bf0dcf726e074159c60516447e4474904c0033f018c1f33d7dac6c5"}, - {file = "pyarrow-16.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:91d28f9a40f1264eab2af7905a4d95320ac2f287891e9c8b0035f264fe3c3a4b"}, - {file = "pyarrow-16.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:99af421ee451a78884d7faea23816c429e263bd3618b22d38e7992c9ce2a7ad9"}, - {file = "pyarrow-16.0.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:d22d0941e6c7bafddf5f4c0662e46f2075850f1c044bf1a03150dd9e189427ce"}, - {file = "pyarrow-16.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:266ddb7e823f03733c15adc8b5078db2df6980f9aa93d6bb57ece615df4e0ba7"}, - {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cc23090224b6594f5a92d26ad47465af47c1d9c079dd4a0061ae39551889efe"}, - {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56850a0afe9ef37249d5387355449c0f94d12ff7994af88f16803a26d38f2016"}, - {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:705db70d3e2293c2f6f8e84874b5b775f690465798f66e94bb2c07bab0a6bb55"}, - {file = "pyarrow-16.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:5448564754c154997bc09e95a44b81b9e31ae918a86c0fcb35c4aa4922756f55"}, - {file = "pyarrow-16.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:729f7b262aa620c9df8b9967db96c1575e4cfc8c25d078a06968e527b8d6ec05"}, - {file = "pyarrow-16.0.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:fb8065dbc0d051bf2ae2453af0484d99a43135cadabacf0af588a3be81fbbb9b"}, - {file = "pyarrow-16.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:20ce707d9aa390593ea93218b19d0eadab56390311cb87aad32c9a869b0e958c"}, - {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5823275c8addbbb50cd4e6a6839952682a33255b447277e37a6f518d6972f4e1"}, - {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ab8b9050752b16a8b53fcd9853bf07d8daf19093533e990085168f40c64d978"}, - {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:42e56557bc7c5c10d3e42c3b32f6cff649a29d637e8f4e8b311d334cc4326730"}, - {file = "pyarrow-16.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2a7abdee4a4a7cfa239e2e8d721224c4b34ffe69a0ca7981354fe03c1328789b"}, - {file = "pyarrow-16.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:ef2f309b68396bcc5a354106741d333494d6a0d3e1951271849787109f0229a6"}, - {file = "pyarrow-16.0.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:ed66e5217b4526fa3585b5e39b0b82f501b88a10d36bd0d2a4d8aa7b5a48e2df"}, - {file = "pyarrow-16.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cc8814310486f2a73c661ba8354540f17eef51e1b6dd090b93e3419d3a097b3a"}, - {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c2f5e239db7ed43e0ad2baf46a6465f89c824cc703f38ef0fde927d8e0955f7"}, - {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f293e92d1db251447cb028ae12f7bc47526e4649c3a9924c8376cab4ad6b98bd"}, - {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:dd9334a07b6dc21afe0857aa31842365a62eca664e415a3f9536e3a8bb832c07"}, - {file = "pyarrow-16.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:d91073d1e2fef2c121154680e2ba7e35ecf8d4969cc0af1fa6f14a8675858159"}, - {file = "pyarrow-16.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:71d52561cd7aefd22cf52538f262850b0cc9e4ec50af2aaa601da3a16ef48877"}, - {file = "pyarrow-16.0.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:b93c9a50b965ee0bf4fef65e53b758a7e8dcc0c2d86cebcc037aaaf1b306ecc0"}, - {file = "pyarrow-16.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d831690844706e374c455fba2fb8cfcb7b797bfe53ceda4b54334316e1ac4fa4"}, - {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35692ce8ad0b8c666aa60f83950957096d92f2a9d8d7deda93fb835e6053307e"}, - {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9dd3151d098e56f16a8389c1247137f9e4c22720b01c6f3aa6dec29a99b74d80"}, - {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:bd40467bdb3cbaf2044ed7a6f7f251c8f941c8b31275aaaf88e746c4f3ca4a7a"}, - {file = "pyarrow-16.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:00a1dcb22ad4ceb8af87f7bd30cc3354788776c417f493089e0a0af981bc8d80"}, - {file = "pyarrow-16.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:fda9a7cebd1b1d46c97b511f60f73a5b766a6de4c5236f144f41a5d5afec1f35"}, - {file = "pyarrow-16.0.0.tar.gz", hash = "sha256:59bb1f1edbbf4114c72415f039f1359f1a57d166a331c3229788ccbfbb31689a"}, + {file = "pyarrow-17.0.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:a5c8b238d47e48812ee577ee20c9a2779e6a5904f1708ae240f53ecbee7c9f07"}, + {file = "pyarrow-17.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:db023dc4c6cae1015de9e198d41250688383c3f9af8f565370ab2b4cb5f62655"}, + {file = "pyarrow-17.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da1e060b3876faa11cee287839f9cc7cdc00649f475714b8680a05fd9071d545"}, + {file = "pyarrow-17.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75c06d4624c0ad6674364bb46ef38c3132768139ddec1c56582dbac54f2663e2"}, + {file = "pyarrow-17.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:fa3c246cc58cb5a4a5cb407a18f193354ea47dd0648194e6265bd24177982fe8"}, + {file = "pyarrow-17.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:f7ae2de664e0b158d1607699a16a488de3d008ba99b3a7aa5de1cbc13574d047"}, + {file = "pyarrow-17.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:5984f416552eea15fd9cee03da53542bf4cddaef5afecefb9aa8d1010c335087"}, + {file = "pyarrow-17.0.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:1c8856e2ef09eb87ecf937104aacfa0708f22dfeb039c363ec99735190ffb977"}, + {file = "pyarrow-17.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e19f569567efcbbd42084e87f948778eb371d308e137a0f97afe19bb860ccb3"}, + {file = "pyarrow-17.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b244dc8e08a23b3e352899a006a26ae7b4d0da7bb636872fa8f5884e70acf15"}, + {file = "pyarrow-17.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b72e87fe3e1db343995562f7fff8aee354b55ee83d13afba65400c178ab2597"}, + {file = "pyarrow-17.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dc5c31c37409dfbc5d014047817cb4ccd8c1ea25d19576acf1a001fe07f5b420"}, + {file = "pyarrow-17.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e3343cb1e88bc2ea605986d4b94948716edc7a8d14afd4e2c097232f729758b4"}, + {file = "pyarrow-17.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:a27532c38f3de9eb3e90ecab63dfda948a8ca859a66e3a47f5f42d1e403c4d03"}, + {file = "pyarrow-17.0.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:9b8a823cea605221e61f34859dcc03207e52e409ccf6354634143e23af7c8d22"}, + {file = "pyarrow-17.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f1e70de6cb5790a50b01d2b686d54aaf73da01266850b05e3af2a1bc89e16053"}, + {file = "pyarrow-17.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0071ce35788c6f9077ff9ecba4858108eebe2ea5a3f7cf2cf55ebc1dbc6ee24a"}, + {file = "pyarrow-17.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:757074882f844411fcca735e39aae74248a1531367a7c80799b4266390ae51cc"}, + {file = "pyarrow-17.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:9ba11c4f16976e89146781a83833df7f82077cdab7dc6232c897789343f7891a"}, + {file = "pyarrow-17.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b0c6ac301093b42d34410b187bba560b17c0330f64907bfa4f7f7f2444b0cf9b"}, + {file = "pyarrow-17.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:392bc9feabc647338e6c89267635e111d71edad5fcffba204425a7c8d13610d7"}, + {file = "pyarrow-17.0.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:af5ff82a04b2171415f1410cff7ebb79861afc5dae50be73ce06d6e870615204"}, + {file = "pyarrow-17.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:edca18eaca89cd6382dfbcff3dd2d87633433043650c07375d095cd3517561d8"}, + {file = "pyarrow-17.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c7916bff914ac5d4a8fe25b7a25e432ff921e72f6f2b7547d1e325c1ad9d155"}, + {file = "pyarrow-17.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f553ca691b9e94b202ff741bdd40f6ccb70cdd5fbf65c187af132f1317de6145"}, + {file = "pyarrow-17.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:0cdb0e627c86c373205a2f94a510ac4376fdc523f8bb36beab2e7f204416163c"}, + {file = "pyarrow-17.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:d7d192305d9d8bc9082d10f361fc70a73590a4c65cf31c3e6926cd72b76bc35c"}, + {file = "pyarrow-17.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:02dae06ce212d8b3244dd3e7d12d9c4d3046945a5933d28026598e9dbbda1fca"}, + {file = "pyarrow-17.0.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:13d7a460b412f31e4c0efa1148e1d29bdf18ad1411eb6757d38f8fbdcc8645fb"}, + {file = "pyarrow-17.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9b564a51fbccfab5a04a80453e5ac6c9954a9c5ef2890d1bcf63741909c3f8df"}, + {file = "pyarrow-17.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32503827abbc5aadedfa235f5ece8c4f8f8b0a3cf01066bc8d29de7539532687"}, + {file = "pyarrow-17.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a155acc7f154b9ffcc85497509bcd0d43efb80d6f733b0dc3bb14e281f131c8b"}, + {file = "pyarrow-17.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:dec8d129254d0188a49f8a1fc99e0560dc1b85f60af729f47de4046015f9b0a5"}, + {file = "pyarrow-17.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:a48ddf5c3c6a6c505904545c25a4ae13646ae1f8ba703c4df4a1bfe4f4006bda"}, + {file = "pyarrow-17.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:42bf93249a083aca230ba7e2786c5f673507fa97bbd9725a1e2754715151a204"}, + {file = "pyarrow-17.0.0.tar.gz", hash = "sha256:4beca9521ed2c0921c1023e68d097d0299b62c362639ea315572a58f3f50fd28"}, ] [package.dependencies] numpy = ">=1.16.6" +[package.extras] +test = ["cffi", "hypothesis", "pandas", "pytest", "pytz"] + +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + [[package]] name = "pygments" -version = "2.17.2" +version = "2.18.0" description = "Pygments is a syntax highlighting package written in Python." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, - {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, ] [package.extras] -plugins = ["importlib-metadata"] windows-terminal = ["colorama (>=0.4.6)"] [[package]] @@ -1148,13 +2361,13 @@ diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" -version = "8.2.0" +version = "8.3.1" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ - {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"}, - {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"}, + {file = "pytest-8.3.1-py3-none-any.whl", hash = "sha256:e9600ccf4f563976e2c99fa02c7624ab938296551f280835ee6516df8bc4ae8c"}, + {file = "pytest-8.3.1.tar.gz", hash = "sha256:7e8e5c5abd6e93cb1cc151f23e57adc31fcf8cfd2a3ff2da63e23f732de35db6"}, ] [package.dependencies] @@ -1162,7 +2375,7 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" -pluggy = ">=1.5,<2.0" +pluggy = ">=1.5,<2" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] @@ -1182,6 +2395,17 @@ files = [ [package.dependencies] six = ">=1.5" +[[package]] +name = "python-json-logger" +version = "2.0.7" +description = "A python library adding a json log formatter" +optional = false +python-versions = ">=3.6" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + [[package]] name = "pytz" version = "2024.1" @@ -1193,89 +2417,459 @@ files = [ {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, ] +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.13" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, + {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, + {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, + {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, + {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, +] + +[[package]] +name = "pyzmq" +version = "26.0.3" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:44dd6fc3034f1eaa72ece33588867df9e006a7303725a12d64c3dff92330f625"}, + {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:acb704195a71ac5ea5ecf2811c9ee19ecdc62b91878528302dd0be1b9451cc90"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbb9c997932473a27afa93954bb77a9f9b786b4ccf718d903f35da3232317de"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6bcb34f869d431799c3ee7d516554797f7760cb2198ecaa89c3f176f72d062be"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ece17ec5f20d7d9b442e5174ae9f020365d01ba7c112205a4d59cf19dc38ee"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ba6e5e6588e49139a0979d03a7deb9c734bde647b9a8808f26acf9c547cab1bf"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3bf8b000a4e2967e6dfdd8656cd0757d18c7e5ce3d16339e550bd462f4857e59"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:2136f64fbb86451dbbf70223635a468272dd20075f988a102bf8a3f194a411dc"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e8918973fbd34e7814f59143c5f600ecd38b8038161239fd1a3d33d5817a38b8"}, + {file = "pyzmq-26.0.3-cp310-cp310-win32.whl", hash = "sha256:0aaf982e68a7ac284377d051c742610220fd06d330dcd4c4dbb4cdd77c22a537"}, + {file = "pyzmq-26.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:f1a9b7d00fdf60b4039f4455afd031fe85ee8305b019334b72dcf73c567edc47"}, + {file = "pyzmq-26.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:80b12f25d805a919d53efc0a5ad7c0c0326f13b4eae981a5d7b7cc343318ebb7"}, + {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:a72a84570f84c374b4c287183debc776dc319d3e8ce6b6a0041ce2e400de3f32"}, + {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7ca684ee649b55fd8f378127ac8462fb6c85f251c2fb027eb3c887e8ee347bcd"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e222562dc0f38571c8b1ffdae9d7adb866363134299264a1958d077800b193b7"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f17cde1db0754c35a91ac00b22b25c11da6eec5746431d6e5092f0cd31a3fea9"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7c0c0b3244bb2275abe255d4a30c050d541c6cb18b870975553f1fb6f37527"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac97a21de3712afe6a6c071abfad40a6224fd14fa6ff0ff8d0c6e6cd4e2f807a"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:88b88282e55fa39dd556d7fc04160bcf39dea015f78e0cecec8ff4f06c1fc2b5"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:72b67f966b57dbd18dcc7efbc1c7fc9f5f983e572db1877081f075004614fcdd"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f4b6cecbbf3b7380f3b61de3a7b93cb721125dc125c854c14ddc91225ba52f83"}, + {file = "pyzmq-26.0.3-cp311-cp311-win32.whl", hash = "sha256:eed56b6a39216d31ff8cd2f1d048b5bf1700e4b32a01b14379c3b6dde9ce3aa3"}, + {file = "pyzmq-26.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:3191d312c73e3cfd0f0afdf51df8405aafeb0bad71e7ed8f68b24b63c4f36500"}, + {file = "pyzmq-26.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:b6907da3017ef55139cf0e417c5123a84c7332520e73a6902ff1f79046cd3b94"}, + {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:068ca17214038ae986d68f4a7021f97e187ed278ab6dccb79f837d765a54d753"}, + {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7821d44fe07335bea256b9f1f41474a642ca55fa671dfd9f00af8d68a920c2d4"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb438a26d87c123bb318e5f2b3d86a36060b01f22fbdffd8cf247d52f7c9a2b"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69ea9d6d9baa25a4dc9cef5e2b77b8537827b122214f210dd925132e34ae9b12"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7daa3e1369355766dea11f1d8ef829905c3b9da886ea3152788dc25ee6079e02"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6ca7a9a06b52d0e38ccf6bca1aeff7be178917893f3883f37b75589d42c4ac20"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1b7d0e124948daa4d9686d421ef5087c0516bc6179fdcf8828b8444f8e461a77"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e746524418b70f38550f2190eeee834db8850088c834d4c8406fbb9bc1ae10b2"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:6b3146f9ae6af82c47a5282ac8803523d381b3b21caeae0327ed2f7ecb718798"}, + {file = "pyzmq-26.0.3-cp312-cp312-win32.whl", hash = "sha256:2b291d1230845871c00c8462c50565a9cd6026fe1228e77ca934470bb7d70ea0"}, + {file = "pyzmq-26.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:926838a535c2c1ea21c903f909a9a54e675c2126728c21381a94ddf37c3cbddf"}, + {file = "pyzmq-26.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:5bf6c237f8c681dfb91b17f8435b2735951f0d1fad10cc5dfd96db110243370b"}, + {file = "pyzmq-26.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c0991f5a96a8e620f7691e61178cd8f457b49e17b7d9cfa2067e2a0a89fc1d5"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:dbf012d8fcb9f2cf0643b65df3b355fdd74fc0035d70bb5c845e9e30a3a4654b"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:01fbfbeb8249a68d257f601deb50c70c929dc2dfe683b754659569e502fbd3aa"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c8eb19abe87029c18f226d42b8a2c9efdd139d08f8bf6e085dd9075446db450"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5344b896e79800af86ad643408ca9aa303a017f6ebff8cee5a3163c1e9aec987"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:204e0f176fd1d067671157d049466869b3ae1fc51e354708b0dc41cf94e23a3a"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a42db008d58530efa3b881eeee4991146de0b790e095f7ae43ba5cc612decbc5"}, + {file = "pyzmq-26.0.3-cp37-cp37m-win32.whl", hash = "sha256:8d7a498671ca87e32b54cb47c82a92b40130a26c5197d392720a1bce1b3c77cf"}, + {file = "pyzmq-26.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:3b4032a96410bdc760061b14ed6a33613ffb7f702181ba999df5d16fb96ba16a"}, + {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2cc4e280098c1b192c42a849de8de2c8e0f3a84086a76ec5b07bfee29bda7d18"}, + {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5bde86a2ed3ce587fa2b207424ce15b9a83a9fa14422dcc1c5356a13aed3df9d"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:34106f68e20e6ff253c9f596ea50397dbd8699828d55e8fa18bd4323d8d966e6"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ebbbd0e728af5db9b04e56389e2299a57ea8b9dd15c9759153ee2455b32be6ad"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6b1d1c631e5940cac5a0b22c5379c86e8df6a4ec277c7a856b714021ab6cfad"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e891ce81edd463b3b4c3b885c5603c00141151dd9c6936d98a680c8c72fe5c67"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:9b273ecfbc590a1b98f014ae41e5cf723932f3b53ba9367cfb676f838038b32c"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b32bff85fb02a75ea0b68f21e2412255b5731f3f389ed9aecc13a6752f58ac97"}, + {file = "pyzmq-26.0.3-cp38-cp38-win32.whl", hash = "sha256:f6c21c00478a7bea93caaaef9e7629145d4153b15a8653e8bb4609d4bc70dbfc"}, + {file = "pyzmq-26.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:3401613148d93ef0fd9aabdbddb212de3db7a4475367f49f590c837355343972"}, + {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:2ed8357f4c6e0daa4f3baf31832df8a33334e0fe5b020a61bc8b345a3db7a606"}, + {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c1c8f2a2ca45292084c75bb6d3a25545cff0ed931ed228d3a1810ae3758f975f"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b63731993cdddcc8e087c64e9cf003f909262b359110070183d7f3025d1c56b5"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b3cd31f859b662ac5d7f4226ec7d8bd60384fa037fc02aee6ff0b53ba29a3ba8"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115f8359402fa527cf47708d6f8a0f8234f0e9ca0cab7c18c9c189c194dbf620"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:715bdf952b9533ba13dfcf1f431a8f49e63cecc31d91d007bc1deb914f47d0e4"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:e1258c639e00bf5e8a522fec6c3eaa3e30cf1c23a2f21a586be7e04d50c9acab"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15c59e780be8f30a60816a9adab900c12a58d79c1ac742b4a8df044ab2a6d920"}, + {file = "pyzmq-26.0.3-cp39-cp39-win32.whl", hash = "sha256:d0cdde3c78d8ab5b46595054e5def32a755fc028685add5ddc7403e9f6de9879"}, + {file = "pyzmq-26.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:ce828058d482ef860746bf532822842e0ff484e27f540ef5c813d516dd8896d2"}, + {file = "pyzmq-26.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:788f15721c64109cf720791714dc14afd0f449d63f3a5487724f024345067381"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2c18645ef6294d99b256806e34653e86236eb266278c8ec8112622b61db255de"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e6bc96ebe49604df3ec2c6389cc3876cabe475e6bfc84ced1bf4e630662cb35"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:971e8990c5cc4ddcff26e149398fc7b0f6a042306e82500f5e8db3b10ce69f84"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8416c23161abd94cc7da80c734ad7c9f5dbebdadfdaa77dad78244457448223"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:082a2988364b60bb5de809373098361cf1dbb239623e39e46cb18bc035ed9c0c"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d57dfbf9737763b3a60d26e6800e02e04284926329aee8fb01049635e957fe81"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:77a85dca4c2430ac04dc2a2185c2deb3858a34fe7f403d0a946fa56970cf60a1"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c82a6d952a1d555bf4be42b6532927d2a5686dd3c3e280e5f63225ab47ac1f5"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4496b1282c70c442809fc1b151977c3d967bfb33e4e17cedbf226d97de18f709"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:e4946d6bdb7ba972dfda282f9127e5756d4f299028b1566d1245fa0d438847e6"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:03c0ae165e700364b266876d712acb1ac02693acd920afa67da2ebb91a0b3c09"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3e3070e680f79887d60feeda051a58d0ac36622e1759f305a41059eff62c6da7"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6ca08b840fe95d1c2bd9ab92dac5685f949fc6f9ae820ec16193e5ddf603c3b2"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e76654e9dbfb835b3518f9938e565c7806976c07b37c33526b574cc1a1050480"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:871587bdadd1075b112e697173e946a07d722459d20716ceb3d1bd6c64bd08ce"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d0a2d1bd63a4ad79483049b26514e70fa618ce6115220da9efdff63688808b17"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0270b49b6847f0d106d64b5086e9ad5dc8a902413b5dbbb15d12b60f9c1747a4"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:703c60b9910488d3d0954ca585c34f541e506a091a41930e663a098d3b794c67"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74423631b6be371edfbf7eabb02ab995c2563fee60a80a30829176842e71722a"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4adfbb5451196842a88fda3612e2c0414134874bffb1c2ce83ab4242ec9e027d"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3516119f4f9b8671083a70b6afaa0a070f5683e431ab3dc26e9215620d7ca1ad"}, + {file = "pyzmq-26.0.3.tar.gz", hash = "sha256:dba7d9f2e047dfa2bca3b01f4f84aa5246725203d6284e3790f2ca15fba6b40a"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + +[[package]] +name = "referencing" +version = "0.35.1" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + +[[package]] +name = "requests" +version = "2.32.3" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.8" +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +description = "A pure python RFC3339 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[package.dependencies] +six = "*" + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +description = "Pure python rfc3986 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rpds-py" +version = "0.19.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.19.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:fb37bd599f031f1a6fb9e58ec62864ccf3ad549cf14bac527dbfa97123edcca4"}, + {file = "rpds_py-0.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3384d278df99ec2c6acf701d067147320b864ef6727405d6470838476e44d9e8"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54548e0be3ac117595408fd4ca0ac9278fde89829b0b518be92863b17ff67a2"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8eb488ef928cdbc05a27245e52de73c0d7c72a34240ef4d9893fdf65a8c1a955"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a5da93debdfe27b2bfc69eefb592e1831d957b9535e0943a0ee8b97996de21b5"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79e205c70afddd41f6ee79a8656aec738492a550247a7af697d5bd1aee14f766"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:959179efb3e4a27610e8d54d667c02a9feaa86bbabaf63efa7faa4dfa780d4f1"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a6e605bb9edcf010f54f8b6a590dd23a4b40a8cb141255eec2a03db249bc915b"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9133d75dc119a61d1a0ded38fb9ba40a00ef41697cc07adb6ae098c875195a3f"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd36b712d35e757e28bf2f40a71e8f8a2d43c8b026d881aa0c617b450d6865c9"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354f3a91718489912f2e0fc331c24eaaf6a4565c080e00fbedb6015857c00582"}, + {file = "rpds_py-0.19.0-cp310-none-win32.whl", hash = "sha256:ebcbf356bf5c51afc3290e491d3722b26aaf5b6af3c1c7f6a1b757828a46e336"}, + {file = "rpds_py-0.19.0-cp310-none-win_amd64.whl", hash = "sha256:75a6076289b2df6c8ecb9d13ff79ae0cad1d5fb40af377a5021016d58cd691ec"}, + {file = "rpds_py-0.19.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6d45080095e585f8c5097897313def60caa2046da202cdb17a01f147fb263b81"}, + {file = "rpds_py-0.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c5c9581019c96f865483d031691a5ff1cc455feb4d84fc6920a5ffc48a794d8a"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1540d807364c84516417115c38f0119dfec5ea5c0dd9a25332dea60b1d26fc4d"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9e65489222b410f79711dc3d2d5003d2757e30874096b2008d50329ea4d0f88c"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9da6f400eeb8c36f72ef6646ea530d6d175a4f77ff2ed8dfd6352842274c1d8b"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37f46bb11858717e0efa7893c0f7055c43b44c103e40e69442db5061cb26ed34"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:071d4adc734de562bd11d43bd134330fb6249769b2f66b9310dab7460f4bf714"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9625367c8955e4319049113ea4f8fee0c6c1145192d57946c6ffcd8fe8bf48dd"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e19509145275d46bc4d1e16af0b57a12d227c8253655a46bbd5ec317e941279d"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d438e4c020d8c39961deaf58f6913b1bf8832d9b6f62ec35bd93e97807e9cbc"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90bf55d9d139e5d127193170f38c584ed3c79e16638890d2e36f23aa1630b952"}, + {file = "rpds_py-0.19.0-cp311-none-win32.whl", hash = "sha256:8d6ad132b1bc13d05ffe5b85e7a01a3998bf3a6302ba594b28d61b8c2cf13aaf"}, + {file = "rpds_py-0.19.0-cp311-none-win_amd64.whl", hash = "sha256:7ec72df7354e6b7f6eb2a17fa6901350018c3a9ad78e48d7b2b54d0412539a67"}, + {file = "rpds_py-0.19.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:5095a7c838a8647c32aa37c3a460d2c48debff7fc26e1136aee60100a8cd8f68"}, + {file = "rpds_py-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f2f78ef14077e08856e788fa482107aa602636c16c25bdf59c22ea525a785e9"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7cc6cb44f8636fbf4a934ca72f3e786ba3c9f9ba4f4d74611e7da80684e48d2"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf902878b4af334a09de7a45badbff0389e7cf8dc2e4dcf5f07125d0b7c2656d"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:688aa6b8aa724db1596514751ffb767766e02e5c4a87486ab36b8e1ebc1aedac"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57dbc9167d48e355e2569346b5aa4077f29bf86389c924df25c0a8b9124461fb"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b4cf5a9497874822341c2ebe0d5850fed392034caadc0bad134ab6822c0925b"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8a790d235b9d39c70a466200d506bb33a98e2ee374a9b4eec7a8ac64c2c261fa"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1d16089dfa58719c98a1c06f2daceba6d8e3fb9b5d7931af4a990a3c486241cb"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bc9128e74fe94650367fe23f37074f121b9f796cabbd2f928f13e9661837296d"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c8f77e661ffd96ff104bebf7d0f3255b02aa5d5b28326f5408d6284c4a8b3248"}, + {file = "rpds_py-0.19.0-cp312-none-win32.whl", hash = "sha256:5f83689a38e76969327e9b682be5521d87a0c9e5a2e187d2bc6be4765f0d4600"}, + {file = "rpds_py-0.19.0-cp312-none-win_amd64.whl", hash = "sha256:06925c50f86da0596b9c3c64c3837b2481337b83ef3519e5db2701df695453a4"}, + {file = "rpds_py-0.19.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:52e466bea6f8f3a44b1234570244b1cff45150f59a4acae3fcc5fd700c2993ca"}, + {file = "rpds_py-0.19.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e21cc693045fda7f745c790cb687958161ce172ffe3c5719ca1764e752237d16"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b31f059878eb1f5da8b2fd82480cc18bed8dcd7fb8fe68370e2e6285fa86da6"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1dd46f309e953927dd018567d6a9e2fb84783963650171f6c5fe7e5c41fd5666"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34a01a4490e170376cd79258b7f755fa13b1a6c3667e872c8e35051ae857a92b"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcf426a8c38eb57f7bf28932e68425ba86def6e756a5b8cb4731d8e62e4e0223"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f68eea5df6347d3f1378ce992d86b2af16ad7ff4dcb4a19ccdc23dea901b87fb"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dab8d921b55a28287733263c0e4c7db11b3ee22aee158a4de09f13c93283c62d"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6fe87efd7f47266dfc42fe76dae89060038f1d9cb911f89ae7e5084148d1cc08"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:535d4b52524a961d220875688159277f0e9eeeda0ac45e766092bfb54437543f"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:8b1a94b8afc154fbe36978a511a1f155f9bd97664e4f1f7a374d72e180ceb0ae"}, + {file = "rpds_py-0.19.0-cp38-none-win32.whl", hash = "sha256:7c98298a15d6b90c8f6e3caa6457f4f022423caa5fa1a1ca7a5e9e512bdb77a4"}, + {file = "rpds_py-0.19.0-cp38-none-win_amd64.whl", hash = "sha256:b0da31853ab6e58a11db3205729133ce0df26e6804e93079dee095be3d681dc1"}, + {file = "rpds_py-0.19.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5039e3cef7b3e7a060de468a4a60a60a1f31786da94c6cb054e7a3c75906111c"}, + {file = "rpds_py-0.19.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ab1932ca6cb8c7499a4d87cb21ccc0d3326f172cfb6a64021a889b591bb3045c"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2afd2164a1e85226fcb6a1da77a5c8896c18bfe08e82e8ceced5181c42d2179"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1c30841f5040de47a0046c243fc1b44ddc87d1b12435a43b8edff7e7cb1e0d0"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f757f359f30ec7dcebca662a6bd46d1098f8b9fb1fcd661a9e13f2e8ce343ba1"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15e65395a59d2e0e96caf8ee5389ffb4604e980479c32742936ddd7ade914b22"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb0f6eb3a320f24b94d177e62f4074ff438f2ad9d27e75a46221904ef21a7b05"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b228e693a2559888790936e20f5f88b6e9f8162c681830eda303bad7517b4d5a"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2575efaa5d949c9f4e2cdbe7d805d02122c16065bfb8d95c129372d65a291a0b"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:5c872814b77a4e84afa293a1bee08c14daed1068b2bb1cc312edbf020bbbca2b"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:850720e1b383df199b8433a20e02b25b72f0fded28bc03c5bd79e2ce7ef050be"}, + {file = "rpds_py-0.19.0-cp39-none-win32.whl", hash = "sha256:ce84a7efa5af9f54c0aa7692c45861c1667080814286cacb9958c07fc50294fb"}, + {file = "rpds_py-0.19.0-cp39-none-win_amd64.whl", hash = "sha256:1c26da90b8d06227d7769f34915913911222d24ce08c0ab2d60b354e2d9c7aff"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:75969cf900d7be665ccb1622a9aba225cf386bbc9c3bcfeeab9f62b5048f4a07"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8445f23f13339da640d1be8e44e5baf4af97e396882ebbf1692aecd67f67c479"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5a7c1062ef8aea3eda149f08120f10795835fc1c8bc6ad948fb9652a113ca55"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:462b0c18fbb48fdbf980914a02ee38c423a25fcc4cf40f66bacc95a2d2d73bc8"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3208f9aea18991ac7f2b39721e947bbd752a1abbe79ad90d9b6a84a74d44409b"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3444fe52b82f122d8a99bf66777aed6b858d392b12f4c317da19f8234db4533"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88cb4bac7185a9f0168d38c01d7a00addece9822a52870eee26b8d5b61409213"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6b130bd4163c93798a6b9bb96be64a7c43e1cec81126ffa7ffaa106e1fc5cef5"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:a707b158b4410aefb6b054715545bbb21aaa5d5d0080217290131c49c2124a6e"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:dc9ac4659456bde7c567107556ab065801622396b435a3ff213daef27b495388"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:81ea573aa46d3b6b3d890cd3c0ad82105985e6058a4baed03cf92518081eec8c"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3f148c3f47f7f29a79c38cc5d020edcb5ca780020fab94dbc21f9af95c463581"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0906357f90784a66e89ae3eadc2654f36c580a7d65cf63e6a616e4aec3a81be"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f629ecc2db6a4736b5ba95a8347b0089240d69ad14ac364f557d52ad68cf94b0"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6feacd1d178c30e5bc37184526e56740342fd2aa6371a28367bad7908d454fc"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae8b6068ee374fdfab63689be0963333aa83b0815ead5d8648389a8ded593378"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78d57546bad81e0da13263e4c9ce30e96dcbe720dbff5ada08d2600a3502e526"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8b6683a37338818646af718c9ca2a07f89787551057fae57c4ec0446dc6224b"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e8481b946792415adc07410420d6fc65a352b45d347b78fec45d8f8f0d7496f0"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:bec35eb20792ea64c3c57891bc3ca0bedb2884fbac2c8249d9b731447ecde4fa"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:aa5476c3e3a402c37779e95f7b4048db2cb5b0ed0b9d006983965e93f40fe05a"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:19d02c45f2507b489fd4df7b827940f1420480b3e2e471e952af4d44a1ea8e34"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a3e2fd14c5d49ee1da322672375963f19f32b3d5953f0615b175ff7b9d38daed"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:93a91c2640645303e874eada51f4f33351b84b351a689d470f8108d0e0694210"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5b9fc03bf76a94065299d4a2ecd8dfbae4ae8e2e8098bbfa6ab6413ca267709"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a4b07cdf3f84310c08c1de2c12ddadbb7a77568bcb16e95489f9c81074322ed"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba0ed0dc6763d8bd6e5de5cf0d746d28e706a10b615ea382ac0ab17bb7388633"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:474bc83233abdcf2124ed3f66230a1c8435896046caa4b0b5ab6013c640803cc"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:329c719d31362355a96b435f4653e3b4b061fcc9eba9f91dd40804ca637d914e"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef9101f3f7b59043a34f1dccbb385ca760467590951952d6701df0da9893ca0c"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:0121803b0f424ee2109d6e1f27db45b166ebaa4b32ff47d6aa225642636cd834"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:8344127403dea42f5970adccf6c5957a71a47f522171fafaf4c6ddb41b61703a"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:443cec402ddd650bb2b885113e1dcedb22b1175c6be223b14246a714b61cd521"}, + {file = "rpds_py-0.19.0.tar.gz", hash = "sha256:4fdc9afadbeb393b4bbbad75481e0ea78e4469f2e1d713a90811700830b553a9"}, +] + [[package]] name = "scikit-learn" -version = "1.4.2" +version = "1.5.1" description = "A set of python modules for machine learning and data mining" optional = false python-versions = ">=3.9" files = [ - {file = "scikit-learn-1.4.2.tar.gz", hash = "sha256:daa1c471d95bad080c6e44b4946c9390a4842adc3082572c20e4f8884e39e959"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8539a41b3d6d1af82eb629f9c57f37428ff1481c1e34dddb3b9d7af8ede67ac5"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:68b8404841f944a4a1459b07198fa2edd41a82f189b44f3e1d55c104dbc2e40c"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81bf5d8bbe87643103334032dd82f7419bc8c8d02a763643a6b9a5c7288c5054"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36f0ea5d0f693cb247a073d21a4123bdf4172e470e6d163c12b74cbb1536cf38"}, - {file = "scikit_learn-1.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:87440e2e188c87db80ea4023440923dccbd56fbc2d557b18ced00fef79da0727"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:45dee87ac5309bb82e3ea633955030df9bbcb8d2cdb30383c6cd483691c546cc"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1d0b25d9c651fd050555aadd57431b53d4cf664e749069da77f3d52c5ad14b3b"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0203c368058ab92efc6168a1507d388d41469c873e96ec220ca8e74079bf62e"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44c62f2b124848a28fd695db5bc4da019287abf390bfce602ddc8aa1ec186aae"}, - {file = "scikit_learn-1.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:5cd7b524115499b18b63f0c96f4224eb885564937a0b3477531b2b63ce331904"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:90378e1747949f90c8f385898fff35d73193dfcaec3dd75d6b542f90c4e89755"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ff4effe5a1d4e8fed260a83a163f7dbf4f6087b54528d8880bab1d1377bd78be"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:671e2f0c3f2c15409dae4f282a3a619601fa824d2c820e5b608d9d775f91780c"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d36d0bc983336bbc1be22f9b686b50c964f593c8a9a913a792442af9bf4f5e68"}, - {file = "scikit_learn-1.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:d762070980c17ba3e9a4a1e043ba0518ce4c55152032f1af0ca6f39b376b5928"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d9993d5e78a8148b1d0fdf5b15ed92452af5581734129998c26f481c46586d68"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:426d258fddac674fdf33f3cb2d54d26f49406e2599dbf9a32b4d1696091d4256"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5460a1a5b043ae5ae4596b3126a4ec33ccba1b51e7ca2c5d36dac2169f62ab1d"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49d64ef6cb8c093d883e5a36c4766548d974898d378e395ba41a806d0e824db8"}, - {file = "scikit_learn-1.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:c97a50b05c194be9146d61fe87dbf8eac62b203d9e87a3ccc6ae9aed2dfaf361"}, + {file = "scikit_learn-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:781586c414f8cc58e71da4f3d7af311e0505a683e112f2f62919e3019abd3745"}, + {file = "scikit_learn-1.5.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f5b213bc29cc30a89a3130393b0e39c847a15d769d6e59539cd86b75d276b1a7"}, + {file = "scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ff4ba34c2abff5ec59c803ed1d97d61b036f659a17f55be102679e88f926fac"}, + {file = "scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:161808750c267b77b4a9603cf9c93579c7a74ba8486b1336034c2f1579546d21"}, + {file = "scikit_learn-1.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:10e49170691514a94bb2e03787aa921b82dbc507a4ea1f20fd95557862c98dc1"}, + {file = "scikit_learn-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:154297ee43c0b83af12464adeab378dee2d0a700ccd03979e2b821e7dd7cc1c2"}, + {file = "scikit_learn-1.5.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:b5e865e9bd59396220de49cb4a57b17016256637c61b4c5cc81aaf16bc123bbe"}, + {file = "scikit_learn-1.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:909144d50f367a513cee6090873ae582dba019cb3fca063b38054fa42704c3a4"}, + {file = "scikit_learn-1.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:689b6f74b2c880276e365fe84fe4f1befd6a774f016339c65655eaff12e10cbf"}, + {file = "scikit_learn-1.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:9a07f90846313a7639af6a019d849ff72baadfa4c74c778821ae0fad07b7275b"}, + {file = "scikit_learn-1.5.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5944ce1faada31c55fb2ba20a5346b88e36811aab504ccafb9f0339e9f780395"}, + {file = "scikit_learn-1.5.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0828673c5b520e879f2af6a9e99eee0eefea69a2188be1ca68a6121b809055c1"}, + {file = "scikit_learn-1.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:508907e5f81390e16d754e8815f7497e52139162fd69c4fdbd2dfa5d6cc88915"}, + {file = "scikit_learn-1.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97625f217c5c0c5d0505fa2af28ae424bd37949bb2f16ace3ff5f2f81fb4498b"}, + {file = "scikit_learn-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:da3f404e9e284d2b0a157e1b56b6566a34eb2798205cba35a211df3296ab7a74"}, + {file = "scikit_learn-1.5.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:88e0672c7ac21eb149d409c74cc29f1d611d5158175846e7a9c2427bd12b3956"}, + {file = "scikit_learn-1.5.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:7b073a27797a283187a4ef4ee149959defc350b46cbf63a84d8514fe16b69855"}, + {file = "scikit_learn-1.5.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b59e3e62d2be870e5c74af4e793293753565c7383ae82943b83383fdcf5cc5c1"}, + {file = "scikit_learn-1.5.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bd8d3a19d4bd6dc5a7d4f358c8c3a60934dc058f363c34c0ac1e9e12a31421d"}, + {file = "scikit_learn-1.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:5f57428de0c900a98389c4a433d4a3cf89de979b3aa24d1c1d251802aa15e44d"}, + {file = "scikit_learn-1.5.1.tar.gz", hash = "sha256:0ea5d40c0e3951df445721927448755d3fe1d80833b0b7308ebff5d2a45e6414"}, ] [package.dependencies] joblib = ">=1.2.0" numpy = ">=1.19.5" scipy = ">=1.6.0" -threadpoolctl = ">=2.0.0" +threadpoolctl = ">=3.1.0" [package.extras] -benchmark = ["matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "pandas (>=1.1.5)"] -docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.16.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-gallery (>=0.16.0)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)"] examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] -tests = ["black (>=23.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.19.12)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.17.2)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] [[package]] name = "scipy" -version = "1.13.0" +version = "1.14.0" description = "Fundamental algorithms for scientific computing in Python" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" files = [ - {file = "scipy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba419578ab343a4e0a77c0ef82f088238a93eef141b2b8017e46149776dfad4d"}, - {file = "scipy-1.13.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:22789b56a999265431c417d462e5b7f2b487e831ca7bef5edeb56efe4c93f86e"}, - {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05f1432ba070e90d42d7fd836462c50bf98bd08bed0aa616c359eed8a04e3922"}, - {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8434f6f3fa49f631fae84afee424e2483289dfc30a47755b4b4e6b07b2633a4"}, - {file = "scipy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:dcbb9ea49b0167de4167c40eeee6e167caeef11effb0670b554d10b1e693a8b9"}, - {file = "scipy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:1d2f7bb14c178f8b13ebae93f67e42b0a6b0fc50eba1cd8021c9b6e08e8fb1cd"}, - {file = "scipy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fbcf8abaf5aa2dc8d6400566c1a727aed338b5fe880cde64907596a89d576fa"}, - {file = "scipy-1.13.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5e4a756355522eb60fcd61f8372ac2549073c8788f6114449b37e9e8104f15a5"}, - {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5acd8e1dbd8dbe38d0004b1497019b2dbbc3d70691e65d69615f8a7292865d7"}, - {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ff7dad5d24a8045d836671e082a490848e8639cabb3dbdacb29f943a678683d"}, - {file = "scipy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4dca18c3ffee287ddd3bc8f1dabaf45f5305c5afc9f8ab9cbfab855e70b2df5c"}, - {file = "scipy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a2f471de4d01200718b2b8927f7d76b5d9bde18047ea0fa8bd15c5ba3f26a1d6"}, - {file = "scipy-1.13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0de696f589681c2802f9090fff730c218f7c51ff49bf252b6a97ec4a5d19e8b"}, - {file = "scipy-1.13.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b2a3ff461ec4756b7e8e42e1c681077349a038f0686132d623fa404c0bee2551"}, - {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf9fe63e7a4bf01d3645b13ff2aa6dea023d38993f42aaac81a18b1bda7a82a"}, - {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e7626dfd91cdea5714f343ce1176b6c4745155d234f1033584154f60ef1ff42"}, - {file = "scipy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:109d391d720fcebf2fbe008621952b08e52907cf4c8c7efc7376822151820820"}, - {file = "scipy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8930ae3ea371d6b91c203b1032b9600d69c568e537b7988a3073dfe4d4774f21"}, - {file = "scipy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5407708195cb38d70fd2d6bb04b1b9dd5c92297d86e9f9daae1576bd9e06f602"}, - {file = "scipy-1.13.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:ac38c4c92951ac0f729c4c48c9e13eb3675d9986cc0c83943784d7390d540c78"}, - {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09c74543c4fbeb67af6ce457f6a6a28e5d3739a87f62412e4a16e46f164f0ae5"}, - {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28e286bf9ac422d6beb559bc61312c348ca9b0f0dae0d7c5afde7f722d6ea13d"}, - {file = "scipy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:33fde20efc380bd23a78a4d26d59fc8704e9b5fd9b08841693eb46716ba13d86"}, - {file = "scipy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:45c08bec71d3546d606989ba6e7daa6f0992918171e2a6f7fbedfa7361c2de1e"}, - {file = "scipy-1.13.0.tar.gz", hash = "sha256:58569af537ea29d3f78e5abd18398459f195546bb3be23d16677fb26616cc11e"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7e911933d54ead4d557c02402710c2396529540b81dd554fc1ba270eb7308484"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:687af0a35462402dd851726295c1a5ae5f987bd6e9026f52e9505994e2f84ef6"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:07e179dc0205a50721022344fb85074f772eadbda1e1b3eecdc483f8033709b7"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:6a9c9a9b226d9a21e0a208bdb024c3982932e43811b62d202aaf1bb59af264b1"}, + {file = "scipy-1.14.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:076c27284c768b84a45dcf2e914d4000aac537da74236a0d45d82c6fa4b7b3c0"}, + {file = "scipy-1.14.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42470ea0195336df319741e230626b6225a740fd9dce9642ca13e98f667047c0"}, + {file = "scipy-1.14.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:176c6f0d0470a32f1b2efaf40c3d37a24876cebf447498a4cefb947a79c21e9d"}, + {file = "scipy-1.14.0-cp310-cp310-win_amd64.whl", hash = "sha256:ad36af9626d27a4326c8e884917b7ec321d8a1841cd6dacc67d2a9e90c2f0359"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6d056a8709ccda6cf36cdd2eac597d13bc03dba38360f418560a93050c76a16e"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f0a50da861a7ec4573b7c716b2ebdcdf142b66b756a0d392c236ae568b3a93fb"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:94c164a9e2498e68308e6e148646e486d979f7fcdb8b4cf34b5441894bdb9caf"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:a7d46c3e0aea5c064e734c3eac5cf9eb1f8c4ceee756262f2c7327c4c2691c86"}, + {file = "scipy-1.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9eee2989868e274aae26125345584254d97c56194c072ed96cb433f32f692ed8"}, + {file = "scipy-1.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e3154691b9f7ed73778d746da2df67a19d046a6c8087c8b385bc4cdb2cfca74"}, + {file = "scipy-1.14.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c40003d880f39c11c1edbae8144e3813904b10514cd3d3d00c277ae996488cdb"}, + {file = "scipy-1.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:5b083c8940028bb7e0b4172acafda6df762da1927b9091f9611b0bcd8676f2bc"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bff2438ea1330e06e53c424893ec0072640dac00f29c6a43a575cbae4c99b2b9"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bbc0471b5f22c11c389075d091d3885693fd3f5e9a54ce051b46308bc787e5d4"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:64b2ff514a98cf2bb734a9f90d32dc89dc6ad4a4a36a312cd0d6327170339eb0"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:7d3da42fbbbb860211a811782504f38ae7aaec9de8764a9bef6b262de7a2b50f"}, + {file = "scipy-1.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d91db2c41dd6c20646af280355d41dfa1ec7eead235642178bd57635a3f82209"}, + {file = "scipy-1.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a01cc03bcdc777c9da3cfdcc74b5a75caffb48a6c39c8450a9a05f82c4250a14"}, + {file = "scipy-1.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:65df4da3c12a2bb9ad52b86b4dcf46813e869afb006e58be0f516bc370165159"}, + {file = "scipy-1.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:4c4161597c75043f7154238ef419c29a64ac4a7c889d588ea77690ac4d0d9b20"}, + {file = "scipy-1.14.0.tar.gz", hash = "sha256:b5923f48cb840380f9854339176ef21763118a7300a88203ccd0bdd26e58527b"}, ] [package.dependencies] -numpy = ">=1.22.4,<2.3" +numpy = ">=1.23.5,<2.3" [package.extras] -dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] -doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] -test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.13.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["Cython", "array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] [[package]] name = "seaborn" @@ -1298,6 +2892,22 @@ dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"] +[[package]] +name = "send2trash" +version = "1.8.3" +description = "Send file to trash natively under Mac OS X, Windows and Linux" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[package.extras] +nativelib = ["pyobjc-framework-Cocoa", "pywin32"] +objc = ["pyobjc-framework-Cocoa"] +win32 = ["pywin32"] + [[package]] name = "six" version = "1.16.0" @@ -1309,6 +2919,28 @@ files = [ {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, ] +[[package]] +name = "sniffio" +version = "1.3.1" +description = "Sniff out which async library your code is running under" +optional = false +python-versions = ">=3.7" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "soupsieve" +version = "2.5" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -1328,6 +2960,27 @@ pure-eval = "*" [package.extras] tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] +[[package]] +name = "terminado" +version = "0.18.1" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] + [[package]] name = "threadpoolctl" version = "3.5.0" @@ -1339,6 +2992,24 @@ files = [ {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"}, ] +[[package]] +name = "tinycss2" +version = "1.3.0" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["pytest", "ruff"] + [[package]] name = "tomli" version = "2.0.1" @@ -1350,6 +3021,26 @@ files = [ {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] +[[package]] +name = "tornado" +version = "6.4.1" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">=3.8" +files = [ + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698"}, + {file = "tornado-6.4.1-cp38-abi3-win32.whl", hash = "sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d"}, + {file = "tornado-6.4.1-cp38-abi3-win_amd64.whl", hash = "sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7"}, + {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"}, +] + [[package]] name = "traitlets" version = "5.14.3" @@ -1365,15 +3056,26 @@ files = [ docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240316" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.9.0.20240316.tar.gz", hash = "sha256:5d2f2e240b86905e40944dd787db6da9263f0deabef1076ddaed797351ec0202"}, + {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"}, +] + [[package]] name = "typing-extensions" -version = "4.11.0" +version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" files = [ - {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, - {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, ] [[package]] @@ -1387,6 +3089,37 @@ files = [ {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, ] +[[package]] +name = "uri-template" +version = "1.3.0" +description = "RFC 6570 URI Template Processor" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[package.extras] +dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] + +[[package]] +name = "urllib3" +version = "2.2.2" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + [[package]] name = "wcwidth" version = "0.2.13" @@ -1398,7 +3131,151 @@ files = [ {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, ] +[[package]] +name = "webcolors" +version = "24.6.0" +description = "A library for working with the color formats defined by HTML and CSS." +optional = false +python-versions = ">=3.8" +files = [ + {file = "webcolors-24.6.0-py3-none-any.whl", hash = "sha256:8cf5bc7e28defd1d48b9e83d5fc30741328305a8195c29a8e668fa45586568a1"}, + {file = "webcolors-24.6.0.tar.gz", hash = "sha256:1d160d1de46b3e81e58d0a280d0c78b467dc80f47294b91b1ad8029d2cedb55b"}, +] + +[package.extras] +docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] +tests = ["coverage[toml]"] + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +optional = false +python-versions = "*" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +description = "WebSocket client for Python with low level API options" +optional = false +python-versions = ">=3.8" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "y-py" +version = "0.6.2" +description = "Python bindings for the Y-CRDT built from yrs (Rust)" +optional = false +python-versions = "*" +files = [ + {file = "y_py-0.6.2-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:c26bada6cd109095139237a46f50fc4308f861f0d304bc9e70acbc6c4503d158"}, + {file = "y_py-0.6.2-cp310-cp310-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:bae1b1ad8d2b8cf938a60313f8f7461de609621c5dcae491b6e54975f76f83c5"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e794e44fa260300b8850246c6371d94014753c73528f97f6ccb42f5e7ce698ae"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b2686d7d8ca31531458a48e08b0344a8eec6c402405446ce7d838e2a7e43355a"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d917f5bc27b85611ceee4eb85f0e4088b0a03b4eed22c472409933a94ee953cf"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f6071328aad06fdcc0a4acc2dc4839396d645f5916de07584af807eb7c08407"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:266ec46ab9f9cb40fbb5e649f55c329fc4620fa0b1a8117bdeefe91595e182dc"}, + {file = "y_py-0.6.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce15a842c2a0bf46180ae136743b561fa276300dd7fa61fe76daf00ec7dc0c2d"}, + {file = "y_py-0.6.2-cp310-none-win32.whl", hash = "sha256:1d5b544e79ace93fdbd0b36ed329c86e346898153ac7ba2ec62bc9b4c6b745c9"}, + {file = "y_py-0.6.2-cp310-none-win_amd64.whl", hash = "sha256:80a827e173372682959a57e6b8cc4f6468b1a4495b4bc7a775ef6ca05ae3e8e8"}, + {file = "y_py-0.6.2-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:a21148b8ea09a631b752d975f9410ee2a31c0e16796fdc113422a6d244be10e5"}, + {file = "y_py-0.6.2-cp311-cp311-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:898fede446ca1926b8406bdd711617c2aebba8227ee8ec1f0c2f8568047116f7"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce7c20b9395696d3b5425dccf2706d374e61ccf8f3656bff9423093a6df488f5"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a3932f53418b408fa03bd002e6dc573a74075c2c092926dde80657c39aa2e054"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:df35ea436592eb7e30e59c5403ec08ec3a5e7759e270cf226df73c47b3e739f5"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26cb1307c3ca9e21a3e307ab2c2099677e071ae9c26ec10ddffb3faceddd76b3"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:863e175ce5585f9ff3eba2aa16626928387e2a576157f02c8eb247a218ecdeae"}, + {file = "y_py-0.6.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:35fcb9def6ce137540fdc0e91b08729677548b9c393c0151a6359fd199da3bd7"}, + {file = "y_py-0.6.2-cp311-none-win32.whl", hash = "sha256:86422c6090f34906c062fd3e4fdfdccf3934f2922021e979573ae315050b4288"}, + {file = "y_py-0.6.2-cp311-none-win_amd64.whl", hash = "sha256:6c2f2831c5733b404d2f2da4bfd02bb4612ae18d0822e14ae79b0b92436b816d"}, + {file = "y_py-0.6.2-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:7cbefd4f1060f05768227ddf83be126397b1d430b026c64e0eb25d3cf50c5734"}, + {file = "y_py-0.6.2-cp312-cp312-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:032365dfe932bfab8e80937ad6093b4c22e67d63ad880096b5fa8768f8d829ba"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a70aee572da3994238c974694767365f237fc5949a550bee78a650fe16f83184"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae80d505aee7b3172cdcc2620ca6e2f85586337371138bb2b71aa377d2c31e9a"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2a497ebe617bec6a420fc47378856caae40ab0652e756f3ed40c5f1fe2a12220"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e8638355ae2f996356f7f281e03a3e3ce31f1259510f9d551465356532e0302c"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8448da4092265142662bbd3fc46cb8b0796b1e259189c020bc8f738899abd0b5"}, + {file = "y_py-0.6.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:69cfbcbe0a05f43e780e6a198080ba28034bf2bb4804d7d28f71a0379bfd1b19"}, + {file = "y_py-0.6.2-cp37-cp37m-macosx_10_7_x86_64.whl", hash = "sha256:1f798165158b76365a463a4f8aa2e3c2a12eb89b1fc092e7020e93713f2ad4dc"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92878cc05e844c8da937204bc34c2e6caf66709ce5936802fbfb35f04132892"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9b8822a5c0fd9a8cffcabfcc0cd7326bad537ee614fc3654e413a03137b6da1a"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e13cba03c7af8c8a846c4495875a09d64362cc4caeed495ada5390644411bbe7"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82f2e5b31678065e7a7fa089ed974af5a4f076673cf4f414219bdadfc3246a21"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1935d12e503780b859d343161a80df65205d23cad7b4f6c3df6e50321e188a3"}, + {file = "y_py-0.6.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bd302c6d46a3be57664571a5f0d4224646804be9890a01d73a0b294f2d3bbff1"}, + {file = "y_py-0.6.2-cp37-none-win32.whl", hash = "sha256:5415083f7f10eac25e1c434c87f07cb9bfa58909a6cad6649166fdad21119fc5"}, + {file = "y_py-0.6.2-cp37-none-win_amd64.whl", hash = "sha256:376c5cc0c177f03267340f36aec23e5eaf19520d41428d87605ca2ca3235d845"}, + {file = "y_py-0.6.2-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:3c011303eb2b360695d2bd4bd7ca85f42373ae89fcea48e7fa5b8dc6fc254a98"}, + {file = "y_py-0.6.2-cp38-cp38-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:c08311db17647a47d4898fc6f8d9c1f0e58b927752c894877ff0c38b3db0d6e1"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b7cafbe946b4cafc1e5709957e6dd5c6259d241d48ed75713ded42a5e8a4663"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3ba99d0bdbd9cabd65f914cd07b4fb2e939ce199b54ae5ace1639ce1edf8e0a2"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dab84c52f64e10adc79011a08673eb80286c159b14e8fb455524bf2994f0cb38"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:72875641a907523d37f4619eb4b303611d17e0a76f2ffc423b62dd1ca67eef41"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c31240e30d5636ded02a54b7280aa129344fe8e964fd63885e85d9a8a83db206"}, + {file = "y_py-0.6.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c28d977f516d4928f6bc0cd44561f6d0fdd661d76bac7cdc4b73e3c209441d9"}, + {file = "y_py-0.6.2-cp38-none-win32.whl", hash = "sha256:c011997f62d0c3b40a617e61b7faaaf6078e4eeff2e95ce4c45838db537816eb"}, + {file = "y_py-0.6.2-cp38-none-win_amd64.whl", hash = "sha256:ce0ae49879d10610cf3c40f4f376bb3cc425b18d939966ac63a2a9c73eb6f32a"}, + {file = "y_py-0.6.2-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:47fcc19158150dc4a6ae9a970c5bc12f40b0298a2b7d0c573a510a7b6bead3f3"}, + {file = "y_py-0.6.2-cp39-cp39-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:2d2b054a1a5f4004967532a4b82c6d1a45421ef2a5b41d35b6a8d41c7142aabe"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0787e85645bb4986c27e271715bc5ce21bba428a17964e5ec527368ed64669bc"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:17bce637a89f6e75f0013be68becac3e38dc082e7aefaf38935e89215f0aa64a"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:beea5ad9bd9e56aa77a6583b6f4e347d66f1fe7b1a2cb196fff53b7634f9dc84"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1dca48687f41efd862355e58b0aa31150586219324901dbea2989a506e291d4"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17edd21eef863d230ea00004ebc6d582cc91d325e7132deb93f0a90eb368c855"}, + {file = "y_py-0.6.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:de9cfafe97c75cd3ea052a24cd4aabf9fb0cfc3c0f9f810f00121cdf123db9e4"}, + {file = "y_py-0.6.2-cp39-none-win32.whl", hash = "sha256:82f5ca62bedbf35aaf5a75d1f53b4457a1d9b6ff033497ca346e2a0cedf13d14"}, + {file = "y_py-0.6.2-cp39-none-win_amd64.whl", hash = "sha256:7227f232f2daf130ba786f6834548f2cfcfa45b7ec4f0d449e72560ac298186c"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:0649a41cd3c98e290c16592c082dbe42c7ffec747b596172eebcafb7fd8767b0"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:bf6020560584671e76375b7a0539e0d5388fc70fa183c99dc769895f7ef90233"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cf817a72ffec4295def5c5be615dd8f1e954cdf449d72ebac579ff427951328"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7c7302619fc962e53093ba4a94559281491c045c925e5c4defec5dac358e0568"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cd6213c3cf2b9eee6f2c9867f198c39124c557f4b3b77d04a73f30fd1277a59"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b4fac4ea2ce27b86d173ae45765ced7f159120687d4410bb6d0846cbdb170a3"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:932abb560fe739416b50716a72ba6c6c20b219edded4389d1fc93266f3505d4b"}, + {file = "y_py-0.6.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e42258f66ad9f16d9b62e9c9642742982acb1f30b90f5061522048c1cb99814f"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:cfc8381df1f0f873da8969729974f90111cfb61a725ef0a2e0e6215408fe1217"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:613f83713714972886e81d71685403098a83ffdacf616f12344b52bc73705107"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:316e5e1c40259d482883d1926fd33fa558dc87b2bd2ca53ce237a6fe8a34e473"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:015f7f6c1ce8a83d57955d1dc7ddd57cb633ae00576741a4fc9a0f72ed70007d"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ff32548e45e45bf3280ac1d28b3148337a5c6714c28db23aeb0693e33eba257e"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0f2d881f0f8bf5674f8fe4774a438c545501e40fa27320c73be4f22463af4b05"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3bbe2f925cc587545c8d01587b4523177408edd252a32ce6d61b97113fe234d"}, + {file = "y_py-0.6.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8f5c14d25611b263b876e9ada1701415a13c3e9f02ea397224fbe4ca9703992b"}, + {file = "y_py-0.6.2.tar.gz", hash = "sha256:4757a82a50406a0b3a333aa0122019a331bd6f16e49fed67dca423f928b3fd4d"}, +] + +[[package]] +name = "ypy-websocket" +version = "0.8.4" +description = "WebSocket connector for Ypy" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ypy_websocket-0.8.4-py3-none-any.whl", hash = "sha256:b1ba0dfcc9762f0ca168d2378062d3ca1299d39076b0f145d961359121042be5"}, + {file = "ypy_websocket-0.8.4.tar.gz", hash = "sha256:43a001473f5c8abcf182f603049cf305cbc855ad8deaa9dfa0f3b5a7cea9d0ff"}, +] + +[package.dependencies] +aiofiles = ">=22.1.0,<23" +aiosqlite = ">=0.17.0,<1" +y-py = ">=0.6.0,<0.7.0" + +[package.extras] +test = ["mypy", "pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)"] + [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "0ac7b43d1158129dbdeb439be5d650c0f16283babdeb5d3ddab037eee69eca1d" +content-hash = "0c564d6f60c1e511e23d40d6377d35a20bda06dd332268c764e44a9708c6f2ce" diff --git a/pyproject.toml b/pyproject.toml index b819642..8f3328b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,3 +24,4 @@ black = "^24.4.2" [tool.poetry.group.dev.dependencies] ipython = "^8.17.2" pytest = "^8.0.0" +jupyterlab = "^3.5.0" From 73581677d92a8437199bcc020c7dd02acff4aae0 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sun, 21 Jul 2024 12:46:57 -0400 Subject: [PATCH 07/44] Added pandoc --- poetry.lock | 89 ++++++++++++++++++++++++++++++++++---------------- pyproject.toml | 2 ++ 2 files changed, 62 insertions(+), 29 deletions(-) diff --git a/poetry.lock b/poetry.lock index 3dcdad1..be1a7c9 100644 --- a/poetry.lock +++ b/poetry.lock @@ -674,17 +674,6 @@ files = [ graph = ["objgraph (>=1.7.2)"] profile = ["gprof2dot (>=2022.7.29)"] -[[package]] -name = "entrypoints" -version = "0.4" -description = "Discover and load entry points from installed packages." -optional = false -python-versions = ">=3.6" -files = [ - {file = "entrypoints-0.4-py3-none-any.whl", hash = "sha256:f174b5ff827504fd3cd97cc3f8649f3693f51538c7e4bdf3ef002c8429d42f9f"}, - {file = "entrypoints-0.4.tar.gz", hash = "sha256:b706eddaa9218a19ebcd67b56818f05bb27589b1ca9e8d797b74affad4ccacd4"}, -] - [[package]] name = "exceptiongroup" version = "1.2.2" @@ -1035,27 +1024,25 @@ referencing = ">=0.31.0" [[package]] name = "jupyter-client" -version = "7.4.9" +version = "8.6.2" description = "Jupyter protocol implementation and client libraries" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "jupyter_client-7.4.9-py3-none-any.whl", hash = "sha256:214668aaea208195f4c13d28eb272ba79f945fc0cf3f11c7092c20b2ca1980e7"}, - {file = "jupyter_client-7.4.9.tar.gz", hash = "sha256:52be28e04171f07aed8f20e1616a5a552ab9fee9cbbe6c1896ae170c3880d392"}, + {file = "jupyter_client-8.6.2-py3-none-any.whl", hash = "sha256:50cbc5c66fd1b8f65ecb66bc490ab73217993632809b6e505687de18e9dea39f"}, + {file = "jupyter_client-8.6.2.tar.gz", hash = "sha256:2bda14d55ee5ba58552a8c53ae43d215ad9868853489213f37da060ced54d8df"}, ] [package.dependencies] -entrypoints = "*" -jupyter-core = ">=4.9.2" -nest-asyncio = ">=1.5.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" python-dateutil = ">=2.8.2" pyzmq = ">=23.0" tornado = ">=6.2" -traitlets = "*" +traitlets = ">=5.3" [package.extras] -doc = ["ipykernel", "myst-parser", "sphinx (>=1.3.6)", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] -test = ["codecov", "coverage", "ipykernel (>=6.12)", "ipython", "mypy", "pre-commit", "pytest", "pytest-asyncio (>=0.18)", "pytest-cov", "pytest-timeout"] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest (<8.2.0)", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] [[package]] name = "jupyter-core" @@ -1767,13 +1754,13 @@ files = [ [[package]] name = "notebook" -version = "6.5.7" +version = "6.5.4" description = "A web-based notebook environment for interactive computing" optional = false python-versions = ">=3.7" files = [ - {file = "notebook-6.5.7-py3-none-any.whl", hash = "sha256:a6afa9a4ff4d149a0771ff8b8c881a7a73b3835f9add0606696d6e9d98ac1cd0"}, - {file = "notebook-6.5.7.tar.gz", hash = "sha256:04eb9011dfac634fbd4442adaf0a8c27cd26beef831fe1d19faf930c327768e4"}, + {file = "notebook-6.5.4-py3-none-any.whl", hash = "sha256:dd17e78aefe64c768737b32bf171c1c766666a21cc79a44d37a1700771cab56f"}, + {file = "notebook-6.5.4.tar.gz", hash = "sha256:517209568bd47261e2def27a140e97d49070602eea0d226a696f42a7f16c9a4e"}, ] [package.dependencies] @@ -1781,7 +1768,7 @@ argon2-cffi = "*" ipykernel = "*" ipython-genutils = "*" jinja2 = "*" -jupyter-client = ">=5.3.4,<8" +jupyter-client = ">=5.3.4" jupyter-core = ">=4.6.1" nbclassic = ">=0.4.7" nbconvert = ">=5" @@ -1997,6 +1984,20 @@ sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-d test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] xml = ["lxml (>=4.9.2)"] +[[package]] +name = "pandoc" +version = "2.3" +description = "Pandoc Documents for Python" +optional = false +python-versions = "*" +files = [ + {file = "pandoc-2.3.tar.gz", hash = "sha256:e772c2c6d871146894579828dbaf1efd538eb64fc7e71d4a6b3a11a18baef90d"}, +] + +[package.dependencies] +plumbum = "*" +ply = "*" + [[package]] name = "pandocfilters" version = "1.5.1" @@ -2176,6 +2177,36 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "plumbum" +version = "1.8.3" +description = "Plumbum: shell combinators library" +optional = false +python-versions = ">=3.6" +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[package.dependencies] +pywin32 = {version = "*", markers = "platform_system == \"Windows\" and platform_python_implementation != \"PyPy\""} + +[package.extras] +dev = ["paramiko", "psutil", "pytest (>=6.0)", "pytest-cov", "pytest-mock", "pytest-timeout"] +docs = ["sphinx (>=4.0.0)", "sphinx-rtd-theme (>=1.0.0)"] +ssh = ["paramiko"] + +[[package]] +name = "ply" +version = "3.11" +description = "Python Lex & Yacc" +optional = false +python-versions = "*" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + [[package]] name = "prometheus-client" version = "0.20.0" @@ -2246,13 +2277,13 @@ files = [ [[package]] name = "pure-eval" -version = "0.2.2" +version = "0.2.3" description = "Safely evaluate AST nodes without side effects" optional = false python-versions = "*" files = [ - {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, - {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, ] [package.extras] @@ -3278,4 +3309,4 @@ test = ["mypy", "pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "0c564d6f60c1e511e23d40d6377d35a20bda06dd332268c764e44a9708c6f2ce" +content-hash = "e0b1a87c98a901bbd1e0f4c8f0ce994ac180e76f1f57bb8b2144c30c65d3f521" diff --git a/pyproject.toml b/pyproject.toml index 8f3328b..eba3410 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,3 +25,5 @@ black = "^24.4.2" ipython = "^8.17.2" pytest = "^8.0.0" jupyterlab = "^3.5.0" +nbconvert = "^7.16.4" +pandoc = "^2.3" From 72ccaee711279a659ed215f4a74311ecb3954873 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sun, 21 Jul 2024 12:47:08 -0400 Subject: [PATCH 08/44] README generated by nbconvert --- README.md | 168 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..d6ee667 --- /dev/null +++ b/README.md @@ -0,0 +1,168 @@ +[![DOI](https://zenodo.org/badge/289387436.svg)](https://zenodo.org/badge/latestdoi/289387436) +[![Downloads](https://static.pepy.tech/badge/miceforest)](https://pepy.tech/project/miceforest) +[![Pypi](https://img.shields.io/pypi/v/miceforest.svg)](https://pypi.python.org/pypi/miceforest) +[![Conda +Version](https://img.shields.io/conda/vn/conda-forge/miceforest.svg)](https://anaconda.org/conda-forge/miceforest) +[![PyVersions](https://img.shields.io/pypi/pyversions/miceforest.svg?logo=python&logoColor=white)](https://pypi.org/project/miceforest/) +[![tests + +mypy](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml) +[![Documentation +Status](https://readthedocs.org/projects/miceforest/badge/?version=latest)](https://miceforest.readthedocs.io/en/latest/?badge=latest) +[![CodeCov](https://codecov.io/gh/AnotherSamWilson/miceforest/branch/master/graphs/badge.svg?branch=master&service=github)](https://codecov.io/gh/AnotherSamWilson/miceforest) + + + + + +# miceforest: Fast, Memory Efficient Imputation with LightGBM + + + +Fast, memory efficient Multiple Imputation by Chained Equations (MICE) +with lightgbm. The R version of this package may be found +[here](https://github.com/FarrellDay/miceRanger). + +`miceforest` was designed to be: + + - **Fast** + - Uses lightgbm as a backend + - Has efficient mean matching solutions. + - Can utilize GPU training + - **Flexible** + - Can impute pandas dataframes and numpy arrays + - Handles categorical data automatically + - Fits into a sklearn pipeline + - User can customize every aspect of the imputation process + - **Production Ready** + - Can impute new, unseen datasets quickly + - Kernels are efficiently compressed during saving and loading + - Data can be imputed in place to save memory + - Can build models on non-missing data + + +This document contains a thorough walkthrough of the package, +benchmarks, and an introduction to multiple imputation. More information +on MICE can be found in Stef van Buuren’s excellent online book, which +you can find +[here](https://stefvanbuuren.name/fimd/ch-introduction.html). + +#### Table of Contents: + + - [Package + Meta](https://github.com/AnotherSamWilson/miceforest#Package-Meta) + - [The + Basics](https://github.com/AnotherSamWilson/miceforest#The-Basics) + - [Basic + Examples](https://github.com/AnotherSamWilson/miceforest#Basic-Examples) + - [Customizing LightGBM + Parameters](https://github.com/AnotherSamWilson/miceforest#Customizing-LightGBM-Parameters) + - [Available Mean Match + Schemes](https://github.com/AnotherSamWilson/miceforest#Controlling-Tree-Growth) + - [Imputing New Data with Existing + Models](https://github.com/AnotherSamWilson/miceforest#Imputing-New-Data-with-Existing-Models) + - [Saving and Loading + Kernels](https://github.com/AnotherSamWilson/miceforest#Saving-and-Loading-Kernels) + - [Implementing sklearn + Pipelines](https://github.com/AnotherSamWilson/miceforest#Implementing-sklearn-Pipelines) + - [Advanced + Features](https://github.com/AnotherSamWilson/miceforest#Advanced-Features) + - [Customizing the Imputation + Process](https://github.com/AnotherSamWilson/miceforest#Customizing-the-Imputation-Process) + - [Building Models on Nonmissing + Data](https://github.com/AnotherSamWilson/miceforest#Building-Models-on-Nonmissing-Data) + - [Tuning + Parameters](https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters) + - [On + Reproducibility](https://github.com/AnotherSamWilson/miceforest#On-Reproducibility) + - [How to Make the Process + Faster](https://github.com/AnotherSamWilson/miceforest#How-to-Make-the-Process-Faster) + - [Imputing Data In + Place](https://github.com/AnotherSamWilson/miceforest#Imputing-Data-In-Place) + - [Diagnostic + Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting) + - [Imputed + Distributions](https://github.com/AnotherSamWilson/miceforest#Distribution-of-Imputed-Values) + - [Correlation + Convergence](https://github.com/AnotherSamWilson/miceforest#Convergence-of-Correlation) + - [Variable + Importance](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) + - [Mean + Convergence](https://github.com/AnotherSamWilson/miceforest#Variable-Importance) + - [Benchmarks](https://github.com/AnotherSamWilson/miceforest#Benchmarks) + - [Using the Imputed + Data](https://github.com/AnotherSamWilson/miceforest#Using-the-Imputed-Data) + - [The MICE + Algorithm](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) + - [Introduction](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm) + - [Common Use + Cases](https://github.com/AnotherSamWilson/miceforest#Common-Use-Cases) + - [Predictive Mean + Matching](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) + - [Effects of Mean + Matching](https://github.com/AnotherSamWilson/miceforest#Effects-of-Mean-Matching) + +## Installation + +This package can be installed using either pip or conda, through +conda-forge: + +``` bash +# Using pip +$ pip install miceforest --no-cache-dir + +# Using conda +$ conda install -c conda-forge miceforest +``` + +You can also download the latest development version from this +repository. If you want to install from github with conda, you must +first run `conda install pip git`. + +``` bash +$ pip install git+https://github.com/AnotherSamWilson/miceforest.git +``` + +## Classes + +miceforest has 3 main classes which the user will interact with: + + - [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) + - This class contains the raw data off of which the `mice` algorithm + is performed. During this process, models will be trained, and the + imputed (predicted) values will be stored. These values can be used + to fill in the missing values of the raw data. The raw data can be + copied, or referenced directly. Models can be saved, and used to + impute new datasets. + - [`ImputedData`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputedData.html#miceforest.ImputedData) + - The result of `ImputationKernel.impute_new_data(new_data)`. This + contains the raw data in `new_data` as well as the imputed values. + - [`MeanMatchScheme`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.MeanMatchScheme.html#miceforest.MeanMatchScheme) + - Determines how mean matching should be carried out. There are 3 + built-in mean match schemes available in miceforest, discussed + below. + + +## Basic Usage + +We will be looking at a few simple examples of imputation. We need to +load the packages, and define the data: + +```python +import miceforest as mf +from sklearn.datasets import load_iris +import pandas as pd +import numpy as np + +# Load data and introduce missing values +iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1) +iris.rename({"target": "species"}, inplace=True, axis=1) +iris['species'] = iris['species'].astype('category') +iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991) +``` + + +```python + +``` + + From 99999bcd79f2821669f59f59cfeb772fc5fd6a57 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Sun, 21 Jul 2024 12:52:25 -0400 Subject: [PATCH 09/44] Changed name of README.ipynb --- .gitignore | 1 + README.ipynb => README_gen.ipynb | 0 2 files changed, 1 insertion(+) rename README.ipynb => README_gen.ipynb (100%) diff --git a/.gitignore b/.gitignore index 0a3decf..65f5d4e 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,4 @@ pyproject.toml *.DS_Store* .devcontainer Dockerfile +dev_guide.md diff --git a/README.ipynb b/README_gen.ipynb similarity index 100% rename from README.ipynb rename to README_gen.ipynb From 05140644ae0bf8806b25000865efc3519c6cd83e Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Thu, 25 Jul 2024 17:14:44 -0400 Subject: [PATCH 10/44] Moved plotting to plotnine --- poetry.lock | 121 ++++++++++++++++++++++++++++++++++++++++++++++++- pyproject.toml | 1 + 2 files changed, 121 insertions(+), 1 deletion(-) diff --git a/poetry.lock b/poetry.lock index be1a7c9..24d98f8 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1549,6 +1549,33 @@ files = [ {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, ] +[[package]] +name = "mizani" +version = "0.11.4" +description = "Scales for Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "mizani-0.11.4-py3-none-any.whl", hash = "sha256:5b6271dc3da2c88694dca2e0e0a7e1879f0e2fb046c789776f54d090a5243735"}, + {file = "mizani-0.11.4.tar.gz", hash = "sha256:9fdb79e88602ca29132613b428d6c1e8af436e88e37d55a0f8eb99fe044c9bc2"}, +] + +[package.dependencies] +numpy = ">=1.23.0" +pandas = ">=2.1.0" +scipy = ">=1.7.0" +tzdata = {version = "*", markers = "platform_system == \"Windows\" or platform_system == \"Emscripten\""} + +[package.extras] +all = ["mizani[build]", "mizani[dev]", "mizani[doc]", "mizani[lint]", "mizani[test]"] +build = ["build", "wheel"] +dev = ["mizani[typing]", "notebook", "pre-commit", "twine"] +doc = ["numpydoc (>=1.6.0)", "sphinx (>=7.2.0)"] +lint = ["ruff"] +rtd = ["mock"] +test = ["pytest-cov"] +typing = ["pandas-stubs", "pyright (==1.1.364)"] + [[package]] name = "msgpack" version = "1.0.8" @@ -2035,6 +2062,24 @@ files = [ {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, ] +[[package]] +name = "patsy" +version = "0.5.6" +description = "A Python package for describing statistical models and for building design matrices." +optional = false +python-versions = "*" +files = [ + {file = "patsy-0.5.6-py2.py3-none-any.whl", hash = "sha256:19056886fd8fa71863fa32f0eb090267f21fb74be00f19f5c70b2e9d76c883c6"}, + {file = "patsy-0.5.6.tar.gz", hash = "sha256:95c6d47a7222535f84bff7f63d7303f2e297747a598db89cf5c67f0c0c7d2cdb"}, +] + +[package.dependencies] +numpy = ">=1.4" +six = "*" + +[package.extras] +test = ["pytest", "pytest-cov", "scipy"] + [[package]] name = "pexpect" version = "4.9.0" @@ -2162,6 +2207,35 @@ docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx- test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] type = ["mypy (>=1.8)"] +[[package]] +name = "plotnine" +version = "0.13.6" +description = "A Grammar of Graphics for Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "plotnine-0.13.6-py3-none-any.whl", hash = "sha256:4acc1af29fa4e91e726b67d49277e8368f62e1c817f01bf14ecd8ca5e83bfaea"}, + {file = "plotnine-0.13.6.tar.gz", hash = "sha256:3c8c8f958c295345140230ea29803488f83aba9b5a8d0b1b2eb3eaefbf0a06b8"}, +] + +[package.dependencies] +matplotlib = ">=3.7.0" +mizani = ">=0.11.0,<0.12.0" +numpy = ">=1.23.0" +pandas = ">=2.1.0,<3.0.0" +scipy = ">=1.7.0" +statsmodels = ">=0.14.0" + +[package.extras] +all = ["plotnine[build]", "plotnine[dev]", "plotnine[doc]", "plotnine[extra]", "plotnine[lint]", "plotnine[test]"] +build = ["build", "wheel"] +dev = ["plotnine[typing]", "pre-commit", "twine"] +doc = ["click", "importlib-resources", "jupyter", "nbsphinx", "numpydoc (>=0.9.1)", "quartodoc (>=0.7.2)"] +extra = ["adjustText", "geopandas", "scikit-learn", "scikit-misc (>=0.3.0)"] +lint = ["ruff"] +test = ["pytest-cov"] +typing = ["ipython", "pandas-stubs", "pyright (==1.1.362)"] + [[package]] name = "pluggy" version = "1.5.0" @@ -2991,6 +3065,51 @@ pure-eval = "*" [package.extras] tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] +[[package]] +name = "statsmodels" +version = "0.14.2" +description = "Statistical computations and models for Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "statsmodels-0.14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df5d6f95c46f0341da6c79ee7617e025bf2b371e190a8e60af1ae9cabbdb7a97"}, + {file = "statsmodels-0.14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a87ef21fadb445b650f327340dde703f13aec1540f3d497afb66324499dea97a"}, + {file = "statsmodels-0.14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5827a12e3ede2b98a784476d61d6bec43011fedb64aa815f2098e0573bece257"}, + {file = "statsmodels-0.14.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f2b7611a61adb7d596a6d239abdf1a4d5492b931b00d5ed23d32844d40e48e"}, + {file = "statsmodels-0.14.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c254c66142f1167b4c7d031cf8db55294cc62ff3280e090fc45bd10a7f5fd029"}, + {file = "statsmodels-0.14.2-cp310-cp310-win_amd64.whl", hash = "sha256:0e46e9d59293c1af4cc1f4e5248f17e7e7bc596bfce44d327c789ac27f09111b"}, + {file = "statsmodels-0.14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:50fcb633987779e795142f51ba49fb27648d46e8a1382b32ebe8e503aaabaa9e"}, + {file = "statsmodels-0.14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:876794068abfaeed41df71b7887000031ecf44fbfa6b50d53ccb12ebb4ab747a"}, + {file = "statsmodels-0.14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a91f6c4943de13e3ce2e20ee3b5d26d02bd42300616a421becd53756f5deb37"}, + {file = "statsmodels-0.14.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4864a1c4615c5ea5f2e3b078a75bdedc90dd9da210a37e0738e064b419eccee2"}, + {file = "statsmodels-0.14.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:afbd92410e0df06f3d8c4e7c0e2e71f63f4969531f280fb66059e2ecdb6e0415"}, + {file = "statsmodels-0.14.2-cp311-cp311-win_amd64.whl", hash = "sha256:8e004cfad0e46ce73fe3f3812010c746f0d4cfd48e307b45c14e9e360f3d2510"}, + {file = "statsmodels-0.14.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:eb0ba1ad3627705f5ae20af6b2982f500546d43892543b36c7bca3e2f87105e7"}, + {file = "statsmodels-0.14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fd2f0110b73fc3fa5a2f21c3ca99b0e22285cccf38e56b5b8fd8ce28791b0f"}, + {file = "statsmodels-0.14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac780ad9ff552773798829a0b9c46820b0faa10e6454891f5e49a845123758ab"}, + {file = "statsmodels-0.14.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55d1742778400ae67acb04b50a2c7f5804182f8a874bd09ca397d69ed159a751"}, + {file = "statsmodels-0.14.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f870d14a587ea58a3b596aa994c2ed889cc051f9e450e887d2c83656fc6a64bf"}, + {file = "statsmodels-0.14.2-cp312-cp312-win_amd64.whl", hash = "sha256:f450fcbae214aae66bd9d2b9af48e0f8ba1cb0e8596c6ebb34e6e3f0fec6542c"}, + {file = "statsmodels-0.14.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:201c3d00929c4a67cda1fe05b098c8dcf1b1eeefa88e80a8f963a844801ed59f"}, + {file = "statsmodels-0.14.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9edefa4ce08e40bc1d67d2f79bc686ee5e238e801312b5a029ee7786448c389a"}, + {file = "statsmodels-0.14.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c78a7601fdae1aa32104c5ebff2e0b72c26f33e870e2f94ab1bcfd927ece9b"}, + {file = "statsmodels-0.14.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f36494df7c03d63168fccee5038a62f469469ed6a4dd6eaeb9338abedcd0d5f5"}, + {file = "statsmodels-0.14.2-cp39-cp39-win_amd64.whl", hash = "sha256:8875823bdd41806dc853333cc4e1b7ef9481bad2380a999e66ea42382cf2178d"}, + {file = "statsmodels-0.14.2.tar.gz", hash = "sha256:890550147ad3a81cda24f0ba1a5c4021adc1601080bd00e191ae7cd6feecd6ad"}, +] + +[package.dependencies] +numpy = ">=1.22.3" +packaging = ">=21.3" +pandas = ">=1.4,<2.1.0 || >2.1.0" +patsy = ">=0.5.6" +scipy = ">=1.8,<1.9.2 || >1.9.2" + +[package.extras] +build = ["cython (>=0.29.33)"] +develop = ["colorama", "cython (>=0.29.33)", "cython (>=3.0.10,<4)", "flake8", "isort", "joblib", "matplotlib (>=3)", "pytest (>=7.3.0,<8)", "pytest-cov", "pytest-randomly", "pytest-xdist", "pywinpty", "setuptools-scm[toml] (>=8.0,<9.0)"] +docs = ["ipykernel", "jupyter-client", "matplotlib", "nbconvert", "nbformat", "numpydoc", "pandas-datareader", "sphinx"] + [[package]] name = "terminado" version = "0.18.1" @@ -3309,4 +3428,4 @@ test = ["mypy", "pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "e0b1a87c98a901bbd1e0f4c8f0ce994ac180e76f1f57bb8b2144c30c65d3f521" +content-hash = "981c5371d62cc50eb6f47551934a31c8a5d50249de33f18561834e3bef52f2dd" diff --git a/pyproject.toml b/pyproject.toml index eba3410..cabbcb0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,6 +20,7 @@ seaborn = "^0.13.0" matplotlib = "^3.3.0" scikit-learn = "^1.4.0" black = "^24.4.2" +plotnine = "^0.13.6" [tool.poetry.group.dev.dependencies] ipython = "^8.17.2" From a1cb8183b5363b496eaed88c359e537ac4255d73 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:26:44 -0400 Subject: [PATCH 11/44] Took out unecessary functions, changed how cat folds work --- miceforest/utils.py | 26 ++++---------------------- 1 file changed, 4 insertions(+), 22 deletions(-) diff --git a/miceforest/utils.py b/miceforest/utils.py index 0e78eb9..7d4971f 100644 --- a/miceforest/utils.py +++ b/miceforest/utils.py @@ -6,23 +6,6 @@ from typing import Union, List, Dict, Optional -def _to_2d(x): - """ - Ensures an array is 2 dimensional, in place. - """ - if x.ndim == 1: - x.shape = (-1, 1) - - -def _to_1d(x): - """ - Ensures an array is 1 dimensional, in place. - """ - if x.ndim == 2: - assert x.shape[1] == 1 - x.shape = -1 - - def get_best_int_downcast(x: int): assert isinstance(x, int) int_dtypes = ["uint8", "uint16", "uint32", "uint64"] @@ -205,10 +188,9 @@ def stratified_categorical_folds(y: Series, nfold: int): Create primitive stratified folds for categorical data. Should be digestible by lightgbm.cv function. """ - y = y.cat.codes.to_numpy() - y = y.reshape( - y.shape[0], - ).copy() + assert isinstance(y, Series), "y must be a pandas Series" + assert y.dtype.name[0:3].lower() == "int", "y should be the category codes" + y = y.to_numpy() elements = len(y) uniq, inv, counts = np.unique(y, return_counts=True, return_inverse=True) assert elements >= nfold, "more splits then elements." @@ -312,7 +294,7 @@ def ensure_rng(random_state) -> RandomState: # raise ValueError("Can't cast to numpy array") -def _expand_value_to_dict(default, value, keys): +def _expand_value_to_dict(default, value, keys) -> dict: if isinstance(value, dict): ret = {key: value.get(key, default) for key in keys} else: From f09ad099f9211b1390b57051aa9c115dccc2a70c Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:26:56 -0400 Subject: [PATCH 12/44] type hinting --- miceforest/logger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/miceforest/logger.py b/miceforest/logger.py index ec4778f..e2afc46 100644 --- a/miceforest/logger.py +++ b/miceforest/logger.py @@ -32,7 +32,7 @@ def __init__( self.verbose = verbose self.initialization_time = datetime.now() self.timed_levels = timed_levels - self.started_timers = {} + self.started_timers: dict = {} if self.verbose: print(f"Initialized logger with name {name} and {len(timed_levels)} levels") From 1c4fc0e0c1dad1e68cd07f3dae2efcc1345c28b3 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:27:46 -0400 Subject: [PATCH 13/44] Took out unecessary plotting code, changed how dataset names are stored. --- miceforest/imputed_data.py | 203 ++++++++++++++++++------------------- 1 file changed, 99 insertions(+), 104 deletions(-) diff --git a/miceforest/imputed_data.py b/miceforest/imputed_data.py index 2c7bd7e..6d78b58 100644 --- a/miceforest/imputed_data.py +++ b/miceforest/imputed_data.py @@ -1,5 +1,5 @@ import numpy as np -from pandas import DataFrame, MultiIndex, RangeIndex, read_parquet, Series +from pandas import DataFrame, MultiIndex, RangeIndex, read_parquet, Series, concat from .utils import ( get_best_int_downcast, hash_numpy_int_array, @@ -14,8 +14,9 @@ class ImputedData: def __init__( self, impute_data: DataFrame, - num_datasets: int = 5, - variable_schema: Union[List[str], Dict[str, str]] = None, + # num_datasets: int = 5, + datasets: List[int], + variable_schema: Optional[Union[List[str], Dict[str, List[str]]]] = None, save_all_iterations_data: bool = True, copy_data: bool = True, random_seed_array: Optional[np.ndarray] = None, @@ -24,6 +25,7 @@ def __init__( self.working_data = impute_data.copy() if copy_data else impute_data self.shape = self.working_data.shape self.save_all_iterations_data = save_all_iterations_data + self.datasets = datasets assert isinstance( self.working_data.index, RangeIndex @@ -39,7 +41,6 @@ def __init__( column_names.append(col) pd_dtypes_orig[col] = series.dtype.name - column_names: List[str] = [str(x) for x in self.working_data.columns] self.column_names = column_names pd_dtypes_orig = self.working_data.dtypes @@ -107,17 +108,17 @@ def __init__( self.na_counts = na_counts self.na_where = na_where - self.num_datasets = num_datasets + self.num_datasets = len(datasets) self.initialized = False self.imputed_variable_count = len(self.imputed_variables) self.modeled_variable_count = len(self.modeled_variables) - self.iterations = np.zeros( - shape=(num_datasets, self.modeled_variable_count) - ).astype(int) + # self.iterations = np.zeros( + # shape=(self.num_datasets, self.modeled_variable_count) + # ).astype(int) # Create a multiindexed dataframe to store our imputation values iv_multiindex = MultiIndex.from_product( - [[0], np.arange(num_datasets)], names=("iteration", "dataset") + [[0], datasets], names=("iteration", "dataset") ) self.imputation_values = { var: DataFrame(index=na_where[var], columns=iv_multiindex).astype( @@ -129,7 +130,7 @@ def __init__( # Create an iteration counter self.iteration_tab = {} for variable in self.modeled_variables: - for dataset in range(num_datasets): + for dataset in datasets: self.iteration_tab[variable, dataset] = 0 # Subsetting allows us to get to the imputation values: @@ -185,10 +186,10 @@ def __setstate__(self, state): self.imputation_values[col] = read_parquet(bytes) def __repr__(self): - summary_string = f'\n{" " * 14}Class: ImputedData\n{self.__ids_info()}' + summary_string = f'\n{" " * 14}Class: ImputedData\n{self._ids_info()}' return summary_string - def __ids_info(self): + def _ids_info(self): summary_string = f"""\ Datasets: {self.num_datasets} Iterations: {self.iteration_count()} @@ -200,7 +201,7 @@ def __ids_info(self): """ return summary_string - def _get_nonmissing_index(self, variable): + def _get_nonmissing_index(self, variable: str): na_where = self.na_where[variable] dtype = na_where.dtype non_missing_ind = np.setdiff1d( @@ -208,16 +209,10 @@ def _get_nonmissing_index(self, variable): ) return non_missing_ind - def _get_nonmissing_values(self, variable): + def _get_nonmissing_values(self, variable: str): ind = self._get_nonmissing_index(variable) return self.working_data.loc[ind, variable] - def get_bachelor_features(self, variable): - na_where = self.na_where[variable] - predictors = self.variable_schema[variable] - bachelor_features = self.working_data.loc[na_where, predictors] - return bachelor_features - def _ampute_original_data(self): """Need to put self.working_data back in its original form""" for variable in self.imputed_variables: @@ -233,25 +228,16 @@ def _get_hashed_seeds(self, variable: str): else: return None - # def _cycle_random_seed_array(self, variable: str): - # if self.random_seed_array is not None: - # na_where = self.na_where[variable] - # hash_numpy_int_array(self.random_seed_array, ind=na_where) - # else: - # pass - - def _prep_multi_plot( - self, - variables, - ): - plots = len(variables) - plotrows, plotcols = int(np.ceil(np.sqrt(plots))), int( - np.ceil(plots / np.ceil(np.sqrt(plots))) - ) - return plots, plotrows, plotcols + def get_bachelor_features(self, variable): + na_where = self.na_where[variable] + predictors = self.variable_schema[variable] + bachelor_features = self.working_data.loc[na_where, predictors] + return bachelor_features def iteration_count( - self, dataset: Optional[int] = None, variable: Optional[str] = None + self, + dataset: Union[slice, int] = slice(None), + variable: Union[slice, str] = slice(None), ): """ Grabs the iteration count for specified variables, datasets. @@ -281,11 +267,6 @@ def iteration_count( iteration_tab = Series(self.iteration_tab) iteration_tab.index.names = ["variable", "dataset"] - if variable is None: - variable = slice(None) - if dataset is None: - dataset = slice(None) - iterations = np.unique(iteration_tab.loc[variable, dataset]) if iterations.shape[0] > 1: raise ValueError("Multiple iteration counts found") @@ -295,7 +276,7 @@ def iteration_count( def complete_data( self, dataset: int = 0, - iteration: Optional[int] = None, + iteration: int = -1, inplace: bool = False, variables: Optional[List[str]] = None, ): @@ -308,8 +289,8 @@ def complete_data( The dataset to complete. iteration: int Impute data with values obtained at this iteration. - If None, returns the most up-to-date iterations, - even if different between variables. If not none, + If -1, returns the most up-to-date iterations, + even if different between variables. If not -1, iteration must have been saved in imputed values. inplace: bool Should the data be completed in place? If True, @@ -335,7 +316,7 @@ def complete_data( ), "Not all variables specified were imputed." for variable in imp_vars: - if iteration is None: + if iteration == -1: iteration = self.iteration_count(dataset=dataset, variable=variable) na_where = self.na_where[variable] impute_data.loc[na_where, variable] = self[variable, iteration, dataset] @@ -410,69 +391,83 @@ def complete_data( # ax[axr, axc].set_ylabel("mean") # plt.subplots_adjust(**adj_args) - # def plot_imputed_distributions( - # self, datasets=None, variables=None, iteration=None, **adj_args - # ): - # """ - # Plot the imputed value distributions. - # Red lines are the distribution of original data - # Black lines are the distribution of the imputed values. + def plot_imputed_distributions( + self, variables: Optional[List[str]] = None, iteration: int = -1 + ): + """ + Plot the imputed value distributions. + Red lines are the distribution of original data + Black lines are the distribution of the imputed values. - # Parameters - # ---------- - # datasets: None, int, list[int] - # variables: None, str, int, list[str], or list[int] - # The variables to plot. If None, all numeric variables - # are plotted. - # iteration: None, int - # The iteration to plot the distribution for. - # If None, the latest iteration is plotted. - # save_all_iterations must be True if specifying - # an iteration. - # adj_args - # Additional arguments passed to plt.subplots_adjust() + Parameters + ---------- + datasets: None, int, list[int] + variables: None, list[str] + The variables to plot. If None, all numeric variables + are plotted. + iteration: int + The iteration to plot the distribution for. + If None, the latest iteration is plotted. + save_all_iterations must be True if specifying + an iteration. + adj_args + Additional arguments passed to plt.subplots_adjust() - # """ - # # Move this to .compat at some point. - # try: - # import seaborn as sns - # import matplotlib.pyplot as plt - # from matplotlib import gridspec - # except ImportError: - # raise ImportError( - # "matplotlib and seaborn must be installed to plot distributions." - # ) + """ + # Move this to .compat at some point. + try: + from plotnine import ( + ggplot, + geom_density, + aes, + facet_wrap, + scale_color_manual, + ggtitle, + xlab, + theme, + ) + except ImportError: + raise ImportError("plotnine must be installed to plot distributions.") - # if datasets is None: - # datasets = list(range(self.dataset_count())) - # else: - # datasets = _ensure_iterable(datasets) - # if iteration is None: - # iteration = self.iteration_count(datasets=datasets, variables=variables) - # num_vars = self._get_num_vars(variables) - # plots, plotrows, plotcols = self._prep_multi_plot(num_vars) - # gs = gridspec.GridSpec(plotrows, plotcols) - # fig, ax = plt.subplots(plotrows, plotcols, squeeze=False) + if iteration == -1: + iteration = self.iteration_count() - # for v in range(plots): - # var = num_vars[v] - # axr, axc = next(iter(gs[v].rowspan)), next(iter(gs[v].colspan)) - # iteration_level_imputations = { - # ds: self[ds, var, iteration] for ds in datasets - # } - # plt.sca(ax[axr, axc]) - # non_missing_ind = self._get_nonmissing_index(var) - # nonmissing_values = _subset_data( - # self.working_data, row_ind=non_missing_ind, col_ind=var, return_1d=True - # ) - # ax[axr, axc] = sns.kdeplot(nonmissing_values, color="red", linewidth=2) - # for imparray in iteration_level_imputations.values(): - # ax[axr, axc] = sns.kdeplot( - # imparray, color="black", linewidth=1, warn_singular=False - # ) - # ax[axr, axc].set(xlabel=self._get_var_name_from_scalar(var)) + colors = {str(i): "black" for i in range(self.num_datasets)} + colors["-1"] = "red" - # plt.subplots_adjust(**adj_args) + num_vars = self.working_data.select_dtypes("number").columns.to_list() + + if variables is None: + variables = [var for var in self.imputed_variables if var in num_vars] + else: + variables = [var for var in variables if var in num_vars] + + dat = DataFrame() + for variable in variables: + + imps = self.imputation_values[variable].loc[:, iteration].melt() + imps["variable"] = variable + ind = self._get_nonmissing_index(variable) + orig = self.working_data.loc[ind, variable].rename("value").to_frame() + orig["dataset"] = -1 + orig["variable"] = variable + dat = concat([dat, imps, orig], axis=0) + + dat["dataset"] = dat["dataset"].astype("string") + + fig = ( + ggplot() + + geom_density( + data=dat, mapping=aes(x="value", group="dataset", color="dataset") + ) + + facet_wrap("variable", scales="free") + + scale_color_manual(values=colors) + + ggtitle("Distribution Plots") + + xlab("") + + theme(legend_position="none") + ) + + return fig # def get_correlations( # self, datasets: List[int], variables: Union[List[int], List[str]] From b2c19c47e0eb932c037f12dfde7b3f9a07019d6a Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:29:00 -0400 Subject: [PATCH 14/44] Took out unecessary functions, fixed bugs in fast mean matching --- miceforest/imputation_kernel.py | 932 +++++++++++++++----------------- 1 file changed, 434 insertions(+), 498 deletions(-) diff --git a/miceforest/imputation_kernel.py b/miceforest/imputation_kernel.py index 7a214d4..640dca5 100644 --- a/miceforest/imputation_kernel.py +++ b/miceforest/imputation_kernel.py @@ -1,6 +1,6 @@ from miceforest.default_lightgbm_parameters import ( - default_parameters, - make_default_tuning_space, + _DEFAULT_LGB_PARAMS, + _sample_parameters, ) from miceforest.logger import Logger from miceforest.imputed_data import ImputedData @@ -12,8 +12,6 @@ ensure_rng, stratified_categorical_folds, stratified_continuous_folds, - _to_2d, - _to_1d, ) import numpy as np from warnings import warn @@ -22,7 +20,7 @@ from io import BytesIO from scipy.spatial import KDTree from copy import copy -from typing import Union, List, Dict, Any, Optional, Tuple +from typing import Union, List, Dict, Any, Optional, Tuple, Generator from pandas import Series, DataFrame, MultiIndex, read_parquet, Categorical from pandas.api.types import is_integer_dtype @@ -32,11 +30,9 @@ _DEFAULT_MEANMATCH_STRATEGY = "normal" _MICE_TIMED_LEVELS = ["Dataset", "Iteration", "Variable", "Event"] _IMPUTE_NEW_DATA_TIMED_LEVELS = ["Dataset", "Iteration", "Variable", "Event"] +_TUNING_TIMED_LEVELS = ["Variable", "Iteration"] _PRE_LINK_DATATYPE = "float16" -# These can inherently be 2D, Series cannot. -_MEAN_MATCH_PRED_TYPE = Union[np.ndarray, DataFrame] - class ImputationKernel(ImputedData): """ @@ -171,7 +167,7 @@ def __init__( self, data: DataFrame, num_datasets: int = 1, - variable_schema: Union[List[str], Dict[str, str]] = None, + variable_schema: Optional[Union[List[str], Dict[str, List[str]]]] = None, imputation_order: str = "ascending", mean_match_candidates: Union[ int, Dict[str, int] @@ -186,9 +182,12 @@ def __init__( random_state: Optional[Union[int, np.random.RandomState]] = None, ): + datasets = list(range(num_datasets)) + super().__init__( impute_data=data, - num_datasets=num_datasets, + # num_datasets=num_datasets, + datasets=datasets, variable_schema=variable_schema, save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, @@ -231,7 +230,7 @@ def __init__( self.models: Dict[Tuple[str, int, int], Booster] = {} # Candidate preds are stored the same as models. - self.candidate_preds: Dict[Tuple[str, int, int], Series] = {} + self.candidate_preds: Dict[str, DataFrame] = {} # Optimal parameters can only be found on 1 dataset at the current iteration. self.optimal_parameters: Dict[str, Dict[str, Any]] = {} @@ -284,6 +283,10 @@ def __init__( self.modeled_binary_columns = _list_union( binary_columns, self.model_training_order ) + predictor_columns = sum(self.variable_schema.values(), []) + self.predictor_columns = [ + col for col in data.columns if col in predictor_columns + ] # Make sure all pandas categorical levels are used. rare_level_cols = [] @@ -325,16 +328,18 @@ def __init__( ): self.mean_matching_requires_candidates.append(variable) - self.loggers = [] + self.loggers: List[Logger] = [] # Manage randomness self._completely_random_kernel = random_state is None self._random_state = ensure_rng(random_state) # Set initial imputations (iteration 0). - self._initialize_dataset( - self, random_state=self._random_state - ) + self._initialize_dataset(self, random_state=self._random_state) + + # Save for use later + self.optimal_parameter_losses: Dict[str, float] = dict() + self.optimal_parameters = dict() def __getstate__(self): """ @@ -380,7 +385,7 @@ def __setstate__(self, state): self.candidate_preds[col] = read_parquet(bytes) def __repr__(self): - summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self.__ids_info()}' + summary_string = f'\n{" " * 14}Class: ImputationKernel\n{self._ids_info()}' return summary_string def _initialize_dataset(self, imputed_data, random_state): @@ -406,7 +411,7 @@ def _initialize_dataset(self, imputed_data, random_state): missing_ind = imputed_data.na_where[variable] missing_num = imputed_data.na_counts[variable] - for dataset in range(imputed_data.num_datasets): + for dataset in imputed_data.datasets: # Initialize using the random_state if no record seeds were passed. if imputed_data.random_seed_array is None: imputation_values = candidate_values.sample( @@ -426,7 +431,25 @@ def _initialize_dataset(self, imputed_data, random_state): imputed_data.initialized = True - def _get_lgb_params(self, variable, variable_parameters, random_state, **kwlgb): + @staticmethod + def _uncover_aliases(params): + """ + Switches all aliases in the parameter dict to their + True name, easiest way to avoid duplicate parameters. + """ + alias_dict = _ConfigAliases._get_all_param_aliases() + for param in list(params): + for true_name, aliases in alias_dict.items(): + if param in aliases: + params[true_name] = params.pop(param) + + def _make_lgb_params( + self, + variable: str, + default_parameters: dict, + variable_parameters: dict, + **kwlgb, + ): """ Builds the parameters for a lightgbm model. Infers objective based on datatype of the response variable, assigns a random seed, finds @@ -434,10 +457,13 @@ def _get_lgb_params(self, variable, variable_parameters, random_state, **kwlgb): Parameters ---------- - var: int + variable: int The variable to be modeled - vsp: dict + default_parameters: dict + The base set of parameters that should be used. + + variable_parameters: dict Variable specific parameters. These are supplied by the user. random_state: np.random.RandomState @@ -445,10 +471,10 @@ def _get_lgb_params(self, variable, variable_parameters, random_state, **kwlgb): kwlgb: dict Any additional parameters that should take presidence - over the defaults or user supplied. + over the defaults. """ - seed = _draw_random_int32(random_state, size=1)[0] + seed = _draw_random_int32(self._random_state, size=1)[0] if variable in self.modeled_categorical_columns: n_c = self.category_counts[variable] @@ -462,53 +488,59 @@ def _get_lgb_params(self, variable, variable_parameters, random_state, **kwlgb): lgb_params.update(obj) lgb_params["seed"] = seed + self._uncover_aliases(lgb_params) + self._uncover_aliases(kwlgb) + self._uncover_aliases(variable_parameters) + # Priority is [variable specific] > [global in kwargs] > [defaults] lgb_params.update(kwlgb) lgb_params.update(variable_parameters) return lgb_params - def _get_random_sample(self, parameters, random_state): - """ - Searches through a parameter set and selects a random - number between the values in any provided tuple of length 2. - """ + # WHEN TUNING, THESE PARAMETERS OVERWRITE THE DEFAULTS ABOVE + # These need to be main parameter names, not aliases + def _make_tuning_space( + self, + variable: str, + variable_parameters: dict, + use_gbdt: bool, + min_samples: int, + max_samples: int, + **kwargs, + ): - parameters = parameters.copy() - for p, v in parameters.items(): - if hasattr(v, "__iter__"): - if isinstance(v, list): - parameters[p] = random_state.choice(v) - elif isinstance(v, tuple): - parameters[p] = random_state.uniform(v[0], v[1], size=1)[0] - else: - pass - parameters = self._make_params_digestible(parameters) - return parameters + # Start with the default parameters, update with the search space + params = _DEFAULT_LGB_PARAMS.copy() + search_space = { + "min_data_in_leaf": (min_samples, max_samples), + "max_depth": (2, 6), + "num_leaves": (2, 25), + "bagging_fraction": (0.1, 1.0), + "feature_fraction_bynode": (0.1, 1.0), + } + params.update(search_space) - def _make_params_digestible(self, params): - """ - Cursory checks to force parameters to be digestible - """ + # Set our defaults if using gbdt + if use_gbdt: + params["boosting"] = "gbdt" + params["learning_rate"] = 0.02 + params["num_iterations"] = 250 + + params = self._make_lgb_params( + variable=variable, + default_parameters=params, + variable_parameters=variable_parameters, + **kwargs, + ) - int_params = [ - "num_leaves", - "min_data_in_leaf", - "num_threads", - "max_depth", - "num_iterations", - "bagging_freq", - "max_drop", - "min_data_per_group", - "max_cat_to_onehot", - ] - params = { - key: int(val) if key in int_params else val for key, val in params.items() - } return params + @staticmethod def _get_oof_performance( - self, parameters, folds, train_pointer, categorical_feature + parameters: dict, + folds: Generator, + train_set: Dataset, ): """ Performance is gathered from built-in lightgbm.cv out of fold metric. @@ -518,10 +550,9 @@ def _get_oof_performance( num_iterations = parameters.pop("num_iterations") lgbcv = cv( params=parameters, - train_set=train_pointer, + train_set=train_set, folds=folds, num_boost_round=num_iterations, - categorical_feature=categorical_feature, return_cvbooster=True, callbacks=[ early_stopping(stopping_rounds=10, verbose=False), @@ -575,76 +606,20 @@ def _make_features_label(self, variable: str, seed: int): label = features.pop(variable) return features, label - def compile_candidate_preds(self): - """ - Candidate predictions can be pre-generated before imputing new data. - This can save a substantial amount of time, especially if save_models == 1. - """ - - compile_objectives = ( - self.mean_match_scheme.get_objectives_requiring_candidate_preds() - ) - - for key, model in self.models.items(): - already_compiled = key in self.candidate_preds.keys() - objective = model.params["objective"] - if objective in compile_objectives and not already_compiled: - var = key[1] - candidate_features, _, _ = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=model.params["seed"], - ) - self.candidate_preds[key] = self.mean_match_scheme.model_predict( - model, candidate_features - ) - - else: - continue - - def delete_candidate_preds(self): - """ - Deletes the pre-computed candidate predictions. - """ - - self.candidate_preds = {} - - def fit(self, X, y, **fit_params): - """ - Method for fitting a kernel when used in a sklearn pipeline. - Should not be called by the user directly. - """ - assert self.num_datasets == 1, ( - "miceforest kernel should be initialized with datasets=1 if " - "being used in a sklearn pipeline." - ) - assert X.equals(self.working_data), ( - "It looks like this kernel is being used in a sklearn pipeline. " - "The data passed in fit() should be the same as the data that " - "was originally passed to the kernel. If this kernel is not being " - "used in an sklearn pipeline, please just use the mice() method." - ) - self.mice(**fit_params) - return self - @staticmethod def _mean_match_nearest_neighbors( mean_match_candidates: int, - bachelor_preds: _MEAN_MATCH_PRED_TYPE, - candidate_preds: _MEAN_MATCH_PRED_TYPE, + bachelor_preds: DataFrame, + candidate_preds: DataFrame, candidate_values: Series, random_state: np.random.RandomState, hashed_seeds: Optional[np.ndarray] = None, - ): + ) -> Series: """ Determines the values of candidates which will be used to impute the bachelors """ assert mean_match_candidates > 0, "Do not use nearest_neighbors with 0 mmc." - - _to_2d(bachelor_preds) - _to_2d(candidate_preds) - num_bachelors = bachelor_preds.shape[0] # balanced_tree = False fixes a recursion issue for some reason. @@ -675,13 +650,15 @@ def _mean_match_nearest_neighbors( @staticmethod def _mean_match_binary_fast( mean_match_candidates: int, - bachelor_preds: _MEAN_MATCH_PRED_TYPE, + bachelor_preds: DataFrame, random_state: np.random.RandomState, hashed_seeds: Optional[np.ndarray], - ): + ) -> np.ndarray: """ Chooses 0/1 randomly weighted by probability obtained from prediction. If mean_match_candidates is 0, choose class with highest probability. + + Returns a np.ndarray, because these get set to categorical later on. """ if mean_match_candidates == 0: imp_values = np.floor(bachelor_preds + 0.5) @@ -694,32 +671,35 @@ def _mean_match_binary_fast( imp_values = [] for i in range(num_bachelors): np.random.seed(seed=hashed_seeds[i]) - imp_values.append(np.random.binomial(n=1, p=bachelor_preds[i])) + imp_values.append(np.random.binomial(n=1, p=bachelor_preds.iloc[i])) imp_values = np.array(imp_values) + imp_values.shape = (-1,) + return imp_values @staticmethod def _mean_match_multiclass_fast( mean_match_candidates: int, - bachelor_preds: _MEAN_MATCH_PRED_TYPE, + bachelor_preds: DataFrame, random_state: np.random.RandomState, hashed_seeds: Optional[np.ndarray], ): """ If mean_match_candidates is 0, choose class with highest probability. Otherwise, randomly choose class weighted by class probabilities. + + Returns a np.ndarray, because these get set to categorical later on. """ if mean_match_candidates == 0: imp_values = np.argmax(bachelor_preds, axis=1) else: num_bachelors = bachelor_preds.shape[0] + bachelor_preds = bachelor_preds.cumsum(axis=1).to_numpy() if hashed_seeds is None: - # Turn bachelor_preds into discrete cdf, and choose - bachelor_preds = bachelor_preds.cumsum(axis=1) compare = random_state.uniform(0, 1, size=(num_bachelors, 1)) imp_values = (bachelor_preds < compare).sum(1) @@ -727,8 +707,11 @@ def _mean_match_multiclass_fast( dtype = hashed_seeds.dtype dtype_max = np.iinfo(dtype).max compare = np.abs(hashed_seeds / dtype_max) + compare.shape = (-1, 1) imp_values = (bachelor_preds < compare).sum(1) + imp_values.shape = (-1,) + return imp_values def _mean_match_fast( @@ -759,7 +742,6 @@ def _mean_match_fast( else: raise ValueError("Shouldnt be able to get here") - _to_1d(imputation_values) dtype = self.working_data[variable].dtype imputation_values = Categorical.from_codes(codes=imputation_values, dtype=dtype) @@ -799,7 +781,7 @@ def _get_candidate_preds_mice( candidate_features: DataFrame, dataset: int, iteration: int, - ): + ) -> DataFrame: """ This function also records the candidate predictions """ @@ -856,7 +838,7 @@ def _get_bachelor_preds( bachelor_features: DataFrame, dataset: int, iteration: int, - ) -> np.ndarray: + ) -> DataFrame: shap = self.mean_match_strategy[variable] == "shap" fast = self.mean_match_strategy[variable] == "fast" @@ -885,6 +867,86 @@ def _get_bachelor_preds( return bachelor_preds + def _record_candidate_preds( + self, + variable: str, + candidate_preds: DataFrame, + ): + + assign_col_index = candidate_preds.columns + + if variable not in self.candidate_preds.keys(): + inferred_iteration = assign_col_index.get_level_values("iteration").unique() + assert ( + len(inferred_iteration) == 1 + ), f"Malformed iteration multiindex for {variable}: {assign_col_index}" + inferred_iteration = inferred_iteration[0] + assert ( + inferred_iteration == 1 + ), "Adding initial candidate preds after iteration 1." + self.candidate_preds[variable] = candidate_preds + else: + self.candidate_preds[variable][assign_col_index] = candidate_preds + + def _prepare_prediction_multiindex( + self, + variable: str, + preds: np.ndarray, + shap: bool, + dataset: int, + iteration: int, + ) -> DataFrame: + + multiclass = variable in self.modeled_categorical_columns + cols = self.variable_schema[variable] + ["Intercept"] + + if shap: + + if multiclass: + + categories = self.working_data[variable].dtype.categories + cat_count = self.category_counts[variable] + preds = DataFrame(preds, columns=cols * cat_count) + del preds["Intercept"] + cols.remove("Intercept") + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], categories, cols], + names=("iteration", "dataset", "categories", "predictor"), + ) + preds.columns = assign_col_index + + else: + preds = DataFrame(preds, columns=cols) + del preds["Intercept"] + cols.remove("Intercept") + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], cols], + names=("iteration", "dataset", "predictor"), + ) + preds.columns = assign_col_index + + else: + + if multiclass: + + categories = self.working_data[variable].dtype.categories + preds = DataFrame(preds, columns=categories) + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset], categories], + names=("iteration", "dataset", "categories"), + ) + preds.columns = assign_col_index + + else: + + preds = DataFrame(preds, columns=[variable]) + assign_col_index = MultiIndex.from_product( + [[iteration], [dataset]], names=("iteration", "dataset") + ) + preds.columns = assign_col_index + + return preds + def mean_match_mice( self, variable: str, @@ -981,8 +1043,6 @@ def mean_match_ind( if using_candidate_data: - print(f"Mean matching {variable} using nearest neighbor") - candidate_preds = self._get_candidate_preds_from_store( variable=variable, dataset=dataset, @@ -1016,86 +1076,6 @@ def mean_match_ind( return imputation_values - def _record_candidate_preds( - self, - variable: str, - candidate_preds: DataFrame, - ): - - assign_col_index = candidate_preds.columns - - if variable not in self.candidate_preds.keys(): - inferred_iteration = assign_col_index.get_level_values("iteration").unique() - assert ( - len(inferred_iteration) == 1 - ), f"Malformed iteration multiindex for {variable}: {print(assign_col_index)}" - inferred_iteration = inferred_iteration[0] - assert ( - inferred_iteration == 1 - ), "Adding initial candidate preds after iteration 1." - self.candidate_preds[variable] = candidate_preds - else: - self.candidate_preds[variable][assign_col_index] = candidate_preds - - def _prepare_prediction_multiindex( - self, - variable: str, - preds: np.ndarray, - shap: bool, - dataset: int, - iteration: int, - ) -> DataFrame: - - multiclass = variable in self.modeled_categorical_columns - cols = self.variable_schema[variable] + ["Intercept"] - - if shap: - - if multiclass: - - categories = self.working_data[variable].dtype.categories - cat_count = self.category_counts[variable] - preds = DataFrame(preds, columns=cols * cat_count) - del preds["Intercept"] - cols.remove("Intercept") - assign_col_index = MultiIndex.from_product( - [[iteration], [dataset], categories, cols], - names=("iteration", "dataset", "categories", "predictor"), - ) - preds.columns = assign_col_index - - else: - preds = DataFrame(preds, columns=cols) - del preds["Intercept"] - cols.remove("Intercept") - assign_col_index = MultiIndex.from_product( - [[iteration], [dataset], cols], - names=("iteration", "dataset", "predictor"), - ) - preds.columns = assign_col_index - - else: - - if multiclass: - - categories = self.working_data[variable].dtype.categories - preds = DataFrame(preds, columns=categories) - assign_col_index = MultiIndex.from_product( - [[iteration], [dataset], categories], - names=("iteration", "dataset", "categories"), - ) - preds.columns = assign_col_index - - else: - - preds = DataFrame(preds, columns=[variable]) - assign_col_index = MultiIndex.from_product( - [[iteration], [dataset]], names=("iteration", "dataset") - ) - preds.columns = assign_col_index - - return preds - def mice( self, iterations: int, @@ -1165,7 +1145,7 @@ def mice( # absolute_iteration = self.iteration_count(datasets=dataset) logger.log(str(iteration) + " ", end="") - for dataset in range(self.num_datasets): + for dataset in self.datasets: logger.log("Dataset " + str(dataset)) # Set self.working_data to the most current iteration. @@ -1175,10 +1155,10 @@ def mice( logger.log(" | " + variable, end="") # Define the lightgbm parameters - lgbpars = self._get_lgb_params( - variable, - variable_parameters.get(variable, {}), - self._random_state, + lgbpars = self._make_lgb_params( + variable=variable, + default_parameters=_DEFAULT_LGB_PARAMS.copy(), + variable_parameters=variable_parameters.get(variable, dict()), **kwlgb, ) @@ -1273,10 +1253,10 @@ def get_model( self, variable: str, dataset: int, - iteration: Optional[int] = None, + iteration: int = -1, ): # Allow passing -1 to get the latest iteration's model - if (iteration is None) or (iteration == -1): + if iteration == -1: iteration = self.iteration_count(dataset=dataset, variable=variable) try: model = self.models[variable, iteration, dataset] @@ -1284,6 +1264,24 @@ def get_model( raise ValueError("Model was not saved.") return model + def fit(self, X, y, **fit_params): + """ + Method for fitting a kernel when used in a sklearn pipeline. + Should not be called by the user directly. + """ + assert self.num_datasets == 1, ( + "miceforest kernel should be initialized with datasets=1 if " + "being used in a sklearn pipeline." + ) + assert X.equals(self.working_data), ( + "It looks like this kernel is being used in a sklearn pipeline. " + "The data passed in fit() should be the same as the data that " + "was originally passed to the kernel. If this kernel is not being " + "used in an sklearn pipeline, please just use the mice() method." + ) + self.mice(**fit_params) + return self + def transform(self, X, y=None): """ Method for calling a kernel when used in a sklearn pipeline. @@ -1295,15 +1293,17 @@ def transform(self, X, y=None): def tune_parameters( self, - dataset: int, + dataset: int = 0, variables: Optional[List[str]] = None, - variable_parameters: Optional[Dict[str, Any]] = None, + variable_parameters: Dict[str, Any] = dict(), parameter_sampling_method: str = "random", + max_reattempts: int = 5, + use_gbdt: bool = True, nfold: int = 10, optimization_steps: int = 5, random_state: Optional[Union[int, np.random.RandomState]] = None, verbose: bool = False, - **kwbounds, + **kwargs, ): """ Perform hyperparameter tuning on models at the current iteration. @@ -1313,8 +1313,6 @@ def tune_parameters( .. code-block:: text A few notes: - - Underlying models will now be gradient boosted trees by default (or any - other boosting type compatible with lightgbm.cv). - The parameters are tuned on the data that would currently be returned by complete_data(dataset). It is usually a good idea to run at least 1 iteration of mice with the default parameters to get a more accurate idea of the @@ -1328,7 +1326,7 @@ def tune_parameters( - lightgbm parameters are chosen in the following order of priority: 1) Anything specified in variable_parameters 2) Parameters specified globally in **kwbounds - 3) Default tuning space (miceforest.default_lightgbm_parameters.make_default_tuning_space) + 3) Default tuning space (miceforest.default_lightgbm_parameters) 4) Default parameters (miceforest.default_lightgbm_parameters.default_parameters) - See examples for a detailed run-through. See https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters @@ -1339,220 +1337,194 @@ def tune_parameters( ---------- dataset: int (required) - - .. code-block:: text - - The dataset to run parameter tuning on. Tuning parameters on 1 dataset usually results - in acceptable parameters for all datasets. However, tuning results are still stored - seperately for each dataset. + The dataset to run parameter tuning on. Tuning parameters on 1 dataset usually results + in acceptable parameters for all datasets. However, tuning results are still stored + seperately for each dataset. variables: None or list - - .. code-block:: text - - - If None, default hyper-parameter spaces are selected based on kernel data, and - all variables with missing values are tuned. - - If list, must either be indexes or variable names corresponding to the variables - that are to be tuned. + - If None, default hyper-parameter spaces are selected based on kernel data, and + all variables with missing values are tuned. + - If list, must either be indexes or variable names corresponding to the variables + that are to be tuned. variable_parameters: None or dict - - .. code-block:: text - - Defines the tuning space. Dict keys must be variable names or indices, and a subset - of the variables parameter. Values must be a dict with lightgbm parameter names as - keys, and values that abide by the following rules: - scalar: If a single value is passed, that parameter will be used to build the - model, and will not be tuned. - tuple: If a tuple is passed, it must have length = 2 and will be interpreted as - the bounds to search within for that parameter. - list: If a list is passed, values will be randomly selected from the list. - NOTE: This is only possible with method = 'random'. - - example: If you wish to tune the imputation model for the 4th variable with specific - bounds and parameters, you could pass: - variable_parameters = { - 4: { - 'learning_rate: 0.01', - 'min_sum_hessian_in_leaf: (0.1, 10), - 'extra_trees': [True, False] - } + Defines the tuning space. Dict keys must be variable names or indices, and a subset + of the variables parameter. Values must be a dict with lightgbm parameter names as + keys, and values that abide by the following rules: + scalar: If a single value is passed, that parameter will be used to build the + model, and will not be tuned. + tuple: If a tuple is passed, it must have length = 2 and will be interpreted as + the bounds to search within for that parameter. + list: If a list is passed, values will be randomly selected from the list. + NOTE: This is only possible with method = 'random'. + + example: If you wish to tune the imputation model for the 4th variable with specific + bounds and parameters, you could pass: + variable_parameters = { + 'column': { + 'learning_rate: 0.01', + 'min_sum_hessian_in_leaf: (0.1, 10), + 'extra_trees': [True, False] } - All models for variable 4 will have a learning_rate = 0.01. The process will randomly - search within the bounds (0.1, 10) for min_sum_hessian_in_leaf, and extra_trees will - be randomly selected from the list. Also note, the variable name for the 4th column - could also be passed instead of the integer 4. All other variables will be tuned with - the default search space, unless **kwbounds are passed. + } + All models for variable 'column' will have a learning_rate = 0.01. The process will randomly + search within the bounds (0.1, 10) for min_sum_hessian_in_leaf, and extra_trees will + be randomly selected from the list. Also note, the variable name for the 4th column + could also be passed instead of the integer 4. All other variables will be tuned with + the default search space, unless **kwbounds are passed. parameter_sampling_method: str + If 'random', parameters are randomly selected. + Other methods will be added in future releases. - .. code-block:: text + max_reattempts: int + The maximum number of failures (or non-learners) before the process stops, and moves to the + next variable. Failures can be caused by bad parameters passed to lightgbm. Non-learners + occur when trees cannot possibly be built (i.e. min_samples_in_leaf > dataset.shape[0]). - If 'random', parameters are randomly selected. - Other methods will be added in future releases. + use_gbdt: bool + Whether the models should use gradient boosting instead of random forests. + If True, the optimal number of iterations will be found in lgb.cv, along + with the other parameters. nfold: int - - .. code-block:: text - - The number of folds to perform cross validation with. More folds takes longer, but - Gives a more accurate distribution of the error metric. + The number of folds to perform cross validation with. More folds takes longer, but + Gives a more accurate distribution of the error metric. optimization_steps: - - .. code-block:: text - - How many steps to run the process for. + How many steps to run the process for. random_state: int or np.random.RandomState or None (default=None) - - .. code-block:: text - - The random state of the process. Ensures reproduceability. If None, the random state - of the kernel is used. Beware, this permanently alters the random state of the kernel - and ensures non-reproduceable results, unless the entire process up to this point - is re-run. + The random state of the process. Ensures reproduceability. If None, the random state + of the kernel is used. Beware, this permanently alters the random state of the kernel + and ensures non-reproduceable results, unless the entire process up to this point + is re-run. kwbounds: - - .. code-block:: text - - Any additional arguments that you want to apply globally to every variable. - For example, if you want to limit the number of iterations, you could pass - num_iterations = x to this functions, and it would apply globally. Custom - bounds can also be passed. + Any additional arguments that you want to apply globally to every variable. + For example, if you want to limit the number of iterations, you could pass + num_iterations = x to this functions, and it would apply globally. Custom + bounds can also be passed. Returns ------- - 2 dicts: optimal_parameters, optimal_parameter_losses - - - optimal_parameters: dict + dict: optimal_parameters A dict of the optimal parameters found for each variable. This can be passed directly to the variable_parameters parameter in mice() - - .. code-block:: text - {variable: {parameter_name: parameter_value}} - - optimal_parameter_losses: dict - The average out of fold cv loss obtained directly from - lightgbm.cv() associated with the optimal parameter set. - - .. code-block:: text - - {variable: loss} - """ - if random_state is None: - random_state = self._random_state - else: - random_state = ensure_rng(random_state) + random_state = ensure_rng(random_state) if variables is None: variables = self.imputation_order - else: - variables = self._get_var_ind_from_list(variables) self.complete_data(dataset, inplace=True) logger = Logger( name=f"tune: {optimization_steps}", + timed_levels=_TUNING_TIMED_LEVELS, verbose=verbose, ) - vsp = self._format_variable_parameters(variable_parameters) - variable_parameter_space = {} + for variable in variables: + + logger.log(f"Optimizing {variable}") + + seed = _draw_random_int32(random_state=random_state, size=1) - for var in variables: - default_tuning_space = make_default_tuning_space( - self.category_counts[var] if var in self.categorical_variables else 1, - int((self.shape[0] - len(self.na_where[var])) / 10), + ( + candidate_features, + candidate_values, + ) = self._make_features_label(variable=variable, seed=seed) + + min_samples = ( + self.category_counts[variable] + if variable in self.modeled_categorical_columns + else 1 ) + max_samples = int(candidate_features.shape[0] / 5) - variable_parameter_space[var] = self._get_lgb_params( - var=var, - vsp={**kwbounds, **vsp[var]}, - random_state=random_state, - **default_tuning_space, + assert isinstance( + variable_parameters, dict + ), "variable_parameters should be a dict" + vp = variable_parameters.get(variable, dict()).copy() + + tuning_space = self._make_tuning_space( + variable=variable, + variable_parameters=vp, + use_gbdt=use_gbdt, + min_samples=min_samples, + max_samples=max_samples, + **kwargs, ) - if parameter_sampling_method == "random": - for var, parameter_space in variable_parameter_space.items(): - logger.log(self._get_var_name_from_scalar(var) + " | ", end="") - - ( - candidate_features, - candidate_values, - feature_cat_index, - ) = self._make_features_label( - variable=var, - subset_count=self.data_subset[var], - random_seed=_draw_random_int32( - random_state=self._random_state, size=1 - )[0], + # lightgbm requires integers for label. Categories won't work. + if candidate_values.dtype.name == "category": + assert variable in self.modeled_categorical_columns, ( + "Something went wrong in definining categorical " + f"status of variable {variable}. Please open an issue." ) + candidate_values = candidate_values.cat.codes + is_cat = True + else: + is_cat = False - # lightgbm requires integers for label. Categories won't work. - if candidate_values.dtype.name == "category": - candidate_values = candidate_values.cat.codes - - is_categorical = var in self.categorical_variables - - for step in range(optimization_steps): - logger.log(str(step), end="") - - # Make multiple attempts to learn something. - non_learners = 0 - learning_attempts = 10 - while non_learners < learning_attempts: - # Pointer and folds need to be re-initialized after every run. - train_pointer = Dataset( - data=candidate_features, - label=candidate_values, - categorical_feature=feature_cat_index, - free_raw_data=False, - ) - if is_categorical: - folds = stratified_categorical_folds( - candidate_values, nfold - ) - else: - folds = stratified_continuous_folds(candidate_values, nfold) - sampling_point = self._get_random_sample( - parameters=parameter_space, random_state=random_state + for step in range(optimization_steps): + + # Make multiple attempts to learn something. + non_learners = 0 + while non_learners < max_reattempts: + + # Sample parameters + sampled_parameters = _sample_parameters( + parameters=tuning_space, + random_state=random_state, + parameter_sampling_method=parameter_sampling_method, + ) + logger.log( + f" Step {step} - Parameters: {sampled_parameters}", end="" + ) + + # Pointer and folds need to be re-initialized after every run. + train_set = Dataset( + data=candidate_features, + label=candidate_values, + ) + if is_cat: + folds = stratified_categorical_folds(candidate_values, nfold) + else: + folds = stratified_continuous_folds(candidate_values, nfold) + + try: + loss, best_iteration = self._get_oof_performance( + parameters=sampled_parameters.copy(), + folds=folds, + train_set=train_set, ) - try: - loss, best_iteration = self._get_oof_performance( - parameters=sampling_point.copy(), - folds=folds, - train_pointer=train_pointer, - categorical_feature=feature_cat_index, - ) - except: - loss, best_iteration = np.Inf, 0 - - if best_iteration > 1: - break - else: - non_learners += 1 - - if loss < self.optimal_parameter_losses[dataset][var]: - del sampling_point["seed"] - sampling_point["num_iterations"] = best_iteration - self.optimal_parameters[dataset][var] = sampling_point - self.optimal_parameter_losses[dataset][var] = loss - - logger.log(" - ", end="") + except Exception as err: + non_learners += 1 + logger.log(f" - Lightgbm Error {err=}, {type(err)=}") + continue + + if best_iteration > 1: + logger.log(f" - Success - Loss: {loss}") + break + else: + logger.log(" - Non-Learner") + non_learners += 1 - logger.log("\n", end="") + best_loss = self.optimal_parameter_losses.get(variable, np.inf) + if loss < best_loss: + del sampled_parameters["seed"] + sampled_parameters["num_iterations"] = best_iteration + self.optimal_parameters[variable] = sampled_parameters + self.optimal_parameter_losses[variable] = loss - self._ampute_original_data() - return ( - self.optimal_parameters[dataset], - self.optimal_parameter_losses[dataset], - ) + self._ampute_original_data() + return self.optimal_parameters def impute_new_data( self, @@ -1656,7 +1628,8 @@ def impute_new_data( "To save this data, set save_all_iterations_data to True when making kernel." ) - datasets = list(range(self.num_datasets)) if datasets is None else datasets + # datasets = list(range(self.num_datasets)) if datasets is None else datasets + datasets = self.datasets if datasets is None else datasets kernel_iterations = self.iteration_count() iterations = kernel_iterations if iterations is None else iterations logger = Logger( @@ -1678,7 +1651,8 @@ def impute_new_data( imputed_data = ImputedData( impute_data=new_data, - num_datasets=len(datasets), + # num_datasets=len(datasets), + datasets=datasets, variable_schema=self.variable_schema.copy(), save_all_iterations_data=save_all_iterations_data, copy_data=copy_data, @@ -1710,8 +1684,7 @@ def impute_new_data( for dataset in datasets: logger.log("Dataset " + str(dataset)) self.complete_data(dataset=dataset, inplace=True) - ds_new = datasets.index(dataset) - imputed_data.complete_data(dataset=ds_new, inplace=True) + imputed_data.complete_data(dataset=dataset, inplace=True) for variable in new_imputation_order: logger.log(" | " + variable, end="") @@ -1759,65 +1732,13 @@ def impute_new_data( return imputed_data - # def save_kernel( - # self, filepath, clevel=None, cname=None, n_threads=None, copy_while_saving=True - # ): - # """ - # Compresses and saves the kernel to a file. - - # Parameters - # ---------- - # filepath: str - # The file to save to. - - # clevel: int - # The compression level, sent to clevel argument in blosc.compress() - - # cname: str - # The compression algorithm used. - # Sent to cname argument in blosc.compress. - # If None is specified, the default is lz4hc. - - # n_threads: int - # The number of threads to use for compression. - # By default, all threads are used. - - # copy_while_saving: boolean - # Should the kernel be copied while saving? Copying is safer, but - # may take more memory. - - # """ - - # clevel = 9 if clevel is None else clevel - # cname = "lz4hc" if cname is None else cname - # n_threads = blosc2.detect_number_of_cores() if n_threads is None else n_threads - - # if copy_while_saving: - # kernel = copy(self) - # else: - # kernel = self - - # # convert working data to parquet bytes object - # if kernel.original_data_class == "pd_DataFrame": - # working_data_bytes = BytesIO() - # kernel.working_data.to_parquet(working_data_bytes) - # kernel.working_data = working_data_bytes - - # blosc2.set_nthreads(n_threads) - - # with open(filepath, "wb") as f: - # dill.dump( - # blosc2.compress( - # dill.dumps(kernel), - # clevel=clevel, - # typesize=8, - # shuffle=blosc2.NOSHUFFLE, - # cname=cname, - # ), - # f, - # ) - - def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: + def get_feature_importance( + self, + dataset: int = 0, + iteration: int = -1, + importance_type: str = "split", + normalize: bool = True, + ) -> np.ndarray: """ Return a matrix of feature importance. The cells represent the normalized feature importance of the @@ -1831,7 +1752,8 @@ def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: iteration: int The iteration to return the feature importance for. - Right now, the model must be saved to return importance + The model must be saved to return importance. + Use -1 to specify the latest iteration. Returns ------- @@ -1840,35 +1762,37 @@ def get_feature_importance(self, dataset, iteration=None) -> np.ndarray: """ - if iteration is None: + if iteration == -1: iteration = self.iteration_count(dataset=dataset) - importance_matrix = np.full( - shape=(len(self.imputation_order), len(self.predictor_vars)), - fill_value=np.NaN, + modeled_vars = [ + col for col in self.working_data.columns if col in self.model_training_order + ] + + importance_matrix = DataFrame( + index=modeled_vars, columns=self.predictor_columns ) + for modeled_variable in modeled_vars: + predictor_vars = self.variable_schema[modeled_variable] + importances = self.get_model( + variable=modeled_variable, dataset=dataset, iteration=iteration + ).feature_importance(importance_type=importance_type) + importances = Series(importances, index=predictor_vars) + importance_matrix.loc[modeled_variable, predictor_vars] = importances - for ivar in self.imputation_order: - importance_dict = dict( - zip( - self.variable_schema[ivar], - self.get_model(dataset, ivar, iteration).feature_importance(), - ) - ) - for pvar in importance_dict: - importance_matrix[ - np.sort(self.imputation_order).tolist().index(ivar), - np.sort(self.predictor_vars).tolist().index(pvar), - ] = importance_dict[pvar] + importance_matrix = importance_matrix.astype("float64") + + if normalize: + importance_matrix /= importance_matrix.sum(1).to_numpy().reshape(-1, 1) return importance_matrix def plot_feature_importance( self, dataset, + importance_type: str = "split", normalize: bool = True, - iteration: Optional[int] = None, - **kw_plot, + iteration: int = -1, ): """ Plot the feature importance. See get_feature_importance() @@ -1881,6 +1805,8 @@ def plot_feature_importance( iteration: int The iteration to plot the feature importance of. + The model must be saved to plot feature importance. + Use -1 to return the latest iteration. normalize: book Should the values be normalize from 0-1? @@ -1893,36 +1819,46 @@ def plot_feature_importance( # Move this to .compat at some point. try: - from seaborn import heatmap + from plotnine import ( + ggplot, + aes, + geom_tile, + theme, + element_text, + xlab, + ylab, + ggtitle, + element_blank, + geom_label, + scale_fill_distiller, + ) except ImportError: - raise ImportError("seaborn must be installed to plot importance") + raise ImportError("plotnine must be installed to plot importance") importance_matrix = self.get_feature_importance( - dataset=dataset, iteration=iteration + dataset=dataset, + iteration=iteration, + normalize=normalize, + importance_type=importance_type, + ) + importance_matrix = importance_matrix.reset_index().melt(id_vars="index") + importance_matrix["Importance"] = importance_matrix["value"].round(2) + importance_matrix = importance_matrix.dropna() + + fig = ( + ggplot(importance_matrix, aes(x="variable", y="index", fill="Importance")) + + geom_tile(show_legend=False) + + ylab("Modeled Variable") + + xlab("Predictor") + + ggtitle("Feature Importance") + + geom_label(aes(label="Importance"), fill="white", size=8) + + scale_fill_distiller(palette=1, direction=1) + + theme( + axis_text_x=element_text(rotation=30, hjust=1), + plot_title=element_text(ha="left", size=20), + panel_background=element_blank(), + figure_size=(6, 6), + ) ) - if normalize: - importance_matrix = ( - importance_matrix / np.nansum(importance_matrix, 1).reshape(-1, 1) - ).round(2) - - imputed_var_names = [ - self._get_var_name_from_scalar(int(i)) - for i in np.sort(self.imputation_order) - ] - predictor_var_names = [ - self._get_var_name_from_scalar(int(i)) for i in np.sort(self.predictor_vars) - ] - - params = { - **{ - "cmap": "coolwarm", - "annot": True, - "fmt": ".2f", - "xticklabels": predictor_var_names, - "yticklabels": imputed_var_names, - "annot_kws": {"size": 16}, - }, - **kw_plot, - } - print(heatmap(importance_matrix, **params)) + return fig From feeb31690dbf163ff5716bc4ff0d3fbf1beaab91 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:29:30 -0400 Subject: [PATCH 15/44] Moved tuning args over to default_lightgbm_parameters module --- miceforest/default_lightgbm_parameters.py | 78 +++++++++++++++++------ 1 file changed, 60 insertions(+), 18 deletions(-) diff --git a/miceforest/default_lightgbm_parameters.py b/miceforest/default_lightgbm_parameters.py index f7b8393..c94bbb0 100644 --- a/miceforest/default_lightgbm_parameters.py +++ b/miceforest/default_lightgbm_parameters.py @@ -1,35 +1,77 @@ +import numpy as np +from .utils import _draw_random_int32 + + +# A few parameters that generally benefit +# from searching in the log space. +_LOG_SPACE_SEARCH = [ + "min_data_in_leaf", + "min_sum_hessian_in_leaf", + "lambda_l1", + "lambda_l2", + "cat_l2", + "cat_smooth", + "path_smooth", + "min_gain_to_split", +] + + # THESE VALUES WILL ALWAYS BE USED WHEN VALUES ARE NOT PASSED BY USER. # seed is always set by the calling processes _random_state. # These need to be main parameter names, not aliases -default_parameters = { +_DEFAULT_LGB_PARAMS = { "boosting": "random_forest", "data_sample_strategy": "bagging", "num_iterations": 48, "max_depth": 8, "num_leaves": 128, "min_data_in_leaf": 1, - "min_sum_hessian_in_leaf": 0.00001, + "min_sum_hessian_in_leaf": 0.1, "min_gain_to_split": 0.0, "bagging_fraction": 0.632, - # "feature_fraction": 0.632, "feature_fraction_bynode": 0.632, "bagging_freq": 1, "verbosity": -1, } -# WHEN TUNING, THESE PARAMETERS OVERWRITE THE DEFAULTS ABOVE -# These need to be main parameter names, not aliases -def make_default_tuning_space(min_samples, max_samples): - space = { - "boosting": "gbdt", - "learning_rate": 0.02, - "num_iterations": 250, - "min_data_in_leaf": (min_samples, max_samples), - "min_sum_hessian_in_leaf": 0.1, - "num_leaves": (2, 25), - "bagging_fraction": (0.1, 1.0), - "feature_fraction_bynode": (0.1, 1.0), - "cat_smooth": (0, 25), - } - return space +def _sample_parameters(parameters: dict, random_state, parameter_sampling_method: str): + """ + Searches through a parameter set and selects a random + number between the values in any provided tuple of length 2. + """ + assert ( + parameter_sampling_method == "random" + ), "Only random parameter sampling is supported right now." + parameters = parameters.copy() + for p, v in parameters.items(): + if isinstance(v, list): + choice = random_state.choice(v) + elif isinstance(v, tuple): + assert ( + len(v) == 2 + ), "Tuples passed must be length 2, representing the bounds." + assert v[0] < v[1], f"{p} lower bound > upper bound" + if p in _LOG_SPACE_SEARCH: + choice = np.exp( + random_state.uniform( + np.log(v[0]), + np.log(v[1]), + size=1, + )[0] + ) + else: + choice = random_state.uniform( + v[0], + v[1], + size=1, + )[0] + if isinstance(v[0], int): + choice = int(choice) + else: + choice = parameters[p] + parameters[p] = choice + + parameters["seed"] = _draw_random_int32(random_state, size=1)[0] + + return parameters From cbd1904b58522adf9e66839e9ec41087a22c6e6f Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:35:55 -0400 Subject: [PATCH 16/44] Updated README --- README.md | 965 +++++++++++++++++++++++++++++++++ README_gen.ipynb | 1337 +++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 2296 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index d6ee667..616f5c6 100644 --- a/README.md +++ b/README.md @@ -147,6 +147,7 @@ miceforest has 3 main classes which the user will interact with: We will be looking at a few simple examples of imputation. We need to load the packages, and define the data: + ```python import miceforest as mf from sklearn.datasets import load_iris @@ -160,9 +161,973 @@ iris['species'] = iris['species'].astype('category') iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991) ``` +If you only want to create a single imputed dataset, you can use +[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) +with some default settings: + + +```python +# Create kernel. +kds = mf.ImputationKernel( + iris_amp, + random_state=1991 +) + +# Run the MICE algorithm for 2 iterations +kds.mice(2) + +# Return the completed dataset. +iris_complete = kds.complete_data() +``` + +There are also an array of plotting functions available, these are +discussed below in the section [Diagnostic +Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting). + +We usually don’t want to impute just a single dataset. In statistics, +multiple imputation is a process by which the uncertainty/other effects +caused by missing values can be examined by creating multiple different +imputed datasets. +[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel) +can contain an arbitrary number of different datasets, all of which have +gone through mutually exclusive imputation processes: + + +```python +# Create kernel. +kernel = mf.ImputationKernel( + iris_amp, + num_datasets=4, + random_state=1 +) + +# Run the MICE algorithm for 2 iterations on each of the datasets +kernel.mice(2) + +# Printing the kernel will show you some high level information. +print(kernel) +``` + + + Class: ImputationKernel + Datasets: 4 + Iterations: 2 + Data Samples: 150 + Data Columns: 5 + Imputed Variables: 5 + Modeled Variables: 5 + All Iterations Saved: True + + + +After we have run mice, we can obtain our completed dataset directly +from the kernel: + + +```python +completed_dataset = kernel.complete_data(dataset=2) +print(completed_dataset.isnull().sum(0)) +``` + + sepal length (cm) 0 + sepal width (cm) 0 + petal length (cm) 0 + petal width (cm) 0 + species 0 + dtype: int64 + + +## Customizing LightGBM Parameters + +Parameters can be passed directly to lightgbm in several different ways. +Parameters you wish to apply globally to every model can simply be +passed as kwargs to `mice`: + + +```python +# Run the MICE algorithm for 1 more iteration on the kernel with new parameters +kernel.mice(iterations=1, n_estimators=50) +``` + +You can also pass pass variable-specific arguments to +`variable_parameters` in mice. For instance, let’s say you noticed the +imputation of the `[species]` column was taking a little longer, because +it is multiclass. You could decrease the n\_estimators specifically for +that column with: + + +```python +# Run the MICE algorithm for 2 more iterations on the kernel +kernel.mice( + iterations=1, + variable_parameters={'species': {'n_estimators': 25}}, + n_estimators=50 +) + +# Let's get the actual models for these variables: +species_model = kernel.get_model(dataset=0,variable="species") +sepalwidth_model = kernel.get_model(dataset=0,variable="sepal width (cm)") + +print( +f"""Species used {str(species_model.params["num_iterations"])} iterations +Sepal Width used {str(sepalwidth_model.params["num_iterations"])} iterations +""" +) +``` + + Species used 25 iterations + Sepal Width used 50 iterations + + + +In this scenario, any parameters specified in `variable_parameters` +takes presidence over the kwargs. + +Since we can pass any parameters we want to LightGBM, we can completely +customize how our models are built. That includes how the data should be +modeled. If your data contains count data, or any other data which can +be parameterized by lightgbm, you can simply specify that variable to be +modeled with the corresponding objective function. + +For example, let’s pretend `sepal width (cm)` is a count field which can +be parameterized by a Poisson distribution. Let’s also change our +boosting method to gradient boosted trees: + + +```python +# Create kernel. +cust_kernel = mf.ImputationKernel( + iris_amp, + num_datasets=1, + random_state=1 +) + +cust_kernel.mice( + iterations=1, + variable_parameters={'sepal width (cm)': {'objective': 'poisson'}}, + boosting = 'gbdt', + min_sum_hessian_in_leaf=0.01 +) +``` + +Other nice parameters like `monotone_constraints` can also be passed. +Setting the parameter `device: 'gpu'` will utilize GPU learning, if +LightGBM is set up to do this on your machine. + +## Adjusting The Mean Matching Scheme + +Note: It is probably a good idea to read [this +section](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching) +first, to get some context on how mean matching works. + +There are 4 imputation strategies employed by `miceforest`: +- **Fast** Mean Matching: Available only on binary and categorical variables. Chooses a class randomly based on the predicted probabilities output by lightgbm. +- **Normal** Mean Matching: Employs mean matching as described in the section below. +- **Shap** Mean Matching: Runs a nearest neighbor search on the shap values of the bachelor predictions in the shap values of the candidate predictions. Finds the `mean_match_candidates` nearest neighbors, and chooses one randomly as the imputation value. +- Value Imputation: Uses the value output by lightgbm as the imputation value. Skips mean matching entirely. To use, set `mean_match_candidates = 0`. + +Here is the code required to use each method: + + +```python +# Create kernel. +cust_kernel = mf.ImputationKernel( + iris_amp, + num_datasets=1, + random_state=1, + mean_match_strategy={ + 'sepal length (cm)': 'normal', + 'sepal width (cm)': 'shap', + 'species': 'fast', + }, + mean_match_candidates={ + 'petal length (cm)': 0, + } +) + +cust_kernel.mice( + iterations=1, +) +``` + +### Imputing New Data with Existing Models + +Multiple Imputation can take a long time. If you wish to impute a +dataset using the MICE algorithm, but don’t have time to train new +models, it is possible to impute new datasets using a `ImputationKernel` +object. The `impute_new_data()` function uses the models collected by +`ImputationKernel` to perform multiple imputation without updating the +models at each iteration: + + +```python +# Our 'new data' is just the first 15 rows of iris_amp +from datetime import datetime + +# Define our new data as the first 15 rows +new_data = iris_amp.iloc[range(15)].reset_index(drop=True) + +start_t = datetime.now() +new_data_imputed = cust_kernel.impute_new_data(new_data=new_data) +print(f"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds") +``` + + New Data imputed in 0.040128 seconds + + +## Saving and Loading Kernels + +Saving `miceforest` kernels is efficient. During the pickling process, the following steps are taken: + +1. Convert working data to parquet bytes. +2. Serialize the kernel. +4. Save to a file. + +You can save and load the kernel like any other object using `pickle` or `dill`: + + + +```python +from tempfile import mkstemp +import dill +new_file, filename = mkstemp() + +with open(filename, "wb") as f: + dill.dump(kernel, f) + +with open(filename, "rb") as f: + kernel_from_pickle = dill.load(f) +``` + +## Implementing sklearn Pipelines + +`miceforest` kernels can be fit into sklearn pipelines to impute training and scoring +datasets: + + +```python +import numpy as np +from sklearn.preprocessing import StandardScaler +from sklearn.datasets import make_classification +from sklearn.model_selection import train_test_split +from sklearn.pipeline import Pipeline +import miceforest as mf + +kernel = mf.ImputationKernel(iris_amp, num_datasets=1, random_state=1) + +pipe = Pipeline([ + ('impute', kernel), + ('scaler', StandardScaler()), +]) + +# The pipeline can be used as any other estimator +# and avoids leaking the test set into the train set +X_train_t = pipe.fit_transform( + X=iris_amp, + y=None, + impute__iterations=2 +) +X_test_t = pipe.transform(new_data) + +# Show that neither now have missing values. +assert not np.any(np.isnan(X_train_t)) +assert not np.any(np.isnan(X_test_t)) +``` + +## Building Models on Nonmissing Data + +The MICE process itself is used to impute missing data in a dataset. +However, sometimes a variable can be fully recognized in the training +data, but needs to be imputed later on in a different dataset. It is +possible to train models to impute variables even if they have no +missing values by specifying them in the `variable_schema` parameter. +In this case, `variable_schema` is treated as the list of variables +to train models on. + + +```python +# Set petal length (cm) in our amputed data +# to original values with no missing data. +iris_amp['sepal width (cm)'] = iris['sepal width (cm)'].copy() +iris_amp.isnull().sum() +``` + + + + + sepal length (cm) 37 + sepal width (cm) 0 + petal length (cm) 37 + petal width (cm) 37 + species 37 + dtype: int64 + + + + +```python +kernel = mf.ImputationKernel( + data=iris_amp, + variable_schema=iris_amp.columns.to_list(), + num_datasets=1, + random_state=1, +) +kernel.mice(1) +``` + + +```python +# Remember, the dataset we are imputing does have +# missing values in the sepal width (cm) column +new_data.isnull().sum() +``` + + + + + sepal length (cm) 4 + sepal width (cm) 3 + petal length (cm) 1 + petal width (cm) 3 + species 3 + dtype: int64 + + + + +```python +new_data_imp = kernel.impute_new_data(new_data) +new_data_imp = new_data_imp.complete_data() + +# All columns have been imputed. +new_data_imp.isnull().sum() +``` + + + + + sepal length (cm) 0 + sepal width (cm) 0 + petal length (cm) 0 + petal width (cm) 0 + species 0 + dtype: int64 + + + +## Tuning Parameters + +`miceforest` allows you to tune the parameters on a kernel dataset. +These parameters can then be used to build the models in future +iterations of mice. In its most simple invocation, you can just call the +function with the desired optimization steps: + + +```python +optimal_params = kernel.tune_parameters( + dataset=0, + use_gbdt=True, + num_iterations=500, + random_state=1, +) +kernel.mice(1, variable_parameters=optimal_params) +pd.DataFrame(optimal_params) +``` + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sepal length (cm)petal length (cm)petal width (cm)species
boostinggbdtgbdtgbdtgbdt
data_sample_strategybaggingbaggingbaggingbagging
num_iterations142248262172
max_depth4455
num_leaves1217219
min_data_in_leaf22155
min_sum_hessian_in_leaf0.10.10.10.1
min_gain_to_split0.00.00.00.0
bagging_fraction0.5809730.5015210.5867090.795465
feature_fraction_bynode0.9225660.2999120.5031820.237637
bagging_freq1111
verbosity-1-1-1-1
learning_rate0.020.020.020.02
objectiveregressionregressionregressionmulticlass
num_classNaNNaNNaN3
+
+ + + +This will perform 10 fold cross validation on random samples of +parameters. By default, all variables models are tuned. + +The parameter tuning is pretty flexible. If you wish to set some model +parameters static, or to change the bounds that are searched in, you can +simply pass this information to either the `variable_parameters` +parameter, `**kwbounds`, or both: + + +```python +optimal_params = kernel.tune_parameters( + dataset=0, + variables = ['sepal width (cm)','species','petal width (cm)'], + variable_parameters = { + 'sepal width (cm)': {'bagging_fraction': 0.5}, + 'species': {'bagging_freq': (5,10)} + }, + use_gbdt=True, + optimization_steps=5, + extra_trees = [True, False] +) + +kernel.mice(1, variable_parameters=optimal_params) +``` + +In this example, we did a few things - we specified that only `sepal +width (cm)`, `species`, and `petal width (cm)` should be tuned. We also +specified some specific parameters in `variable_parameters`. Notice that +`bagging_fraction` was passed as a scalar, `0.5`. This means that, for +the variable `sepal width (cm)`, the parameter `bagging_fraction` will +be set as that number and not be tuned. We did the opposite for +`bagging_freq`. We specified bounds that the process should search in. +We also passed the argument `extra_trees` as a list. Since it was passed +to \*\*kwbounds, this parameter will apply to all variables that are +being tuned. Passing values as a list tells the process that it should +randomly sample values from the list, instead of treating them as set of +counts to search within. + +Additionally, we set `use_gbdt=True`. This switches the process to use +gradient boosted trees, instead of random forests. Typically, gradient +boosted trees will perform better. The optimal `num_iterations` is also +determined by early stopping in cross validation. + +The tuning process follows these rules for different parameter values it +finds: + + - Scalar: That value is used, and not tuned. + - Tuple: Should be length 2. Treated as the lower and upper bound to + search in. + - List: Treated as a distinct list of values to try randomly. + + +## On Reproducibility + +`miceforest` allows for different “levels” of reproducibility, global +and record-level. + +##### **Global Reproducibility** + +Global reproducibility ensures that the same values will be imputed if +the same code is run multiple times. To ensure global reproducibility, +all the user needs to do is set a `random_state` when the kernel is +initialized. + +##### **Record-Level Reproducibility** + +Sometimes we want to obtain reproducible imputations at the record +level, without having to pass the same dataset. This is possible by +passing a list of record-specific seeds to the `random_seed_array` +parameter. This is useful if imputing new data multiple times, and you +would like imputations for each row to match each time it is imputed. + + ```python +# Define seeds for the data, and impute iris +import numpy as np +random_seed_array = np.random.randint(0, 9999, size=iris_amp.shape[0], dtype='uint32') +iris_imputed = kernel.impute_new_data( + iris_amp, + random_state=4, + random_seed_array=random_seed_array +) +# Select a random sample +new_inds = np.random.choice(150, size=15) +new_data = iris_amp.loc[new_inds].reset_index(drop=True) +new_seeds = random_seed_array[new_inds] +new_imputed = kernel.impute_new_data( + new_data, + random_state=4, + random_seed_array=new_seeds +) + +# We imputed the same values for the 15 values each time, +# because each record was associated with the same seed. +assert new_imputed.complete_data(0).equals( + iris_imputed.complete_data(0).loc[new_inds].reset_index(drop=True) +) ``` +## How to Make the Process Faster + +Multiple Imputation is one of the most robust ways to handle missing +data - but it can take a long time. There are several strategies you can +use to decrease the time a process takes to run: + + - Decrease `data_subset`. By default all non-missing datapoints for + each variable are used to train the model and perform mean matching. + This can cause the model training nearest-neighbors search to take a + long time for large data. A subset of these points can be searched + instead by using `data_subset`. + - If categorical columns are taking a long time, you can set + `mean_match_strategy="fast"`. You can also set different parameters + specifically for categorical columns, like smaller `bagging_fraction` + or `num_iterations`, or try grouping the categories before they are + imputed. Model training time for categorical variables is linear with + the number of distinct categories. + - Decrease `mean_match_candidates`. The maximum number of neighbors + that are considered with the default parameters is 10. However, for + large datasets, this can still be an expensive operation. Consider + explicitly setting `mean_match_candidates` lower. Setting + `mean_match_candidates=0` will skip mean matching entirely, and + just use the lightgbm predictions as the imputation values. + - Use different lightgbm parameters. lightgbm is usually not the + problem, however if a certain variable has a large number of + classes, then the max number of trees actually grown is (\# classes) + \* (n\_estimators). You can specifically decrease the bagging + fraction or n\_estimators for large multi-class variables, or grow + less trees in general. + +## Imputing Data In Place + +It is possible to run the entire process without copying the dataset. If +`copy_data=False`, then the data is referenced directly: + + + +```python +kernel_inplace = mf.ImputationKernel( + iris_amp, + num_datasets=1, + copy_data=False, + random_state=1, +) +kernel_inplace.mice(2) +``` + +Note, that this probably won’t (but could) change the original dataset +in undesirable ways. Throughout the `mice` procedure, imputed values are +stored directly in the original data. At the end, the missing values are +put back as `np.NaN`. + +We can also complete our original data in place. This is useful if the dataset is large, and copies can’t be made in +memory: + + +```python +kernel_inplace.complete_data(dataset=0, inplace=True) +print(iris_amp.isnull().sum(0)) +``` + + sepal length (cm) 0 + sepal width (cm) 0 + petal length (cm) 0 + petal width (cm) 0 + species 0 + dtype: int64 + + +## Diagnostic Plotting + +As of now, there is 2 diagnostic plot available. More coming soon! + +### Feature Importance + + +```python +kernel.plot_feature_importance(dataset=0) +``` + + + +![png](README_files/README_48_0.png) + + + +### Plot Imputed Distributions + + +```python +kernel.plot_imputed_distributions() +``` + + + +![png](README_files/README_50_0.png) + + + +## Using the Imputed Data + +To return the imputed data simply use the `complete_data` method: + + +```python +dataset_1 = kernel.complete_data(0) +``` + +This will return a single specified dataset. Multiple datasets are +typically created so that some measure of confidence around each +prediction can be created. + +Since we know what the original data looked like, we can cheat and see +how well the imputations compare to the original data: + + +```python +acclist = [] +iterations = kernel.iteration_count()+1 +for iteration in range(iterations): + species_na_count = kernel.na_counts['species'] + compdat = kernel.complete_data(dataset=0,iteration=iteration) + + # Record the accuract of the imputations of species. + acclist.append( + round(1-sum(compdat['species'] != iris['species'])/species_na_count,2) + ) + +# acclist shows the accuracy of the imputations over the iterations. +acclist = pd.Series(acclist).rename("Species Imputation Accuracy") +acclist.index = range(iterations) +acclist.index.name = "Iteration" +acclist +``` + + + + + Iteration + 0 0.35 + 1 0.81 + 2 0.81 + 3 0.81 + Name: Species Imputation Accuracy, dtype: float64 + + + +In this instance, we went from a low accuracy (what is expected with +random sampling) to a much higher accuracy. +## The MICE Algorithm + +Multiple Imputation by Chained Equations ‘fills in’ (imputes) missing +data in a dataset through an iterative series of predictive models. In +each iteration, each specified variable in the dataset is imputed using +the other variables in the dataset. These iterations should be run until +it appears that convergence has been met. + + + +This process is continued until all specified variables have been +imputed. Additional iterations can be run if it appears that the average +imputed values have not converged, although no more than 5 iterations +are usually necessary. + +### Common Use Cases + +##### **Data Leakage:** + +MICE is particularly useful if missing values are associated with the +target variable in a way that introduces leakage. For instance, let’s +say you wanted to model customer retention at the time of sign up. A +certain variable is collected at sign up or 1 month after sign up. The +absence of that variable is a data leak, since it tells you that the +customer did not retain for 1 month. + +##### **Funnel Analysis:** + +Information is often collected at different stages of a ‘funnel’. MICE +can be used to make educated guesses about the characteristics of +entities at different points in a funnel. + +##### **Confidence Intervals:** + +MICE can be used to impute missing values, however it is important to +keep in mind that these imputed values are a prediction. Creating +multiple datasets with different imputed values allows you to do two +types of inference: + + - Imputed Value Distribution: A profile can be built for each imputed + value, allowing you to make statements about the likely distribution + of that value. + - Model Prediction Distribution: With multiple datasets, you can build + multiple models and create a distribution of predictions for each + sample. Those samples with imputed values which were not able to be + imputed with much confidence would have a larger variance in their + predictions. + + +## Predictive Mean Matching + +`miceforest` can make use of a procedure called predictive mean matching +(PMM) to select which values are imputed. PMM involves selecting a +datapoint from the original, nonmissing data (candidates) which has a +predicted value close to the predicted value of the missing sample +(bachelors). The closest N (`mean_match_candidates` parameter) values +are selected, from which a value is chosen at random. This can be +specified on a column-by-column basis. Going into more detail from our +example above, we see how this works in practice: + + + +This method is very useful if you have a variable which needs imputing +which has any of the following characteristics: + + - Multimodal + - Integer + - Skewed + + +### Effects of Mean Matching + +As an example, let’s construct a dataset with some of the above +characteristics: + + +```python +randst = np.random.RandomState(1991) +# random uniform variable +nrws = 1000 +uniform_vec = randst.uniform(size=nrws) + +def make_bimodal(mean1,mean2,size): + bimodal_1 = randst.normal(size=nrws, loc=mean1) + bimodal_2 = randst.normal(size=nrws, loc=mean2) + bimdvec = [] + for i in range(size): + bimdvec.append(randst.choice([bimodal_1[i], bimodal_2[i]])) + return np.array(bimdvec) + +# Make 2 Bimodal Variables +close_bimodal_vec = make_bimodal(2,-2,nrws) +far_bimodal_vec = make_bimodal(3,-3,nrws) + + +# Highly skewed variable correlated with Uniform_Variable +skewed_vec = np.exp(uniform_vec*randst.uniform(size=nrws)*3) + randst.uniform(size=nrws)*3 + +# Integer variable correlated with Close_Bimodal_Variable and Uniform_Variable +integer_vec = np.round(uniform_vec + close_bimodal_vec/3 + randst.uniform(size=nrws)*2) + +# Make a DataFrame +dat = pd.DataFrame( + { + 'uniform_var':uniform_vec, + 'close_bimodal_var':close_bimodal_vec, + 'far_bimodal_var':far_bimodal_vec, + 'skewed_var':skewed_vec, + 'integer_var':integer_vec + } +) + +# Ampute the data. +ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst) +``` + + + + + + + + + +```python +import plotnine as p9 +import itertools + +def plot_matrix(df, columns): + pdf = [] + for a1, b1 in itertools.combinations(columns, 2): + for (a,b) in ((a1, b1), (b1, a1)): + sub = df[[a, b]].rename(columns={a: "x", b: "y"}).assign(a=a, b=b) + pdf.append(sub) + + g = ( + p9.ggplot(pd.concat(pdf)) + + p9.geom_point(p9.aes('x','y')) + + p9.facet_grid('b~a', scales='free') + + p9.theme(figure_size=(7, 7)) + + p9.xlab("") + p9.ylab("") + ) + return g + +plot_matrix(dat, dat.columns) +``` + + + +![png](README_files/README_60_0.png) + + + +We can see how our variables are distributed and correlated in the graph +above. Now let’s run our imputation process twice, once using mean +matching, and once using the model prediction. + + +```python +kernel_mean_match = mf.ImputationKernel( + data=ampdat, + num_datasets=3, + mean_match_candidates=5, + random_state=1 +) +kernel_mean_match.mice(2) +kernel_no_mean_match = mf.ImputationKernel( + data=ampdat, + num_datasets=3, + mean_match_candidates=0, + random_state=1 +) +kernel_no_mean_match.mice(2) +``` + + +```python +kernel_mean_match.plot_imputed_distributions() +``` + + + +![png](README_files/README_63_0.png) + + + + +```python +kernel_no_mean_match.plot_imputed_distributions() +``` + + + +![png](README_files/README_64_0.png) + + + +You can see the effects that mean matching has, depending on the +distribution of the data. Simply returning the value from the model +prediction, while it may provide a better ‘fit’, will not provide +imputations with a similair distribution to the original. This may be +beneficial, depending on your goal. + + +```python + +``` diff --git a/README_gen.ipynb b/README_gen.ipynb index f16e471..b7304e4 100644 --- a/README_gen.ipynb +++ b/README_gen.ipynb @@ -182,10 +182,11 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 1, "metadata": {}, + "outputs": [], "source": [ - "```python\n", "import miceforest as mf\n", "from sklearn.datasets import load_iris\n", "import pandas as pd\n", @@ -195,20 +196,1344 @@ "iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1)\n", "iris.rename({\"target\": \"species\"}, inplace=True, axis=1)\n", "iris['species'] = iris['species'].astype('category')\n", - "iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991)\n", - "```" + "iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you only want to create a single imputed dataset, you can use\n", + "[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)\n", + "with some default settings:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Create kernel. \n", + "kds = mf.ImputationKernel(\n", + " iris_amp,\n", + " random_state=1991\n", + ")\n", + "\n", + "# Run the MICE algorithm for 2 iterations\n", + "kds.mice(2)\n", + "\n", + "# Return the completed dataset.\n", + "iris_complete = kds.complete_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are also an array of plotting functions available, these are\n", + "discussed below in the section [Diagnostic\n", + "Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting). \n", + "\n", + "We usually don’t want to impute just a single dataset. In statistics,\n", + "multiple imputation is a process by which the uncertainty/other effects\n", + "caused by missing values can be examined by creating multiple different\n", + "imputed datasets.\n", + "[`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)\n", + "can contain an arbitrary number of different datasets, all of which have\n", + "gone through mutually exclusive imputation processes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Class: ImputationKernel\n", + " Datasets: 4\n", + " Iterations: 2\n", + " Data Samples: 150\n", + " Data Columns: 5\n", + " Imputed Variables: 5\n", + " Modeled Variables: 5\n", + "All Iterations Saved: True\n", + " \n" + ] + } + ], + "source": [ + "# Create kernel. \n", + "kernel = mf.ImputationKernel(\n", + " iris_amp,\n", + " num_datasets=4,\n", + " random_state=1\n", + ")\n", + "\n", + "# Run the MICE algorithm for 2 iterations on each of the datasets\n", + "kernel.mice(2)\n", + "\n", + "# Printing the kernel will show you some high level information.\n", + "print(kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we have run mice, we can obtain our completed dataset directly\n", + "from the kernel:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sepal length (cm) 0\n", + "sepal width (cm) 0\n", + "petal length (cm) 0\n", + "petal width (cm) 0\n", + "species 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "completed_dataset = kernel.complete_data(dataset=2)\n", + "print(completed_dataset.isnull().sum(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Customizing LightGBM Parameters\n", + "\n", + "Parameters can be passed directly to lightgbm in several different ways.\n", + "Parameters you wish to apply globally to every model can simply be\n", + "passed as kwargs to `mice`:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the MICE algorithm for 1 more iteration on the kernel with new parameters\n", + "kernel.mice(iterations=1, n_estimators=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also pass pass variable-specific arguments to\n", + "`variable_parameters` in mice. For instance, let’s say you noticed the\n", + "imputation of the `[species]` column was taking a little longer, because\n", + "it is multiclass. You could decrease the n\\_estimators specifically for\n", + "that column with:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Species used 25 iterations\n", + "Sepal Width used 50 iterations\n", + "\n" + ] + } + ], + "source": [ + "# Run the MICE algorithm for 2 more iterations on the kernel \n", + "kernel.mice(\n", + " iterations=1,\n", + " variable_parameters={'species': {'n_estimators': 25}},\n", + " n_estimators=50\n", + ")\n", + "\n", + "# Let's get the actual models for these variables:\n", + "species_model = kernel.get_model(dataset=0,variable=\"species\")\n", + "sepalwidth_model = kernel.get_model(dataset=0,variable=\"sepal width (cm)\")\n", + "\n", + "print(\n", + "f\"\"\"Species used {str(species_model.params[\"num_iterations\"])} iterations\n", + "Sepal Width used {str(sepalwidth_model.params[\"num_iterations\"])} iterations\n", + "\"\"\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this scenario, any parameters specified in `variable_parameters`\n", + "takes presidence over the kwargs.\n", + "\n", + "Since we can pass any parameters we want to LightGBM, we can completely\n", + "customize how our models are built. That includes how the data should be\n", + "modeled. If your data contains count data, or any other data which can\n", + "be parameterized by lightgbm, you can simply specify that variable to be\n", + "modeled with the corresponding objective function.\n", + "\n", + "For example, let’s pretend `sepal width (cm)` is a count field which can\n", + "be parameterized by a Poisson distribution. Let’s also change our\n", + "boosting method to gradient boosted trees:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Create kernel. \n", + "cust_kernel = mf.ImputationKernel(\n", + " iris_amp,\n", + " num_datasets=1,\n", + " random_state=1\n", + ")\n", + "\n", + "cust_kernel.mice(\n", + " iterations=1, \n", + " variable_parameters={'sepal width (cm)': {'objective': 'poisson'}},\n", + " boosting = 'gbdt',\n", + " min_sum_hessian_in_leaf=0.01\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Other nice parameters like `monotone_constraints` can also be passed.\n", + "Setting the parameter `device: 'gpu'` will utilize GPU learning, if\n", + "LightGBM is set up to do this on your machine." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adjusting The Mean Matching Scheme\n", + "\n", + "Note: It is probably a good idea to read [this\n", + "section](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching)\n", + "first, to get some context on how mean matching works.\n", + "\n", + "There are 4 imputation strategies employed by `miceforest`:\n", + "- **Fast** Mean Matching: Available only on binary and categorical variables. Chooses a class randomly based on the predicted probabilities output by lightgbm.\n", + "- **Normal** Mean Matching: Employs mean matching as described in the section below.\n", + "- **Shap** Mean Matching: Runs a nearest neighbor search on the shap values of the bachelor predictions in the shap values of the candidate predictions. Finds the `mean_match_candidates` nearest neighbors, and chooses one randomly as the imputation value.\n", + "- Value Imputation: Uses the value output by lightgbm as the imputation value. Skips mean matching entirely. To use, set `mean_match_candidates = 0`.\n", + "\n", + "Here is the code required to use each method:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Create kernel. \n", + "cust_kernel = mf.ImputationKernel(\n", + " iris_amp,\n", + " num_datasets=1,\n", + " random_state=1,\n", + " mean_match_strategy={\n", + " 'sepal length (cm)': 'normal',\n", + " 'sepal width (cm)': 'shap',\n", + " 'species': 'fast',\n", + " },\n", + " mean_match_candidates={\n", + " 'petal length (cm)': 0,\n", + " }\n", + ")\n", + "\n", + "cust_kernel.mice(\n", + " iterations=1, \n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imputing New Data with Existing Models\n", + "\n", + "Multiple Imputation can take a long time. If you wish to impute a\n", + "dataset using the MICE algorithm, but don’t have time to train new\n", + "models, it is possible to impute new datasets using a `ImputationKernel`\n", + "object. The `impute_new_data()` function uses the models collected by\n", + "`ImputationKernel` to perform multiple imputation without updating the\n", + "models at each iteration:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New Data imputed in 0.040396 seconds\n" + ] + } + ], + "source": [ + "# Our 'new data' is just the first 15 rows of iris_amp\n", + "from datetime import datetime\n", + "\n", + "# Define our new data as the first 15 rows\n", + "new_data = iris_amp.iloc[range(15)].reset_index(drop=True)\n", + "\n", + "start_t = datetime.now()\n", + "new_data_imputed = cust_kernel.impute_new_data(new_data=new_data)\n", + "print(f\"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving and Loading Kernels\n", + "\n", + "Saving `miceforest` kernels is efficient. During the pickling process, the following steps are taken:\n", + "\n", + "1. Convert working data to parquet bytes.\n", + "2. Serialize the kernel.\n", + "4. Save to a file.\n", + "\n", + "You can save and load the kernel like any other object using `pickle` or `dill`:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from tempfile import mkstemp\n", + "import dill\n", + "new_file, filename = mkstemp()\n", + "\n", + "with open(filename, \"wb\") as f:\n", + " dill.dump(kernel, f)\n", + "\n", + "with open(filename, \"rb\") as f:\n", + " kernel_from_pickle = dill.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementing sklearn Pipelines\n", + "\n", + "`miceforest` kernels can be fit into sklearn pipelines to impute training and scoring\n", + "datasets:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import Pipeline\n", + "import miceforest as mf\n", + "\n", + "kernel = mf.ImputationKernel(iris_amp, num_datasets=1, random_state=1)\n", + "\n", + "pipe = Pipeline([\n", + " ('impute', kernel),\n", + " ('scaler', StandardScaler()),\n", + "])\n", + "\n", + "# The pipeline can be used as any other estimator\n", + "# and avoids leaking the test set into the train set\n", + "X_train_t = pipe.fit_transform(\n", + " X=iris_amp,\n", + " y=None,\n", + " impute__iterations=2\n", + ")\n", + "X_test_t = pipe.transform(new_data)\n", + "\n", + "# Show that neither now have missing values.\n", + "assert not np.any(np.isnan(X_train_t))\n", + "assert not np.any(np.isnan(X_test_t))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building Models on Nonmissing Data\n", + "\n", + "The MICE process itself is used to impute missing data in a dataset.\n", + "However, sometimes a variable can be fully recognized in the training\n", + "data, but needs to be imputed later on in a different dataset. It is\n", + "possible to train models to impute variables even if they have no\n", + "missing values by specifying them in the `variable_schema` parameter. \n", + "In this case, `variable_schema` is treated as the list of variables \n", + "to train models on." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sepal length (cm) 37\n", + "sepal width (cm) 0\n", + "petal length (cm) 37\n", + "petal width (cm) 37\n", + "species 37\n", + "dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set petal length (cm) in our amputed data \n", + "# to original values with no missing data.\n", + "iris_amp['sepal width (cm)'] = iris['sepal width (cm)'].copy()\n", + "iris_amp.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = mf.ImputationKernel(\n", + " data=iris_amp, \n", + " variable_schema=iris_amp.columns.to_list(), \n", + " num_datasets=1,\n", + " random_state=1,\n", + ")\n", + "kernel.mice(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sepal length (cm) 4\n", + "sepal width (cm) 3\n", + "petal length (cm) 1\n", + "petal width (cm) 3\n", + "species 3\n", + "dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Remember, the dataset we are imputing does have \n", + "# missing values in the sepal width (cm) column\n", + "new_data.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sepal length (cm) 0\n", + "sepal width (cm) 0\n", + "petal length (cm) 0\n", + "petal width (cm) 0\n", + "species 0\n", + "dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_data_imp = kernel.impute_new_data(new_data)\n", + "new_data_imp = new_data_imp.complete_data()\n", + "\n", + "# All columns have been imputed.\n", + "new_data_imp.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tuning Parameters\n", + "\n", + "`miceforest` allows you to tune the parameters on a kernel dataset.\n", + "These parameters can then be used to build the models in future\n", + "iterations of mice. In its most simple invocation, you can just call the\n", + "function with the desired optimization steps:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal length (cm)petal length (cm)petal width (cm)species
boostinggbdtgbdtgbdtgbdt
data_sample_strategybaggingbaggingbaggingbagging
num_iterations142248262172
max_depth4455
num_leaves1217219
min_data_in_leaf22155
min_sum_hessian_in_leaf0.10.10.10.1
min_gain_to_split0.00.00.00.0
bagging_fraction0.5809730.5015210.5867090.795465
feature_fraction_bynode0.9225660.2999120.5031820.237637
bagging_freq1111
verbosity-1-1-1-1
learning_rate0.020.020.020.02
objectiveregressionregressionregressionmulticlass
num_classNaNNaNNaN3
\n", + "
" + ], + "text/plain": [ + " sepal length (cm) petal length (cm) petal width (cm) \\\n", + "boosting gbdt gbdt gbdt \n", + "data_sample_strategy bagging bagging bagging \n", + "num_iterations 142 248 262 \n", + "max_depth 4 4 5 \n", + "num_leaves 12 17 2 \n", + "min_data_in_leaf 2 2 15 \n", + "min_sum_hessian_in_leaf 0.1 0.1 0.1 \n", + "min_gain_to_split 0.0 0.0 0.0 \n", + "bagging_fraction 0.580973 0.501521 0.586709 \n", + "feature_fraction_bynode 0.922566 0.299912 0.503182 \n", + "bagging_freq 1 1 1 \n", + "verbosity -1 -1 -1 \n", + "learning_rate 0.02 0.02 0.02 \n", + "objective regression regression regression \n", + "num_class NaN NaN NaN \n", + "\n", + " species \n", + "boosting gbdt \n", + "data_sample_strategy bagging \n", + "num_iterations 172 \n", + "max_depth 5 \n", + "num_leaves 19 \n", + "min_data_in_leaf 5 \n", + "min_sum_hessian_in_leaf 0.1 \n", + "min_gain_to_split 0.0 \n", + "bagging_fraction 0.795465 \n", + "feature_fraction_bynode 0.237637 \n", + "bagging_freq 1 \n", + "verbosity -1 \n", + "learning_rate 0.02 \n", + "objective multiclass \n", + "num_class 3 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "optimal_params = kernel.tune_parameters(\n", + " dataset=0, \n", + " use_gbdt=True,\n", + " num_iterations=500,\n", + " random_state=1,\n", + ")\n", + "kernel.mice(1, variable_parameters=optimal_params)\n", + "pd.DataFrame(optimal_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will perform 10 fold cross validation on random samples of\n", + "parameters. By default, all variables models are tuned. \n", + "\n", + "The parameter tuning is pretty flexible. If you wish to set some model\n", + "parameters static, or to change the bounds that are searched in, you can\n", + "simply pass this information to either the `variable_parameters`\n", + "parameter, `**kwbounds`, or both:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_params = kernel.tune_parameters(\n", + " dataset=0,\n", + " variables = ['sepal width (cm)','species','petal width (cm)'],\n", + " variable_parameters = {\n", + " 'sepal width (cm)': {'bagging_fraction': 0.5},\n", + " 'species': {'bagging_freq': (5,10)}\n", + " },\n", + " use_gbdt=True,\n", + " optimization_steps=5,\n", + " extra_trees = [True, False]\n", + ")\n", + "\n", + "kernel.mice(1, variable_parameters=optimal_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we did a few things - we specified that only `sepal\n", + "width (cm)`, `species`, and `petal width (cm)` should be tuned. We also\n", + "specified some specific parameters in `variable_parameters`. Notice that\n", + "`bagging_fraction` was passed as a scalar, `0.5`. This means that, for\n", + "the variable `sepal width (cm)`, the parameter `bagging_fraction` will\n", + "be set as that number and not be tuned. We did the opposite for\n", + "`bagging_freq`. We specified bounds that the process should search in.\n", + "We also passed the argument `extra_trees` as a list. Since it was passed\n", + "to \\*\\*kwbounds, this parameter will apply to all variables that are\n", + "being tuned. Passing values as a list tells the process that it should\n", + "randomly sample values from the list, instead of treating them as set of\n", + "counts to search within.\n", + "\n", + "Additionally, we set `use_gbdt=True`. This switches the process to use\n", + "gradient boosted trees, instead of random forests. Typically, gradient\n", + "boosted trees will perform better. The optimal `num_iterations` is also\n", + "determined by early stopping in cross validation.\n", + "\n", + "The tuning process follows these rules for different parameter values it\n", + "finds:\n", + "\n", + " - Scalar: That value is used, and not tuned. \n", + " - Tuple: Should be length 2. Treated as the lower and upper bound to\n", + " search in. \n", + " - List: Treated as a distinct list of values to try randomly.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## On Reproducibility\n", + "\n", + "`miceforest` allows for different “levels” of reproducibility, global\n", + "and record-level.\n", + "\n", + "##### **Global Reproducibility**\n", + "\n", + "Global reproducibility ensures that the same values will be imputed if\n", + "the same code is run multiple times. To ensure global reproducibility,\n", + "all the user needs to do is set a `random_state` when the kernel is\n", + "initialized.\n", + "\n", + "##### **Record-Level Reproducibility**\n", + "\n", + "Sometimes we want to obtain reproducible imputations at the record\n", + "level, without having to pass the same dataset. This is possible by\n", + "passing a list of record-specific seeds to the `random_seed_array`\n", + "parameter. This is useful if imputing new data multiple times, and you\n", + "would like imputations for each row to match each time it is imputed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Define seeds for the data, and impute iris\n", + "import numpy as np\n", + "random_seed_array = np.random.randint(0, 9999, size=iris_amp.shape[0], dtype='uint32')\n", + "iris_imputed = kernel.impute_new_data(\n", + " iris_amp,\n", + " random_state=4,\n", + " random_seed_array=random_seed_array\n", + ")\n", + "\n", + "# Select a random sample\n", + "new_inds = np.random.choice(150, size=15)\n", + "new_data = iris_amp.loc[new_inds].reset_index(drop=True)\n", + "new_seeds = random_seed_array[new_inds]\n", + "new_imputed = kernel.impute_new_data(\n", + " new_data,\n", + " random_state=4,\n", + " random_seed_array=new_seeds\n", + ")\n", + "\n", + "# We imputed the same values for the 15 values each time,\n", + "# because each record was associated with the same seed.\n", + "assert new_imputed.complete_data(0).equals(\n", + " iris_imputed.complete_data(0).loc[new_inds].reset_index(drop=True)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How to Make the Process Faster\n", + "\n", + "Multiple Imputation is one of the most robust ways to handle missing\n", + "data - but it can take a long time. There are several strategies you can\n", + "use to decrease the time a process takes to run:\n", + "\n", + " - Decrease `data_subset`. By default all non-missing datapoints for\n", + " each variable are used to train the model and perform mean matching.\n", + " This can cause the model training nearest-neighbors search to take a\n", + " long time for large data. A subset of these points can be searched\n", + " instead by using `data_subset`. \n", + " - If categorical columns are taking a long time, you can set \n", + " `mean_match_strategy=\"fast\"`. You can also set different parameters\n", + " specifically for categorical columns, like smaller `bagging_fraction` \n", + " or `num_iterations`, or try grouping the categories before they are\n", + " imputed. Model training time for categorical variables is linear with\n", + " the number of distinct categories. \n", + " - Decrease `mean_match_candidates`. The maximum number of neighbors\n", + " that are considered with the default parameters is 10. However, for\n", + " large datasets, this can still be an expensive operation. Consider\n", + " explicitly setting `mean_match_candidates` lower. Setting \n", + " `mean_match_candidates=0` will skip mean matching entirely, and \n", + " just use the lightgbm predictions as the imputation values.\n", + " - Use different lightgbm parameters. lightgbm is usually not the\n", + " problem, however if a certain variable has a large number of\n", + " classes, then the max number of trees actually grown is (\\# classes)\n", + " \\* (n\\_estimators). You can specifically decrease the bagging\n", + " fraction or n\\_estimators for large multi-class variables, or grow\n", + " less trees in general. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imputing Data In Place\n", + "\n", + "It is possible to run the entire process without copying the dataset. If\n", + "`copy_data=False`, then the data is referenced directly:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_inplace = mf.ImputationKernel(\n", + " iris_amp,\n", + " num_datasets=1,\n", + " copy_data=False,\n", + " random_state=1,\n", + ")\n", + "kernel_inplace.mice(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note, that this probably won’t (but could) change the original dataset\n", + "in undesirable ways. Throughout the `mice` procedure, imputed values are\n", + "stored directly in the original data. At the end, the missing values are\n", + "put back as `np.NaN`.\n", + "\n", + "We can also complete our original data in place. This is useful if the dataset is large, and copies can’t be made in\n", + "memory:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sepal length (cm) 0\n", + "sepal width (cm) 0\n", + "petal length (cm) 0\n", + "petal width (cm) 0\n", + "species 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "kernel_inplace.complete_data(dataset=0, inplace=True)\n", + "print(iris_amp.isnull().sum(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Diagnostic Plotting\n", + "\n", + "As of now, there is 2 diagnostic plot available. More coming soon!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Feature Importance" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": { + "image/png": { + "height": 600, + "width": 600 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kernel.plot_feature_importance(dataset=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Imputed Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": { + "image/png": { + "height": 480, + "width": 640 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kernel.plot_imputed_distributions()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using the Imputed Data\n", + "\n", + "To return the imputed data simply use the `complete_data` method:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "dataset_1 = kernel.complete_data(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will return a single specified dataset. Multiple datasets are\n", + "typically created so that some measure of confidence around each\n", + "prediction can be created.\n", + "\n", + "Since we know what the original data looked like, we can cheat and see\n", + "how well the imputations compare to the original data:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Iteration\n", + "0 0.35\n", + "1 0.81\n", + "2 0.81\n", + "3 0.78\n", + "Name: Species Imputation Accuracy, dtype: float64" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "acclist = []\n", + "iterations = kernel.iteration_count()+1\n", + "for iteration in range(iterations):\n", + " species_na_count = kernel.na_counts['species']\n", + " compdat = kernel.complete_data(dataset=0,iteration=iteration)\n", + " \n", + " # Record the accuract of the imputations of species.\n", + " acclist.append(\n", + " round(1-sum(compdat['species'] != iris['species'])/species_na_count,2)\n", + " )\n", + "\n", + "# acclist shows the accuracy of the imputations over the iterations.\n", + "acclist = pd.Series(acclist).rename(\"Species Imputation Accuracy\")\n", + "acclist.index = range(iterations)\n", + "acclist.index.name = \"Iteration\"\n", + "acclist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this instance, we went from a low accuracy (what is expected with\n", + "random sampling) to a much higher accuracy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The MICE Algorithm\n", + "\n", + "Multiple Imputation by Chained Equations ‘fills in’ (imputes) missing\n", + "data in a dataset through an iterative series of predictive models. In\n", + "each iteration, each specified variable in the dataset is imputed using\n", + "the other variables in the dataset. These iterations should be run until\n", + "it appears that convergence has been met.\n", + "\n", + "\n", + "\n", + "This process is continued until all specified variables have been\n", + "imputed. Additional iterations can be run if it appears that the average\n", + "imputed values have not converged, although no more than 5 iterations\n", + "are usually necessary.\n", + "\n", + "### Common Use Cases\n", + "\n", + "##### **Data Leakage:**\n", + "\n", + "MICE is particularly useful if missing values are associated with the\n", + "target variable in a way that introduces leakage. For instance, let’s\n", + "say you wanted to model customer retention at the time of sign up. A\n", + "certain variable is collected at sign up or 1 month after sign up. The\n", + "absence of that variable is a data leak, since it tells you that the\n", + "customer did not retain for 1 month.\n", + "\n", + "##### **Funnel Analysis:**\n", + "\n", + "Information is often collected at different stages of a ‘funnel’. MICE\n", + "can be used to make educated guesses about the characteristics of\n", + "entities at different points in a funnel.\n", + "\n", + "##### **Confidence Intervals:**\n", + "\n", + "MICE can be used to impute missing values, however it is important to\n", + "keep in mind that these imputed values are a prediction. Creating\n", + "multiple datasets with different imputed values allows you to do two\n", + "types of inference:\n", + "\n", + " - Imputed Value Distribution: A profile can be built for each imputed\n", + " value, allowing you to make statements about the likely distribution\n", + " of that value. \n", + " - Model Prediction Distribution: With multiple datasets, you can build\n", + " multiple models and create a distribution of predictions for each\n", + " sample. Those samples with imputed values which were not able to be\n", + " imputed with much confidence would have a larger variance in their\n", + " predictions.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predictive Mean Matching\n", + "\n", + "`miceforest` can make use of a procedure called predictive mean matching\n", + "(PMM) to select which values are imputed. PMM involves selecting a\n", + "datapoint from the original, nonmissing data (candidates) which has a\n", + "predicted value close to the predicted value of the missing sample\n", + "(bachelors). The closest N (`mean_match_candidates` parameter) values\n", + "are selected, from which a value is chosen at random. This can be\n", + "specified on a column-by-column basis. Going into more detail from our\n", + "example above, we see how this works in practice:\n", + "\n", + "\n", + "\n", + "This method is very useful if you have a variable which needs imputing\n", + "which has any of the following characteristics:\n", + "\n", + " - Multimodal \n", + " - Integer \n", + " - Skewed\n" + ] }, { "cell_type": "markdown", "metadata": {}, + "source": [ + "### Effects of Mean Matching\n", + "\n", + "As an example, let’s construct a dataset with some of the above\n", + "characteristics:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "randst = np.random.RandomState(1991)\n", + "# random uniform variable\n", + "nrws = 1000\n", + "uniform_vec = randst.uniform(size=nrws)\n", + "\n", + "def make_bimodal(mean1,mean2,size):\n", + " bimodal_1 = randst.normal(size=nrws, loc=mean1)\n", + " bimodal_2 = randst.normal(size=nrws, loc=mean2)\n", + " bimdvec = []\n", + " for i in range(size):\n", + " bimdvec.append(randst.choice([bimodal_1[i], bimodal_2[i]]))\n", + " return np.array(bimdvec)\n", + "\n", + "# Make 2 Bimodal Variables\n", + "close_bimodal_vec = make_bimodal(2,-2,nrws)\n", + "far_bimodal_vec = make_bimodal(3,-3,nrws)\n", + "\n", + "\n", + "# Highly skewed variable correlated with Uniform_Variable\n", + "skewed_vec = np.exp(uniform_vec*randst.uniform(size=nrws)*3) + randst.uniform(size=nrws)*3\n", + "\n", + "# Integer variable correlated with Close_Bimodal_Variable and Uniform_Variable\n", + "integer_vec = np.round(uniform_vec + close_bimodal_vec/3 + randst.uniform(size=nrws)*2)\n", + "\n", + "# Make a DataFrame\n", + "dat = pd.DataFrame(\n", + " {\n", + " 'uniform_var':uniform_vec,\n", + " 'close_bimodal_var':close_bimodal_vec,\n", + " 'far_bimodal_var':far_bimodal_vec,\n", + " 'skewed_var':skewed_vec,\n", + " 'integer_var':integer_vec\n", + " }\n", + ")\n", + "\n", + "# Ampute the data.\n", + "ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": { + "image/png": { + "height": 700, + "width": 700 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import plotnine as p9\n", + "import itertools\n", + "\n", + "def plot_matrix(df, columns):\n", + " pdf = []\n", + " for a1, b1 in itertools.combinations(columns, 2):\n", + " for (a,b) in ((a1, b1), (b1, a1)):\n", + " sub = df[[a, b]].rename(columns={a: \"x\", b: \"y\"}).assign(a=a, b=b)\n", + " pdf.append(sub)\n", + "\n", + " g = (\n", + " p9.ggplot(pd.concat(pdf))\n", + " + p9.geom_point(p9.aes('x','y'))\n", + " + p9.facet_grid('b~a', scales='free')\n", + " + p9.theme(figure_size=(7, 7))\n", + " + p9.xlab(\"\") + p9.ylab(\"\")\n", + " )\n", + " return g\n", + "\n", + "plot_matrix(dat, dat.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see how our variables are distributed and correlated in the graph\n", + "above. Now let’s run our imputation process twice, once using mean\n", + "matching, and once using the model prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mean_match = mf.ImputationKernel(\n", + " data=ampdat,\n", + " num_datasets=3,\n", + " mean_match_candidates=5,\n", + " random_state=1\n", + ")\n", + "kernel_mean_match.mice(2)\n", + "kernel_no_mean_match = mf.ImputationKernel(\n", + " data=ampdat,\n", + " num_datasets=3,\n", + " mean_match_candidates=0,\n", + " random_state=1\n", + ")\n", + "kernel_no_mean_match.mice(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": { + "image/png": { + "height": 480, + "width": 640 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kernel_mean_match.plot_imputed_distributions()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQAAAAPACAYAAABq3NR5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3hTZRsG8DtJd0sXo6VAS5ll771B9h6CAgqK+IEg4FZQQEBUhoIgoqCAAgIiQ/aQPcsqG8oqFEpbuvdKzvdHeo5Jm6Rpm7RJe/+ui4uTnPWe06zznOd9H5kgCAKIiIiIiIiIiIioRJIXdwOIiIiIiIiIiIjIfBgAJCIiIiIiIiIiKsEYACQiIiIiIiIiIirBGAAkIiIiIiIiIiIqwRgAJCIiIiIiIiIiKsEYACQiIiIiIiIiIirBGAAkIiIiIiIiIiIqwRgAJCIiIiIiIiIiKsEYACQiIiIiIiIiIirBGAAkIiIiIiIiIiIqwRgAJCIiIiIiIiIiKsEYACQiIiIiIiIiIirBGAAkIiIiq7V27VrIZDLIZDJUrVq1uJtjVp07d5aOdfbs2YVeriQZO3asdMxjx44t7uaUSCEhIdI5lslkCAkJKe4mERERUT4wAEhERERERERERFSC2RR3A4iIiKjkWLt2Ld544w298xUKBRwcHODu7g5vb2/UqFEDDRs2RMeOHdGmTRsoFIoibG3BhISEYO3atdLj0pJlVxQ0z+XYsWNLfFanOYSEhMDf39/gMvb29nB3d0eVKlXQvHlzDBw4ED179oRMJiuiVhbMjh07EBQUBABo3LgxBg0aVKztISIisiYMABIREVGRUSqVSE5ORnJyMp49e4ZLly5h8+bNAAAvLy+88cYbmDZtGry8vIq5pfqFhITgyy+/lB4zAGg6mue1c+fODACaSXp6OiIiIhAREYGLFy9i5cqVCAgIwJo1a9C6devibp5eO3bswLp16wAAY8aMYQCQiIgoHxgAJCIiIrPx8fGBo6Oj9FgQBCQkJCA+Ph6ZmZlay0ZEROCbb77BihUrsGDBAvzvf//Lc/tjx44tNWO+HTt2rLibYLHWrl2rlZVJ//Hw8ICnp6fWc2lpaYiMjNR6D965cwcdO3bErl270LNnz6JuJhEREZkZxwAkIiIis9mwYQPu378v/Xvw4AFevHiBjIwMhIeHY8eOHZgyZQrc3NykdRISEjBhwgS89957xdhyopJhypQpWu/B+/fv4+nTp0hMTMTevXvRtGlTadnMzEyMGDEC0dHRxdhiIiIiMgcGAImIiKhYeHl5YeDAgVi6dCmePn2Kzz77TGsMsiVLlmD58uXF2EKiksve3h69e/fG2bNn0bVrV+n5+Ph4fP/998XYMiIiIjIHdgEmIiKiYufi4oL58+ejZcuWGDp0KFQqFQBg2rRp6NGjB2rVqmWyfaWmpuLSpUu4desWYmNjkZWVBWdnZ1SsWFEqSmJra2uy/Rnr9u3buHr1KsLCwqBUKtGqVSt07NjRpPsICQnB+fPn8fTpUygUCvj5+aFbt25wdXU16X6syZMnT3DmzBlEREQgLS0NFSpUQEBAAFq1agW5vPD3ygVBwOnTpxEcHIyIiAi4u7ujfv36aNu2rUUUvbGzs8OqVatQq1YtKJVKAMCuXbswb948k+0jMzMTp06dkjKAy5Qpg4oVK6JDhw6oUKGCyfZjDEt9/xMREZmdQERERGQia9asEQBI/44ePZrvbcyZM0drG2PGjDFqf35+fga3GxsbK7z77ruCq6ur1vZz/nN0dBT69u0rXLx4UWv9Tp06GVwv579OnTrlaoOuc7Nv3z6hSZMmudYfOHCg3v3PmjVL73HqWu7u3btC9+7dBZlMlms/Dg4OwqRJk4TExESD508QBGHMmDFG/V00PXr0SGt/jx490po/a9asfJ1XXT9fC9Ku/fv3C82aNdO7j/Llywtz584VUlNT89zW0aNHdbZv7dq1gr+/v87t+/j4CBs2bDCqrfmR83wbeq1oatGihbSOTCYTMjMzDW43599Rl5iYGGHq1Kl633NyuVzo0qWLcOHCBaOPx5h/a9asybWdwr7/iYiIrB27ABMREZFF+fTTT1GxYkXp8YYNGxAeHl6obYaEhKBx48ZYtmwZEhISDC6bmpqKPXv24OTJk4XapzHmzZuHPn364MqVK2bbx5EjR9CiRQscOnQIgiDkmp+WloYff/wRzZo1K/R5tgaCIGDSpEno1asXLl26pHe5Fy9e4IsvvkDTpk3x9OnTfO/jf//7H8aOHYtHjx7pXCYsLAyjRo3CokWL8rVtc6lWrZo0LQhCoccBvHr1KurUqYOlS5fqfc+pVCocPXoUrVq1wsKFCwu1P0Ms9f1PRERUlNgFmIiIiCyKra0tJk6ciJkzZwIAsrKycPToUbz66qsF2p4gCBg+fDgeP34sPdesWTN0794dVatWhYODAxISEvD48WNcunQJp06dQlZWVq7tVKpUCdWrV0dqairCwsKk56tXr65zv5UqVTLYrm3btmHZsmUAAD8/PwwZMgQ1a9YEAAQHByMlJSXfx5rT8+fP8corryAhIQGOjo4YOnQoWrRoAXt7e9y+fRubNm1CRESEtM8ePXrg/PnzWpWbzc3T01M6hw8ePJCez1lB2lTeffddrFixQnpsb2+PQYMGoXXr1nByckJwcDA2b94sBf1u376Njh074uLFi7mq6erz1Vdf4ZdffgEAtGjRAn369EGVKlWQkpKC48ePY/v27VI3908//RRdu3bVKsZRHHK+5gvTPTk4OBhdunRBbGys9Fzt2rUxbNgwVK1aFfHx8Thy5Aj2798PlUoFlUqFjz/+GLa2tpg2bZrWtmxtbaXXR2RkJBITEwEAZcqU0dt9WLNLu6ne/0RERFavONMPiYiIqGQxRRdgQRCEs2fPam3nf//7X57709cF+N9//9Xq2vjHH38Y3HdsbKywdOlSYcuWLTrn6+vuaQzo6HL44YcfCunp6XmuW5AuwHK5XAAg1KlTRwgODs61bHx8vDB48GCt9syYMUPvts3RBVhTQV87xrZr3759WvuoXbu2cOvWrVzLpaSkaG0TgDBq1Ci92835mpDL5YKjo6OwefNmncsfOnRIcHBwkJYfPHiw0ceal4J2Aa5fv760jkKhEJRKpcHt6vs7KpVKoW3btlrLzp49O9f2BEEQTpw4IZQtW1Zazt7eXrhx44beNhbk9Wfq9z8REZG1YhdgIiIisjhNmjSBnZ2d9LgwXWSPHTsmTQ8aNAijR482uLy7uzumTJmCl19+ucD7NNabb76JhQsXah2rKalUKri5uWHfvn1SdqEmV1dXbNq0CS1btpSeW7hwIaKioszSnuL28ccfS9Nubm44cOAA6tSpk2s5R0dH/Pbbb+jVq5f03IYNGxAUFGTUflQqFTZu3Ijhw4frnP/SSy/ho48+kh7v2bNHymwrDlevXsWNGzekx82bNy9wAZQdO3bgzJkz0uNp06Zh1qxZOrfXoUMH7NixQ5qXnp6OGTNmFGi/+ljy+5+IiKgoMQBIREREFsfe3l5rHMDCjEemOa6driBYcXFwcMCCBQvMvp9PP/0Ufn5+eufb2dlhyZIl0uOMjAysX7/e7O0qamfOnMH169elxzNmzDB4XuRyOZYvX65VEfann34yal+9evXCoEGDDC4zfvx4aTojI8Po4KKpxcTEYMyYMVrPDRkypMDbW7lypTRdoUIFzJ071+Dy7du3x9ixY6XHu3fvzveYi4ZY6vufiIioqDEASERERBbJ3d1dmo6JiSnwdpycnKTpc+fOFaZJJtWnTx+ULVvWrPtQKBR4880381yuTZs2qFevnvR4165d5mxWsdizZ480bWNjY9R5qV69Onr06CE93rt3r1H70gxo6VOlShX4+PhIj+/evWvUtk0hPT0d9+/fx48//ojGjRvj6tWr0jwfHx9MmjSpQNtNTU3F0aNHpccjR46Ei4tLnutNnDhRmlYqlThw4ECB9q+Lpb7/iYiIihoDgERERGSRNAMHheke2bhxY2n6xIkTmDJlCuLi4grRMtNo06aN2ffRqFEjvYUSctIMdF2+fFlnxWBrFhgYKE03b97c6OBrnz59pOmnT58aVSm5VatWRm1bMwBortfkl19+CZlMpvXPwcEBNWvWxOTJkxEaGiot6+rqil27dsHZ2blA+7p8+bJWAQ3NLtSGNG/eHOXLl5cea/6tCstS3/9ERERFjQFAIiIiskiaQT/Nqp75NXToUK1gz7Jly+Dj44MhQ4ZgxYoVuHnzZrEEu/RVDzYlzay+vNSvX1+ajouLQ2RkpDmaVGzu3bsnTTdo0MDo9Ro2bKj1ODg4OM91vL29jdq2ZqAtOTnZ6DaZQ48ePRAUFFSoasSa5xgo+HnOuZ3CsNT3PxERUVGzKe4GEBEREemimaXj6elZ4O2UKVMGf/75JwYNGoSUlBQA6q6K27dvx/bt2wEA5cuXR/fu3fHqq6+id+/eUCgUhWq7se0yN2Oz/wBoZWABQGxsLLy8vEzdpGITGxsrTec8VkN0nZe8ODg4GN+wbOYKQnl4eOR6/9jb28PNzQ1VqlRB8+bNMWDAANSuXbvQ+8p5bgp6no05x8ay1Pc/ERFRUWMGIBEREVmc9PR0ra6W5cqVK9T2unfvjkuXLmHAgAE6q5G+ePECGzduRP/+/dGgQQOcOHGiUPszho2N+e/DOjo6Gr2s5lhpAJCUlGTq5hQrzQy7nMdqSM7usNZ2XqZMmYL79+9r/bt58ybOnDmDzZs346OPPjJJ8A/QPsc2NjZaBVTyonmeTX2OLfH9T0REVNQYACQiIiKLc+nSJWRkZEiPC9MtURQQEICdO3fi8ePH+OmnnzB8+HCtSsOi27dvo1u3blpFI6xVamqq0cuK2VEiY4o3WBPN48l5rIbk7Jpb0s6LKWmem6ysLGRmZhq9ruZ5Nsc5Lo3vfyIiIk0MABIREZHFOXjwoNbjTp06mWzblStXxoQJE7B582aEhYXh1q1b+Prrr7XG5MvKysL48eORlpZmsv0Wh/yM4/fixQutxx4eHrmWkclk+W5DfoKQ5qR5PDmP1RBjzgup5Tw3BT3P5jzHpen9T0REpIkBQCIiIrIoGRkZ+Pnnn6XHtra26Ny5s9n2V6dOHXz66ae4ffs2Ro4cKT3//PlzHD161Gz7LQo3b940etkbN25I0+7u7jrHD9TsOmtsFl1ERITRbTCnGjVqSNPXrl0zer2cy9asWdNkbSppNM8xUPDzXJTnuCS//4mIiDQxAEhEREQW5dtvv9Ua/+/111/PVzGLgrK1tcWPP/6oleV2+/ZtnctpUqlUZm9bQV29etXoLEDNrMtmzZrpzPZzd3eXpsPCwoza7rlz54xaDtAeF9HU57VVq1bS9KVLlxAdHW3Uevv27ZOmq1SporPbKKk1bdpU62944MABo9a7dOmSVgag5t9Kk+Z7z9SvD2Pf/0RERNaKAUAiIiKyGDt37sTs2bOlxzY2Nvjss8+KbP/u7u5a1UizsrJyLZNzfLKEhASzt6uglEol1q5dm+dy58+f18oW7Nevn87latWqJU1fvXoV6enpBrcrCAJ+//134xoL7XNr6vPat29faTorKwu//vprnus8evRIK4iluQ3KzdHREV27dpUeb9y40aiCHitXrpSmFQoFevbsqXM5c74+AOPe/0RERNaKAUAiIiIqdklJSZgxYwYGDx6sldmzbNkyrbG5CuLx48dGL/v8+XOtzDA/P79cy+R8TrPrrCX6+uuvERoaqnd+ZmYmpk2bJj22t7fH6NGjdS6rmZmVlJSELVu2GNz30qVL85VFpXluTX1e27Rpg4YNG0qP58+fb/C1oVKp8O6772oVspgwYYJJ21QS/e9//5OmIyMj8cUXXxhc/uzZs/jtt9+kx/3790elSpV0LluQ14ep3/9ERETWigFAIiIiKhYRERH4559/MG3aNFSuXBnz58+HIAjS/I8++sgkAZexY8eia9eu2LZtm8GMtbi4OLz22mtQKpUA1IGwHj165FrO3d1dKxNu9uzZ+Sp2UJTkcjni4uLQu3dvPHjwINf8xMREjBw5Uqub7ocffohy5crp3F5AQAAaNWokPf7ggw90jjOoUqmwbNkyfPjhh/kqHKIZYFy5ciWuX79u9LrG+Pbbb6Xp+Ph49OrVC3fv3s21XFpaGsaPH69VCXb06NFax066DRo0CG3btpUeL1myBHPnztXZZff06dMYOHCgNM/e3h7z5s3Tu23N18eDBw/www8/5JmlZ+r3PxERkbWyyXsRIiIiooIZNWoUHB0dpceCICAxMRHx8fHIyMjQuY6rqysWLlyIt99+2yRtEAQBx44dw9GjR+Hq6op27dqhWbNmqFixIpydnREXF4dr165h+/btiI2NldabMWOG3mqkY8eOxfTp0wEA//77L7y9vVG1alWUKVNGWqZ58+ZYvXq1SY6hoMaPH4/t27fj5s2baNCgAYYNG4aWLVvCzs4Od+7cwZ9//qk13mKDBg0wY8YMg9ucOXMmhg4dCkBdubVZs2YYOXIkWrRoARsbG4SEhGDHjh24desWAODLL7/ErFmzjGrvmDFj8MsvvwAAnj17hoYNG8LHxwdly5aFXP7ffeugoKD8nAZJr169MGnSJPz4448AgDt37qBx48YYPHgwWrduDUdHR9y7dw+bNm3Sypr09/fHDz/8UKB9ljZyuRxr1qxB69atpffTzJkz8eeff2LYsGHw8/NDfHw8jh49in379kkBNwD45ptvUK9ePb3bbt26NWrXri0FbadOnYoZM2bA19dXa3zAOXPmYMCAAQDM8/4nIiKyRgwAEhERkdkYWygCALy8vPDmm29i2rRpZiv6kZCQgH379mkVdtDlnXfeweeff653/gcffIDDhw/jyJEjANQZbw8fPtRaRrNgRnHx9vbGpk2bMGjQICQkJOCPP/7AH3/8oXPZmjVr4sCBA1oBW12GDBmCCRMmSOO2paenY82aNVizZo3WcjKZDLNnz8brr79udACwbdu2mDFjBr766ivpubCwsHy9jvKybNkyqFQq/PTTTwDU2X5//vkn/vzzT53LBwQE4NChQwwG5UOtWrVw5MgR9OrVS6oCffv2bcydO1fn8jKZDN9++61WV3R9y/3+++/o3bs3YmJiAKi7oovBZpE4LydTvf+JiIisEbsAExERUZGRy+VwdHRExYoV0bRpUwwfPhxfffUVTp06hbCwMMyfP9/kwb+5c+di4sSJqFatWp7Ltm3bFnv27MlVDTQnOzs7HDx4EBs2bMCgQYNQtWpVODs756u7a1Hp0qULLly4gO7du+tsn4ODA9555x1cvnzZ6Aq3K1aswPfff683yFm3bl3s2rULM2fOzHd7582bhxMnTuCNN95A3bp14erqqpX9V1gymQwrVqzAvn370LRpU73LlStXDnPmzMGVK1dQuXJlk+2/tGjcuDFu376NKVOmaGXGapLL5ejSpQvOnz+Pjz76yKjttmzZEjdu3MDs2bPRvn17lC9fHnZ2dnqXN8f7n4iIyBrJBM3BdoiIiIhKsPDwcFy/fh2PHj1CbGwssrKyUKZMGfj5+aF58+Z6iw+UFCEhITh37hyePXsGuVwOX19fvPTSS3BzcyvQ9tLT03H8+HHcvXsXSUlJqFixIurVq4cWLVqYuOXmExISgrNnzyI8PBzp6emoUKECAgIC0Lp1a5MGHkuzjIwMnDx5Eg8fPkRUVBScnZ1RsWJFdOrUyWzZvrqU9vc/ERGVbgwAEhERERERERERlWC8rUlERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSCMQBIRERERERERERUgjEASEREREREREREVIIxAEhERERERERERFSC2RR3A6hoBAcHF3cTiIgsQq1atYq7CVaN3ydERPwuKSx+lxARqRXl9wkzAImIiIiIiIiIiEowBgCJiIiIiIiIiIhKMAYAiYiIiIiIiIiISjAGAImIiIiIiIiIiEowBgCJiIiIiIiIiIhKMAYAiYiIiIiIiIiISjAGAImIiIiIiIiIiEowBgCJiIiIiIiIiIhKMAYAiYiIiIiIiIiISjAGAImIiIiIiIiIiEowBgCpxAsKCkKXLl3QpUuX4m5KkVq7di26dOmCadOmFWh98ZwFBQWZtF3FrbDnRZ9p06ahS5cuWLt2rUm3S0SWKzU1FStXrsTo0aPRo0cPi/+uKcznurk+Oy2BOb7vSutvDyKyfPzNSlR62RR3A4iIiIis0cyZM3Hx4kUAgIODA1xcXIq5RUREREXv/v37OHXqFFxcXDBs2LDibg4R6cEAIBHpVKVKFQCAvb19MbeEiMjyhISESMG/L7/8Eh07dizmFpmXm5sbqlSpggoVKhR3U4iIqBAqVKiAKlWqwM3NzWTbvH//PtatWwcvLy8GAIksGAOARKTT77//XtxNICKyWI8ePQIAuLq6lvjgHwAMHjwYgwcPLu5mEBFRIU2fPr24m0BExYRjABIRERHlU3p6OgDA0dGxmFtCRERERJQ3ZgCS1Xr27Bn+/vtvXL58GZGRkRAEARUqVEBAQAC6deuGli1bGr2tkJAQbN68GVeuXEFMTAzs7e1RtWpVdO/eHX379oVCodC53vXr1/H333/j1q1biI2NhZ2dHdzd3VGlShW0aNEC/fr109mFNjo6Gn/99RfOnz+PiIgIqFQqeHt7o1WrVhgxYgQ8PT0LfF70OXjwIHbu3ImQkBAAQM2aNTF8+HC0bdtW5/LiwOXff/89GjduLD0fFBSE9957DwBw9OhRBAcHY/369bhx4wZSU1Ph6+uLESNGoGvXrgAAQRCwd+9e7N69G0+ePIFMJkOjRo3w9ttvw8/PT297IyIisHnzZly4cAGRkZGwsbFB5cqV0blzZwwePBgODg5617137x7++OMPXL16Fenp6fD29kbXrl3xyiuvGDxHiYmJOH78OAIDA/HkyRNERUUhKysL5cqVQ9OmTTFixAhUqlTJ4DYK4/bt23jnnXcgl8uxadMmlC9fXudySqUSL7/8MmJjY/H++++jf//+AICsrCycO3cOZ86cwb179xAVFYXk5GS4ubmhTp06GDx4MJo0aaJzm2vXrsW6devQqFEjLFmyBIcOHcLu3bsREhKChIQEzJ07F+3btzfbsRNZC/G9IoqIiNAq9PDJJ5+gV69euHnzJk6cOIGbN28iMjIScXFxcHR0RPXq1fHSSy+hZ8+eOr9bcn7G3rp1C5s3b8aNGzcQFxeHwYMHY/LkyYU+jhcvXmDdunUIDAxEXFwcPD090b59e7z++utwdXXVe9ziZ4SmadOm4erVqxgzZgxGjx6NLVu24NChQ3j+/DnKlCmDli1b4s0330TZsmUBqL+/169fj0uXLiEuLg7e3t7o27cvXn75Zcjluu9NC4KAw4cP48CBA7h37x5SU1Ph5uaGBg0aYNiwYahbt67eY83MzMTWrVtx4MABPH/+HE5OTqhbty5GjRplcD0ABf47msqnn36K8+fPo1+/fvjggw/0Lrdt2zYsW7YM5cuXx6ZNm6TzGBYWhqNHj+LKlSt4/vw5oqKiYGNjg0qVKqFdu3YYOnSo3rErNX8HVKpUCevXr8eFCxcQFRUFX19frF692vQHTERmp/mZPXbsWOl5zfd8jRo1sH79epw8eRIvXryAi4sLmjVrhjfeeAM+Pj5a29P8Dsz5nQj8972o6enTp/jrr79w+fJlvHjxAnK5HD4+PujQoYPBzyWVSoWdO3di3759CA0NhZ2dHapXr46XX34Zbdq0wSuvvIKIiAid+xQdP34cBw4cwJ07d5CYmAhnZ2fUrl0b/fr1Q4cOHXItHx4ejldffRUA8OeffyI9PR0bN26Urhtbt26NefPm6TnbuvE3PxUXBgDJKu3evRtLly5FVlYWAMDOzg729vYIDQ3FkydPcPr0aezevduobR04cAALFy6EUqkEADg7OyMtLQ03btzAjRs3cPDgQXzzzTe5voj27NmDxYsXQxAEAP+NlRcWFoawsDCcP38erVu3zhUwOnv2LObOnYvU1FQAgK2tLWQyGR4/fozHjx/jwIED+Prrr1GnTp2Cn6AcfvzxR2zduhVyuRxOTk5ITk7G1atXcfXqVYwdOxZjxowp0HbPnj2LWbNmISsrC05OTkhLS0NwcDDmzp0rXajOmzcPR44cgY2NDWxsbJCWloYzZ87gxo0b+Omnn3L9iACAixcvYubMmdI5cnJyQmZmJoKDgxEcHIz9+/dj4cKFOseiOn78OObOnav193z27BnWrFmDwMBANGrUSO/x/P3339KFvUKhkF4Lz549w7Nnz3Do0CHMmzcPzZo1K9D5ykudOnVQqVIlPHv2DEePHsXw4cN1Lnfp0iXExsbC1tYWnTt3lp6/ceMGvvjiCwCATCaDk5MT5HI5oqKicPLkSZw8eRJvvfUWRo0aZbAdP/zwA7Zv3w65XA5nZ2e9F+REpZGjoyM8PDyQkZGB5ORkyOVyrXGU7OzsAEArSOfo6Ag7OzskJCTgypUruHLlCk6ePIl58+YZDB4dOXIE8+fPh1KpNOl78dmzZ/jyyy+lYJZcLkdERAT+/vtvnDp1CkuXLoWXl1e+t5uVlYWPPvoIQUFB0nmIiorC3r17ce3aNSxfvhzPnj3DJ598gqSkJDg7OyMrKwuhoaFYuXIlXrx4oTO4mZGRgS+//BJnzpwBAOm7LCoqCkePHsWxY8cwfvx46QJNU2pqKj755BNcv34dgPqzPTMzE2fOnEFgYCBmzpxp8JhM8XcsjG7duuH8+fM4ceIEpk6dChsb3T/dDx8+DADo2rWr1utkwYIFuHr1KgD1a9PBwQGJiYm4d+8e7t27h4MHD2LJkiV6Lz4BIDQ0FLNnz0Z8fDwcHBzMGvAkouIXFRWFBQsW4Pnz59IN99jYWBw+fBgXLlzATz/9hIoVK0rLG/pOBP77XhTt2bMHS5Yska7jHBwckJmZiQcPHuDBgwfStVnOa6isrCzMmjVL67vA1tYWQUFBuHLlSp43x1JTUzF37lycPXtWes7Z2Rnx8fEIDAxEYGAgevXqhY8//hgymUznNq5du4bvv/8eaWlpcHJyKvDnIX/zU3FhAJCszqlTp7B48WIAQKtWrTBu3DjUrFkTAJCSkoKgoCD8+++/Rm3r9u3bUvCvVatWePfdd1GpUiVkZmbi8OHD+OGHH3Dz5k0sWLAAc+bMkdZLS0vDjz/+CEEQ0KtXL4wZMwbe3t4AgKSkJNy/fx+HDh2Cra2t1v7u37+PWbNmQalUYsSIERg0aBC8vLwgCAIePXqElStX4uLFi/jiiy+wbt06ODs7F/p83b9/H1evXsWrr76KkSNHwsXFBTExMfj5559x8OBBrF27FnXq1MlXxqRo/vz56N69O8aNGwdPT0/ExcVh0aJFOH36NFavXo24uDicPXsW06dPR+fOnWFjY4MbN25g9uzZiImJwerVq3NdfIWHh2PWrFlITU1FQEAAPvjgA9SoUQNKpRJnz57F4sWL8eTJE8yaNQvLly/X+uINCwvDN998A6VSiYYNG+L999+Hn58fMjMzcejQISxdulTKgNSlbNmyePPNN9GmTRv4+/tDoVBAqVTi4cOH+PXXX3H+/HnMmzcPGzduNFu3v5deegnr1q3D4cOH9f4YEC/0WrVqhTJlykjP29vbY+DAgejcuTNq164ttTEyMhJbt27FX3/9hV9//RVNmjTRm/USHByMa9euYezYsdId2OTkZGRkZJj4SIms04gRIzBixAjs378f3377rZRxlVO7du3Qo0cPNGrUSLoYSkpKwuHDh7Fq1SqcO3cOf/31l8HM5EWLFqFdu3aYOHEivL29oVQq8eLFi0Ifw08//QR3d3fMmTMHDRo0gEqlwrlz57Bw4UJERERg7ty5WLZsmd4LIH127twJOzs7zJ8/H61atYIgCDh79iy+/vprPH36FGvWrMG5c+fQoEEDTJ48GT4+PkhOTsYvv/yCf/75B9u2bUP//v1zZYevXLkSZ86cgUKhwNtvv43+/fvD0dERUVFR+OWXX3Do0CH88ssv8PX1Rbt27XId6/Xr12Fra4tJkyahd+/esLOzw7Nnz/D999/j22+/NXhMpvg7Fkb79u3h4OCAhIQEnD9/PtfxAeqA7u3btwGov0M01axZE926dUOLFi3g5eUFmUyGjIwMXLp0CT/99BNCQ0OxePFifPPNN3rbIF7sz5s3D/Xr15f2SUQl0w8//AAvLy8sX74c9erVg1KpxLlz5/DNN98gPj4eq1at0vr9vm3btjy/E0Xnzp3D4sWLYW9vj9dffx19+/aFp6cnlEolbt++jeXLl+Pu3buYOXMmVq1apRWQ2rhxI86cOQOZTIZx48Zh8ODBcHJyQkxMDFatWoWVK1fqvUkCqG+InD17Fv7+/njrrbfQtGlTODg4ICUlBQcPHsSqVauwf/9+VK1aFSNGjNC5jSVLlqB27dqYOnUq/P39IQgCwsLCCnCW+ZufigdDvGRVsrKysHz5cgDqH+Xz58+Xgn+AOlOsbdu20h2RvPz2229QKpWoWbMm5s2bJ91psrW1Re/evfHhhx8CAE6ePIlbt25J6z169AipqalwcHDAhx9+KAX/AMDFxQWNGzfGRx99lCtDbfny5cjMzMSECRMwYcIEeHt7QyaTQS6Xo3r16pg/fz6qVauG6Oho7Nmzp2AnKYfk5GT07dsXb7/9tpTF6OnpiU8//VTKZFuzZk2Btl2zZk189NFHUpdld3d3zJgxA87OzkhNTcUff/yBqVOnonv37lKmY4MGDfC///0PAHD69Gnp7p9o/fr1SElJQbly5bBw4ULUqFEDgDpro3379pgzZw5kMhnu3LmD48ePa627YcMGpKWlwcvLC9988410EWlra4s+ffrgvffeQ3Jyst7j6d+/P1577TXUqFFDCiwqFArUrFkTc+fOhZ+fH+Li4nLt15TEi7d79+7h8ePHueanpaXh1KlTWsuK6tSpg2nTpqFx48ZaAcoKFSrgnXfeQd++fSEIAnbt2qV3/6mpqXj11VcxZswY6fXi7OwMDw+PQh8bUWkyb948dOzYUSsTwsXFBYMGDcK0adMAqANmhlSvXh2zZs2SvmMUCoXW901BZWZm4ttvv0WDBg0AqLMo2rZtiy+//BKAutvr+fPn873dpKQkfPHFF2jTpg3kcrn0uS1eSIkBwrlz50rZ387Ozpg6dSoqVaoEQRByfb5GRkZK5+ntt9/G8OHDpc+3cuXK4bPPPkOLFi0AAKtWrdJaNyIiQvounThxIgYOHChlolSqVAnz58+XuiXrY4q/Y2E4OjpKQT/xQjAn8aanv7+/9J0pmjRpEvr37y/93gDU2Tht2rTBggULYGNjg8DAQISHh+ttg0KhwMKFC6XgHwCzDodBRMXLxsYGixYtQr169QCoPwPatWuH1157DYA6GSPn73djKJVKLFu2DIIgYPr06XjttdekawiFQoH69etjwYIFKFu2LB4+fCj93gXUv0/FwOLIkSMxatQoODk5AVBf13z88cdo0qQJ0tLSdO47KCgIx44dQ8WKFfH999+jbdu2Unajk5MTBg0aJA2zsHHjRr3H5+HhgW+//Rb+/v4A1Nl3Bf085G9+Kg4MAJJVuXz5MiIiIiCTyaRxEwoqMTERly5dAgCMGjVK5x2jbt26oUqVKgDUYzGJxMw8pVKJhIQEo/YXFhaGq1evwsHBAQMHDtS5jK2tLTp16gRA3Q3WVHSlf8tkMun5O3fuGPzxr4+u7laOjo5S9+Xy5cuje/fuuZZp2rQpAHW3rqdPn0rPC4KAEydOAACGDRumc/yPBg0aoHnz5gCAY8eO6Vx36NChOjP0evbsWaBubYD6byPu98aNGwXahjEqV66MgIAAALov9s6cOYPU1FQ4OzujTZs2+dp269atARhuv1wu13sXkohMQ3zvhoeHIyoqSu9yw4cPN0t3nM6dO+u8YGnYsCEaNmwIAAW60VGvXj2tMWNFmsMmDB8+PFeXKblcLq338OFDrXknTpyASqVCmTJldFYhlslk0hhWjx8/xoMHD6R5J0+ehEqlgqurqzRukiY7O7tCfd4Z+3csLPHC7+zZs0hJSck1XwwA5rxAzIu3tzf8/PwgCILB74UePXqYZWxiIrJM/fr1y9WNF4B0MyIzM1Pr97uxrl69irCwMGmsP11cXV2lXkma10IXLlxAamoqbGxsdH5uy2QyjBw5Uu++9+7dCwDo3bu3zmMDgE6dOsHW1hYJCQkIDg7WucygQYN0ju9eEPzNT8WBXYDJqohZeL6+vjrHjsuP4OBgafw+fYOkAuoLl9DQUK0vgkqVKqFy5cp4+vQpJk2ahEGDBqFFixaoWrWq3i5TN2/eBKD+0jTUVUhMu46MjMz3Meni5eWlNU6Hpnr16kndXO/du5fvzJJq1arpfF68c+Tn56fz4lXzzlJiYqI0HRYWJj3O629y4cIFrb9JWFgYkpKSAEDnBSig/nHQsGFDHDp0SO+2nzx5gu3bt+PatWsIDw9Hamqq9DoRRUdH613fFLp164Y7d+7g33//xbhx47TmiRd6nTp1yjWmCgAkJCRgx44dCAwMRGhoKJKSkqBSqbSWMXShWqlSJb0/jIjIeEqlEvv378fx48fx4MEDJCYmIjMzM9dy0dHRKFeunM5tiNkXpqbvMxIAGjVqhGvXrum9+DFEzIjIyd3dPc9lxACT+DkuEtvRoEGDXMNqiOrUqQMnJyekpKQgODgY1atX11q3fv36eruFGfquAUzzdyysFi1awN3dHXFxcThx4oTWwPbBwcFSga1u3brpXP/ixYvYt28f7ty5g+joaKmCdc7262Ou1yERWSYxKJWT5lihmr/fjSVeC7148QJDhgzRu5w4BrjmtdD9+/cBqK8tdBWqArSva/Tte8uWLdi+fbvefYvrRkRE6Ow6a+rPQ/7mp6LGACBZldjYWAAocBaXpvj4eADqDAB9XyTAf192cXFx0nMKhQKff/45vvjiCzx//hw//fQTfvrpJzg7O6Nx48bo2rUrOnXqpJXlIP64ViqV0nEYoi+FPb8MXZDY2dnBzc0NMTExRrUpJ31dp8Sgn775mudF80ta/JsAhtst/k0025zfdXU5cuQIvv76ayntXyaTwdnZWbroTE1NRVpamsn+Nvp07doVP/30E54/f44bN25I3a4SEhIQGBgIQHemR0hICN5//32t8+Lo6Ch1ccjKykJiYqLB9mteqBNRwaSmpuKjjz6SLjiA/z5vxc9H8X0qXujoYq4f5oY+I8V5mt95xjLmMz+v742c3a7Edhhqs0wmQ9myZZGSkqLVbmPWNTTPVH/HwlIoFOjcuTN27NiBf//9VysAKGaNNGjQQOdvI3GAd81tubq6Sn+TxMREZGVlGfxe4AUiUekidq3NSTMIpSvIlhfxWigzMzPf10LGfJ7b2tpK1zU5ic/lvMmkj64bJYDpPw/5m5+KGgOARAVUu3ZtrF+/HqdOncKFCxdw48YNPH36FKdPn8bp06fx119/4bvvvpO6oop3ZKpUqYLff/+9OJtOOogFTLKystCwYUOMHz8etWrV0vqx89tvv+GPP/7IlRFoap6enlKW4+HDh6UfA8eOHUNWVhbKly+vs5rxt99+i9jYWJQrVw5Tp05F48aNtbpRX7p0SRrXUh9W/yIqvN9//x03b96EjY0NJk6ciA4dOmjdfFAqlUZ112S11eJlqr+jKXTv3h07duzA5cuXERMTA09PT6hUKml4El3tOH/+vBT869+/P4YNG4bKlStrfc5PmTIF169fN/i9xtchEZmCeC3UokULLFiwoEj3LQYsv/jiC3Tt2rXA2zH15yF/81NR41+drIrYRSgiIqLQ2xLv4GRkZBgcx0+suKjrLomdnR26du2KTz75BH/88Qe2bNmCcePGwcbGBnfu3MG6deukZcVur1FRUQW6a1ZQhlK/MzMzpcw5SxjwVfOumqF2i38TzTZrrmuoK5O+Cprnz5+XCrt8/fXXqF+/fq50e113FM1FvJg7duyY9HoRuwJ07do115d2REQE7ty5AwCYPn062rdvn2sMxYJkeRJR/onj540cORJDhgzJlXlc3O9FQ5+R4jxLyQwQ22HoO0EQBJ3tFqcNHa+h7VrS37Fu3brw8fGBSqXCkSNHAKgHtY+KioKtrS06d+6cax1xnNyGDRvi/fffh6+vb67vjuJ+LRJR6SH+bi/IMEfGfJ5nZmbqvaYz5TWkqfE3PxUlBgDJqohjMTx58qTAJddFtWrVksbru3z5st7lxHm1atXKc5vly5fH6NGjpcHGr169Ks0Tx4xITU3Vet7cIiIi9Bb4uHnzpvRFo1lNubj4+PhIJe4N/U3E4i2afxMfHx/pyy8oKEjneoIg4Nq1azrniYFBX19fnV0fBEEo0r9bhw4d4ODggPj4eAQGBiIiIgLXr18HoDvTQzOwqW/sFn3nhYhMS3w/6nsvXrlypSibk4uhzzJxnjHfeUVBbMf169d1jr0HALdv35aKY2i2W5y+ceOG3htvhj4XLe3vKI7xJ3b7FS8QW7VqJX13ahKDm/ra/+LFCzx79swcTSWiUkbfGOiaxGuhJ0+e5PuzR6xwHhISonf8wZs3b+qt3ivu+9y5c/nab1Hgb34qSgwAklVp2rQpvLy8IAgCVqxYkWug0/woU6aMVJlQX7n3f//9F0+ePAEArXRxfRchIjFzTCzoAagDS+KXz88//6x3bAlAHWwydowKY2zYsEHnPjZu3AhA/eWR3wIg5iCTyaQqyNu2bUNycnKuZa5fvy5VBevSpYvedXWNeXHo0CG9d/7Eys7h4eFafzfRgQMHClTxrKAcHR3Rtm1bAOrX4ZEjRyAIAvz9/aUfQZrE9gOQXrOanjx5YrD4CRGZjvh+1PVeTE9P1/mZXJSOHj2q8ybajRs3pJsk4udpcevYsSPkcjkSExN1DtwuCALWrl0LQD04vFgARHPd+Ph47N69O9e6GRkZ2LJli959W9rfUbwQvHv3Lh4+fIgTJ05oPZ+TofYD6mEtzD2kBRGVDuLnjaHrl/xcx2VlZWmNrdqiRQs4OjoiKysLf/31l851Nm3apHd7vXv3BgBcu3ZNyo7WpyAFTgqDv/mpKDEASFZFoVBg0qRJAIDTp09jxowZUlUoQJ1dd+zYMXzxxRdGbe/NN9+EQqHAvXv38Pnnn0t3ozIzM7Fv3z4sWrQIgPrOTJ06daT1/v33X0ydOhV79uzRCihlZGTg8OHD2LlzJwD1XXlNU6dOhb29PYKDgzFlyhRcunRJKyvh2bNn2L59O8aNG4ezZ8/m59To5ezsjN27d2PVqlXSl3JMTAwWLFiACxcuAADeeOMNk+zLFEaNGgUnJye8ePECH330kfT3VSqVOHXqFGbOnAlBEBAQEICOHTtqrTty5EjY29vj+fPn+PTTT6UvxczMTOzfvx/fffed1pempmbNmkEmkyEhIQHffvut1N03NTUVW7duxXfffWewWIw5iBd1p0+fxv79+7Wey8nPz0/qnrZw4UI8fPgQgPq8nT17Fh988IE0MDARmZd4c2n9+vU4e/asdJFz//59fPjhh8XeNcfGxgaffPKJlGGgUqlw9uxZ6fO1Xr16ub6/ikuFChUwaNAgAMAvv/yCv/76S7oojIqKwtdffy19l40fPz7Xun379gUA/Pjjj/jnn3+kGzzPnj3DjBkzDHYBtrS/o6+vr5TV+M033yApKQnOzs5o06aNzuXF9p87dw5//vmndOxRUVFYtGgRDhw4oDNzkIgov8QK78nJydLwCTnZ2Nhg2rRpkMvlOHPmDD7++GPcunVL+mxVqVQICQnBxo0b8dprr2ld4zk6OmL48OEA1IkNf/75p/RdIF7XXLp0Se9v3ebNm0uJA1999RXWrl2r9fmfmpqKy5cvY+HChZgyZUohz0b+8Tc/FRUWASGr06FDB0ydOhXLli3DuXPncO7cOdjb28Pe3h6JiYkQBEFvkCenOnXq4KOPPsLChQtx/vx5nD9/Hi4uLkhLS5MyAuvVq4ePP/4417rXrl2TMiVy7h9Qd1d+7bXXtNapWbMmvvrqK8yZMwfBwcH48MMPYWNjAycnJ6SmpuaZWVgQNWrUQM2aNbFx40Zs2rQJzs7OSEpKkto5duxYtGzZ0uT7LShvb2/Mnj0bM2fOxO3btzF+/Hg4OzsjMzNTunipUqUKvvzyy1wD8fr4+OCzzz7D3LlzcfXqVYwZMwYuLi5IT09HZmYm6tWrh0aNGkmZj5p8fX0xdOhQbN26FUeOHMGRI0fg4uKClJQUqFQqtGjRQir8UlRatGgBV1dXJCQk4MmTJ5DJZFIXsJzkcjneffddzJ49Gw8ePMC4ceOkO6WZmZnw8vLC5MmTMX/+/CJrP1FpNW7cOFy6dAnx8fGYPn06bG1tYWtri5SUFNjb22Pu3Lk6v1eKysSJE7F69WpMmTIFjo6OUKlUUla6l5cXvvjiC6O6cxWV//3vfwgPD8eZM2ewYsUK/Pzzz3ByctL6Lnv77bfRrl27XOtOnDgRISEhuH79Or7//nssW7YMDg4OSEpKgkKhwKxZszBz5kyd+7XEv+NLL72E4OBg3Lt3D4A6UzPneLWiXr16Yf/+/bh16xZ++eUXrF69WjpvgPrm3+XLl4t0eAsiKpkqVaqExo0bIygoCLNnz4azs7M0NM/EiROlrPLWrVtj+vTpWLhwIS5duoRLly7B1tYWjo6OSElJ0duFFwBGjx6NO3fu4Pz589JnmnhdAwDvvvsuNm/ejLS0NJ2fi5988glkMhmOHDmCdevWYd26ddI1Y0pKivR9UqlSJZOeG2PwNz8VFQYAySoNGjQITZs2xdatW3H58mW8ePECSqUSvr6+qFOnTr6q8vXs2RO1atXCli1bcOXKFcTExMDe3h61a9dG9+7d0bdvX9jYaL9V2rZti08++QRXrlzB/fv3ER0djaSkJJQpUwbVqlVDly5d0LdvX52Vopo1a4b169dj586dOHv2LEJDQ5GUlARHR0dUrVoVdevWRbt27aQ796YwadIk1KhRAzt37sTjx4/h6OiImjVrYvjw4VLKuSVp0aIF1q5di02bNuHChQuIjIyEjY0Natasic6dO2PIkCF672x16tQJFStWxB9//IFr164hLS0NPj4+6Nq1K1555RWdwT/RpEmT4Ofnh3/++QchISFQqVSoUaMGunfvjsGDB+OPP/4w1yHrZGNjg86dO+Off/4BADRo0ABeXl56l+/QoQMWL16MDRs24NatW8jKyoKXlxfatWuHkSNHSncIici8fHx88NNPP2HNmjW4ePEiEhMT4eTkhLZt22LkyJFSpkRxqVSpEn755ResW7cOgYGBiIuLg5eXF9q3b4/XX3+9yLOd82JnZ4d58+bh8OHD2LdvHx48eICUlBR4enqiQYMGePnll6UxgnNydHTE4sWLsXXrVhw4cABhYWFQKBRo27YtRo0apXc9wDL/jl27dsXKlSuljBlDv3dsbW2xaNEirF+/HseOHUNkZCQUCgWaN2+OIUOGoE2bNgbH2yUiyo85c+Zg7dq1OHfuHF68eCH1ktLsyguoxzNt2LAhduzYgcDAQDx//hxJSUlwcXFB5cqVUa9ePXTo0AENGjTQWs/GxgZfffUVdu7cib1790pD8zRt2hTDhw9Hy5Yt8euvvwJArqIYgDph44svvkCfPn2wd+9e3Lx5U+rxU6FCBfj7+6Np06ZaQwwVFf7mp6IiEzj4R6kQHBxc3E0gIrIIllLcwFrx+4SIiN8lhcXvEjK1Z8+eYfTo0QDU4wEaCqARWZKi/D7hGIBEREREREREZLXEXj6+vr4M/hHpwQAgEREREREREVm0WbNm4cyZM1qVep89e4ZFixZh7969AIARI0YUV/OILB7HACQiIiIiIiIii3bq1CmcOHECAODk5ARBELTGGOzXrx/69OlTXM0jsngMABJZsMjISEyYMCFf64wYMYJ3vizA5s2bsXnz5nyts3LlSlSoUMFMLSKikmDZsmU4evRovtbZtm2bmVpD+TFkyJB8Ld+lSxe8++67ZmoNEZH1ef/99xEYGIiHDx8iNjYWGRkZKFeuHAICAtCnTx+0adOmyNvE3/xkTRgAJLJgKpUKsbGx+VonZ6UtKh6pqan5/tuJVR2JiPRJTk7O92cLWYb8/t2Sk5PN1BIiIuvUt29f9O3bt7iboYW/+cmasApwKcFKW0REaqzcWDj8PiEi4ndJYfG7hIhIjVWAiYiIiIiIiIiIyCQYACQiIiIiIiIiIirBGAAkIiIiIiIiIiIqwRgAJCIiIiIiIiIiKsFYBbiU8PT0zHMZDw8PKBQKKJVKi6kwqFAo4OHhgdjYWCiVyuJujoTnyng8V8bjuTKOJZ6n0sSY7xNdLPXvZomvccAyzxfPVf5Y4vniucofSz1fJYG1fZcUx2u0OI61uN6LPFbzKi2vX6B0HWtBMAOQiIiIiIiIiIioBGMAkIiIiIiIiIiIqARjAJCIiIiIiIiIiKgEYwCQiIiIiIiIiIioBGMAkIiIiIiIiIiIqARjAJCIiIiIiIiIiKgEYwCQiIiIiIiIiIioBGMAkIiIiIiIiIiIqASzKe4GEBERlSbx8fHYunUrAgMDER0dDXt7e1SvXh19+vRB69atC7XtzMxMHDx4EKdPn0ZoaCiSk5Ph5uYGHx8fNGzYEIMGDYK9vb2JjoSIiIiIiKwFA4BERERF5MmTJ5gxYwbi4+MBAI6OjkhOTkZQUBCCgoLQv39/jB8/vkDbDgsLw9y5c/Hs2TMAgEKhgIODA6KjoxEdHY3r16+jW7duDAASEREREZVCDAASEREVgczMTMybNw/x8fHw8/PD+++/D39/f6Snp2Pnzp3YsGEDdu3aBX9/f7z00kv52nZMTAymT5+OmJgY1K5dG6NHj0b9+vWhUCiQnp6Ox48f48yZM7CzszPT0RERERERkSVjAJCIiKgIHDhwAOHh4bC3t8fMmTNRvnx5AIC9vT2GDx+OmJgY7N27F+vXr0fnzp1hY2P8V/TKlSsRExODunXrYu7cubC1tZXm2dvbo1atWqhVq5bJj4mIiIiIiKwDi4AQEREVgWPHjgEAOnbsKAX/NA0dOhQymQwxMTG4fv260dt9/Pgxzp07BwB45513tIJ/REREREREAAOARERGU6lUiIuLgyAIxd0UsjKpqam4d+8eAKBp06Y6lylfvjwqV64MALh69arR2xYDi/7+/vD19S1cQ4lKCEEQEB0dzc9rIiJrEBkJqFTF3QqiEo8BQCKiPKhUKixduhS1atVCzZo10bJlSxw4cKC4m0VW5OnTp1Igws/PT+9y4rzQ0FCjt3379m0AQLVq1ZCcnIw1a9bg7bffxpAhQ/Daa69hzpw5uHjxYiFaT2RdwsPD0bNnTwQEBKBPnz5ITEws7iYREZEeDitXQl6lCuDvDzx+XNzNISrROAYgEZEBgiBg2rRp+PPPP6XnQkJC8Nprr+GHH37AK6+8UoytI2sRExMjTXt6eupdTpwXGxtr9LafP38uTb/33nsIDw+HQqGAo6MjEhIScPHiRVy8eBEDBw7EuHHj8tze+vXrsXHjRr3zX331VYwcOdLo9onkcrn0v4eHR77XNxeZTAYAcHNzs6hsMUs8X9ZyrkaNGoUrV64AAC5evIgvv/wSv/76a5G3yxLPlyW+rgDLPFeA5Z4vopJCFh4O59mzIVMqgSdPIJs7F1i4sLibRVRiMQBIRGTAmjVrpOBfQEAAhg4diuXLlyM+Ph4ffvghGjZsiLp16xZzK8nSpaWlSdP29vZ6lxPnpaamGr3tpKQkAMDRo0chk8nw1ltvoWfPnrC3t0dMTAzWrVuHo0ePYufOnahevTo6d+5scHvJycmIjIzUOz8lJQUKhcLo9uUkk8kKtb65iBf6lsYSz5cln6vAwEAcPHhQ6/kNGzZg/vz58PHxKZZ2WeL5ssTXFWCZ5wqw3PNFZO0ctm1TB/+yyTZtgmzWLAguLsXYKqKSiwFAIiI9wsPDMWfOHABA1apVsWvXLri7u6Njx47o168f0tPT8dlnn2HHjh1S9gJRUROzZVQqFYYNG4YBAwZI8zw9PTFt2jSEhobi/v37+Ouvv/IMADo7O6NChQp65zs5OUGp8WPdWHK5HDKZDIIgQGVB4/zIZDLI5XKoVCqLyzyytPNlDedq1qxZANSv4+3bt6NHjx7IysrC5s2bMWXKlCJtlyWeL0t8XQGWea4Aw+eLAUGiwrM9fFjrsSwtDTbnziHzpZeKqUVEJRsDgEREeixevBjJyckAgGXLlsHd3R2AuojD5MmT8f333+PMmTM4fPgwunfvXowtJUvn4OAgTaenp8PJyUnncunp6QAAR0dHo7ft6OgojXE2cODAXPNlMhkGDhyIxYsXIzQ0FDExMQa7IY8ePRqjR4/WOz8qKipfXZRFHh4eUCgUUKlUBVrfXBQKBTw8PBAfH1+gwKa5WOL5svRzderUKRw6dAgA8Oabb6JJkyaoXr06Hjx4gF27duG1114r0nZZ4vmyxNcVYJnnCjB8vsqVK1dMrSIqIbKyYHvpEgBA9fbbkK9dC2RkwPbMGQYAiczEMvPsiYiKWWRkpNT1t3///mjdurXW/ClTpkhBlBUrVhR5+8i6aAbcNMcDzEmcl5+xpsRtlylTBm5ubjqXEasLA+oAHlFJJGZsOzk54Z133gEAdOvWDQBw7tw5ZGVlFVvbiIhIm+L2bchSUgAAQteuQPPmAACboKBibJV52W3fDnm7dsC33wIWlO1MpQcDgEREOqxatUrKxtLVbczFxQVjx44FAJw6dQq3bt0qyuaRlalcubLUTfzJkyd6lxPnValSxeht+/r65qst7K5OJdHp06dxOLsr2bhx46TsrJYtWwJQj6spVswmIqLiZ3P37n8PGjcGGjZUP19CP6vlISEoM3EiZOfPA59+CuzeXdxNolKIAUAiohyOHj2KZcuWSY/fffddHDt2LNdyb7zxhjRg+V9//VVUzSMr5OjoiJo1awIALl++rHOZqKgohIaGAgAaNWpk9LYbN24MAEhMTER8fLzOZZ4+fSpNly9f3uhtE1kDzbH/nJycMGnSJGle06ZNpWl97z0iIip6inv3AACCnR3g7w80aAAAkEdFQfbiRXE2zSwc1qzRKngi//nnYmwNlVYcA7CUyO9AxZYysLHYDktpjy6W0jaeK+MZOld//fUXJkyYoDUI+Z07dzBixAgsX74cr7zyivR8pUqV0KVLF/z777/YunUrZs2aZbJjtIZzZQkstV26dO7cGcHBwThx4gRGjBiRKxC3bds2CIIAT09PNMj+EWyMNm3aYPXq1UhNTcWOHTswZswYrfmCIGDnzp0AgJo1a0pjWRKVFAcOHMC///4LAHjrrbdQtmxZaV7lypVRtmxZREdH4+bNm8XVRCIiykFx/z4AQFmtGmQKhRQABNTZgZkl7Ial/f792k8cPAhZYiKEMmWKp0FUKjEAWErkZzwpcSBmS+Lq6lrcTdCJ58p41nCuLl++jEmTJknBPzs7O8yePRtff/01EhMTMWXKFDRs2BDt2rWT1hk3bhz+/fdfhIeH48qVKyYpBmIN58oSWOJ5MqRnz574559/EB4ejrlz5+K9996Dv78/0tPTsWvXLuzZsweAugiHjY321/Nbb72FyMhIdO3aFdOmTdOa5+LiguHDh2PdunXYsWMHPD090aNHD9jb2yM2NhZr167F/fv3IZPJMHLkyKI6XKIikZ6ejk8++QQAULZs2VxDNshkMtSqVQtnz57FvexsEyIiKn5SALBGDXVQokYNaZ48JARo375Y2mUO8ufPoXj4EAAg9O8P2a5dkKlUsLl4EZlduhRz66g0YQCwlDCm0purqysUCgWUSiUSEhKKoFV5UygUcHV1RUJCgkVVheO5Mp61nKu0tDS8+uqrWoPEv/zyy5gwYQJatWqF/v37IyUlBa+//jpOnDghVXHt2LEjHB0dkZqaii1btqB59gDGBWEt56q4FfY8FVfQ0NbWFp9//jlmzJiBkJAQTJ06FU5OTkhLS4NKpQIA9OvXDy8VoPLdkCFD8PTpU/z7779YtWoV1qxZA0dHRyQlJUEQBMjlcrz55pto1qyZqQ+LqFjNmTNHyuz74osvdBbCEQOAwcHBRd08IiLSRamE4sED9aQYAPT2huDgAFlaGhQGxku2RjYXLkjTqg8+gGLvXkCphG1gIAOAVKQYACwl8nvhbikX+iKlUmlxbRJZWrt4roynea5+/fXXXBeHw4YNg1KpRMOGDTFnzhx8+OGHePjwIVauXImpU6cCAOzt7dGxY0ccOHAA+/fvx/z5801SZMGSz5UlscQ2GeLr64tly5bh77//RmBgIKKiouDs7Ixq1aqhb9++uapNG0smk2Hq1Klo0aIFDhw4gAcPHiAlJQWenp6oV68eBg4cKI1BSFRSHDx4EL/88gsAdRf7iRMn6rwpIL72IyMjERcXx27wRETFTP78OWTZxfaU1aurn5TJgKpVgTt3IC9hAUBFdsETwcYGaNlS3d05KAiKGzeKuWVU2jAASESlXlJSEpYuXQoAcHNzQ3x8PDw8PLSCMa+//jo2btyIy5cvY9myZRgzZox0EdmzZ08cOHAAT58+xa1bt1CvXr3iOAyyEu7u7hg3bhzGjRtn9DqrV682arm2bduibdu2BW0akdWIjo6WusN7enpi/fr1escErV27tjQdHBwsVQYmIqLiIdcoTqasUuW/GdkBwBKXAXjnDoDs8Q7t7ID69YGgIOl5oqLCKsBEVOqtX78eUVFRAP7LKOvevbvWOGwymQwzZswAAMTHx+PXX3+V5mmO+3fw4MGiaDIRUan2+eef40V2lciVK1eiUqVKepfVzH69nz3mFBERFR95WJg0rdL4/Bb8/QEAisePi7xN5qTI7mWkFG9IZScLyB8/BlJSiqtZVAoxAEhEpZpKpZKCef7+/khKSgIA9OjRI9eyHTt2lDJH1qxZg8zMTACAt7e3lPV3+vTpomg2EVGpdffuXWzduhWAevzLIUOGaM0XBAH37t1DamoqAKBixYqwtbUFADzVyDohIqLioXj2TJpWVaz434yqVQEA8sjIkhMYy8z8b7zDHAFAmSBI84iKArsAE1GpdvjwYYSEhAAAqlatikePHsHW1hZdu3bVufxbb72FwMBAREREYPfu3Rg8eDAAoH379rh58ybOnz+P9PR02NvbF9UhEBGVKj/++CMAwMbGBp9//rnWvMzMTIwYMQInT55ElSpVsGvXLlSqVAmVK1fGo0eP8KSEdSsjslb6uuwX9Tbyu6+i3Keu/RfVfsy9P8Xz5wAAVYUKUGQX1gMAITsACAC24eFQmXH84qI6VvmDB5BlJw2oAgLUT1arJs23ffoUaNzYrG0oLa9fzX2VhmMtCAYAiahU27RpEwD1uGzh4eEAgNatW6NMmTI6l+/Xrx+8vb0RHh6ODRs2aAUAf/75Z6SlpeHSpUsch42IyAxSU1Pxzz//AAAGDRqEKppjR0HdHfjkyZMAgNDQUEyfPh3r1q2Dr68vHj16hNDQ0CJvMxHl5uHhUaj1FQpFobdREK6urkW+z+I4VrMfZ0QEAEDu56d1bIrKlaVpt5QUoAiO2+zHGhsrTbo0bgwoFFKmIwC4REUVyXECpef1C5SuY80PBgCJqNRKSEiQxuzr2bMnNm/eDEDd1VcfW1tbvPzyy1i2bBlOnjyJ8PBweHt7o02bNpDL5VCpVDh9+jQDgEREZnDkyBEkJycDAIYOHao1T6lUYs2aNVrP7d27F0+ePJEChQwAElmGWI2gSH64urpCoVBAqVTqrPptLgqFAq6urkhISJDGiza34jjWojrOMiEhsAGQ4eWF5NjY/47Vywti/lTSvXvIbNTIbG0oqmO1u30bztnTca6uKKNUQuHsDKF8echevEDanTtILeD7wVil5fULWOexFmXQkAFAIiq19uzZg/T0dACAr6+v9LyhACCgvuhctmwZVCoVduzYgQkTJsDNzQ0NGzZEUFAQTp06hY8++sisbSciKo327dsHQJ213alTJ615Fy5ckAJ806ZNw5IlSwAA27Ztkz7jw8LCkJWVpVXkiYiKnikuzIvq4j7nPotrv0W9P3PuU549BqDSx0d7PxrjAcrCworkuM19rLLsoScER0dkubv/N6NqVeDFC8gePy6yv29pef2K+ywtx5ofLAJCRKWWOIi8j4+P1P3X1dUVDRs2NLhevXr1UKdOHQDA33//LT3fvn17AMClS5eQkZFhjiYTEZVqZ86cAQB06tRJKuwhOnToEAB11faJEyeiQYMGAIBjx45JAUClUokwjeqTRERUxDIzIY+OBgCovL2159nbQ+XpCQCQZ3cTtnby7OJTysqVAZlMel4c71DBzHQqQgwAElGpFBsbixMnTgAABg8eLI0Z1bZtW6MyQ8SuZ0FBQdKg8i1atAAApKen4+bNm+ZoNhFRqRUaGipl+LVp0ybX/OPHjwMAGjduDE9PT3Tu3BkAEBgYiHLlymlth4iIioc8KkqaVpUvn2u+ystLvVz2zXlrJwb4VJUqac/w8wMAyB8/BgShqJtFpRQDgERUKh04cEBK0W7evLlUCbhDhw5Grd+vXz+tbQFA06ZNpecuXrxoopYSEREAnDt3TprOOc6qSqXC5cuXAag/0zWXyczMRFxcnLRsZGSkmVtKRET6yF68kKZLQwBQzABU5ShaJRYCkScnQxYfX8StotKKAUAiKpV2794NAPD09NQarNVQAPDMmTN49913MXLkSGzZsgV+2XfuxEIi3t7e0kDzly5dMlfTiYhKpStXrgBQD9VQu3ZtrXkPHjyQPssbZQ8a37hxY2m+ZtZfeAm5qCQiskbyvAKA2d2CS0QAMCsL8ufPAWR3AdYg+PhI0yWluzNZPo6ATESlTlZWljSQ/EsvvYQLFy4AUAcDAwICci0vCAK+/PJL/Pjjj9Jzhw4dgqOjIwDg9OnTSExMRJkyZdCsWTOEhoYyAEhEZGI3btwAANSvXx9yufY9bM3PXDEAWK5cOVSpUgWhoaG4efMm3N3dERcXxwAgEVEx0gwAChUq5JovBQBLQFBMHhUFmUoFQMd4hxqP5eHhUOa4sUVkDswAJKJS5+LFi4iJiQEAdO/eHYGBgQDUY/jJNAbnFc2bN08K/jk7O0sFQFJTUwGou5cdOXIEANCsWTMAQEhICF5o/MAhIqKCEwRBKwCYk9j918nJCTVr1pSeF7MAr1y5Aq/sbmURJeCikojIWmllAJYtm2u+KnvMVllKCpCSUmTtMgeZxpATYtdmiUbF45IQ7CTrwAAgEZU6R48eBQAoFAo0bdoUwcHBAICWLVvqXPaHH34AAAQEBODMmTM4ceIEVqxYobWcGAAUx54C/rsgJSKiwnny5AkSExMBqCux53Tnzh0AQM2aNaFQKKTnxUrAjx49QvnsrmbMACQiKj6y7CIgKg8PIEc1dwAQNIo2idWCrZVcMwCYM9sxRwYgUVFgAJCISh2x+m+TJk2ki0YgdwAwKSkJU6ZMAQC4ublh06ZN8Mker+Pll1/G1KlTpWX3798PQJ2ZIlYRvnr1qvkOgoioFLl165Y0rSsAeO/ePQBA9erVtZ4XxwpUqVRwcnICwAxAIqLiJGYA6hr/D9DOCixRAcCcx2trK2U7MgOQigoDgERUqiQlJUljRXXs2FGqKmlnZ6c1YDwArFy5UsoU+fbbb1GpUiWt+R988AE8PT0BADExMbh//z4cHBykC87r16+b81CIiEqN+/fvS9OaXXwB9biuDx48AKA/AAhAGuKBGYBERMUnzwBg9m9r4L9sQWslHqsgk2llNopKWsVjsnwMABJRqXL+/HlkZWUBUFf8Fcf/a9SoERwcHKTloqOjsXz5cgDqzMAhQ4bk2pajoyMmTJggPRa7BYvjUzEASERkGg8fPgQA+Pj4SJl8osePHyMzMxNA7gCgn58f7OzsAADp6ekA1DeCkpKSzN1kIiLSQQqK6QiI5Xxenj1mt7USMwCFcuUAm9z1V6UAIDMAqYgwAEhEpcqpU6cAqDP+GjVqhKCgIABAq1attJZbs2YNkpOTAQAzZ87UWRwEACZNmiRVoxQrC4tjTj179gzRVt51gYjIEogBwGrVquWaJ47jCuQOANrY2EjPJSQkSM+zGzARUfHITxdgmZX/jhYDgHqPtQRVPCbrwAAgEZUqJ0+eBAC0bdsWwcHBUkaI5vh/aWlp+O233wAArVu3zhUc1GRnZ4eAgAAAQFRUFO7du4eGDRtK85kFSERUeIYCgOL4f/rmi12GozS6krEbMBFRMVCppKCevqAY7O2hcnEBAMitvAuwTAx25iwAkk08BzKNyshE5sQAIBGVGvHx8bh27RoAoGvXrrh48aI0r0WLFtL0X3/9hRfZX8TvvPNOntt95ZVXpOkVK1ZIXYABBgCJiAorOTlZCtgZCgBWqFABrq6uueZXrVoVABCpMRg7MwCJiIqeLCYGMqUSgIEAIP7rBlxSioDoDQCKx5mcDKSlFVm7qPRiAJCISo0LFy5AEAQA6gIgYvdfX19flNMYb+T3338HAPj7+6Nnz555brdfv37S9P79++Hi4gJ/f38ADAASERXWo0ePpGldAUCxQEiNGjV0ri8GANM0Lq5eMNuCiKjIaY7pJ2h09c1J7AYsKyFjAOoLAAoaBU+sPdhJ1oEBQCIqNS5cuABAPSZUixYtpACgZvXf27dvS8+/9tpr0vh+hlSuXBlubm4A1F3Mbt++LY0DKGYcEhFRwYjdfwHdAcAnT54AgHTjJScxAAgA9vb2AMDxWYmIioEsNlaaVnl46F1ODIxZdRfg9HTI4+MBAIIx4x1a87GS1WAAkIhKDbHLb8OGDZGRkSFljWgGAP/8808AgFwux8svv2zUdmUyGdq0aSM9/ueff6RxAB8+fMhqk0REhSBmAMpkMvj5+WnNEwRBCgD6+vrqXF8zAOjs7AyAAUAiouIg1wgAama/5SQGxqw5K06ukWmeVxdgwPorHpN1YACQiEqFrKwsXLp0CYB6vL/Lly9L88QAYGZmJrZu3QpAPUagd3ZlLmN06tRJmt6/fz/q1asHQH1xqlmhkoiI8ufp06cAAG9vbzg4OGjNi46ORmpqKgD9AUAfHx/Y2toCUBduEtcjIqKipdmlV+Xurnc5MTBmzVWAtQKAGoE+TZrdoK052EnWw6a4G1CU4uPjsXXrVgQGBiI6Ohr29vaoXr06+vTpg9atW+d7eykpKTh//jyCgoJw//59REZGQqVSwcPDAwEBAejdu7cUBDDk4cOH2L59O65fv46EhAS4ubmhfv36GDJkiN7uLESUP7dv30ZycjIAdcVfzQIgYrbe0aNHpXGhXn311XxtX7OK8K1bt+Dl5aW176ZNmxa47UREpZkYAKxcubLeeYD+AKBCoUCVKlW0uhJHsasVEVGRk8fFSdOCoS7AYgZgfDyQmQlk38SxJlrdnfVkO2o+zy7AVBRKTQDwyZMnmDFjBuKz++E7OjoiOTkZQUFBCAoKQv/+/TF+/Ph8bfO9997D8+fPpcd2dnaQy+WIjIxEZGQkTpw4gcGDB+ONN97Qu43jx49j6dKlyMrKAqDumhIdHY3jx4/j9OnTeO+999ChQ4cCHDERaRLH/wPUwbo5c+YAAKpXry6N37dz504AQJkyZYwq/qGpbt26cHBwQFpaGgRBwL179+Di4oKkpCTcuXPHREdBRFT6hIWFAQAqVaqUa54xAUAA8PPzw8OHD5GZmQmAAUAiouIgZgCqXFyA7IxsXbTGxouOhpCPXjmWwqjuzk5OEJycIEtJYQYgFYlSEQDMzMzEvHnzEB8fDz8/P7z//vvw9/dHeno6du7ciQ0bNmDXrl3w9/fHSy+9ZPR2lUolqlatih49eqBZs2aoWLEiBEFAWFgYfv/9d5w9exbbt2+Ht7c3evfunWv9J0+eSMG/9u3b46233oKnpydiYmKwatUqnD59GkuWLIG/v7/Ou95EZDwxAFipUiVUqlRJeix2/83IyMD+/fsBAL1795YGijeWjY0NWrVqhePHjwMAjh07hjp16uDChQsMABIRFYIY5DMmAJiRkaFzG+I4gCkpKQDYBZiIqDiIWXGGsv+AHNVx4+KgtMIAoNHdncuWhSIlxeorHpN1KBVjAB44cADh4eGwt7fHzJkzpW619vb2GD58uBScW79+vZSJZ4xp06bhhx9+QL9+/VCxYkUA6gGqK1WqhE8++USqArp9+3ad62/YsAFZWVnw9/fHBx98AM/sDzpPT098+OGH8Pf3R2ZmJjZs2FDgYyciNTHg17x5c0RHRyMkJATAfwHAEydOICEhAQDQv3//Au1Dsxvw0aNHUbt2bQBgAJCIqIASEhKkz2ZDAcCyZctKBT50EbMDxfEC4+LipGxAIiIqGnIjA4Cq7N45ACDT6DZsTaRjtbMDDHw/lYSCJ2Q9SkUA8NixYwCAjh07oryOEtxDhw6FTCZDTEwMrl+/bvR269evr3eeXC5H165dAQDh4eG5qoAmJydLAYlBgwZBoVBozVcoFBg0aBAAIDAwULpjTUT5FxkZicePHwNQFwAJCgqS5okBwF27dgFQd8Pv3LlzgfbTpEkTaTo8PBzlsgf8DQ8PR5yV/nghIipOz549k6YNjQGYszpwTrqChzHMtiAiKlJiBqC+MfFEgkbGnDx7CC9rI3V39vAAZDK9y4nZjnIOTUFFoMQHAFNTU3Hv3j0A0DsIf/ny5aUflVevXjXZvl1dXaVppVKpNe/WrVtStqG+donPZ2Zm4vbt2yZrF1Fpoxnwa9asmfRYLpejfv36yMzMxL59+wAAPXv2zFVl0liaAUAAWtklzAIkIso/zS6+hjIADY3/B6grAefEbsBEREVLyooz0CUW0O4yq1lMw5pI3Z3zCHaWhIrHZD1KfADw6dOnEAQBgOG7w+K80NBQk+37xo0bAAB3d3etYKDmftzd3aUCBDm5ublJ8548eWKydhGVNmJg38bGBvXq1cOVK1cAALVq1YKLiwtOnz6N2Owv6YJ2/wWAcuXKoUqVKtJjzSJBDAASEeWfWAAE0B0AFOdrfvbqoit7kAFAIqKiJWUA5jUGoGYA0Ep70cizMwDzHO9Q7ALMrHQqAiW+CIhm9w5PA9F3cV6sie4wREVFSQUFunXrBlmOtF9xP4baJM6Pj4/Ps13r16/Hxo0b9c5/9dVXMXLkSIPbkMvl0v8eeXxQFRXxvLm5uUmBXEvAc2U8SzhXN2/eBKDutu/j4yMFBFu2bAkPDw+cPHkSAODg4IChQ4fCycmpwPtq1aqVFOC/ceMGypYti+joaDx69CjP47eEc5WTJb6uLPE8EZF5iBl+jo6OuX4zZWZmStV8dQUHNXl5eUEul0OlUknPsRIwEVHRMnYMQDg4QHBwgCwtzXq7ABsZ7BTHAJTFxgJKJZBjaDAiUyrxAcC0tDRp2lBVT3GeODh0YWRlZWHRokVITU1FhQoVMGzYsFzLiPvJq9Kose1KTk5GZGSk3vkpKSm5xhnURyaTGb1sUREv+C2NOc9VWFgYtm3bhqtXryIxMRFeXl5o164d+vbta3Cg89J4rgwRBAGXLl0CoC4AEhkZKY0p1bJlSygUChw4cAAA0LlzZ5QpU6ZQ+2vZsiW2bt0KAAgODkabNm1w9uxZ3Lp1i+9BE7PE80REpiVm+Pn4+OS6mfrixQvpxoSuLr6abGxs4O3trZVRyAAgEVERSk2FLPuaNq+gGKAuBKJIS7PeDMDsdufZBTh7vkwQIIuNhZDdJZjIHEp8ALCoCYKA5cuX49atW7Czs8OHH35oMFhjKs7OzqhQoYLe+U5OTrnGIcxJLpdDJpNBEAStO+TFSSaTSXfsLSX7CDDvuUpKSsLMmTOxYsWKXFWpf/jhB3h4eOCdd97Bp59+CkdHR2leaTxXxnj27BnCw8MBqMfVDAwMlOY1bdoU9+/fx927dwEAPXr0yPN9kpdmzZppPRa78V+/fh1ZWVm5LmA1Ffe50sUSX1eFPU8MGhJZD/Hzu2LFinrnAXkHAAF1lmBYWJj0mcYuwERERUeuEcjLKygGZGcJRkRYbQBQKgKSx3iHWt2d4+MZACSzKvEBQM3B/NPT0/V27UtPTwcArYBKQfzyyy84cuQIFAoFPv74YwQEBOhcTtyPuF99jG3X6NGjMXr0aL3zo6Ki8uxG7OHhAYVCAZVKZbKu0IWlUCjg4eGB+Pj4QgdmTMlc5+rp06cYPXq01GUVUF/0eHh4IDQ0FImJiYiNjcVXX32FDRs24Oeff5aKxZS2c2Ws48ePS9O1atWSuubb2NjAz88PGzZskOa3bdu20G2sVq2a1mMxezc6OhrBwcEGA/XFfa50scTXVWHPUzn+sCKyGhEREQDUXXhz0gwA6goQ5lSpUiVcuHBBCgBayucsEVFpINMYmiuvoBgACNk30eXWGADMzIQ8MRFA3sFOrYrHcXGwjBQAKqksr0+XiWmOFxNjYGBNcV5hxpP67bffsGfPHsjlcrz//vto2bJlnu0y1CZTtYusQ1RUFIYNGyYF/zp37owjR47g2rVrOH78OIKDg/Hnn39Kr6uQkBAMGDAAf//9d3E22+KJFX/t7OwQEBAgPa5fvz4cHR3x77//AlAXAsoZvCsIFxcX1K5dW3qs+R6/f/9+obdPRFSaiEE+XQFAMTgIGJ8BCEDKHI6zxotKIiIrpZUBaEwX4OzAmMwKxwDUrFyc5xiAGgVBrTXbkaxHiQ8AVq5cWepyZ6iSrjgvrypy+vz+++/YsWMHZDIZ3n33XXTo0MHg8uJ+4uLikJCQoHOZ+Ph4xGd/4Pn6+haoXWQdlEol3njjDTx48AAAMHnyZGzevBkNGjSQlrGxscFLL72EXbt2YdGiRbCzs0N6ejomTpyIP//8s7iabvHEgF/dunVhZ2cnFQBp0aIF0tPTpQIgXbt2Ndg9Nz+aNGkiTYeEhEjTDAASERkvNTVV+h3k7e2da74YHHR0dJSGWzAkZwCQGYBEREVHpnHNK+QjA9Aag2Jyje+XPDMANQKE1hjsJOtS4gOAjo6OqFmzJgDg8uXLOpeJioqSqnY2atQo3/vYuHGjNOj/hAkT0K1btzzXqVu3LmxsbAy268qVKwAAW1tb1KlTJ9/tIuuxZMkSnDt3DgAwZswYzJw5U2/RBblcjjFjxmDnzp3w8PCAIAiYOnUq/vnnn6JsslUQBEEK+DVu3BhhYWF48eIFAHVBkHPnziElJQUAjHrfGkvzcyQxMVEaB5QBQCIi42kWNzPUBVhXgRBdclYKZgYgEVHR0QoAGlF0TwyMWWMXYK3uznlkAGp1AeaNKTKzEh8ABNRdKQHgxIkT0sW/pm3btkEQBHh6emplXBlj69at2LRpEwBg3Lhx6N27t1HrOTk5oUWLFgCAnTt35hpbS6lUYufOnQDUVUX1jV1I1u/BgwdYvHgxAHW31K+++sqoC5nmzZtj69atcHNzgyAIeOedd6SgMak9ffpUGuS9UaNGWuenefPmOHz4MAB19+D27dubbL85P0fKly8PALh3757J9kFEVNJpdvE1FADUlR2oS84AIDMAiYiKjix7TDwAULm45Lm81AU4Lg6wkEJ0xspXBqCLC4TsAnXWmO1I1qVUBAB79uwJb29vpKWlYe7cuXj06BEAdYGNrVu3Ys+ePQDUhTTErDzRW2+9hQEDBmDJkiW5tvvPP//g999/B6DO2ho4cGC+2jVq1CjY2NjgwYMH+O6776QforGxsfjuu+/w4MED2NraYtSoUfk9ZLIis2fPRmZmJhQKBX788UfY29sbvW7Dhg2xbt062NjYICUlBUOGDNHbpbw0Erv/AuoMQPGxvb096tevL43/16ZNG5NW665Xr57WYzs7OwDMACQiyg/NIh+6gnxigNCY8f90LccMQCKioiMGAAW5HDDid7fUBTgzE8jusWMt8jMGIGQyKQtQzi7AZGYlvgowoO5C+/nnn2PGjBkICQnB1KlT4eTkhLS0NGkcmH79+uGll17K13Z//fVXAIBMJsPOnTuljD1dPvvss1zdeH19fTF16lQsXboUJ0+exKlTp+Dk5ITk5GQA6jHfpk6disqVK+erXWQ9Ll++LFWlHTt2LOrWrZvvbbRr1w7z58/Hxx9/jJCQEHz22Wf44YcfTN1Uq3T9+nUA6gBc7dq1pe7A9erVQ0REBO7cuQNAPf6fKbm4uMDf31+62ZCWlgZAPdZoenp6voK8RESlVV4ZgOJ8YyoAA0DZsmVha2uLzMxMAJCqmyuyMy+IrE18fDy2bt2KwMBAREdHw97eHtWrV0efPn3QunXrQm07MzMTBw8exOnTpxEaGork5GS4ubnBx8cHDRs2xKBBg/h7hvJFCgCWKQMY0dspV3VcE96sNzetDEBjxzuMjtYKHBKZQ6kIAALqYNuyZcvw999/IzAwEFFRUXB2dka1atXQt2/fAn1JCtmpyIIg5HkXOSsrS+fznTp1QpUqVbBt2zbcuHEDCQkJUlfkIUOGwN/fP9/tIushBuocHR3xwQcfFHg7Y8eOxfHjx7Fnzx78+eef6NGjB/r162eqZlotsaJy7dq1YWNjI2UANmnSBPv27ZOWM+X4f6IGDRpIAUBxHCuVSoVHjx4hICDA5PsjIippxACfk5MTXHJ0F8vIyEBUVBQA4zMA5XI5vLy88PTpUwDq328JCQnwMKIaJZGlefLkCWbMmCEVynF0dERycjKCgoIQFBSE/v37Y/z48QXadlhYGObOnYtnz54BABQKBRwcHBAdHY3o6Ghcv34d3bp1YwCQ8kUrAGgElUbgTBYXB+QYxsGSiWMAqsqUAWxt81xe5e4OBVgEhMyv1AQAAcDd3R3jxo3DuHHjjF5n9erVeueZquhCtWrV8OGHH5pkW2Q9goODpe7nI0eOlMaJKwiZTIbvv/8eFy9eREREBGbMmIEuXbqYtFurNRIDgPXq1UNISIgUqG/cuLGUeVmpUiXUqlXL5PuuX7++9BkhZgAC6nEAGQAkIsqbGADU1f1Xs0CIsRmA4rbEACCgHnaFAUCyNpmZmZg3bx7i4+Ph5+eH999/H/7+/khPT8fOnTuxYcMG7Nq1C/7+/vnu4RQTE4Pp06cjJiYGtWvXxujRo1G/fn0oFAqkp6fj8ePHOHPmjDS8CZGx8hsAFHIGAK2ImAGY1/h/IqkLsJUdJ1mfUhUAJLIkYnBZoVDgnXfeKfT2ypUrhyVLluDVV19FWFgYlixZghkzZhR6u9YqLi5OunNdr149rfEA69evj+nTpwNQZ/8ZU3Qlv3IWApHJZBAEgeMAktUzRXdJS+pyKbbFktqUk6W0rajPlWYAMOc+9QUA82pbzmBhQkKC2Y7H0l9bltQuSz9XgGW17cCBAwgPD4e9vT1mzpwp3US2t7fH8OHDERMTg71792L9+vXo3LlzrjHODVm5ciViYmJQt25dzJ07F7Ya2Uv29vaoVauWWW6cUsknL0QA0NrGxhMrHguurkYtLxU8sbLjJOvDACBRMUhNTcXff/8NAOjVqxd8fX1Nst0RI0Zg+fLlOH36NFasWIGRI0eW2m7kYvYfoA4AigU/nJycEB8fj8TsHyHm6P4LqIOMmlxdXREfH88AIFm9wmZLKRQKi8y4cjXyR3pRs8TzVVTnSuziW6VKlVznQBwvWZwPGHeuqlatqvU4KyvL7OfXEl9blvi6AizzXAGWd76OHTsGAOjYsaPOHiRDhw7Fvn37EBMTg+vXr6NJkyZGbffx48c4d+4cAOCdd97RCv4RFZYUFDO2C3B2ERAAVjc2nnisKiM/06SCJ1Z2nGR9GAAkKgZ79+6VqvWassqzTCbDt99+i44dOyIjIwOLFi3Cjz/+aLLtW5OcAcBFixYBUAfmjh49CkBdaKdDhw5m2b+3tzfKly+PFy9eAID0I5oBQLJ2sQX8cerq6gqFQgGlUmlR1coVCgVcXV2RkJAApVJZ3M2RWOL5KupzFRYWBkAddM75utP8LBULhBhzrnIGcUJDQwv8ms6LJb62LPF1BVjmuQIMn6/iCgimpqbi3r17AICmTZvqXKZ8+fKoXLkyQkNDcfXqVaMDgGJg0d/f32Q3p4lEhekCbHUZgElJAPJxrNmfJ9Z2nGR9GAAkKgYbN24EoA4SdenSxaTbrlu3LoYPH45NmzZh69ateO+991CjRg2T7sMa3Lp1C4C6u5e7u7tUAbhJkyZSNmDr1q1Rxsgv5oLQDDaK4wDeu3cPgiCYpdsxUVEwxcW5JV3gi5RKpUW2C7C881UU5yojIwPR0dEA1AG+nPsTg4NOTk5an+N5tatChQpaj6Ojo81+LJb62rLUNlliuwDLOV9Pnz6VChH6+fnpXc7Pzw+hoaEIDQ01etu3b98GoB6fPDk5GVu2bMHZs2el4ok1a9ZEnz590Lx588IdBJVKYlDM2Kw42NlBcHKCLCXF6sYALHAX4JQUID0dYIEdMhN5cTeAqLSJiIjAyZMnAai77OZnXBZjvf/++1AoFFCpVFLmW2mjWQDkwYMHUnexqlWr4saNGwDM1/1XpNkNOCn7R09iYqLW2FVERJSb2P0XyB20A4Dw8HAA6uBgfm6o5CwoEmdlF5VEMdnVRQHA00CBAXFefjJcnz9/Lk2/99572L59O168eAEHBwckJCTg4sWLmDNnDn799dcCtJxKu/x2AQY0AmNW9lktZTvmqGCvj6DZ3dnKjpWsCzMAiYrY/v37pTu3rVq1woIFC3Dv3j14eHigd+/e6Ny5c6Gzw/z9/fHKK69gw4YN2LZtGz7++GNUq1bNFM23CllZWbhz5w4AdUakZgEQcew/APmujJdfOQuBiO7fvy91WSMiotzE4RMA6BzjTAwA6qoQbEjO5c3V/ZfIXMQeBYC6KIc+4rzU1FSjty3erDx69ChkMhneeust9OzZE/b29oiJicG6detw9OhR7Ny5E9WrV0fnzp31bmv9+vVSjxddXn31VYwcOdLotonkcrn0f1F2wxZ/m7u5uUm/482tOI7VbMcpCFJQzKF8edjnOB59xyr38ADCwmCfng47E58Dc/5NxYIn9hUq5Gq3zmOtXFma7y4IgBUdqz58r1omBgCJitiePXsAqO/Mvvnmm1o/5NasWYOOHTtixYoVhQ4QTZ06FRs3boQgCFi9ejXmz59fqO1Zk4cPH0rntX79+rhw4QIAoEyZMlL2n4+PD+rWrQuVSmW2duQsBCK6f/8+2rVrZ7b9EhFZO80MwHLlyuWaL2ZS5zcAmLMKMDMAif4jXiyrVCoMGzYMAwYMkOZ5enpi2rRpCA0Nxf379/HXX38ZDAAmJycb7PGQkpJSqMrKMpmsWCozixf6Rak4jtXkx5maCmRlqbft4QHoOZ5cx5rdhVaekKB3ncIy+bEqlUB2MF3u7m7csWp8zyms6ViNwPeqZWEAkKgIxcfHS91/xS4cMpkMtWrVwtOnT5GcnIwTJ06gR48e2LFjR6Eq+Pr7+6N3797Yu3cvNm7ciE8//dRiq+uZWs4CIKtWrQIANGzYEMePHwegrr5s7nH4/P39YWdnh4yMDADqoiNZWVl49OiRWfdLRGTtNAOApswALFOmDJycnJCSkgKAGYBkfRwcHKTp9PR0ODk56VwuPT0dAODo6Gj0th0dHaWeEgMHDsw1XyaTYeDAgVi8eDFCQ0MRExOjtxuys7Ozzu77IicnpwKNqyiXyyGTySAIgllv4uYkk8kgl8uhUqmKNKuoqI/VbMcZEwMxLKJycYGQ42+v71jlrq6QARDi4qAy8TicZjvWuLj/jrVMGeOO1dVVWkcZFaUOIppQaXn9AtZ5rEUZNGQAkKgIHTp0CFnZd78A9YXL+vXr0ahRIyQlJWHOnDlYs2YNwsLCMHToUOzbt69QmYBvv/029u7di+TkZKxfvx7vvPOOKQ7D4okBQHt7e/j6+kpZf97e3jh9+jQAoHfv3gXats3Zs3DYvBk2164BggBlzZpI790bGQMG5LpbZ2Njg1q1akn7t7OzYwCQiMgIml2Ay5YtqzUvPT1duomW3+9ImUwGLy8v6XOYGYBkbTQDbjExMXoDgOJ7JD/d0Tw9PZGYmIgyZcrATWNMMk2VNboqRkVF6Q0Ajh49GqNHj9a7r6ioqAIF4D08PKRxrosygK9QKODh4YH4+PgiKwhTHMdqruOUP30K8ZWSJJcjI8fx6DvWMo6OsAegjI1FnInPQVEca7JCgXQjjlUul0vrpDx9mmudwiotr1/AOo9VV08Hc2EREKIiJFafBdR3cDdv3oxGjRoBAFxcXLBgwQJ8/vnnAIDQ0FD873//0woY5lfbtm2lcejWrFlTpHdfipMYAAwICMDDhw+l8W/E/xUKRb7H/5PFxKDMa6/BfcAAOGzYAJvr12Fz4wbst2+H69tvw71zZyiyKw1rqlu3rjQtZgIyAEhEZJiYAejh4QFbW1uteREREdJ0fjMAc67DDECyNpUrV5Z6MDx58kTvcuK8KlWqGL1tX1/ffLXF3D0pqOSQa4zBbWxlXOC/isEyjfUtnVjsBFBnABpDLHYCsAgImRcDgERFRKVSYf/+/dLjWbNmaQWHRFOnTsUbb7wBADh9+nShqvjKZDJpWyEhIThz5kyBt2VNNCsAX7lyRXpeDLy1aNEC7hpftHmRP30K9x49YJ/991M5OyOjRw+k9+0LVXbXNJs7d+Depw/stm/XWjcgIECaFoO5ISEhpSYYS0RUEGIGoK674qYMADIDkKyNo6MjatasCQC4fPmyzmWioqIQGhoKANKNZmM0btwYgLpgWnx8vM5lnj59Kk3r6p5PpItmAC8/VYDFYKFmUM3SFehYHR0h2Nmp19fz3iMyBQYAiYpIUFCQVF3N29sbY8eO1bvs3Llz0bRpUwDA0qVLcf369QLvd/DgwVL3EEPV2EqKmJgYPH/+HIA6++5qdlaem5sbbt++DQDo1q2b0duTRUfDbfBgKB4/BgCkjRiB2CtXkLBhAxLXrkXMlStImjMHgp0dZBkZKDNhAuy2bZPWr1OnTq5tpqamSuNXERFRbmIGoK4AoObnpykyAItqjCAiUxGLb5w4cUKru7xo27ZtEAQBnp6eUk8QY7Rp00YaM3DHjh255guCgJ07dwIAatasma+bqVS6aQbw8hUAzF5WlpgIWMlntdaxGpvtKJNJy8qtKNhJ1ocBQKIismLFCmn6448/ho2N/iE47e3t8eOPP8Le3h5ZWVmYNm1agbsCu7i4SFXcdu3apfeObklx69Ytabp+/fpSBqBm5Ueju/8qlSgzYQIUISEAgJSPPkLS8uUQNMfTsbdH2sSJiN+5Eyo3N8hUKpSZMgU22ZWHdQUAAXYDJiIyxFAGoGYAsCDj5GoGAJVKpVQQhMha9OzZE97e3khLS8PcuXOl3xTp6enYunUr9uzZA0A9Dl/O35tvvfUWBgwYgCVLluTarouLC4YPHw5AHQDctWuXVEwkNjYWS5Yswf379yGTyTBy5EgzHiGVNJpZccZ2iwU0MgCVSiA52eTtMgdZdsIHUMBgJwOAZEYMABIVAUEQcPjwYQCAra2tUT+aatSogQ8++AAAcO3aNfz6668F3v+oUaMAAGlpadieo4tqSSMW3ACA6tWrS92BxQyP8uXLG3033OHXX2F37BgAIG3kSKR8/LHeZbOaN0fCpk0Q7O0hS0+H65gxkEVFwcfHR2f15YcPHxp7SEREpY4xGYBOTk5wcXHRu420tDQsXrwYffv2xZgxY3Dx4kUA2jeEACCBF1tkZWxtbfH555/Dzc0NISEhmDp1Kl555RWMGDECv//+OwRBQL9+/fI93jEADBkyBN26dYNSqcSqVavw6quvYtSoURg7diyOHj0KuVyOcePGoVmzZmY4MiqpCtsFGNAeR9CSyQuSAQiN8Q75nURmxAAgURG4cOECkrPvWjVv3tzoUt+TJ0+WMsgWLVpU4MHKW7VqhWrVqgFQdwspycQMQB8fHzx//hyZmZkA/huzpkuXLpDL8/7ok4eFwenrrwEAWbVrI+mbb/JcJ6t5cyRl31GXv3gBlw8/hAza4wCK+2YGIBGRboIgSAHAChUq5JovjgFoqPtvdHQ0+vTpg2+++QaBgYHYu3cv+vfvj3///TdX1mBJz4ynksnX1xfLli3DwIEDUbFiRWRmZsLZ2RmNGjXC9OnT8fbbbxdouzKZDFOnTsWnn36KJk2awMnJCampqfD09ETHjh2xcOFCqWcJkbHEoJagUADZ3cyNoRlAs5bAmFaw08BNqpwEKyx4QtZHfx9EIjKZX375RZoWs/GMYWtri7lz52LYsGGIi4vDwoULMX/+/HzvXyaTYfDgwVi8eDHOnTuH58+f58qAKCn0FQARA7DG3g13njUL8uwU/qRFi4z+sZI+bBhsjx2Dw+bNsN+zB+nbt6Nu3boIDAwE8F/FPGYAEhHplpCQIN28MVQERF/338zMTLz22mvS+Lm1a9fG48ePkZaWhkmTJmHTpk259kdkjdzd3TFu3DiMGzfO6HVWr15t1HJt27ZF27ZtC9o0Ii1it1ihTBkgH9WjNbsLW00AUAx2OjkBBoZ8yskaC56Q9WEGIJGZZWZmSt1/AaBr1675Wr9Tp07o0aMHAOC3337DvXv3CtSOQYMGAdAewLmkycrKwt27dwFoBwCdnZ0BqINvnTp1ynM7ihs3YJ89+HXayJHIat06X+1Inj8fSh8f9b5nzkQdf39pnlKpBKCuBExERLmJ2X+A7gBgZGQkAP0BwCVLluBC9jisr732Go4fP46ff/4ZgDoz8J9//tFanhmARETmJWa15adLbM7lrSUwJh5rfsY6BP7rGi3ndxKZEQOARGZ26tQpKfvMy8sL5cuXz/c2vvzyS9jY2ECpVGL27NkFakdAQIDUFbWkBgDv378vDVZdr149BAUFAYA0AHbz5s3h6emZ53acFiwAAAh2dgbH/dNHcHVF8ty5AABFRAQaZ1ci1vTo0SNWniQi0kEM8AGGxwDU1QU4ODgY3333HQCgSZMmWLBgARQKBfr06YN27doBADZt2gQnJydpHWYAEhGZlzguXn7G/wOsNAAoHmsBg53sAkzmxAAgkZnt379fmjYm+0yXGjVq4I033gAAHDx4EKdPny7QdsQswIsXLyI0NLRA27BkmhWA/f39ERwcDOC/7A5juv8qbt6E/b59AIC011+HqlKlArUlo39/ZLRvDwBotnt3rvkpKSlSNzYiIvqPZgZgzptmGRkZiImJAaA7A3D+/PnIysqCjY0Nli1bplUBdfz48QDUFYY1i4cwA5CIyLykDMB8jIkH5AgAWklgTKu7cz6wCzAVBQYAicxIEATs3btXetymTRts2bIFffr0QbVq1dC4cWN88MEHRhWE+OCDD1Am+4vkyy+/LFD2mBgABJCrC1RJIFYAdnR0REJCAlQqldZ8YwKAjtnjNQq2tkidOrXgjZHJkPzllwCAshkZ8NYxhiALgRAR5WYoAKiZHZgzAHjp0iXs2bMHgLrrb+3atbXm9+zZE2XLlgUAre8HZgASEZlXgbsAawTR5FbyWV3QDECpCnB6OpDdo4nI1BgAJDKj27dvS12VAGDHjh2YNGkSLly4gMTERDx79gy///47OnXqhI0bNxrcVtmyZTFlyhQAwJUrVwrUjbd69eqoV68eAGBfdpZbSSIWAAkICJAGfxd5eXmhQYMGBteXRUfD/u+/AQDpAwdCZaDCpDGUDRsivW9fAECjtLRc81kIhIgoNzEAaGdnJ934EmlmTucMAC7JrsLu4OCA999/P9d2bWxspDF14+LipOcZACQiMq+CjosHGxt1MQ1YT2acSbIdreRYyfowAEhkRgcOHJCmbW1tcfz4cQBAlSpVMHHiRPTt2xdyuRypqamYOnUqfvjhB4Pbe/vtt6XqvV999RUyMjLy3aaePXsCAC5cuCB1oyopxC7AdevWlQqAiFV3u3XrJk3r4/DHH+q7bgDS3n7bJG0SxxCspyNjkxmARES5vXjxAoB6/L+cn9v6AoDh4eHYunUrAGDYsGE6xwcEgD59+gBQF40SsQswEZF5SUGx/AYA8V/Q0FqCYvJCjgEIWM+xkvVhAJDIjI4cOSJNZ2ZmAgC6dOmCkydPYs6cOVi7di12794tBfXmzp2LP/74Q+/2nJyc8OmnnwJQV5Fdt25dvtvUq1cvAOruT5rVia1ddHS0lG2pWQBE7CrdvXt3wxsQBDhkZ2FmNm+OrCZNTNIuZd26SO/fH3V0zGMAkIgoN80AYE6aWfWaQb7Vq1dL37NvvfWW3m23b98eCoVC67mSdjOMiMjSFLQLsOY6pWUMQACQW8mxkvWxyXsRKgly/tg19fLmIrbDUtqji762paSk4NKlS1rP1apVC+vWrdMafLx169bYvXs3+vXrh+fPn+OTTz5BnTp10KpVK53bHTlyJFauXInbt29j8eLFGDlyJFxdXY0+V02bNoWXlxciIiJw4MABvPrqq/k53EIx59/x9u3b0nTVqlUREhIiPbaxsUGXLl1ynSPN9ijOnYMiOyCXMWqUSduaPnky6u7alev5kJAQvfuxlNe8pb8HLbVdRFRwYhdgXQFAMQPQwcEBrtkXS4IgYMOGDQCAFi1aSENd6OLi4oJGjRrh8uXLufZHRERmIAgF7hYLWGEAkBmAZMEYACwlPDw8jF5WoVDka/mi4FqAu0VFwdC5unTpkpSNIFqzZg2qVKmSa1kPDw/s2rUL7du3R1paGsaPH4/r16/D3d1d57YXL16MPn36IDo6Gr/88gu++uoraZ4x56p///5YvXo1jh49CmdnZ9jZ2eW5TmGZ+3WlOZ5ezuPp0KED/Pz8cq2jda62b1f/7+AA5zfegLObm+ka16MH6rRoAVy4kKvN7u7uubq48T1oHEs8T0RUeGJALmcBEOC/AKCXl5f02Xn16lXcuXMHADB06NA8t9+uXTutAGBsbGyh20xERHqkpECmVAIoWBdgwZq6AKenS8MJ5Xe8QxUDgFQEGAAsJYz5cStmkSmVSosZEFuhUMDV1RUJCQlQZn9xWAJjzlXOIhsDBgxAnTp19P4tqlWrhsWLF2PSpEl4+vQpJk6ciBUrVuhctlWrVujQoQNOnjyJ77//HiNHjkSVKlWMPlddu3bF6tWrkZiYiN27d6NLly5GHHXBFNXr6uLFiwCAypUrS+P/iTp37qx13nO9rlJT4b5pE2QAMvr0QbJKBZj4gtB24kR4XbiACI3nkpKSEBwcjAoVKgDge9BYhT1PDBoSWTZjAoDi5yYAbN68GQAgl8vRv3//PLffunVrLFu2THrMMQCJiMxHM3OvMF2AraEKsNax5rcLsMbyDACSuTAAWErk98LdUi70RUql0uLaJNLXrpMnT2o9nj59ep7H8PLLL2Pfvn3YvXs3Nm3ahN69e0sDluc0c+ZMdO/eHampqfj666+lixljzlW7du3g6OiI1NRU7N+/Hx07djS4vKmY828oVv2tV6+eVmYHALz00ks69y2eK7u9e6Uv7NThw83STmXv3qhjZ4eIHIVb7t27h7Jly+psmyWx1PegJbaJiAouIyNDqtBrqAuwZgGQXdlDLHTp0kUrMKhPw4YNtR4nZY/XREREpifX+IwtUAagFXUBLlQAkBmAVARYBITIDJKSkrSCUBUrVkT16tXzXE8mk2HhwoVS1sNnn32m98KkcePGGDJkCADgzz//lCrgGsPJyQlt2rQBABw7dszo9SxVZmYmgoODAWhXAAYAX19f1KxZ0+D69rt3AwBUZcsis1Mn8zTSxga169bN9fSTJ0/Msz8iIiukWZBD180RsQiIWADkyZMnUvffvn37GrUPb29vqfgWAKSmpha4vUREZJhmMKtAVYDFAKAVBMW0jjW/2Y4ODhCyhzGyhmAnWScGAInMICgoSCszqWvXrkavW65cOcybNw8AEBYWhkWLFulddvr06bC1tYVKpcKcOXPy1Uax2++9e/fw7NmzfK1rae7du4eM7Mw6Hx8frSqRvXv3zjXGnpbUVNgdOgQAyOjdG7AxX2J0tZ49cz33+PFjs+2PiMjaREdHS9M5A4BZWVlS92AxA/DIkSPS/J46PmP1ady4sTStVCqRlpZWkOYSEVEeNINZqsJUAU5IAATBZO0yB1NlO1pDd2eyTgwAEpmBOB6dyJgxiTQNHjxY6pYrVvzVxc/PD2+++SYA4ODBgzh69KjR++ikkelm7VmAmtmP6dkD74r0daEW2R07BllKinrdfv1M3zgNtVq3zvWcZrViIqLSzlAGYFRUFITsiz8xAPjvv/8CAPz9/VGrVi2j99OoUSOtx5Yy7ioRUUmj1S22IFWAxSIgWVmAhWdsFyoDEFZW8ISsEgOARGaQc/y/nOMN5UUmk+Hbb7+Fra0tlEolPvroI+miJ6f3339fqtD68ccfQ6VSGbWPgIAA6QLq+PHj+Wqfpbl58yYAddfm0NBQ6XlPT0+0atXK4Lp2YvdfV1dkduhgvkYCOrsiMwOQiOg/mhmAnp6eWvPE8f8AdQBQqVTi9OnTANTZfwazvXPQzAAEgER2tyIiMovCdgG2prHxCjMGIGBd3Z3JOjEASGRigiDg0qVL0mNPT0+dlQzzUqNGDUyePBkAcP78eWzZskXncp6enpg6dSoAdebhjh07jNq+TCZD586dAQAnTpwwOnBoiW7cuAFAHdTUzL7s1asXFAqF/hUzM2F34AAAIKNnTyB73A1zqVChAsrk+DHAACAR0X8MZQBqDu/g5eWF27dvS4G7Tvkcv7VevXpaj1kJmIjIPAobFNMMAMot/GaNZuBOVcILnpB1YgCQyMRCQ0ORnJwsPW7YsCGQlASH336D69Ch8GjVCm49e8Jp7lzI8xh777333oOvry8A4Msvv9R7gTJ+/Hj4+PgAAObOnZurG6w+YgAwOjpaqqJrjcQuwAEBAbh69ar0fF4DwtsEBkKefU4zevc2XwOzyWSyXF3UwsPDOQA9EVE2MQBoa2sLlxxdxTQzAL29vXH+/Hnpcfv27fO1Hy8vL9jb20uPIyMjC9JcIiLKgyx7XDzB1hZwcMj3+taYASjI5YCzc77XF5gBSGbGACCRiR3IzigT1XN1hUe7dnD55BPYnTgBxcOHsL18GU4//ACPli3hsHKl3gFtHR0d8dVXXwEAXrx4gW+++UbvctOnTwegzihbu3atUW0VxxkErHccwBcvXkgXbu7u7sjKygIAODg4aB2fLraHDwMABBsbZGYHQ82tTp06uZ7T7LZMRFSaiV2APT09c3XpFQOAtra28PT0lAKAfn5+qFy5cr72I5PJpErCAD+HiYjMRQxmCWXKAPkYqkGkmUln6YExKQBYwGMVMyTlzEonM2EAkMjE9uzZo/W4+a5dUISFAQCyatRA2ogRyGzbFgAgy8iAyxdfwPnDDwE9XXB79uyJ7t27AwB+++03vZl6I0aMQIMGDQAA3333nVEDmleoUEHqBmWtAUBx/D8AWpl0nTp1gkMedxltsgOAma1aFahLQkHoGqSehUCIiNTEDMCc3X+B/wKAFSpUAAApANiuXbsC7atGjRrSdFj29zQREZmWXDMoVgCa68k0quxaIllhj5VdgMnMGAAkMjFxPDpRQ0GAytkZiT/+iLgzZ5C0fDnid+5E7OHDyMq++HD8/Xc4z56tc3symQzz58+Hvb09VCoVPvnkE53j9SkUCixYsACA+gJKX7ZgTmI34AsXLiAtLc3Io7QcmgFAzWrAgwcPNrzis2ewyV43s2tXs7RNF10BwCc5XjNERKWVGADMWQAE+C8A6OXlhYiICClo16ZNmwLtS7NAF8djJSIyj0IHxTQDgBYeGNPKdiwAdgEmc2MAkMiEkpOTtcbpkwMIcHFBwrZtSB8+XCsVXNmoEeL37EFWdtae408/wf6vv3Rut2rVqlKhjwsXLmDz5s06l+vZsye6ZgezVq9erVWMRJ+22dmI6enpuHz5ct4HaWHEAKCvr68UfJXL5ejZs6fhFTW6amd062a29uWkKwD49MSJIts/EZEl0+wCnJNYBMTLywvXrl2Tnm/WrFmB9tWiRQtp+smTJwXaBhERGVbooJgVBQALm+2ocnMDAMjS0wEjx3Qnyg8GAIlMaOfOnVqPawHIXLUKWU2b6lxe8PRE/MaNUHp5AQCcP/5Yb2GQyZMno2rVqgCAOXPmIC4uLtcyMpkMixcvhpOTEwRBwHvvvYeMjAyDbW7dujXkcvVHwZkzZwwua4nEAGC1atWk4iv16tXLNXh8Lvv2AQCUFStCWbeuWduoqVKlSloDzwPA49u3i2z/RESWzJguwN7e3lLBJ4VCIQ1/kV9NmjSRpl+8eFGgbRARkWGFzQCEvT0EGxv1tiy9C7Apg53MAiQzYACQyIRyjv9Xt3ZtZL70ksF1BG9vJP7yCwBAnpQEl/ff11kURLMgSFRUFObPn69ze35+fvjss88AALdv38ayZcsM7t/V1VW6eDp9+rTBZS1Neno6goODAWiP/zd06FDDK2ZlAYcOAcju/luAQXoLSi6Xo1q1alrPhcTEQJZ90UtEVJrp6wKsUqmkIJ1mBmBAQAAcHR0LtK9y5cpJ08aMm0tERPknBu1UGtV887cBmRQYs/gAoFjxOI9jjYiIwOzZs/H2229jyZIl0neQNVU8JuvEACCRCQXl6HJba+BAo9bLatsWqePGAQDsjhyB3e7dOpfr0aMHevXqBQBYu3at3i6+48ePlzIbvvvuO9y9e9fg/sVuwBcvXkS6FaWb3717V6r6q1nB8fXXXze4nuLKFSC7q3ZGEY7/JxILr4geArDdv7/I20FEZElSUlKkmzk5A4BRUVHS532FChWkAGBBs/9ECoUCAKxyDFwiImtQ6AxAjXUtvQuw2D6VgWO9fPky6tWrh3nz5mH79u346quv0LlzZ9y9e1crACi38GMl68QAIJGJJCUlITJ77CJRvXxcmCR//vl/XYHnzgX0dN2dN28eHB0dIQgCJk+ejJSUlFzLKBQKfP/997CxsUFGRgYmTpxosCuwWEExLS3NqsYB1CwAIo4NVb58eZTJ4weG7alT0nRmAatHFkbt2rW1HqcAiNuxo8jbQURkSWI0MqFzdgF+/vy5NO3i4iIVANEs5FEQdnZ2AAClUlmo7RARkW5St9i8hucxQFzX4gOAOjL5NIWHh6NPnz7SeLc+Pj4A1IkMr7zyCl5oFHq09GMl68QAIJGJXNJRwCMgIMD4Dbi4IOXTTwEAikeP4LBunc7F/Pz8MHPmTADA/fv3MW/ePJ3L1atXDx9++CEA4Pr161KFYF1at24NWXY3WGsaB1AMADo4OEiVkcVsRkNsTp4EAGTVqwdBxzhT5lYju/qzpqenTwPZYxgSEZVG0Ro30XJmAIoBP0C7u25hA4DOzs4AAEEQpHFkiYjIRAThvwzAgnYBxn8BQLkldwHWPFY9wc6PPvoIUVFRANQFG4OCgjBr1iwAwNOnT/HZ6tXSsuwCTObAACCRiRxdsULrsYODA6pUqZKvbaS/+iqy6tQBADj+8IPe6k9vvvkmOnXqBABYtWoVjh8/rnO5qVOnonnz5gCAZcuW4dy5czqXc3NzQ/369QFYVwBQrPorduECjBj/LyMDNoGBAICs9u3N1jZDdAUAH2VkaFUmJiIqbTQzAA0FAMViIDKZLNeQCvnl7u4uTd9mQSYiItNKToYse2zzEt8FOCUFsuxscl3BzgsXLmB/9pA/48ePx9ixYyGTyTB58mTp+mXrwYMQ+ylZ9LGS1WIAkMgEFPfv43hIiNZz1atX1wpMGbchBVI++EA9GR4O+y1bdC4ml8uxdOlSuGZ/uUyYMAHPdFQPtrGxwYoVK+Dk5ASVSoXJkycjUc+XiZg5d+HChTwrB1sCQRCkDEDNrI02bdoYXM/m8mXIsrtNZ3XoYL4GGuDv7y9lXIoeApCxGzARlWKGugCLAUBnZ2c8efIEAFClSpW8K77noXz58tJ0UFBQobZFRETaNMexK+kBQFkexyr2xnJ2dpYKO4rmzZsnZaR/KW6PGYBkBgwAEpmAYulS3MnxXM2aNQu0rYx+/ZBVvToAwGnZMkDPuESVKlXC999/D0A9OPqYMWN0FvDw9/eXugk/fvwY06dP17k9cRzA1NRUXLlypUBtL0phYWGIi4vTeq569epa2Ry62IqVjmUyZBnRXdgc7O3ttS46gewA4IEDev/eREQlnaEuwOIYgD4+Pnjw4AEA9Wd+Yfn6+krTmuPKEhFR4eUVFDOWNAagBXcB1gp25sgAvHv3Lo4dOwYAeOedd3JdB5QrVw7jsgtCHgZwDpYd7CTrxQAgUSHJw8NxY+tWZOV4vqABQCgUSH33XfXko0d6KwIDwIABAzB58mQA6opSb731ljQWnqbRo0ejd+/eAIBNmzZht45tWts4gLou1Dp27JjnelIBkCZNIOQRLDSnnBeuDwHIoqOBCxeKp0FERMVMzAB0dHSEk5OT1jwxA7BixYq4f/8+AN3DKeSXOAA7ANy7d6/Q2yMiov/IDATF8kPKALTgAKChYOeGDRsAqHtxTZo0Sef677zzDhwdHQEAP4EBQDIPBgCJCsnh999xJitn+K8QAUAA6S+/LFUEdvztN4PLzpgxQwp8rV+/HjNnzoSQPdaGSCaT4bvvvpPuNr3//vtS1VyRh4eHVLQkMHuMPEt2/fr1XM/l1f0XaWmwFQNsXbqYoVXGyzlu1UNxYt++Im8LEZElEAOAObP/gP8CgJ6enlL2tykCgBUrVpSmnz59WujtERHRfzS7saoKMWSDyhq6AGseq0awMyMjA1uyh3Xq1q0bKleurHP9smXLYsCAAQCALQDisouFEJkSA4BEhZGVBfv163FWx6zCBABhZ4f0118HANieOQPF3bt6F7WxscGaNWukIh4rVqzAggULcgUBy5Urh6VLlwIAYmNj8e677+bKFmzVqhUA9TiAujIJLYmuDMDWrVsbXMfm0iXIxG7SxRwAzFkh+hmANADYu7c4mkNFKD4+Hr/++iv+97//YdiwYRg1ahRmzpypt0hPQe3cuRMDBgzAgAED8NZbb5l020TmIHYBzhkAFARB6gJsb28vPW+KAGC5cuWk6ShebBERmZTJugCLAcD0dMBCxyrXOlaNYOfJkyel77eRI0ca3Mbr2dd/aQC2sDAVmQEDgESFsW8fFM+fI+dlu0wmK/TYRGmvvQYhu4iIw5o1Bpd1dXXFli1b4O/vDwBYtGgRPv/881xBvO7du+ONN94AABw7dgy//vqr1vyWLVsCUAco7hoIOlqCnIO1+/n5aWVy6GKbHWAR5HKgmAqAiHJeuAoAHgPAxYtAZGRxNImKwJMnTzB58mTs3LkTz58/h0KhQHJyMoKCgjB//nysWrXKJPuJjIyUupsQWQsxAzBnAZDY2FikpaUBgNb3mikCgK4aWRrp6em5xpYlIqKCM1kX4OwCGYDldgPWzADUPNZ92b17nJyc0K1bN0RERODs2bM6bzq1aNECtR0cAABbHz82c4upNLIp7gYQWTP5zz/jBYCwHM/7+vpKYzgUlKpiRWT06gX7PXtgv3kzkj//HDCQOu/t7Y2jR4+iW7duePDgAX755Rc8f/4cP/zwg1aVxNmzZ+PkyZO4f/8+5syZgw4dOkjZaGIGIACcP38ederUKdQxmEtSUhJC/8/eecdHUeZ//D1b0kkApUkzVOlVEFAsoCigKCA27jzBdnZPPX9352E5D+88zwb27imKIiAIiqIUEZDeAgrSA4QklPSyZX5/7DxPZjebZDfZ3WyS5/16+XLL7Mwzk2Vn5vN8v5/P4cNer5nHXhH2n38GwNWjB7bkZDh1KizjCwR/AvE+oCugffstjBkT8TEpwovD4eDpp58mJyeH9u3b86c//YnU1FRKSkr48ssv+fjjj1m4cCGpqamMHDmyRtt67bXXKC4upmvXrlEv5isUgopagEX7L0ChkeKekJBQ5aRPIDTyqUjZt28f/fv3r/F6FQpF5ViNSe7aXkew24rkNv1tP1LbCdX2rCaxztK4MQSwXn/b1lJS5GNbYSFunxCNao0t1PtaUCAfi311u9188803AFxwwQU88MADzJ07F/AUjEyaNIlnnnnGK8RwYuvW/HPvXlbn5JCZmRmSc11D+f6at9UQ9rU6KAFQoaguBw/CkiVs8PNWKKoSAIpvuYXYRYuw5OcTO28eJb/7XaXLt2/fnkWLFjFhwgTS0tJYuHAhe/bs4f3335eCU0JCAq+99hpXXHEFxcXF/PGPf2TJkiXExMTQtm1bWrVqxbFjx1i3bh1/+MMfQrIfoWbjxo3lXquq/ReXC9sGz1/LOXhwrf/4tWjRgpiYGEpNbQx7k5IgP9/jA6gEwHrHkiVLyMjIIDY2lmnTpklPztjYWCZNmsTJkydZvHgxH330ERdddBE2W/W+pStWrGDjxo0MHTqUdu3aKQFQUWeoqAXYLACeMiZuOnXqJIOraoKvALh3714lACoUEaBJkyY1+rzVaq3xOqpDcg2q2KpLbexryPZT+KTHxNCkZcsqF69wX02BTSmaBiE8HiHbV4fD8/+YGJoYot3PP//M8ePHAY9/ufl8pus6s2fPJi0tjWXLlklLihu6duWfe/eiA99//z33GuGQoaChfH+hYe1rMNT2PXBEycnJYc6cOaxbt44TJ04QGxtLx44dGT16dNXigR9cLhc7duzgt99+47fffmPv3r0yWOH666+vssf/xRdf5Icffqh0mXbt2jFz5sygx6aIAB9+iKbrmDNbNU1D13W6dOkSkk04LrgA19lnYz1wgLjZs6sUAAGaN2/OwoULuffee1m0aBG//PILl1xyCf/4xz/43e9+h6Zp9O3blz//+c9Mnz6dHTt28K9//Ytp06ahaRqDBw9m/vz5/GxUy0UjH374YbnXqgoAsf7yCxajDcEZQLVguNE0jVatWnHQVN6/r1072LkT7bvvwOUKaJZUUXdYvnw54EmrbuZn5nrChAl8/fXXnDx5ku3bt9OvX7+gt5GXl8fbb79NfHw8t912G0uWLKnpsBWKiKDreoUtwML/z/w4VBNt/gRAhUIRfk5VswsjOTkZq9WKy+Ui19RyGW6sVivJycnk5ubicrkiss3a2NdQ72d8ZiZxeEIxcir5m1e1r1ZAyDl5R47gbNeuxmML2742aiT3dfbs2fJ9If5NmjSJm266iQ8++IC5c+eyY8cOJk6cyJw5c7BarXRs2ZJuwC5g1qxZTJ48ucZjayjfX6ib+xpJ0bDBCICHDh3ib3/7Gzk5OQDEx8dL36UtW7Zw5ZVXcttttwW1zuzsbP7+97/XeGwxMTEkJCT4fa82lGtFAOg6GP5aP6ekgPG9EsEbNQoAMWOxUDxpEonPPov955+x7N+P2/D5q4xGjRrx7rvv8tJLL/Gvf/2LwsJCHnroIb7++mteeOEFWrZsyX333cfSpUtZt24dM2fO5PLLL2fQoEEMGjSI+fPnc+jQIY4dOxaSsvNQUlxczHfffQeUCa7NmjWr0nPRbko2jgYBEDxtwF4CoPE7oJ08iW3TJpznnltbQ1OEmKKiIvbs2QNQYXVRs2bNaNOmDYcPH2br1q3VEgDfffddcnJyuPXWW8uJKApFNJOfn4/DqJ6oqAIwNjZW2j+ESwDcvXt3SNarUCgqJxQ35pG6uffdZm1tN9LbC8k2DTFET0oKeH1+lzPdK7tzckJ6PEK2r+J+sFEjuT4x+Su46aabeP/997HZbIwePZqbb76ZWbNmsWLFCt59912mTJmCOzGRicA/8FQQZmVllTsvVpeG8v0V22wo+xoMDSIExNd36aWXXmL27NnMnj2byZMno2kaCxcuZOnSpUGvOz4+nh49ejBu3Dj+9Kc/VUssOf/88/nwww/9/jd9+vSg16eIABs3wq+/ogPr/fwjD5kACJRce618HDtnTsCfs1gsPPjggyxYsICzzz4bgKVLlzJ8+HDmzZuHxWLh1VdfJSEhAV3Xefjhh3E4HOV8AKONTz75hKKiIgDZIjl48OAqW8FshgDoatUKvXXr8A4yQHr16uX1fH9hIRj7YV+xojaGpAgT6enpcoKgffv2FS4n3vP1uAyE7du38/3339OxY0fGqBZyRR1DtP9CxQJgs2bNcBrtZKESABMSErBYyi6Hf/vtt5CsV6FQKBRlwRg1SQD2/XzUhoAYnUZirDk5OWzdulW+n5qayr/+9S95z6JpGs8++6zsHHv66ac5fvw4enIy4ipO1/VyIqJCURMaRAVguHyXmjVrxqeffuolPMybNy8s+6CILrRZswA4bLWS5eckVNMEYDPus8/Gcd552NeuJe6zzyh6+GEpEgXC4MGDWbZsGU8++STvv/8+p06d4vbbb2fhwoU8++yz/OUvf+Hvf/87u3bt4pVXXuGee+4hKSmJ/Px8fv75Z66++uqQ7UtNKS0t5cUXX5TPRbXIBQEk+ooKQOegQUEdv3DiKwDuPXgQvX9/tI0biVm50vO3VtQLRGsjlBc3zIj3gm2NKi0t5ZVXXsFisXDXXXfVyID4o48+YpbxG+ePG264oUqLC38IkcVisUSVP4o4h6ekpEiRNhqIxuMVzmMlKmTBI4Sb9znTSEZPSUkhPT0dgH79+sllanqsEhMTyTNu3A4fPhyy4x2N361o/F5BdB4riN7jpVDUFYQo5q5hV5uXAGhKFo4mhNgp9nXNmjVeyfXTp08nzkj4FcTGxvLss89y9dVXk5eXx4wZM3guNZWBwBnACTw+gOPHj4/QXijqOw1CAAyX75J5xljRgHA60Qw/h839+sEG7xiQRo0aSRPXUFE8aRL2tWuxHjiA7eefcQbpWZmUlMR//vMfLr/8ch588EGOHTvGwoULWbt2Lc8++yx9+vRh69at/Pe//2XcuHEMHDiQ5cuXR10F4KxZs7zMcwVVCYCWjAyshw4B4Bg0KCxjqw6+FSwFBQVkDx1Ks40bPYElBQWQmFhLo1OEkuLiYvk4Nja2wuXEe6LKNVBmz57N0aNHGT16dI0rkAsKCqTg4o/CwsIaCYyapkVlQlq0ntOj8XiF41iZRe8WLVp47bOoiDX/2+nWrVu541LdY5WcnCwFwPz8fHJyckLWbgXR+d2Kxu8VROexgug9XgpFtCOq9WpcAZiUJB9bolUA9NnXZcuWyfcGDx7MyJEj/X5u2LBhjBo1iiVLlvDBBx/w8OOP0wkYBcwCfvjhB9xud9T+PirqFvVeAIyU75Ki4WD/8Uc0I81p69lnSwHQYrHgdrtJTU0NSTKhmdJx49D/8he0khLiPvuM/GqE1gCMGDGClStX8re//Y3PPvuMrKwsbrnlFkaOHImmaRQXF/PnP/+ZQYMGsXz5ctLS0sjPzyfJdNKtLfLy8nj22WfLvd6yZcsqW8FsJiHTESX+fwAdOnQo99q+Tp1oBmgOB/a1a3GMGBH5gSnqFAcPHmTevHk0adKE3wUQFFQViYmJNG/evML3ExISquVvYrFYpG+neUa8ttE0Tf5+R1vlUbQdr3AeK7Po3KRJE/kdc7vd0itVHIc2bdoQFxcnl6npsWrcuDFHjhyRz3fv3s25IfBgjcbvVjR+ryA6jxVUfryUIKhQVE2oWoCx2dDj49GKiqK3BVjsq1EBuHjxYvneAw88UOlnH374YZYsWUJxcTGvrV7Nf4HL8QiA2dnZbN++nT59+oRn4IoGRb0XAIPxXTp8+HC1fJdqyrZt27jjjjvIysoiJiaGVq1aMWDAAMaMGaPaDaKQmK++8jxISGCriHvHE+ZSXFxMagAhHcGiJydTevnlxH75pWf7//432O3VWlfjxo155ZVXGDt2LA899BBZWVksXbpUpiUtX76coUOHAp6brQ0bNnDRRReFcG+qx8svv0xWVpZ8Li7IL7jggioFV/t6T1aznpCAq0cPouWSPT4+nkaNGsnKE4D9jRszKDYWraQE+48/KgGwnmBu+SgpKakw+KmkpATwfDcCwe12M3PmTJxOJ1OmTCExBBWjkydPrjRxLjs7u1rpjU2aNMFqteJ2u6ud/hgOrFYrTZo0ISfEpuI1JRqPVziPlfn6y2KxyH3OyMigtLQUQCbrdejQweuY1PRY+f672bZtW0g8BqPxuxWN3yuIzmMFlR+vUHd7KBT1EV9fvJqgJyV5BMBorQAU+5qUxKlTp8jIyAA8vxUjqrie79u3L8OHD2flypX8b+VKnsFTAShYunSpEgAVIaHe15GG23cpFGRnZ5OZmUlcXBzFxcXs3buXzz77jHvuucfLOFQRBbhcxH79tefx6NFsS0uTb4kbFH9VXaGgxPDis5w6hf3HH2u8viuuuIIff/yRsWPHAnhFln/66aeyzDwa2oDT09N5/fXXAWQ1ohD2zz///Co/LwJAHAMGQIAen5HCNzhoX3o6DBkCQIwKAqk3mM8/5vOSL+K9QCd/li1bxq+//kqPHj0YNGgQRUVFXv+JwARd18u9plBEEyIEJCkpyavV1ywMimVC6bMLnhZgM/v37w/p+hUKhaKhElIB0FhH1AqApgrAL774Qr5+1VVXBdQddssttwCQlZPDXKA50Ne4r1y5cmXIx6tomETXnXAYCLfvUk3o2LEjXbp04dxzz+WMM87AYrFQWFjIunXreP/99zl58iTTp0/n+eefp3UVqaWhMG2PRqPjqDOF/vFHLEYVWv7o0ew1/biL1pCePXuG5/hNnIh+zz1oBQU0+uYb9AkTvN6uzrFq0qQJ8+bNY+bMmTzyyCNSGNi3bx9t2rQhPT2dTZs21Wh/avq90nWdKVOmUFxcLNuUzYwdO7by9RYVYdm+HQDbBRfQpEmTqPpede/end27d8vn+/btg5EjYflybDt20MTlglqsMoimYyWIxt+qqmjTpo2sWj106BBt2rTxu9whw6uybdu2Aa33uGFHkJaWxnXXXVfhcllZWfL9qVOnMm7cuGCGr1CEHSF+n3HGGV6vmwXAnJwcIHQJwIJGPjemBw4cCOn6FQqFokHidofMAxDKfACjsgXY5cJSUAB49vWzzz6Tb919990BreLyyy+nZcuWZGRk8BpwPTC8c2e27NvHxo0bKS4uLhciolAES70XAKOZK6+8stxrCQkJXHTRRXTv3p0HHniA/Px8PvnkEx6uIg00lKbt0Wh0HDWmp19+6fl/TAzb27b1K4h06dIlPMcvKQmuugo++QTL/Pnw+usQE1NuseocqwceeICBAwdy7bXXynJ1Ebbx888/43a7sVez5VhQ3e/V559/zsKFCwEYP36814xax44dq6643L4dDGHTMmQImMYQDd+r/v37M3/+fPl8//79aLfdBo89BoB1xQqYNKmWRldGNBwrX6Lxt6oi4uPj6dy5M7t372bTpk2yzd5Mdna2FDtUm4eioSEEQN9uDSGKmwm3AKgqABUKhaLmaAUFaMa9UigEQHcUVwCaRUlHYiLbjeKDlJQU2rVrF9A6bDYbkydP5rnnnmMlcAC4oG1bXsZjEbNx40aGDRsW8rErGhb1XgAMl+9SuGnevDljxoxh9uzZbNiwocrkn1CYtkejMXRUmULrOpa5c9EA/dJL2WKEy/jSoUOH8PnXTJyI9ZNP4NQpXN9+C1dcId+q6bEaMmQI69ev56KLLmLv3r3yO1BQUMCmTZsYOHBgtYZck+9VdnY29957L+Bplb3gggu8BMCLL764ymOtrV0rvQ5c/fuDyxVV36sBAwZ4Pd+3bx96//6QnIyWm4t76dJy1Z6RJJqOlaCmv1W1JRpedNFF7N69m5UrV3LdddeVS6WfO3cuuq7TtGlTevXqFdA6b7zxxkqru2fNmsWnn35K8+bNefvtt2s0foUinIj2Xl8BMD09HfD4154+fRoIvQDo2wKsKgAVCoWi5piFOt3nd7Y6yBbgKKwANO/rjxkZsquqohDSipg4cSLPPfccAJ8Cv2/eXF6H//TTT0oAVNSYei8A+vouVSQABuu7FAm6dOkCeKr38vLySElJqXDZUJi2R6MxdDSZQtu2bKGxUYmgX301W430XzOJiYnY7fbwHb9Bg2iamIiloADHxx97pQGH4ljFxcXx3XffMWDAAK99+OSTT6rtuVTd75Wu6/z+97+XLY7/+te/WL58udcygwYNqnKdSatXEwe42rblVEwMnDoVVd8r3/b+w4cPU+JyoQ0bRuzXX6N/912t/nuMpmMlqOlvVW0Zt48aNYoFCxaQkZHBP/7xDx588EFSU1MpKSlh4cKFLFq0CPD8ntt8vCpvvfVWMjMzueSSS6pMklMo6iIVtQCLCsCEhAROnz5NXFxchS301cU36f748eMUFBSEJFRHoVAoGiqayV+8vnsAmvf1Q8N7HPx3/FVGx44d6devH5s3b2YWcF9pKX369GHz5s389NNPoRquogETfT1dIUb4LoH/NhJBsL5LioaHSP/VrVb0K6/0CmgRlaOpqakBmbxWm7g4So2qv5jFi8EIHgkljRo14t133/V67dVXX2Xt2rUh31ZlvPnmm3z77bcAXH/99YwePZotW7Z4LRPILJh90yYAnH37hnqIIaFVq1Ze1b0ul4vDhw/jMPbNeuAAlmPHamt4ihBit9t57LHHSElJ4cCBA9x///1cf/31XHfddXz44Yfous7YsWMZOXJkbQ9VoYg4FbUAi7Z4cW7t0KFDyC0JfFuAAQ4ePBjSbSgUCkVDwyzUuX0mWqpDNHsAin11A0tN94jVqdgbP348ANuBtAMH5DqED6BCURPqvQAofJcANhlCgC/R6rskggHi4+P9XpwqIkuMUZ3jGDoUd9Om0tsByvzRwpUAbKbUMO+35OZiD1NK7Pnnn8+FF14onzscDiZOnMiXwgMxzKxcuZInnngC8LR6PfPMMxQXF7Njxw65zDnnnFNp2zuAdvo01n37AHAGWYIfKfwFWezfvx+HySPOvnp1pIelCBPt2rVjxowZjBs3jlatWuFwOEhMTKRPnz789a9/5fbbb6/tISoUEcftdvsVAHVdly3A4qYn1AnAUL4FGFQbsEKhUNSUkLcACwEwiisANwCnjTCQxMREUlNTg17X1VdfjSgn+fKXX6RvtPABVChqQr1vAYbw+C7VFF3XK60Uy8rKYvHixQAMHDgwKg34GxKWffuw/fYbAKVXXEH63r0UGD/uUHZjUp0f+WApvegi3EYbcOzixTguvTQs2/nLX/7CCpPAWFJSwm233cbRo0e58847w1bp+NtvvzFlyhScTicJCQm8/fbbJCUlsX79ehwOh1zu4osvrnJdNlPFoLNfv3AMNyScddZZ0v8KPAJg/6uvxp2SgiUnB9uaNZTUog+gIrQ0btyYqVOnMnXq1IA/U13/vqo8AhWKaCAnJ0f6eZpbgLOysuT5NVwJwOC/AlAJgAqFQlEzvATAULcA6zqEs+sqSERV4jzTawMHDqzW/VLLli0ZkpDA6sJCFh46xNTzzpM+gKtXr1Y+gIoa0SBUpVGjRtGyZUuKi4v5xz/+IdPdSkpKmDNnTpW+S1dddRUvvvii33UXFBSQm5sr/xMXsCUlJV6vi5ARwfLly3nmmWdYu3YtuSbPgKKiIlasWMGjjz5KXl4e8fHx3HDDDaE6FIpqEvPdd/Jx6aWXsnPnTq/3hTdaJARA4uJwjBjhGdeSJRAmX7YBAwZwnsljMD4+Hl3XmTZtGn/729/C4gd34MABJkyYQE5ODpqm8frrr9OjRw+AcjNel1xySZXrsxlVv7qm4Yyi6l5ffG9o9+3bB1YrzsGDAVUBqFAo6jei+g+8KwDN1i3CUD1SAqBKAlYoFIqaEXIPQFEB6HZDYWGN1xdKLMa+Lja95hv0FwxjW7QAYFtuLidPnqR3794ArFb3BIoa0iAqAIXv0t/+9jfpu5SQkEBxcbEU7Krru/TPf/7Tqy1RMG/ePObNK5sDuP76672qMNxuN2vWrGHNmjWAR1yx2WwUFBTIMaWkpPDII4+E3OxaETwxS5cC4OzcGffZZ7Pzm2/8LheJFmCAkjFjiF2wAEtWFrb163GahLpQ8uijj3LNNdcAHn/M4uJiDh06xFtvvcWRI0d49dVXQ2aSvnfvXiZOnMjRo0cBeOqpp7jClHK8wRS6Eh8f7yVOVoSoAHR17SovGqKRXr16ef1eiMoTx9ChxHz7LbY9e9CystB9qpcVCoWiPmCugDYLgP5EOFUBqFAoFHUDs1dfKCsAxbr1KApq0vLyOA5sM71Wk87Cq9q146/GOfDrr79m8ODBbNmyhU2bNuF0OssVLSkUgdIgKgAh+nyXevXqxeTJkxkwYAAtW7ZE0zQKCwtJTEyke/fu/P73v+fVV1+Var+iFsnPlxVYDkMk9q0AFESkAtAYh263AxDz9ddh286wYcNo3Lgx4GnNnTdvHn2NMI3Fixdz2WWXVXgsgmHNmjVcccUV0uvpscce48477/RaxlwBOHToUOLi4qpcry3KA0AE5557rtfzfYZvoWPIEPma3ZgsUCgUivqGuQLQ3AIsfgvNNijhEAD9eQCqCkCFQqGoGRajBViPi4OYmBqvz1cAjCa03FyW+rxWEwGwY8uWdDcef/311/JeobCwMCT3XoqGS4OSjsPhuzR9+vRqjaV58+ZMmjSpWp9VRJaYH39EM9J2Sw2/vV27dsn3bTab9KtrYZRrhxs9ORnH+ecTs2wZsYsXU2gEZoQaTdMYPXo0s2bNwu12M3/+fObPn8+dd97JN998w+7duxk1ahSPPfYYU6dODXo2yuVy8fLLL/Pss8/K9q4nnniCu+++22u5jIwMKQ5CYO2/lmPHsB4/DkRvAIige/fuXs9F5Ymzd2/0hAS0wkLsq1dTetVVtTA6hUKhCC9VVQAmJSWRm5tLs2bN/Ip1NSXJT4V4eno6DocDuzHZplAoFIrgEC3Aoaj+812PJS8Pd0jWGhq0vDy+NT1PSUmhXbt21V6f3qgRVwM7gbVr1/LMM8/I99avX6+KhBTVpsFUACoU1UX4/7mTknAMHozL5eKXX36R7yckJACe6r9wBWP4o3T0aACsBw5gNQmSoeYPf/iDfPz6668TFxfHBx98wJNPPonNZqO4uJjHHnuMSy+9lJUrV6LrekDrXb16NaNGjWL69Ok4nU7i4uJ45513yol/UD7Be4ThgVgZNtNnojkABDzVJ2bxNDs7m/z8fLDZcAwaBIB97draGp5CoVCEFXMFoDkVXVQAit/HcFT/gf8WYJfLxeHDh8OyPYVCoWgIiBCQkAmApsmaaKsAJCfHSwDs2bNnQPeF6enpPPXUU0yaNIk77riDhQsX4na70ZOTudJYxu128+uvv0pbsPXr14d+/IoGgxIAFYrK0HXshv+f48ILISaGgwcPylRCM5Fq/xWUXH65fByzeHElS9aM3r17ExsbC3gSGb/55hssFgt33XUXixYt4pxzzgFgx44dTJgwgVGjRvHuu+9y9OjRcmJgRkYGs2bNYvTo0YwbN46tW7cC0KNHD5YuXcpVFVS4mf3/2rZtG5DXom3zZgD0mBicPhV20YhotRYcPHgQ8PgAAlh37kQ7dSrSw1IoFIqwIwTAxo0be02GmEPbIHwCoPBh9kW1ASsUCkX1EQKgOwwVgOaE4Whg57FjZJieB9L++9FHH3HeeecxY8YMli1bxty5c5kyZQrXXnst2VYr5wJiSuz777+XbcBKAFTUBCUAKhSVYE1Lw3rsGFDW/rt7926vZYqKioDIC4B6y5Y4Bg4EIDaMAqDVavUK3HjjjTfk4/79+/PDDz/w+OOPywqKzZs38+ijj9KnTx+6d+9O//796d+/P61bt6ZXr17cf//98sSVlJTE3//+d5YsWULXrl0rHIP5RDdixIiAZtSEAOjs2TMkviPhpmXLll7PpQBo+ABquq6qABUKRb1EtACb239PnjzJ6dOnASgoKADCJwBqmqaCQBQKhSLEhLwCMIoFwKUmqyKoWgD89NNP+cMf/kBJSQmaptG3b1/OPPNMAFauXMmYjz6iALjMWP6HH35goHHfd+jQITIyMvyvWKGoAiUAKhSVINp/AUqNttNff/3VaxmHwwFQI5+H6iLagG3bt2M5dChs2xlqVKGBJ7Bj+/bt8rndbueee+5hy5YtPPbYY17VednZ2Wzbto3Nmzdz3PDjA2jdujX/93//x/r167nvvvtkhaE/SkpKvAJAAvH/w+0uEwCjvP1X4FvVKARAZ79+HvNkVBCIQqGon4gKQHMASKQSgAVKAFQoFIrQIgXAEHm3us0twFEmAK4wedlC5QLgtm3buOWWWwDPeW/RokV89913bNq0iRtuuAGAHceO8QdglPGZrKwsr3OkqgJUVJcGFQKiUARLzPffA0YYg1Gh5SsACtq2bRuxcQlKRo8m8amnALAvXgx9+oRlO+YKQIA333yTGTNmeL2WnJzM/fffz3333UdaWhobNmxg586dFBUV4XA4aNmyJS1btuT888+ne/fuXqmOlbFp0yYpslosFs4///wqP2Pdt08mj0V7AIigZ8+eLFiwQD4XAiCxsTgGDiRm1SpsRhq1QqFQ1CeEAGiuABT+f2Y6duwYtjH4EwBVC7BCoVBUHykA+glaqhaJieiahqbrUeUB6HK5WG1UqgPExcXRuXPnCpe94447KC4uxm638/7778vW3vj4eF566SUKCgpYsGAB84Chps8ePHiQhIQECgsLWb9+PVdeeaXfbSgUlaEEQIWiIvLzsRmVZ6UXXyxfrkgArI0KQHfHjji7dsX266/YFy2Cv/wlLNvp378/MTExlBppyHPnzuXvf/87zZs3L7espmn07NmTnj17Ah5Dd6vVisvl4lQ1POzWmKreBg8e7PcmzZe6FAAiEGX9AikAAs4hQzwC4PbtaHl5IWulUCgUimjAXwuwEN8sFgtutxu73U779u3DNgZVAahQKBShJdQpwGgaelISWl5eVFUA/vLLL+S4yzKJu3Xr5tdXFmDWrFmyeu+xxx4rV2ShaRovvfQSO9avZ9+xY0wHurVrx65Dh1ixYgX9+vXjp59+Yt26dWHbH0X9RrUAKxQVYP/5ZzSnEwDH8OGAJ4Vpz549cpkk04yWSGaKNLINeM0ayM4Oyzbi4uLo27dv2TZLS/nwww/Dsi1fvjeqMAHGjBkT0GdE+6+7USNcYawYCSUDBgzwen7I1NLtMC4ONLdbitIKhUJRX/DXAiwqABMSEgA4++yzK7yhCgX+BMCDBw/iNt3UKRQKhSJwQu0BaF5XNAmAa308unv06OF3OYfDwfPPPw9A586defjhh/0ul5SUxHOPPALAKcBueJ+vW7eOPka317Zt26QPvUIRDEoAVCgqwL5qFeBJkXUYpdmHDh3y+rEVAmDz5s2Jj4+P/CApEwA1txu++ips2xEzVCKA491335XJjOHC4XCwZcsW+XzUqFEVL2xC+v/17QsBthrXNgkJCdjtdvn80KFD8sbT0b8/utUKgF3N+CkUinqE0+mUYR/+KgDFOSec/n9QJgCa7SmKi4uV0bpCoVBUB5cLi9EWGyoPQChrJ46mFuCffTy6Kwo2/Pzzz0k3wkIef/zxSj3QL7z4YsYbj3cePgx4zpfiMw6Hg61bt9Zw5IqGSN24M1YoagH7jz8CeMQ/Q9zzTQC2GqJMbbT/Cpx9+uBq1crz5Msvw7YdIQDqug54zGi/DOP2wDO7JdqOW7duzdlnn131h0pLsRkhJXWl/VeQkpIiHxcXF5OZmel5kpSEy5hNtCkBUKFQ1CPM1hBCANR1XVYAikm3cAuAycYNqq8/rfIBVCgUiuDRTJ54YakAjBIBUNf1chWA/gRAt9vNSy+9BHj8bK+77rrK15uczFOABjjdblkBbw5V3LBhQ80Gr2iQKAFQofCDdvo0tm3bAHBccIF83df/T4hTtREAItE0Si+/3PN4yRIoLAzLZgYPHiwrMcSN0htvvCEFwXBQnfZf665daMbfpa4JgGeddZbXc7MPoKhCtW3YAEZrukKhUNR1RPsvlLUAHz9+XFYFOo3fu3AGgEBZBaDvOU35ACoUCkXwCP8/8Ih2+fn5rFq1imXLlsnf9+oQbS3Ahw8f5phJlAP/AuDKlSvlxNbDDz9cpaWFnphID+B647nL5QI86b/ifKgEQEV1UAKgQuEH++rVaMZNgMOUOvvLL794LZeTkwPUsgBIWRswRUXYly8PyzaSk5Pp3bs34An2AE+Fnu+sVygxp+KOHz++kiXLsJsDQOpIArCgQ4cOXs+9BMDBgwGwFBRg3bUrouNSKBSKcCECQKCsAtBf2Fa4KwCFpYe4yRITXqoCUKFQKIJH+v8Br69ZQ9++fbnmmmuYNGkSffr04YUXXqiWx6psAY4SAdD3Pig5Pp5WojPLhPBOb9SoETfeeGPVK7ZacSclIeIdxeTUnj17pMfghg0bwlqIoaifKAFQofCDaP/VExK8qsjMASBQVgFYmy3AAI6hQ3EbVXn2RYvCtp3hRhjK0aNHpTH7G2+8EZZtFRQUyOMdHx9PvwCr+YT/n6tFC9x+TsDRjBBYBeYgEOegQfKx8gFUKBT1BX8VgL6TbeAxTA8nyT4eVUIAVBWACoVCETxaXh468Cfgzx98IIsmAAoLC5k+fTr3339/0AJWtAmAP//8MwCinq9r+/by/CHIysrim2++AWDixIkkJiYGtG69USN6ARf63M8I3/njx49z5MiR6g9e0SBRAqBC4QcRAOI47zyIiQE8My979+71u3xtC4DExOC47DIA7EuWhK1F9AKjHdrhcMjHX3/9tVelWqhYuXKlnBkcOnRoOV+mipABIP36gc8JONoZbFT5Ccw3nu7WrXG1bg0oH0CFQlF/MAuAvhWA4ianadOmXgEh4cA3BVicf5QAqFAoFMGj5ebyOvCi8Tw1NZWPPvqITz/9lO7duwPw6aef8vLLLwe13mjzABQVgEIA7OLHrmLOnDk4HA4AJk+eHPC6RXjK3T4dQmbv3PXr1wczXIVCCYAKhS9aZiY2o/rA7P+XnZ1NrsnPwpz6W+sCIOC44goALCdPhk0gGjx4MDGGINqsWTM0TcPtdvP222+HfFsff/yxfHzTTTcF9BktPx+rceNY1/z/AIYNG+b13FwBCGVVgKoCUKFQ1BdEC7DFYpFBSKICMC4uDgi//x+UFwAF+/fvVy1WCoVCEST79u7lYeNx+9at+eqrrxg1ahQjRoxg4cKF0ifv3//+d7mQxcoQAqAlCioAT5w4IcdebLx2Trdu5ZYToYndu3cv1+1TGWJfxyQleQUhbtu2TXZiKR9ARbAoAVCh8MH+00/ysdn/z7f6z1yN0NqozKpNHCNGyGrF2K+/Dss2EhISONcIo9i6dSuXGVWHH330EXkhPhGvXr0a8CQtX3rppQF9xrp1q/RurIsCYFJSkpcpsG9lpcMQAK3p6ViOHo3o2BQKhSIciArApk2bYrFY0HVdVgAKm41w+/9BxQJgbm6uV7WFQqFQKKrmkf/9j0I8YsMbL7xA8+bN5XvJycm89dZb2Gw2HA4HDz/8cMATLbICsLAQDM/W2mKdnwn5Lj17ej0/dOgQGzduBGDcuHFBrV+0O9vy872KITIyMjjnnHMA5LoVikBRAqBC4YNo/3UnJ+Ps1Uu+7isAisqEFi1ayMe1SnIyjBgBQMzXX0OYKhaED+COHTu44YYbAMjPz+eTTz4J2Tb27dsnBcWePXsGfHztRvsvgLNv35CNJ5KYfaiOHTtGSUmJfC6SgAFshueIQqFQ1GXMAiB4bmxEtX1BQQGAvNEJJ74egGZUG7BCoVAEzqpVq/jemMi5HxhgKqgQdOvWjXvuuQeANWvWsHTp0oDWLUQxAM04R9QW0v/PZFPUxafCb+HChfJx0AKgcV6y5OZy3XXXedkhiYr5bdu2UVxc7PfzCoU/lACoUPgQYwSAOIYNA6tVvu4rAIqZqmho/5VcfTUA1oMHw5YUKwRAXddxOp0yieqtt96S6Yk15ZVXXpGPhcgYCDIAJDUV3Ugqrmu0bNlSPtZ1nfT0dPnc1aMHulHyb1eeHwqFoh4gWoCFAOgvAES0ioWTJNNNpS8qCVgRreTk5PDOO+9wxx13MHHiRG666SamTZtWLpm0pnz55ZdcddVVXHXVVdx6660hXbei/vHMM88AkAL8LT4e7Ha/y9133300btwYgCeffDKgKkDdVK1d20Eg4t9ZC8MWKglo3aaN1zKi/bdXr15B21nIase8PFq1asVFF10k3xOhKg6Hg23btlVn+IoGihIAFQoTlvR0rMaFvsNntmrfvn1ez4uKioAoEwCvvFI+jAlTG3Dfvn1lq9SPP/7I7bffDngqJL799tuQbONrY+yapgXs/wdlAqCjf/+QjKM28L048Ko8sdlwDBzoeah8ABUKRT1AVACKBGDR/msmEhWA5hZgUXWukoAV0cyhQ4e45557+PLLLzl27BhWq5WCggK2bNnC9OnTeeutt0KynczMTC9fZoWiMjZt2iRbY/8ENKnAXgE8v7t33nkn4BHTAhGu3VEiABYWFrJ161YAYo3KvG52u1cC8KFDh9hs3JsEW/0HZRWAYj/NRRG7TIUeqg1YEQxKAFQoTIj2X/AOAIHyFYCiaqFt27bhH1igtGqF0xCIYhcvDssmbDabDKtYtmwZ11xzDWeeeSYAb7zxRo3Xf/ToUbKysgDo0qVLwO2/WlYW1sOHgbrp/yfo6cc7xIwIArHt2AFRkoCmUCgU1cW3BVhUACYmJgKeyryzzjor7OMwtwCLakBhsu47AahQ1DYOh4Onn36anJwc2rdvz0svvcTs2bOZPXs2kydPRtM0Fi5cGHBbZWW89tprFBcXR6QSV1H3EcJznNXKH/EW7PwxZcoUea1v7gCqCK8W4FoUADdv3ozT6QQg3/Cr7WacMwTfffedfDx27Nigt+E2VQACXH755fK8VFRUJM+NKglYEQxKAFQoTNiN9l/3mWfiMlUcuFyuci1Awpw8qioAgdIxYwCwbduGxdQ+GkpGjhwJeMSpgwcP8oc//AGAn376qcazUDNmzJCPb7zxxoA/ZzP7/9VhAfC8887zel5REIjmcnl5HioUCkVdJDs7GygTAEUFYGxsLOBp/zVXVISL2NhY7EabmrjBEqn3qgJQEW0sWbKEjIwMYmNjmTZtGqmpqYDnezxp0iSuuOIKwBPSJkSK6rBixQo2btzI0KFD6VeHr60UkSEjI0O2vF5/1lk0w7tl1x9NmjRh/PjxAHz++eeyCKAivATAWpwIF9WKmqaRafh1d/fxkhUCYGpqarXS7GULcGkplJQQFxfHlaZuL9E+rSoAFcGgBECFQqDrsgLQcf75YLrhOHLkiFcYg7gpgCirAAQco0fLxzHffBOWbZhTeb/99lumTJkib5iee+65Gq1bXDhomiaFxUCwb9kCgG61eoW31DV8BUDfG0/nwIHoxndTtQErFIq6THFxsQz6OOOMM/wmAHfp0iUiY9E0TbYBC/FR+FEpAVARbSxfvhzw+DI3a9as3PsTJkxA0zROnjzJ9u3bq7WNvLw83n77beLj47nttttqMlxFA+Hzzz/H4XAAcI+R+qtXErAkuOWWWwDP7/7s2bMrXTZaPACFANihQwf52jnGRBZ4WoR/+uknwPu+KRi89tUIxzIXR4hutKNHj3L06NFqbUPR8FACoEJhYNm3D6vx41laRfuv+WIr2gRAd+fOODt1AsLnA3jWWWfJVtUlS5bQrFkzKdYtXbqULYYYFyw7d+6UM3/du3eXomIg2DZtAsDVrRsYZrx1kWbNmnmlfPm2AOuNGuHq3h0Au0oCVigUdZhTp07Jx02bNuXo0aMyAT7fqOyIhP+fQLQBi0pAkayYmZkpx6NQ1DZFRUXs2bMHgP4VeB43a9aMNkYYgfApC5Z3332XnJwcbrrpJunRqVBUhK7rfPbZZ4DHL7y3MYFSVQUgQJ8+fejWrRsAs2bNqnw7USAAOp1O2XbbunVr+fo5LVrIx6tWrZLnkGoLgCbxVOzreeedJ++PMjMz5fuqDVgRKEoAVCgMYsz+fz4BIL4CoKgS0DRNXmBFE6VG64f9p5/QTp8OyzYuu+wyADZs2MCJEye46667pIfHf//732qtc/r06fLxPffcE/gHdb1eBICAdxUKlG8BhrI2YNvGjeB2R2xsCoVCEUpE9QJ4BEB/ASCR9B0T3n9iEkbcvIH/32KFojZIT0+X1ant27evcDnx3mHDHzkYtm/fzvfff0/Hjh0ZY1jLKBSVsX37dunheu2118qKNb2ShHWBpmky4GLdunWV+q5GgwdgWlqarF6PN4oOEoE2JgFQtP8mJCQwZMiQam3Hn9hpsVi48MILPe/ruuxKU23AikCx1fYAFIpoQbT/ulq3xm14qQiEAKhpGrquy+qAs846S7YKRROlo0eTMGMGmstFzNKllEycGPJtXHbZZTz//PO43W6+//57Jk2axM0338wbb7zBN998w9atW+nTp0/A63O5XLKlJTY2VvqBBILl0CEshpF8Xfb/EzRv3pycnBwAcnNzOX36tPT5AHCeey689x6W3Fysu3d7+VUqFApFXUEEgICnBfhnP1XNkRQAG1VSqXLgwAF69OgRsbEoFBVh/nfT1NRy6It4z1xpGwilpaW88sorWCwW7rrrLqxWa7XG+dFHH1VazXXDDTcE5fUsEAK9xWKhSZMm1RpbdRBepCkpKVKADTe1sa/V3U9h4WO1WrnllluwzpwJQEzz5gGN/aabbmLatGkALF68mL///e/+F9R1dLsdzeEgweUivgbHpbr7um3bNvlYeGx2A+KbNyeuSRN0Xef7778HPL7pLVu29Pp8wH9XU3Vhsq6DsexDDz3E10aXV1JSEidPnmTz5s2VrquhfH+hYe1rdVACYAMh2JN3dU/2oUaMI+zjMfn/OS+4AKvN+5+GmIkSPyLC36J9+/ZReaxc556Lu0ULLMePE/v11zivuy7k2xs4cCDNmzcnMzOTRYsWccMNN3D//ffzwQcfUFxczLRp01i4cKHfMfrjww8/lD6Ll1xyiRRZA8FuajnWBw6s8m8Sse9VNUlNTZXtPeCZvTe337hNPoExGzZQGsab0mg/VtE6LoVCUTW+FYDmBOCCggKSkpK82qvCjRAA/YUm+AaBKRS1hbkytbJJaPFeUVFRUOufPXs2R48eZfTo0XTu3Ll6gwQKCgq8WhR9KSwsrNE5XNO0WrkGMNu0RIra2Ndg9lPXdebOnQvAqFGjaNWqFRgVgJaUFAhg7B06dGDIkCGsWbOG+fPn88QTT1S8cHIynDiBJT8/oHVXRbB/09WrVwOeMYt7xO6ApXFjsFpJS0uTlbdjx46t8G9X5d/VJCRZTft6ySWXEBsbS0lJibSnEKnEVRWmNJTvLzSsfQ0GJQA2EIJRoq1Wa9Qp18kBGMjWiB07wEgijL38cmJ99t/3wl/82KampkbvsRo3Dt58k5jvvycmPh6M9txQMmnSJGbOnMnSpUvRNI1u3brx8MMP8/TTT7N69Wq+//57rr32WqDy75Wu6zz//PPy+bPPPhvccd250/P/xESShwwJ+GIg7N+ratKrVy++/fZb+fzEiRPex6NxY2jRAo4fJ3HrVhIj8B2MxmMVjb9VCoUicHwrAM0JwAUFBRFLABaI3zkRQAKelMXTp0+rIBBFg+DgwYPMmzePJk2a8Lvf/a5G60pMTKS5EQThj4SEBFwuV9DrtVgssiPHHUEbFE3TsFgsuN3uiFYVRXpfq7Of69evJz09HYDx48fjKinBarTIupOS0AP4O1ssFq655hrWrFnD1q1b2bdvX4Ut7pbkZLQTJ3Dn5AS07oqozr7qus6PP/4IwODBg/n0008BjwDobtQI3eWS1X8AI0aMKPc9D/jvmpSEuKNxnz7tta8DBw7kp59+kuerkpISNm7cyODBg0O2rzVF/VsNnEiKhkoAbCAEUv6fnJzsqR5zucg1Zm1qG6vVSnJyMrm5udW6SAiU2K++QsRNnO7fH910vEpKSspd+IsZzXbt2gXdWhEufI+VbcQIGr35JhQUkPfllzgNz75QMnr0aGbOnElpaSkff/wxN954I3fccQfvvPMOx44d46GHHuKyyy4jJSWl0u/V0qVLOXLkCOA5pq1btw7quCatXo0dcPTpQ34A391Ifa+CRfwbHDBggNfraWlpjBgxwuu1xHPPJearr3CtWkVuGL+D0XisavpbpURDhSI6EAKg3W4nMTGx1hKABaIC0FxhlZKSogRARVQRZ5rQLSkpqTAwTXRVxAcYjOZ2u5k5cyZOp5MpU6aQmJhYo3FOnjyZyZMnV/h+dnZ2ta6hmzRpgtVqxe12R/QaXEw65uTkROx6qDb2tTr7KUQwi8XC+eefz+nDhxF9KwV2OyUBjL1JkyZcddVV/PnPfwY8icJTp071u2zjhARsQOmJE+TX4LhUZ1/37dvH8ePHAWjVqpUUmHoABVYrJadOyUn89u3bk5ycXO5vF/Df1eXiTONh4bFjFJuWve6662TKsOCHH36o8LzZUL6/UDf39cwzz6x6oRChBMAGQrBf/mi50Re4XK6wjsm6cqVnO6mpOFu1AtO29u7d6zV7YLFY5M1Jampq1B4r17BhJCYmYikowL5oESU+AlIoGDBgAK1bt+bIkSN88cUXXHfddcTFxTFt2jT++Mc/cvjwYR555BHefPNNOTZ/4/3Tn/4kn//pT38K7pg6ndiMhDtHv35BfTbc36vq4pvqt3///nLjdAwcSMxXX2H97TfcmZnoYU7oi9ZjFY1jUigUgSFagEUCsKiur40EYCgTAPPy8mjUqBF5eXlSXFEtwIpowez7d/LkyQoFQCGwBzrptWzZMn799Vd69OjBoEGDyrUOi9Z4Xdfle3a7HZtN3U42dBYvXgzAkCFDOOOMM9BMwTOBpAALunbtSufOndmzZw/ffPNNhQKgCAKx1EIIyNq1a+Vjs0jeHU9qr9vtZs2aNQAMGzasZhtLSEC3WtFcrnKBJxMmTOD+++9H13U5Ka6CQBSBoFKAFQqXC7sxg1J6wQXl3vZNADa3M1SWvlbrxMbiMES/mG++8RI1Q4XFYuHqq68GYOXKlWQbbdQTJkyQkfdvvfUW8+bNq3Adb775pmwbSExMlC3DgWL95Rc040K0PgSAQPnvld8k4IED5WObOuErFIo6iBAozjjjDOn/ZybSFYCiBTg/P1+e60VbTnp6uldrsEJRW7Rp00a2xh86dKjC5cR7bdu2DWi9oqopLS2N6667rtx/c+bMASArK0u+tmjRoprsiqIesGfPHulbPXr0aACZAAyBpQCbGTt2LAA//fQTeRUIfEJUrI0UYBFWdcYZZ8jAvnjgbGNcu3btkue2GguAmlbhvsbExHD22WcDZZPhGzZsqNn2FA0CJQAqGjy27duxGCcqx/nnl3vfVwA0z6SKH95opdQ4EVuyssImEl1zzTWA5+Qze/ZswOO98MILL8jgismTJ/tNd9y0aRNPPfWUfH7rrbfKOPtAsW3eLB87fSrn6ip2u91rRt+fAOjs0wfdCEqxr1sXsbEpFApFqBA3SU2bNpXtv2YiXQEoBEBd12nWrBlQdmPldrulqbtCUZvEx8fLcI5Nmzb5XSY7O1t+X/v06ROxsSkaHiKNFkwCoEms0oP0kL7yyisBT+DiDz/84HeZ2hQARQXg4MGD2b17N+BJALYA7uRkr7bcGguAlB0/f/s6ZswYr+fp6elkZGTUeJuK+o0SABUNHrth5Arg8PNDLQRAkSQkvFc0TQt4VrW2KB05Et1ozYgxnaBDSe/evenduzcA77//vjQ+bdGiBW+99RY2m43CwkIuu+wy5s+fL9upV61axfXXXy9bSmw2W4Wl/pVhNy5+3c2a4W7TJhS7FBWYvSAOHz5cvtU1Lg6ncVFvX78+kkNTKBSKkGBuARYVgElGtUhiYmJEE4DBO+xITPYVFhbK11QbsCJauOiiiwBP90VWVla59+fOnYuu6zRt2pRevXoFtM4bb7yRBQsWVPjf9ddfD3g6YcRr48aNC9k+KeomQqTr0aMHbYzrcC8BMIgWYIChQ4eSkpICwIoVK/wuI6oKNSNoJFIcP35cpv6ed955cuKqu2lcIiH47LPPDsk5TBw/ix/Pa39dU6oKUFEVSgBUNHiEAOjs1g3dT1qZEACFsCWEwNatWwddrRZp9JQUWdUYu3gxhCEJSdM0/vCHPwBw4MABr5P1BRdcwPvvv4/NZqOgoIDbbruN8847j4svvphrrrnGyyT1+uuvp1WrVkFv32YIgM5+/SCCaZHhpl27dvKx0+nk2LFj5ZZxnnsuYFRBOhwRG5tCoVCEAnMLsKikEOfVSCcAQ5kHICBvQM3nKRUEoogWRo0aRcuWLSkuLuYf//iHFKdLSkqYM2eObM2dPHlyOY++W2+9lauuuooXX3wx0sNW1DPy8/NZZ3ShXHLJJfL1mgiANpuN8417l5WGR7sv7lqqADT7//Xv31+eE4QA6DIJgOf76SqrDpVVO3br1q2cB6gSABVVoQRARcOmtBS70Zrqr/0XyrcAi3TA1NTU8I4tRJRefjkA1n37sBoeHaFm/PjxsnLi9ddf93rv+uuv5+uvv6Zly5aAJz1rx44dAPKi1GKxcM899wS/4fx8rEbViKOetP8KfL2v/PoAGgKgVlSELS0tIuNSKBSKUKDruldIgRAAhc9e165dIz4mcwWgMHfPzc2VYqASABXRgt1u57HHHiMlJYUDBw5w//33c/3113Pdddfx4Ycfous6Y8eOZeTIkbU9VEU9ZtWqVTiMCWizAGipQQswwPDhwwHPta+/yuvaagEWAmBiYiKxsbFeCcAAaUeOyEmjULT/gmlf/VQAappWbjtKAFRUhRIAFQ0a2+bNaEZ7jz8BMDc3t1xrhTB8jXb/P4EQAAFijJSuUJOYmMjvf/97wNMKsNnkywcwcuRIdu7cyfTp0xk7diyjRo3i5ptvlu2/EyZMoGPHjkFv17ZtG5pRmVlfAkAEffv29Xru1wfQEAABbKoNWKFQ1CEKCwvlhJrNZiuXAFzbAmB8fLx8LNq4VAuwIppo164dM2bMYNy4cbRq1QqHw0FiYiJ9+vThr3/9K7fffnttD1FRzxHtvwkJCQwaNEi+7lUBmJRESUkJ8+bN49577+Xyyy/n4osv5qabbmLmzJkcPXq03HovvPBC+dhfFaBsAS4thZKSkO1PVYh030GDBnkViHQH9JgYVpk8uUMlALqFB6BxbvRFeCYKtm7dqgKrFJWictsVDRr7qlUA6JqGY+jQcu8LnwczmZmZQN0RAN2tW+Po2xf7li3EfP01RQ88EJbt/PGPf+Sdd96hqKiI6dOn89lnn3m1byUnJ3Pbbbdx2223oeu6TA+Oi4vjb3/7W7W2aTcHgNQzAbB79+5ez/0JgO6WLXG1a4f10CHs69dTfNttkRqeQqFQ1AhR/QdllfVmalsANFt8CE9WVQGoiDYaN27M1KlTg/JQfvvtt6u1rRtvvJEbb7yxWp9V1E+WLVsGeNpdzb+ZQgB0xMfz9nvv8dxzz0nPV8GOHTv49ttveeaZZ7jtttv497//LSuvO3ToQJs2bUhPT2fFihXcfPPNXp81txVreXnosbFh2T8zp0+fZufOnQAMGTJE+tbGWa2kulzojRrJ9t8OHTpUy9bIH5VVAEJZtaSguLiYtLQ0+tWz+yJF6FAVgIoGjfT/690bvXHjcu/7tv+eeeaZclalrgiAAKVXXAF4AjMs6elh2Ubz5s255ZZbAFi+fDlfffVVhcu+99578iR55513VtskV/j/uVJT0U3pzPUB3+/XoUOH/C7nGDgQUBWACoWibmEWAEVlvZlIJwCDtwBotVrlY+ENePDgQekHrFAoFA2Zffv2yUkRc/sveMSqA8Awh4O//OUvUvw788wzGTlyJFdeeSXdunUDPLYPr7zyCsOGDWPbtm3885//ZPz48TKAadmyZbLNWOAlAFYgjIWadevWyZbfIUOGSNuKrsnJWAGnyf8vVNV/UHW7c+vWrb18w0G1ASsqRwmAioZLUZFMT3VccIHfRYQAKCrZmptCQuqUAHjVVfJxzMKFYdvOQw89RIsWLQB49NFH/QZXbNmyhSeeeAKAjh078uCDD1Z7ezajArC++f+Bx4DePJvqrwIQytqArenpWPy0USgUCkU0Yq4Gyc7OBpBm5rWRAAyeBGJxvjdXsMfFxQGegAV/5zWFQqFoaIjqP4CLL77Y670Vv/1Gf2C9YfXTtWtXPvjgA7Zv384nn3zCu+++y8qVK1m2bJkMy9i6dSt9+/bl8ccfZ9WqVXKSKD8/n9GjR3u1Cpt9BSPlAyjaf2NjY+nXr59MAD7HOG9ttdvlZFaoAkDARwCsIMzR1+tTCYCKylACoKLBYl+/3uMdQdUBIKISwFwdUFdCQABcnTrh7OGxqI398suwbSc5OZlnnnkGgKysLH73u995VXmkpaVx4403UlRUhM1mY+bMmeXSqwJFy8zEevgwUP/afwVNmzaVjytqPXMoH0CFQlEHMZ8bjhw5AnhurKB2EoDBE0iVZHhLFRcXy8e66aZLtQErFAqFJwAEPF6UHTp0kK9/8803jFu5EpGf/sADD7B8+XJGjx5dLpG6Z8+efPHFF7JiTvzW9uzZ00tU3LJlC1dccYW8LzNXAFoiJACKAJD+/fuj67r0hO1uTNYvM8ROgKF+bKWqixQA3W4oKPC7jNkzEeBnI+BSofCH8gBUNFhE+69us+EYPNjvMuJEI8IqREWWxWKhTZs2ERhl6Ci56ipsaWnYN27EcugQbp9y8VBx5ZVXctddd/Hqq6+ydetW+vfvz9SpUzlx4gRvv/229Hp6/vnnGWi0r1YH25Yt8rFzwICaDjsqadu2LRkZGYBHUC0sLCwnmLp69EBPSEArLMS+fj2l48bVxlAVDQhza2RtriNUiLFE05h8iZaxhfJYiaREKBPVRJtX165dq72Nmo4tOTmZvLw88vPzadWqFXv27MHlcsn3Dx48WM5zqaqxRMvfz5doGle0HyuI7rEpFJHE7XbLijhzu+vSpUu55ZZbcLrdxAH/69GDi6rw+Z41axY//fST12stWrRg1qxZnH/++ezZsweAo0ePMn78eL799lvOinAFYEFBAVuM+44hQ4awd+9eaQfRzZisWmmIc506daJly5Yh27a52tGSl4fbmJgyM2zYMDRNkwLqkSNHyMzM9OpcUygESgBUNFhEAIizf3/w82Oq63q5EBDxY9+mTRvsdrvXTUG0UzJuHIlGdV7swoUU3X132LY1bdo0cnJy+Pjjj0lPT+fJJ5+U71mtVp555hluuOGGGm3Dbvj/6TYbzp49a7SuaKVz586sN1X1HTp0qLwvls2Go39/YlatwqZK/hURoEkN/TatVmuN1xEOzBXe0UQ0Hq9QHCvh7xQfH8/p06eBsgTg/v37V2ufQ3GsGjduzJEjRyguLqZ169bs2bOH/Px84uPjKSoq4tixY0FvIxq/W9H4vYLoPFYQvcdLoagNfvnlF2njIATALVu2MHXqVJxOJ4kWC1+53QxJTaUyeS4tLY3/+7//A6Bly5YMGjSIBQsW8P333/Pee+8xbNgw9uzZQ2xsLCUlJRw9epRbbrmFhW+8IdcRCQ/AjRs3ymIQs/8fQA+3GxewyjiPhdL/D8oHnuAnXCQlJYX+/fuzceNG+dqGDRsYPXp0SMeiqB8oAVDRINHy8sr84yrw/8vKyiLPZ1apwJjdad++fXgHGAbcHTvi7NkT244dxCxYEFYB0Gq18sILL3DhhRfy6quvsmXLFmJiYrjwwgt59NFH6dOnT423IcQuZ48eYPgz1Td69+7NrFmz5HO/AiAeH8CYVauwbdsGRUUQHx/JYSoaGObKrWBITk7GarXicrnIjZBpdyBYrVaSk5PJzc2NqkmdaDxeoTxW6UYgVWJiIkVFRV7vtWvXLqjvWSiPlUihzM7Olum/6enpnH322ezatYtdu3YFPLZo/G5F4/cKovNYQeXHSwmCirDicsHGjeBwQAWdSrWFuWJv6NChpKenc+ONN1JYWIjNZmNOs2ZcdOwYxSbxypfi4mJuu+02SkpKsNvtzJ8/n169etGvXz92797Nk08+yV/+8hfA4786fvx45s6dy/r163nhf//jX8Z6IlEBKMI9rFYrAwcOZMaMGYCnM6xjURFbgByjgj3kAmCA1Y6XXHKJlwD4ww8/KAFQ4RclACoaJLY1a9CMC8yqAkDMiNmuuhQAYqZk3DhsO3Z40oDD2AYMHgP1a665hilTpuByudA0zW/SY7VwubAZJzmnyQOvvtGlSxev5xX6ABqt1JrDgW3rVpznnRfuoSkaMKG4OY+mG3yBy+WKynFB9B2vUBwrEfwhfP/MdO7cudrrr+m4ROJvTk4OnTp1AiAzM5PzzjuPXbt2sX///qC3Ea3frWgdUzSOC6LzeCnqKW43Sffei/XzzwHQ7rkHpk2DWvBG9YcQANu3b0+LFi246qqryMrKAuDFF1/kMqPzR69EAJw5c6Zs7502bRoDBw7EarXy/vvvc8EFF1BUVMSSJUvk8v3792f//v1s3ryZ/86YwbUWCwPc7ohUAK5cuRKAvn37kpSUJANAOnXqhP3gQZablg2l/x/g1fJb2b6OHDmS//znP/L58uXLK1xW0bBRISCKBondOHHpcXE4KvCP8xUAU1JSZAJVnRUATWnAsQsWRGy7MTExWCyh+7mx/vILFqNVzFGPBUDfStNDhw75Xc5p8lK0qyAQhUJRBzCHgEBZ0m5iYmKteuyKFtS8vDyaNWsGeKpexZgq+h1WKBSKUBE7dy5xhvgHYJk5E/v339fiiMrw9f976qmnZOXZvffey3XXXYdmXKPrFbT0HzhwgJdeegmAgQMHcvvtt8v3Bg0axK233gp4hEbxO7xu3TpeeeUV4uLicDqd3KVpuEFuK1zk5uayybAdEmEbogW4a5cuWAoKEHnInTt3pkWLFiHdfqAVgH379pVV6+A5VzlNwSQKhUAJgIoGSYwRAOI499wK20eF/58wfW7durX8Ia2rAqC7QwecvXoBEBPGNOBwYxa56nMFYOvWrb2SMA8ePOh3Ob1pU5ydOwMqCVihUNQNREW9CP4QlYBdunSplQRggVkANBuon3HGGQCcPn1aehYqFApFyNF14l94wfMwKQmM5NyE55+vzVFJfvnlFzmBk5yczBuGH995553HX//6V3A40Axbh4oqAKdPn05xcTEWi4V///vf5YoEHnnkESlmifDANWvW0KlTJx588EEA1rlcfET4PQBXr14tq38vvPBCSkpK5D1i17PPxgn8aCx7/vnnh3z7Xh6AleyrxWLhkksuKfucrvN9bYrGuo726qtw443wzTe1Nw5FOZQAqGhwaCdPYt2xAwBHJT/UogJQRNaLi3+omx6AghIjJda+ZQuWClpKox0hcrlatsRdx9KYg8HXdLyiFmAoE0LtGzaAkQKmUCgU0Yq4gRT+f+YE4NpECIC5ubmy8gTKWoOh4skYhUKhqCnWHTuwGRVm+tNPw+OPA57Jb+tvv9Xm0ABv/78vvvgCgKZNm/Lmm29is9m8qtTcfgTAnTt3Mn/+fABuuOEGevfuXW6ZlJQUGQ4i/NizsrLYt28fd911F+0MC6NHgXyfavJQs2LFCgASEhIYOHAg+/btk4Jg19at2QwIWS7U7b/gIwBWUe04cuRIr+cff/xxyMcTKAn/+heW++6DTz7BOnYsMV99VWtjUXijBEBFg8O+ejWaIZBU5P8HZQKgqPoTxuBQdysAwacNuI5WAdrXrQMM0StK/FDCRevWreXjAwcOoFcg7olWaEtWVp0VdhUKRcPA7XZLAVAk/4pUYH9BR5FECH15eXle7VQxMTHysWoDVigU4SJ23jwAdIsF/dpr4fe/l+/FREEllRAAk5KSpO/fv/71L1oZ6bRmAdBfBeCzzz6LruvExMTw8MMPV7idG2+8sVzBxerVq4mLi+NJw2MwA3hl584a7U9VCAFwyJAhxMTESP8/gG4tWnj5/4U6AASA2Fh0o0LeUkW140UXXeRVTbl27drQjycALPv2Ef/yy16vJf7f/0FJSa2MR+GNEgAVDQ670f7rTkzE2bev32VcLhf79++XjwHZkmS1WmvVn6imuFNTcRgpvOIioy6hZWVhNQQux6BBtTuYCNDZaO0FTxuEMM73xWk6FsoHUKFQRDM5OTny3Oo7qeEbfhRpRAWg2+0myWS+bh6nqgBUKBThIsZo23QMHQotWkC7dug9ewJgX7asso+GHbfbLRNxxeTNmDFjuPrqq+Uy5jZVXwFwx44dLFq0CIDJkydXej9lt9v505/+5PWaELTGjBnDkJQUAF48cCBstgxHjx6VQSUXXXQRUOb/Z7fb6dCokfT/O6dtW6+q8VAifACrSjxu0qQJA02+4KdOnZL3s5Ek/r330JxOdItFVrBajx+PqP+8omKUAKhocNhXrQLAOWQI2O1+l0lPT6e0tNTrNdGedNZZZ8m24LpKyYQJANjS0rDu2lXLowkO+4YN8rE5/KK+0qNHD6/nFVWeuDp1wm1cDCkfQIVCEc34BoCYqe0KwGST4brNZpPVFDk5ObRs2RJQAqBCoQgP2smT2IyKNocROAGgX3opAPa1a8Golq4Ndu/ezalTp+TzJk2a8O9//9vLt9VLAPQJAXnttdcAT0W18PKrjEmTJpGamiqfrzM6gDRN43GjdTjH5eLVV1+txt5Ujaj+Axg+fDjg8UAE6NixI5a8vDL/vwpCJUOBbkxGBeJ36NsG/Mknn4RlTBXidhNrtIZzxRXw2GPohtAba7R+K2oXJQAqGhRaRob01Qik/deM8KAQvhN1mdJrrkE3Ttaxc+bU8miCQ4hbemysDDSpz3Ts2NHreYU3nhaLFERVBaBCoYhmKqpkTkhI8LI9qA3MAmBBQYH0/83MzJTtaJX5sSoUCkV1sZtaNh0mPzkhAGqlpdiNxN3aYL3P9eXf//73cqm3FpNPnVkAzMjIYJ7ReTRhwgQ5oVIZNpuNP/7xj/L5gQMHyMzMBGB4hw6IyIs33nijwvNKTfjhhx8AaNasGd26dQNMCcBdu7I1LQ2xt8PC4P8ncAdYAQjlBcC5c+eGZUwVYdu6FYvRGq5ffz3YbOjCf37lSigoiOh4FOVRAqCiQRFjMq4tDSAARBAXF0dGRgYAbdu2Dc/gIoi7ZUscxkxW7BdfgNtdyyMKHOn/16cPGJ4Y9Rlf/5PKKk+ED6B1586ALhIUCoWiNvCtALQb1fhdu3YtlwYZacxhH7m5uTIJOCsrS/4eKw9AhUIRDoQAqMfHe9sUDR4sH9o2b47wqMpYuXKlfNyrVy9uvPHGcstU1AL8zjvvyG6qO++8M+BtXnfddV6/yxuMTiA9OZmnjdcKCwuZMWNGwOsMhNLSUpmie+mll6JpGqWlpfIesUuXLqzatk0uP8RUsRlqxHEM5Nq+Z8+eXqLswYMH/Ra2hAu7IZrqmiaFa/3KKwHQiouJMX2HFLWDEgAVDQrp/9e4MS7DT8Mf4odSmH63a9eOo0ePysf1gZKJEwGwHjmCbc2aWh5NgJSWYtuyBWgY/n9QPnCm0iRg45houo5t06YwjkqhUCiqz4kTJ7yei/ax2k4ABu8KQHMSsLkC8PDhw9LDUKFQKEKFbetWAJy9e4MpeIiUFJyGJ3RtXt8JQQzgmWeewWq1llvGXwtwQUEBH3zwAQAXXngh3bt3D3ibCQkJ3HLLLfL54sWLPetOSmIIMNp4/b333uP48eMBr7cq1qxZI7u/Lr/8cgD27dsnwyHPOeccfjQCQXoCZ/hM2IeSQD0AwXM+HT16tNdrCyLovRdjCIDOfv1ABGkNH44eHw+Ava7cc9ZjlACoaFDYjQpAx7BhUEmVgRAARVVCq1at5KxVfagABCgdM0b+GMfVkTZg27ZtaEaCVEPw/wNPypo5gbqyWTxHv34ew12UD6BCoYhefAVA4bkbbQJgXl6e3wpAh8PBsWPHamV8CoWinqLrWHfsAPBrcePs1w+ovQrAtWvXSkGsV69eDDZVJZoRAqBusaAb16+ff/659A4MpvpPcPvtt8uJIiFCClHsCWOZoqIiZs6cGfS6K+IbI3E5Li5O+v/tMvmmd+rUiTWHDwNwod0OfsTQUBGMByBQTgCMWBtwaakUsR3mROSYmLLvr9HJpag96naSQZDk5OQwZ84c1q1bx4kTJ4iNjaVjx46MHj2a8847L+j1uVwuduzYwW+//cZvv/3G3r17ZZvo9ddf77cs2h/79u1j3rx5bN++ndzcXFJSUujZsyfjx4/3Mj5V1AzLoUNl6bGV+P+B528CZTcljRs3lu/VFwFQb9SI0ssvJ3bePGIWLIBnnoG4uNoeVqXYjeQxAEcFFx71kdatW0vPkUrTvJKScPXogW37duzr1lEUofEpFApFMFQUAhJtAqC5AtAsAIKnraqyBEuFQqEIBsvhw1gMgcfpp0vJ2a8ffPYZ1qNH0bKy0MOUOFsRTz75pHzsm85rRlSp6Y0agaah6zrvv/8+AJ07d+aSSy6p8LMV0aJFC7p06cKvv/5KdnY2mZmZtDXaYs8FRl14IUtWrOD999/n7rvvDshfsDJ0XWfJkiWAJ/xDTMT/alT8xcTEkJubS4FRHHKRKTE+HARTAQgwbNgwEhMTKTD89n755Rd+/fXXaukdwWBLSysr1BgwALNRk2PQIOyrV2Pbtg2KisAoQlFEngZTAXjo0CHuuecevvzyS44dO4bVaqWgoIAtW7Ywffp03nrrraDXmZ2dzd///nc++OADfvrpJyn+BcOKFSt4+OGHWbFiBSdPniQ2NpYTJ06wYsUKHnroIX788ceqV6IICJH+C+CoxP+vuLiYw8aMjqj6izMJY76ebHWZYqMN2JKbS8zSpbU8mqoRAqDznHPQRVl5A8AcBJKVlSW/l/5wGJWRtg0b6pS3o0KhaDhUZNYeDQJgRR6Ap0+f9rqpVEnACoUilNiM6j+oQAA0tc3aDCEqUmzdulV671ksFi41vN38ISsADdFqy5YtpKWlAfD73/++2j6v1157rXw8c+ZMr4CRR2++GfDcw4XCCzAtLU3eC4r2XyhLAO7UqRNrTYEt5xthUeFCeABaAqwAtNvtjBo1yuu1SKQB20wBNU6fVGRh3aQ5HLJKUFE7NAgB0OFw8PTTT5OTk0P79u156aWXmD17NrNnz2by5MlomsbChQtZWg0BJD4+nh49ejBu3Dj+9Kc/0apVq4A/e+jQIV566SWcTifnn38+77//Pp988gnvv/8+w4YNw+l08uKLL5Kenh70uBTlEQKgu1kzXF26VLjcgQMH0HXd6zXx3Gaz1XhWKZpwXHwxbuOkFfVpwE4ntp9/BsAxZEgtDyayiOQx8HwXjxw5UuGywgfQkpeHNcIXiAqFQhEI/ioAExISoqKizmq1ymoPcwWgeC/WCJ9SAqBCoQglQgDUbTZcfiZDXOecIx9bTa2okeCZZ56Rj3v37i1/B/1h8REAP/zwQ8BTNWcW8YLF3Fn3xRdf4DZV3fU76ywp1H3wwQfVKsoxI9KKLRYLl112mXxdCIBdu3ZllXFf2Qc4o0mTGm2vKmQISGEhBOg/O85I3hXMnj1b+heGC9Ge7jrrLNw+98vmUBvbzp1hHYeichqEALhkyRIyMjKIjY1l2rRpsq02NjaWSZMmccUVVwDw0UcfBfUPo1mzZnz66ac888wzTJ06lYsuusirUqwqPv74Y5xOJ6mpqTz00EM0bdoUgKZNm/Lwww+TmpqKw+Hg448/DmJvFX7RdRkAUnrBBWD4SPjDn8daUZGnmbJ169bYbPWoc95up+TqqwGI+fZbNMOfIxqx7diBJT8fAMfQobU8mshSnSRgUD6ACoUiOvEnAEZDArBAtAGbKwDBU7kogsCUAKhQKEKJ8P9zdeni15JHb9oUt/F7FMkJ3o0bN3qFfwwze7v5QVYANmpEfn6+9J8bM2YMZ9SgUq5Zs2by85mZmaw1KvTA0xr7yCOPAFBSUsJLL71U7e243W455gsuuEAm6hYXF0sbns6dO/OzUZRwCXhVI4YD8/oDbQO+6KKLvO5Zjx8/Ln0Nw4XNqPR09u5d7j29WTPcxoSaVQmAtUp0XGmFmeXLlwOeHv5mfvwSJkyYgKZpnDx5ku3btwe8XovFIg1Jg6WgoID1xs351VdfXS5FyWq1crUhzKxbt47CwsJqbUfhwbp3L1ZjNqiy9l8oLwDabDZ5s1Jf/P/MlEyaBHhKsqO5CtDL/6+BVQD6JgEfOnSowmXd7drJC0S7EgAVCkUUYg4BEddRXSqpzI80QgDMy8vzum40+wBW9jusUCgUwSLaep2mrg9fnEYVoC2CFYAvv/yy1/NBRqdJRZg9AOfNmyfvYX//+9/XeCwijAPgPZOYpeXm0rt3bxl+8b///a/aQU0///yz7L4bP368fP23337DbVjrWCwWiouLgcgIgG6TNUWgAmBCQgIDfQIT33vvvZCOywunE+uePQC4KvgOO3v0AFQFYG1T7wXAoqIi9hhfxv79+/tdplmzZrLtZGuEetJ37twpqw0rGpd43eFweKUOKYLHbvJSrCoARAiACQkJALRp00aeCOqjAOjs109eUMR9/DH4tD9HCzbh/9epE7oxG9dQ8BUARUiNXzRNVgGqCkCFQhGNmAVAYbFxjqm9rbapqAIwMzNTVgAeMELFFAqFosaUlmIxqopdnTpVuJhoA7b++mtErtf37NnD119/7fWar6jkixCo3MnJ/O9//wMgNTW1ysrBQDjfVMQxf+lSRC252Ka5CvDFF1+s1jbmGMUQsbGxjB07Vr4u2n/BMxkEYAWG49nXcKKbBcAAfQCBcoGkCxcurNCDt6ZY9+9HM8IzKxKxhY+ldedO5VNei9R7ATA9PV1eXFYW3iDeO2wqJw4nYjuNGzcmJSXF7zIpKSnyPTXTXDOEAOhq2xZ3FSEeQgAUZdNnn3229FyrTwEgEk2j+KabAE/ptnXbtloekB9cLuxr1gA+sfINhJYtWxITEyOfmy9C/CF8AG1796KZbrQVCoWitikpKSHfsHMwE00VgCIIJDc3l6ZNm8oujczMTDkhk5WVJRMWFQqFoiZYDx5EM7zdXKbgN1/EhL0lJwdLDX3uAmHmzJnoui4rtc8++2yvSRF/CIFqq9PJZsMTTnju15RzTTY3pQ4Hs8Q2DQGwZ8+ejBkzBvBYe1Xmme2PvLw8vvjiCwBGjRrllQovrr3j4uJkx+BAq5VkItACXI0KQICxY8d6HXeHw8Hnn38e0rEJzL6Urgom9FyGAGgpKMCitI1aox6ZmfnH7DMjPPb8Id47FSEPNLGdysYk3s/JyalyXB999BGzZs2q8P0bbrih3CyAL8J7x2Kx0CTMZqaBIn60UlJSygVzBIzbjcWoHtNGjKBJFcdc+DuIpNU2bdrIas1zzjmHJk2a1L9jdeut6E89heZwkDJnDvpFF4VsXCE5Vps3S1Ph2EsvJaaGxzwk36swUNmxateuHb/99hvgqTyp9Fhecgk8/jgAjXftgiuvrPaYovFYReO/P4VCERj+/P8geisALRYLZ5xxBpmZmWRlZXGBqYvg8OHDUTVuhUJRN7Ea13dQRQWgaaLE+ttvuIMInwyWo0ePSrEoNjaW4uLiKtt/oUwAfM+4n7LZbFx//fUhGVPXrl1p1KgReYYI9pamcbeue4lijzzyCIsWLaK0tJTnn3+e//73vwGv//PPP5cTO7fccovXe78aLdodO3Zk06ZNAFxsiLZmgS4ceHkABlEB2KhRIzp37szu3bvla7NmzeK2224LiSBrxmYIpLrNVqGI7ZVknZZGqU+HkyIy1HsBUPTnA5UmFon3RNhDuBHbqWxM5verGldBQQGZmZkVvl9YWFjOZ7AiNE0LeNlIUSNj8LQ0MKqgLCNGQCX7dvr0aXkcxTE3V2h26NDB69jUm2PVsiVcdRV88QWWTz6B55+H+PiQjqtGx8pI2gKwXHxxpX/DYIgWw3lf/B2rHj16SAHw6NGjlR/Lc8+FmBgoLcX6889g+InWhGg8VtH470+hUFTOCT9VydGSACwwewACNG/enMzMTDIzM706AQ4ePKgEQIVCUWO8BMAOHSpczmUEWQJY9u+HKmyNasJbb70liyHE/bS5As8vbjdafj6FwKeGYDZq1KgqqwYDxWKxMHDgQJYtWwbANl1nI9DDJIr16NGDq666igULFvDRRx9x880309tPKIUvLpeLt99+G/BUpPu2LIsKwKZNm8rCkBHGexGtAPRTQV8Z1157Lf/85z/l87S0NDZu3FhlK3ewiApAV6dOnnsQP7i6dEG3WNDcbqy7d4NRramILPVeAGwoJCYmVvrjmpCQgKuK2HARaqLrujQ5rW00TcNiseB2u6tdfaR9953sdXcNH15pfLq/1kqzwNC2bVtcLlf9PFZ/+APWL76AnBzcn3+ObrQF15RQHCvLd9+hAXqXLrhbtKj0bxgIofhehYPKjlW3bt348ssvAY+gf+rUKa/WBC9sNiz9+6OtXYv+00+4a3C8ovFY1fQ7pURDhaL28CcAdunSJaomGcwVgIAMAjGHgIDyAVQoFKFBCICu1q0hMbHC5fRmzXAnJmIpKMBqVNiFg+LiYunf161bN+lFX5UAqOXno+k6nwM5JSUA/O53vwvp2AYNGiQFQIC3gRd92mKnTZvGt99+S3FxMf/3f//HV199VeU5ZsGCBTI3wLdCrrCwUCa/i/vpGLudoYZAGskUYEsQLcAAt956qxQAxbXze++9F3oB0BB8XV27VrxQbCzudu2wHjiA1Sd0UxE56r0AGGeKUS8pKZHBDr6UGD9S8SGueqoIsR2x3YoIdFyTJ09m8uTJFb6fnZ1dZRtxkyZNsFqtuN3uiLVCV4XVaqVJkybk5ORUKWBWRPKSJcQAzo4dOZ2QAJXs25YtW8q9JryK7HY78fHxnDp1qn4eq3PPpclZZ2E9ehTnm2+SayRp1ZQaH6uSEs4wkryLL7iAghAc71B8r8JBZcfqrLPO8nq+adMm+vTpU+G6Evr3J2HtWtiwgVOZmWC3V2tM0XisavqdOvPMM8MwKoVCEQj+WoC7VnbDUAsID8C8vDx0XZcTrJmZmSQlJXHGGWdw4sQJ5c+sUChCghQAK2n/BUDTcKemYtmxI6wC4OzZs+VvdZs2bdi1axeNGjWqsuJZtKe+ZTxv06YNF4XQVgjKi5CzgOk+55X27dtz//338+9//5v169fz4Ycf8oc//KHCdTqdTp577jnAc719ww03eL2/Z88eOQku0oXP7dGDBOO+0V2Bn3+o0JOS5ONgWoABkpKSZKCl2If58+fz5JNPhu562OXCGkCIDXgqXK0HDmCtLNBQEVaiZ7o1TJg99irynTG/Fyk/KTGuysZkfl/5XFUTh0OmxzpM0fEVIQJAxCyRpmmyBah169b1u3LIaqXE8OiI+eknLFHyw2zfsAGtsBAAx8UX1/Joao+OPn4a+6u48HMaF0haURG2tLSwjUuhUCiCwV8FYLQJgKIC0OVyUVBQIAVAkfwoqgBFRYhCoVDUBCGGVNb+K3AZvmnWMFYgv/LKK4Cn8+n48eMADBgwoMr7IC03l53AT8bzyZMnh/zeqX///l7VfHnAXD/3LPfccw+pRsv0tGnTpIefP15//XXpk3f//feXs+jaZQq4ENffw3v0kK+F2wMQqxW3URkaTAiIYLRPUUdpaWml2QHBYjlyRCYAV/UdFv6AqgKw9qj3AmCbNm1kCW9lM7XivbZt20ZkXGI7p0+fli0mvuTk5JCTkwN4AgAUwWPbvBmLYebqCMAnQwiAYva/VatWHD16FGgYf4PiG29EN/69xH34YS2PxoPdKPPXbbYGmQAs8BUAq0oCdphK+23r1oVlTAqFQhEsdUkABE8VoBAAc3NzKS4uVgKgQqEIHfn5WLKzAW+Pv4oQy1j374cwWLNs3LiR9evXA3DTTTeRZkwiBxQAkpfH28Zji8VSrpIuFDRq1Ihu3boBEGcIge+lp5dbLi4ujtdeew2bzUZRURFTpkzx2zWya9cu/v3vfwMe/0B/LctCPDQLgyNM561wtwBDmcgYbAUgwNSpU+VjsQ/vv/9+yDp7zNWoVX2HhQBoOXkSrYpCKEV4qPcCYHx8PJ07dwaQiT2+ZGdnc/jwYYBKW+pCSffu3bHZbJWOS0Sn2+12+UOnCA77jz8CoGsajvPPr3J5EbIg/japqanyuxEpcbg2cbdvj+OSSwCI+/hjMCrvahO70f7rPPdcrxL4hkbTpk29LAy2b99e6fJ6y5a4jJtUu3Ehp1AoFLWNPwEw2oI0zAJgTk6O9AAETxWgmBA8dOhQ1HijKhSKuonVVKDiNnmMVoQQWLTCQrRKAiCryzvvvAN4hKJzzjlHikRVBoAAJdnZiPKBSwcPLmdfEyp8xcjVBQVeSbeCAQMG8Je//AWA3bt3M2nSJDIyMuT76enpXHnllRQUFGCxWPjvf/+L3Y9lzo4dOwBPOy14rsn7m84LEREAjW1UpwKwQ4cOMtRS2IsdPnyYpUuXhmRs1REAAdUGXEvUewEQkN4DK1eulO0bZubOnYuu6zRt2pRevXpFZEwJCQnyh/TLL78sp8C7XC5p+D9o0KAKvQsVlSMEQFevXuhVtFHrui4rAEuNMub27dtz5MgRoGEIgABFU6YAYDl9mth582p1LFp2NrZt2wAoDbGHSF1D0zTONto+oKxatTJEFaBNCYAKhSJK8BUAoy0BGJA3SuDp1PAVAEUFYGFhod/rSoVCoQgUswDoCqDbyG0SWELtA3jy5EnmGdf+48ePl5VvmqYxYMCAKj+/6McfEb/wv5s0KaRjMyMCLIrdbkRUx8cff+x32XvvvZebjGDDLVu2cOGFF/LUU0/x1FNPMXz4cHk9/fjjj/vdR13XpQBYYHSVXXTRRdhNabwRrQCshgAIcNlll8nHogpQiL01RQh57uRk9DPOqHRZLwHQlH6tiBwNQgAcNWoULVu2pLi4mH/84x+yd7+kpIQ5c+awaNEiwONTICq/BLfeeitXXXUVL774ot91FxQUkJubK/8TiZQlJSVer/sL+7jpppuw2Wzs3buX559/XpYlnzp1iueff569e/dit9vlj5YiSAoLZeVTaQD+f8ePH6fQqHgTvn9NmzaV4mxDaAEGcIwYIf1F4t99NyztBYFi//FHNGP7Ddn/T2CuBBYmxJUhfACtR45gMVrZFQqFojYRflKCaEsABmjcuLF8nJOTI1uAwRMEYp6MUW3ACkX1sFqt1fovFOuoybZDvU6b0WkEQGpqlfuqmwQU+8GDIR3L3Llz5T3rbbfdJluBu3fvTuPGjav8/AcrVgBwFjBq7Niw/V3PO+88uWxP4/+zZ8/G5XKVP742Gy+++CJ33nkn4BE5Z8yYwYwZMzh9+jQAjz76KPfcc4/fbWVnZ5NttGgXFxcDcOmll2IxCYCWlJSwf4cxREZLfn61/rbXXHON3KawR1u2bBl79uyp+XfH8KN0d+iA1WardD+1du3QjZBW2/79If3++h7jcK07VH/Tij4fbup9CjB4Wmgfe+wx/va3v3HgwAHuv/9+EhISKC4uloLd2LFjGTlyZNDr/uc//ylnBczMmzdPzqAAXH/99dx4441ey7Rr147777+fl156iR9//JFVq1aRkJAgZxdsNhv3339/1M2M1xXs69ZJQ9JA/P9+8zMLYU5fbigCIFYrxX/4A4lPPIFt2zZsGzfiDHFUfKDEfPcdAO6mTXH27l0rY4gmOpmStQoLC8nLy5N+lf5wmNo1bOvXUzpuXFjHp1AoFFXhKwBGm/8feAevnT59WlabgKcCsHv37vL5wYMHA2qNUygU3tQ04NBqtdZKSGJyqKu9xG/iGWfQpIIWYK99TUmB2FgoKSExI4PEEB6D2bNnA9CzZ0+GDx/O+PHjARg+fHiVx3rPnj2sNO6lpgBnpqZCNYSNQP6ujRs3pmXLlmRkZCDqzU6cOMGPP/7IxIkT/X7mtddeY9y4cTzzzDOsWbMGl8vFBRdcwN/+9jcuvfTSCrf1888/l3vtmmuuIeGllzxPGjWiSTXTdIP6DhuVdfaCgmp978eMGYPVasXlclFcXCwfv/POO7z99ttVr6AyjIkwW9eufsdWbj9TU2HXLuKPHiU+jP+GQ/5vNQBq63cpGBqEAAge8WbGjBl88cUXrFu3juzsbBITE+nQoQNjxozxmkmIJBdeeCFt27Zl7ty57Nixg9zcXNmKPH78eJlepAge+8qVAOh2O47Bg6tcvqqWygYjAOIJA0n417/QiouJe/dd8mtDAHQ4pABYOnJktS4i6hu+QSD79u2r1LfU1b07ekICmlENqwRAhUJR25z0Mf2ORgHQ3AJ86tQpmjRpgs1mw+l0kpmZyVlnnSWfqwpAhaJ6+AtkCITk5GQpXlQUpBgOrFYrycnJ5Obmhiw8ASBx925iAGe7duT5HJOK9jW5fXusu3dTumsXBdU8jr5s27aNLVu2AHDLLbewceNGWSHXp0+fKv9eM2fOBEADpiQkcCrIv02wf9fBgwfz5ZdfcghoARzHI/KNGDGi0s/Mnz8fp9OJ1eqpDqzqb7pmzRqv53379iUmJobi48eJA9yNGpET5N+gOt/hhLg4YgHX6dPkVuNvbrVaGTJkCKtWrQKgZcuWHDlyhP/97388/PDDtGjRIuh1AuB203jvXjSgqE0bik1jq2g/k9q0wb5rF849e8p950NBuP6tVkZNf5ciKRo2GAEQPLMFU6dO9UrCqYqqFPHp06fXdFh06NCBhx9+uMbrUXgj/P+cAweCEZ1eGaICMC4uTpZ4izJ4u91e/R/GOojepAkl48cTN2sWsV9+ScETT6CbWqAigf3nn7EYFx6ll18e0W1HKx06dPB6XpUAiM2GY8AAYn78UfkAKhSKWkfXdfJNbVMQnQJgfHw8sbGxlJSUkJOTg8Vi4cwzzyQjI4PMzExsNhtt2rThwIEDHDBanxQKRXCE4sY8Ujf3vtsM5XYtxm+Iq127Stdrfs/Vti3W3bvRDh0K2Vj+97//AZ4OtMmTJ/PJJ5/I9wYMGFDpdkpLS5k1axYAlwHtGjfmVA3GFcg+DRo0iC+//JJ9wF3Aq3haWg8cOFClb7umabjdbrmdyv6mvqF7F198sWfZnBzA43tXk79BoJ91GwEkWg1ErXHjxkkBUFgJlZaW8uabb/LXv/61Wuu0pKejGffLzrPPrnBs5tedbdtiBywh/P5WtM3a+o2IZqLLdEWhCBHa6dPYtm4FAvP/g7IKQNFSKS72Adq0aRN1HkXhpsgQyrXSUuJrWhpeDWK++QYAPSaGUuX/B5SvAKwqCRjKfABt27ZBUVFYxqVQKBSBkJOTI61XBNEoAEKZD6CogBE+gCL0QwSBqApAhUJRbXQdq/EbEkgAiMBl2ENZ0tNDMozi4mK++OILAC6//HKaN2/OunXrAGjWx4Q6mgABAABJREFUrJn8vauIb775Rvrk3U5ZYEU4GWzq7upi/F/XdS/hMhT4Wn1dbhQlWIwqr0jsK3iERqh+CAjAVVddVbY+t1t2t7333nvSgixYrKZJsKoSgOW2je+TJSsLDP99ReRoWIqGosFg/+mnsvCI888P6DOiAlAYcaampnLISOaq6sRXH3H17k2p4Z0Y99574FO1EVZ0XQqAjgsuAGPWq6GTlJTkVSLuz3/UF5EErDmd2IzWDoVCoagNfBNzExISqqzUqC18BUCRBJyZmQkgg0CUAKhQKKqLduIEmiGAuIO413ALATAjAwy/85rw9ddfy986ET4pAkAGDRokQyMqQlQPtoiJ4Uoik4rbo0cPkgyv9r3AsJ6eOJBZs2aFrAKrsLDQyyKqVatW9O3bF/BU4kFk9hVMKcAlJeAnXDQQunTp4uUnnmNUMZ4+fbrawqnFFGLjDlDENovdVnMIjiIiKAFQUS+R/n8JCTj7969y+dLSUin2ibbfs88+W77WkPz/zBTdfTcAltOnifv444ht17prl5wRLb3iiohtty5gbgMWieaVYQ5wsas2YIVCUYv4CoDRmAAsED6AVVUAHjt2TNqGKBQKRTBYjfsMAFcwAqAxcaLpOhajlbMmiPCP5s2bM2LECLKzs9mzZw9AlSFHBw4cYPny5QD8/swzsROZqjibzcbAHj0AWAX83uj4OnLkiBxPTfnll1+8qtZHjx4tz1miEi9iAqCpGKImVYCXm2yVcnJyOOusswB4/fXXcTqdQa/PcvSoZ3w2G+4A7aLMAqBFTaJFnOi86lIoaojw/3MMGQIxMVUuf8jkQSCMO9u1ayf9ERqqAOi45BKcRtph/Ouvg8MRke3GGgnauqZRMmpURLZZVzjnnHPkY980TX/oTZrg7OJpjrBt2BC2cSkUCkVV+PrldenSxf+CUYCothYVEkIAFBWAQgDUdZ30ELXhKRSKhoVZ/KhOCzCAtYa/P9nZ2VIwmzBhAjabzSv4YtCgQZV+/t133wU8vnpTDc/1SIliQwxxciswon17mfr60UcfhWT9aWlpXs/HjBkjH4sKQHekBEDTdrQahN9c7uOrbrN5IiEOHjzIl19+GfT6rEeOAOBu2TLgwEZztatZBFdEBiUAKuodlmPHsBmzVo4A/f9E+y+UGXcmJyejG23EDVUARNNkFaA1PZ3YBQvCv01dJ3b+fAAcw4aht2wZ/m3WIcw+gEVFReQFMAsofADt69eD8Z1WKBSKSCMqSgTmCY1ow7cCULQA5+fnU1BQ4GUNooJAFApFdbCaqvfcRiVWILhNAqClhi2UCxYskPc+EyZMAGD16tUAxMTE0Lt37wo/m5+fz8dGh9Cll15KJ6OLKlKi2CDD5skN7Ni9m4kTJwIeT0LfivPqYPbabty4MUOGDJHPa6sFGGpWATho0CBpcQGeIhhxfnvxxRfL+fRWhfChdLduHfBn9JQU3MY5VgmAkUcJgIp6h91INwKkh11VmP0dBGJGBBqwAAiUXHMNLuNHPf6llyDIE0Ow2DZtkoayJePHh3VbdRHfIJB9+/ZV+RmHIQBasrOxBNA2rFAoFOHA17YgWgNAoOIQEPC0AQsPQFA+gAqFonpYRPXUmWdCXFzAn3O3bIlu3KfUNAhk7ty5gOf6Uoh9QgDs06cPsbGxFX72888/l51Tt912W8RFsX5DhiDu1lb/8guTJ08GwOl08tlnn9V4/Rs3bpSPR48eXXZv6HaXtQBHKATEfEwtNRAAbTYbl156qddrrVq1Ajwtz19//XVQ6xMtwK4gBEAo8wu0KAEw4igBUFHvEP5/7jPOwGV4Q1SFqAAUM/6Alw9CQxYAsdspuusuAGy7dhGzcGFYNxdrXIjoNhulY8eGdVt1EV8BcPfu3VV+xmlq31A+gAqForbwbZXt1q1bLY2kakQL8OnTp9F1vZwAmJKSIkVCJQAqFIrqIMSTYKr/ALBa5Wdq0gJ8+PBhfv75Z8BT/adpGg6HQyYAV9b+q+s6b7/9NgCdO3fmwuHDIy6KJTZqRH+j7XTtgQP06tWLPn36AJ42YL0GXS8lJSVeLcDXXnutfKwVFMiwybpWAQhw2WWXeT3fvn07TZs2BeCFF14I/LjperUqAKGs5d2qzp8RRwmAivqFrpf5/w0bBgGai4sKwCTDYLVRo0acOHEC8KQUnnnmmWEYbN2h+Pe/x2W04ib85z8QonStcjidZe2/F1+Mbkq8VXho3769VxrblgCSfV0dO+I2jqVNCYAKhaKWMLdkJSUl0cbUxhZtiAlBh8NBYWGhlwDo6wOoBECFQlEdZPVUsAIgpiTgGgiA8wzPbYDxRtfN9u3bZbBRZQEgK1eulJPQt956K1phIZpxfxApARBgqOE7uD4jg9LSUpli/Ntvv7F27dpqrzctLU22Rjdt2pShQ4fK98wefBETAEPkAQgwcuRIr8pOXddlgcHWrVtZtmxZQOvRcnOxFBQA1RAAjfOnqgCMPEoAVNQrrHv3SjPSQP3/oEwAFMlOHTt25LDhqdG2bVsvwaVBEhdH0YMPAmD79VdiqmESGwgx332HxbixKjbNtCnKiIuLo0WLFvL5zp07q/6QxYJzwABAVQAqFIraQwRqgKf6L5rPrWaPpNOnT1cqACoPQIVCUR1kC3A1BEARBGKtgQegaP/t06ePFIBERSBULgC+8cYbgKdoYtKkSVjy8+V7kRLFAM43JriLXC62bNnChAkTiI+P9xpjdTCLYFdffbVXYr1ZgHObusfCiTtEKcDgmYC75JJLAKQQuH37djnx9cILLwS0HvH9heAFQJFkbcnNrfH+KIJDCYCKeoXd9GNdetFFAX0mLy9PXswXFRUBHgHwkDEj0aDbf00U33ST9HdIePbZsCQCx334IQDupk0pHT065OuvL5jb5gKtPBE+gNZdu9SJVqFQ1AriHAvR3f4L3pYgp0+fJjk5Wd4oiUpGswBYk1YzhULRAHE45KR3dQRAWQF45Ei1/Ll//fVX2eIqwj+gTABMTU31mvgws3PnTr777jsAbrrpJpKSkmqlKg5gaKtWiKmkH3/8keTkZG688UYAFi1aFJBVjj8WmIIPp06d6vWe175GqtoxMRHdECFrWgEIcNVVVwGeVmeA4uJiehjWWWvXrpU+kJVhFgCDrWI1C4bm9SjCjxIAFfWKGCPG3pWa6hUxXhnmAJBTp04BSgD0S2wshX/6EwC2vXulWBcqLOnp2L//HoDi66+HSkyHGzrmG2chXleF8AHUdB2bydRYoVAoIsGpU6e80gWjXQBsYrKgOH36NJqmyaRE8bsrgkAKCwvJzs6O+BgVCkXdxZKRIX3kgq2egrIKQK2kBK0avz+i+k/TNK6++mrA0wq63ugUGTx4cIWfnTFjBgB2u50//vGPnvUYgUkQuRRggKZnnklf4/EqIwjy7rvvloEdL7/8ctDrLCkp4ddffwXgjDPOoEuXLl7va6Zqdj1CFYBomhQbNVO1ZXUZNWqUnNQSISA7duyQdliBVAFajRZ28E6mDgSzYFjTIBtFcCgBUFF/KC2VCcClF18c8MdEAAggvR7atGkjZ/iVAFhGyY034jRSGxP+/W+vk31NiXv3XXkhVPK734VsvfWRzp07y8clJSXkBVDR5+jbF90wSlY+gAqFItL42hVEuwDo2wIMZUnAvi3AoHwAFQpFcFhM4onLEGCCQbRQQvBBILquS/+/oUOHSgHo8OHDHDt2DKg4AOTgwYPys9deey1nGUKO+Z5AN/1+hhs9JYURxuP169dTVFRE27ZtmThxIgBz5swJ2qbhs88+k/eEF/u5p7SYBcBI7qshrIaik6dRo0Zy30R1fm5uLv379wdg+fLlbN68udJ1COFOj48P2rfdLBia/y0owo8SABX1Bvv69WiFhYAnQCJQRAWg1RBHwBP8IVACoAmbjYJ//AMAy6lTJDz3XEhWq+XmEvf++wCUXnIJrk6dQrLe+orvTKS5irVCkpJkKrbdSHdTKBSKSLF9+3av5+ecc04tjSQwfFuAoUwAFBOEogIQlACoUCiCwyx6VKcC0EtACdIH8JdffmH//v1AWSsoINN/oWIB8JVXXsHlcqFpGvfee2/ZGMxtsREUxdwpKVxiPC4pKZEVjPfffz8WiwWXy8U///nPwNfndvPiiy/K55MmTSq3jFe1Y6QqAClrNw5FCzCU/e1Pnz4tz2e7d+8mLi4OwOs4+MMrxCZIT1+9aVN0YztW1QIcUZQAqKg32H/4AQDdZvMkAAeIqAAU8eeAl5ePEgC9cVx8MaWXXgpA3DvvYN2xo8brjPvwQyzGbFaR6WJC4R9fAbCqGTqB8AG0bdwYviRnhUKh8MMvv/wiHzdu3JgzzjijFkdTNeYKQBFe4tsC3Lp1azl5qIJAFApFMHi1T1ajAtCrhdKo2guUxYsXy8dXXHGFfCwEwJSUFL+TNMeOHeOTTz4BYOzYsXQyTdjXmiiWksIFgM14/uOPPwLQqVMnmQg8f/58NmzYEND6Fi1aJG2gNE1j4MCB5ZYRLcC6zQamopFwIwRAS4i8vEeNGkVMTAxQNqGVkZEh278XL17Mrl27Kvy8DLEJsv0XAE2T3peqBTiyKAFQUW8Q/n/Oc88NypBVVE+JxKjmzZt7efm0D9BLsCGR/49/oMfGojmdNLrvvhoFgmj5+cS/+irgaVMNRrxtqDRu3Njr5nR9gC29TkMAtOTlYTW8TRSRJycnh3feeYc77riDiRMnctNNNzFt2jTWrl1brfUVFhaybNkyXnjhBe6++26uvfZaJkyYwK233spzzz0nTb4Vitpk37598nGnOlDlHRMTI7sBhD+wuQVY13VsNhttjTY8VQGoUCiCQYonzZpVz/c6IQG30XZpDbKFUgiAAwYMkO2/UCYADhkyxCv1VvDf//6X4uJiAB544AGv97xEscTEoMZTE/SUFJIA4VgoBECAP//5z/J3/JFHHsFRxf1KSUkJTz/9tHzes2dPGvm5p7QYYqfeuHHQlW81IdQVgMnJybINOC0tTRa9HDp0CLvdDlTuoWitQYo1lPlYqhbgyKIEQEW9QMvKwrZtGxB4+i94Kv2EACjMyTt27Mhho5Q+OTnZqw1I4cHdsSOFjzwCgG37duJfeaXa64p/5RUsRjtV0UMPRfREWpcxVwH+GqCYJyoAQbUB1xaHDh3innvu4csvv+TYsWNYrVYKCgrYsmUL06dP56233gp6nQ8++CAvvPACy5Yt4/Dhw+i6jsViITMzk5UrV/KXv/yF9957Lwx7o1AEzmFTi5pIGox2xESLqAAUAmBxcTH5hgm7mCRUAqBCoQgGIXpUp/pPICuoghBQ0tPT2WbcM5mr//Ly8mS11zA/k/H79u3j448/Bjyto7179/Z6X4piKSmRFcWM+zThA7h582ZyDYGsZcuWPPTQQ4An4KKqltZXXnnFa7JqyJAhfpcT1Y6RrHSEsnCVUISACEQCdFZWFpcaHV779++X+z5v3jz/5ze3u+w7XI0Wdij7/gbrYamoGUoAVNQLYlaulI8dl1xSyZLeHD16lELDN1BczHfs2FH+0Kn234opuvtunMbJP+HZZ7Ft2hT0OixHj5ZV/w0ZQumoUSEdY33GfAN9OEDvF3fbttJo2rZmTVjGpagYh8PB008/TU5ODu3bt+ell15i9uzZzJ49m8mTJ6NpGgsXLmTp0qVBrdflcnH22Wdz++2388YbbzBnzhw+++wzXnvtNa8LuK+//jocu6VQVImu616J5X379q29wQSBSAIWHoCiBRjKB4GoFmCFQhEM0j+tmuIJlImHwQiA5vbfMWPGyMcbN26UxRBDhw4t97n//Oc/OJ1OLBYL//d//1fufc0sAEYQt48A6Ha7WWm6L7zrrrtksMV///tflhsdY75s2LCB53y8zc877zy/y8pqxwh6HULoKwDB0wYskn9Pnjwpz3NZWVlomobL5eIVP4UeWnY2Wmkp4N2OHgxCOLQcOwYm+y1FeFECoKJeIPz/3E2b4uzVK+DP7d69Wz4WF/gdO3aU3g+q/bcSbDbyXn7Z0wrscNBoyhS0EycC/7yuk/TIIzK4peDxx1X1XxCYk4BPnz4tL9oqRdNwnH8+ADGrVqmTbYRZsmQJGRkZxMbGMm3aNFJTUwGIjY1l0qRJcib+o48+wul0BrzeBx54gJdffpmxY8fKVh5N02jdujWPPvoovYzfRJHap1BEmhMnTlBq3CiAp62qLiA6AHxbgAGOHz8OlF0nHDt2TLbGKRQKRVWEogJQCC/BeACKycDOnTt72TGI9l+r1VouACQtLY0vvvgCgOuuu87rGlQgRCl3pEUx43d6CJBstB5/99138n2bzcaMGTNITEzE5XIxZcoUVq9e7bWO3377jVtuuQWHw4HNZpOvCy88Xyy1JHaGMgVYkJCQwNixYwHPdeqUKVMA2LVrlxRAZ82aJc95AnNwR7U8ACkTv7WSEjST/ZYivCgBUFH30XXp/+cYPhxMab5VYRYABWYBUFUAVo6rRw/y//UvwHMiSL7lFjCi5Ksi9n//I+bbbwEo+sMfcA4YELZx1kfMLcC6rnMkwAQthzGra8nMxBpIerAiZIhZ5+HDh3tVEgkmTJiApmmcPHmyXGJqZVQmplgsFi4xqqIzMjJkpbNCEUnMLVWA35vHaKSiFmAoSwIWAqCu66SrNiaFQhEIpaVYjCri6rZPgqkFOCMjoHC3kydPssboABk9erTXe0IA7Nmzp6wIA89v22OPPYau68TExPCIYQHkS62JYsb27MAI43rou+++85oY79KlC2+++SYWi4W8vDyuvfZannrqKVauXMnzzz/PyJEjycjIAMoS6jt27Oj1m29GVABGXOw0/i5aXl5IJ/FF0nFhYSHNmzcn2RAaxaRWSUkJb7zxhtdnLGYBsLotwKbPqSTgyKEEQEWdx7pzpzyJlhpGpoEiBECzz1/z5s3lxb4w91ZUTMnkyRRPngyAfc0akqdOrVIEtK1ZQ5LRPuBq25bCadPCPs76hm8S8JYtWwL6nKgABLCvWhXKISkqoaioiD179gDIVhRfmjVrRhtjFnXr1q0h27a4kANPu7BCEWl+++03+TguLo7ECBrE1wQhAIoKQH8twCI5EVQbsEKhCAzL8eNohoBT3QAFKKse1JxONGNSojK+/fZbeR1gFgBdLpdMyfWtelu4cCGrjOvFO++8s8J7I9kWW0stwACXG9fGWVlZ5a6jLrvsMt555x3i4uIoLS1lxowZXH311Tz00EPSM/Dvf/87+/fvB+B80/WyL7XV7iwrAF0uMDqoQsHQoUNlB8nChQtlFeDmzZsZYBRovPfee/L+GLwFwJq2APuuTxFelACoqPPEmLwcHEEEgECZACgu8n0Tr1QLcGDkP/sspYZxbMx335FyzTWe2Ug/2FeuJPmGG9AcDvS4OHLfey+o1GaFh5YtWxIXFyefB5og627fXpbcKwEwcqSnp6MbF/uV/a6I9wL1dQyEHTt2AJ7fObMYqFBECnO1vb/q12iladOmQJkAmJSUJBMlfT0AQQWBKBSKwAiFeALe4qE1gDZg4f/XqlUrLy/WnTt3UlBQAODV/ltUVMQTTzwBQIsWLXjwwQcrXLcMxqilFmCAS9u0QTPshMxtwIKxY8fyzTffMHz4cK/Xe/Toweeff86AAQPkcbikEk95Sy17AAJYQtgGbLVamThxIgArV67kmmuukfcYIg04Pz+fd999t+wzIgG4cWMwVYwGgxIAawdb1YsoFNGN3RAAneecE/QsmqjIET9u7dq1kyXg4rkiAOx2ct95h+QpU4hZuhT7xo00HjqUonvvhSlT4OyzYdcuEl98kbh330XTdXSbjbzXXsPVp09tj75OomkanTp1kuJOWlpaoB/EMWwY1s8+w756taeFQHkvhp2TJ0/Kx0JU8Iev4FBTsrOz+eabbwAYMWKEvDCujI8++ohZs2ZV+P4NN9zAjTfeGPRYxASLxWKR4QrRgDgmKSkpUqSNBqLxeFX3WJmTyjt06BDy/QnXsRIVuTk5OSQlJWG322nVqhV79+4lJyeHJk2a0KRJExo3bszp06fJyMjw2n40frei8XsF0XmsIHqPl6JuY/bsq1EFoOmzlqNHoV+/CpctLCyUViSXX365V9GDaP8FbwFwxowZckLy8ccf92oN9qW2quKIi0OPiUErLaW5y8XAgQNZv349S5Ys4c9//nO5xXv06MEXX3xBRkYG6enpdO7cmSZNmuB2u3n66acBj2/gBRdc4H97paXSvzziAqBpe9rp09CyZcjWPXHiRGbMmIHb7WbFihXcdNNNvPPOO6xdu5YePXqQlpbGm2++yR133EFCQoIU7GrSwq4nJeFOScGSk6MEwAiiBEBF3aawELvhZRFs9d+JEyc4YYRWCHNys/8flF38KwIgPp7c//2PxCeeIP6NN7Dk5ZE4fTpMnw6AFYg3FnUnJZH/6quUGqEHiurRo0cPKQAG03rmGDaMuM8+w5KVhXX3blxdu4ZphAqBORwgNja2wuXEe0UBemlWhtPp5LnnnqOoqIjmzZvL2d2qKCgo8Eps9aWwsBBrEF6rvmiaVqPPhwvfCvBoIRqPV7DHatu2bfJxjx49wrY/oT5WLVq0kI9PnTpFq1ataNGiBXv37iUzM1Nuq0OHDmzatIkDBw743X40frei8XsF0XmsIHqPl6Ju4hWgUIMQkHICYCUsW7ZMXluY038B1q9fD0Dr1q3lvU9aWhovvvgiAOeee27l1xBOJxajci7Sohiahp6SgpaVheX0aS677DLWr1/Ptm3bOHDggJdNg5mWLVvSunVrmjRpIiddfzBCJc8991waVdCdJIRO8G4/jgTm6kotRBPFgu7du0uh75NPPuGjjz7igw8+wOl0ysmP7OxsZs2axa233loWYlMDARs8AqIlJ0d5AEYQJQA2EIK9aImWixwxjorGY1uzBq2kBADniBFBjXuvKQBBVOd06tRJznSdeeaZXt6AVY2xtqnqWEVoEBQ/8wzOsWOJf+IJbBs3lluk9IorKHr6adypqdTWSKPiWFVBIGMTRsXg8TsJdH/cF14oH8euWUNJ9+5VjiNaj1W0jqu20XWdmTNnsnPnTmJiYnj44YcD9l1LTEys0PgaPIlx1fEStFgsaJqGruuBpVZHCE3TsFgsuN3uqKs8irbjVZ1j5Sso9+/fP+RelOE6VuaKr4yMDJo3by5FwYyMDLkfQgDct2+f175F43crGr9XEJ3HCio/Xur8o6guUjxp1gwqmRSsCj0pCXdyMpbc3CqTgEX7b0pKCkONQDiBqAA899xzAXA4HNxzzz04HA5iYmJ4/vnnK+0g0EzecJEWxcQ2LVlZaDk5jLv1Vv75z38CMH/+fB544IGA1nH8+HEZwHZxJZ7yFsMvEGqhAtB0TrKYhMhQccMNN/DYY4+xa9cusrOzGT9+PJ999hlr1qyhQ4cO7Nu3j1deeYWbb74ZixF65aphsYy7dWvYubNKAVsROpQA2EAIpm3BarVGXZtDhb5VK1d6/p+QQKOxY8HkiVYV5rQ+kYzZu3dveYIMpE2pTh2rSDJ2rOe/tDRYvRpycuDMM+HCC4lJTSWmtsdnEBXHyg+Bfq8GDhwoH5eWlmK1WgPbpyZNPG3ZBw6Q8PPPJDz8cJUficZjFY3//irC7NdYUlIifcR8KTEmNOLj4/2+HyhvvvkmP/zwA1arlT//+c9eYnFVTJ48mclGsI8/srOzq9Wi3KRJE6xWK263O2QtzqFAfI9ycnKiKiQlGo9XdY6VrxF7ixYtQr4/4TpW5n+3Bw4coG3bttIz+OjRo3Jbwjx97969nDx5Ut4oR+N3Kxq/VxCdxwoqP15nnnlmLY1KUdcRYkdN/P8E7rPO8giAlQgoDoeDb7/9FvCEYQjrI4Bjx47J4gfR/vuf//xH/nY//PDDVV5DmKviIt4CbNqmlptLamoq/fr1Y/PmzUEJgOL+D2DkyJEVLue1rxEWAMNZAQjIdOTS0lI+/vhj7rvvPj777DNcLhdt27Zl3759pKen89X8+dx6/LhnTDX8DgtfcovpvlwRXpQA2EAI5CIvOTkZq9WKy+WSaUi1jRA0cnNzy18Q6jrJCxdiBUqHD6egqKjK9FkzmzdvBjzVLsLwtVWrVtKsvG3bthUetzp3rGqLs84iecoU72MVBTccUXmsCP575ZvEtmrVKoYMGRLQthKGDCH2wAHcy5aRc/JkhT6A0XisavrvrzZEQ7Pv38mTJysUAEU1ck3G+O6777Jo0SIsFgt/+tOfvPx8FIpIY/b/A0/bVV3hjDPOkI+zs7MBZHVsdnY2brcbi8UiW8wKCgrIzs6uU0EnCoUi8oSqfRKMFuJffsFaiQC4du1aThvC1RU+9jvmELlBgwaxa9cunnzyScBTGHHPPfdUOQaLqQIw4i3AlAmAoirummuuYfPmzaSlpfHrr7/SNQCrmwULFgCQmppKz549K1yuNluAzcc2HBWATZs2ZcyYMcybN48vvviCJ598ktGjR7N48WJ+/vlnWrRowfHjx3n91Ve5VaRY18ADEMr+DViOHwenE2xKngo36gg3EIK9cY+WG32By+UqNybrr79iNWasSkeODHrMv/zyC+BJJBQCYLt27WSKX/v27QNaZ104VtFCtI2rrh+rs846i9jYWFk1tmrVqoDFntJhw4j95BMsJ05AWhqubt2qHE80HqtoHJM/2hjJdLquc+jQoQr9RYUHqa+4Gygffvgh8+fPR9M07r333opNrBWKCOEbUGT21Yt2zBVewjNYCIAOh4PTp0/TtGlTryTgAwcOKAFQoVBUikxQDVEFIFBpC/CiRYsAT1Wzb7rtGsNLPSkpia5duzJu3DhKS0ux2+28/PLLXtWCFVGbohh4VwACXH311Tz++OPous7HH3/MU089VennMzMzWb16NQDjxo2rtN25VsXOmBjciYlYCgrCUgEIni6QefPmUVBQwIIFC7jvvvtYvHgxxcXFDBgwgOPHj7Npxw7WAkOoeRWr27ge1txuLBkZ8rkifESn065CEQAxpnj30hEjgv68SAAWlTjx8fFomiYDQVJTU0MwSoUifGiaRufOneXzLVu2BPxZx7Bh8rH9p59COSyFH+Lj4+XfatOmTX6Xyc7Olm04faqRjj1r1izmzJkDwJ133smIavwuKhShxvx9T0hIqHF7eyRJTEyUwTy+AiAgvQ07dOggX9u3b18ER6hQKOocpaVoWVlAiAXAo0fBj3+mrut8/fXXAFx44YXl/ICFADh48GDeeust+Zv90EMP0aNHj4DGoNVyBaAQHcU4WrVqxaWXXgp4ro0KjdTeivjss8+kx+dVV11V6bK13u5sdIiYj3koOf/88+Wk1kcffcSAAQM4//zzAU+gl7DGeMFYvqaCnVlAVG3AkUEJgIo6i33pUgCc3bsH/eOTn5/PEWP2zel0Ap4AEHMCcEWpUQpFNNG3b1/5+Lfffgv4c+42bXAZ33H7qlUhHpXCHxcZSeUrV64ky7j4NzN37lx0Xadp06b06tUrqHXPmTOHTz/9FICpU6eWa/FRKGoLYasBdav9FzyTLKJ9XwiA5uo+8e+4devW8qYomN9hhULR8LBkZKCFqH0SwGV4kGqlpWjG75SZrVu3ctRoDx49erTXeydOnJAdUZ07d+bf//434JmEfPDBBwMeQ7S0AJvFuSlTpgCQk5PD3LlzK/ys2+3m/fffB6BXr16Vtv+at6FbrehJSdUfdDURx9cSpgpAi8XCDTfcAHjSoXfv3s39998PQF5enhSFvwAOULMUa/D+N6CCQCKDEgAVdRItNxf7zz8DnvbfYDFfoOcYJ62uXbuyf/9++boSABV1AfOFytEgT5wOIwXOvno11JFW2rrMqFGjaNmyJcXFxfzjH/+QvzclJSXMmTNHtuhMnjwZm48Hyq233spVV13Fiy++WG69CxYs4MMPPwTg5ptvZty4ceHdEYUiQAoLC6WvJVBh63s0I3wAK6sAtFgssgpw7969ER6hQqGoS1iMAgQoE+9qgrmK0LxugQi3sFgsXHbZZV7vmf3/li9fTklJCTabjffffz+g1l+BFMU0Db1Ro2CGHxKkB2B+vsdHDk+Sr7iXe/311yu0jFm6dKms3L7lllsqbf+FMrFTT0mp0D87nLhFBWAYPAAFN9xwAxaLRyb6+OOPufDCC2Vnirh2dQMzExIgpmbRjmYB0ern+6sIPUoAVNRJ7MuXoxk/8NURAM0VCeICvnPnzvJHLSEhoU75FCkaLt1M3n0FBQVBeeKVXngh4JlFtG3fHvKxKbyx2+089thjpKSkcODAAe6//36uv/56rrvuOj788EN0XWfs2LGVps/545133gE81Upffvklv//97yv8b9euXeHYNYXCL77ft7p4XhU+gP4qAMX1A6AEQIVCERBmr75QVACaBUCrHx9AIQCed9555ZKrRfuv3W6XlYAPPPCAV3dJIIh2VD05GSyRlxe80nGNsVgsFu644w7AE0b1xRdflPucrus8/fTTADRq1Ihrrrmmym1JsbMW2n+hrAIwXB6A4PEYFzYys2fPxuFwyCrAkydP0t2ofHy7pIT8/PyabSw2FrdxXvUnYCtCjxIAFXWSGKP9152SgvPcc4P+vBAAY2Nj0Y0y/C5dunDgwAHAU/1X1QyQQhENdO/e3eu58LYMBMfw4fKxfdmykI1JUTHt2rVjxowZjBs3jlatWuFwOEhMTKRPnz789a9/5fbbbw96neI3TNd1Tp8+Xel/wvJAoYgEq3zsBepaCzCUrwCMi4sjOTkZwKuVv1OnToDHA1B4SSkUCoUv5iondwh+E70qAH06Qfbu3SuT2P1Zg4jgCzF53L17dx5++OGgxyCr4mqh/dd3u+bKuN/97ncyVO2ZZ54pJ1YtWbKEH3/8EfB4JycF0NIrBEZ3Le9rOFKAzUyePBnwnPu++uorxowZI89zJ4uKAMhxufjkk09qvC2XIYSrFuDIoFKAFXUPt1sKgI6LL65WXLgQSZo3by5N97t27eolACoUdYHGjRuTnJxMrpF8tmLFCs4555yAPqufeSbOXr2wbd+OfcUKioLwe1FUn8aNGzN16lSmTp0a8GfefvvtCt9bsGBBKIalUIQcXwHQ3D5bV/AVAMGzH7m5uRw/fly+1rFjRwCKi4s5evRonWx3VigU4UeIHO5mzcAIGaoJenIyekICWmFhOQFFVP9Bef+/3NxcduzY4RmL243VauXll18mphotnbVeFWd4tQJYTp7Ebfwex8bG8te//pU//vGPpKen8+c//5lXXnkFTdPIzMzkoYceAjy/83feeWdA27LU8r66I1ABCHDZZZfRqlUrjh07xrvvvsv48eO59957uf/++8lwuWgLHAbeeustpk6dKluGq4O7dWvYskW1AEcIVQGoqHNYt2/HYsy6lxoJT8EiZsPETI/NZqN9+/ayBVglACvqEuY24J8Nb8xAKTWCKezr1kFNy/gVCoXCRH1oARYhICdPnpSVfULINLcACwEQVBCIInLk5OTwzjvvcMcddzBx4kRuuukmpk2b5uXtFgyFhYUsW7aMF154gbvvvptrr72WCRMmcOutt/Lcc8+RlpYW4j1oeAiRzhWCBGAANE2uy+LTAizSf3v27Em7du283lu7dq3sIAC46667pM9b0EMQVXG1JYoZvnhQXhibMGGC9D78/PPPueOOO/jqq68YP348x4zj9a9//UtWdleFVtvVjsa+WnJzpd9hOLDZbNx8882A594iLS2NiRMncpbh2Sfq3Pfv38+KFStqtC2vJGtF2FECoKLOEfPdd4DHaLb0kkuC/nxRUZEU+sSJr0OHDuTm5srScFUBqKhLDBgwQD4O1uPNYQiAmsOB3fCCUSgUipridDq9BDLwpOXWNYRnlsvlkqFhwgfQXwswKB9ARWQ4dOgQ99xzD19++SXHjh3DarVSUFDAli1bmD59Om+99VbQ63zwwQd54YUXWLZsGYcPH0bXdSwWC5mZmaxcuZK//OUvvPfee2HYm4aDrAAM4e+hPwElIyOD9evXAzBmzJhyn/nOuJ8Cz33PI488Uu3t13ZVnG4SAH3TcTVNY+bMmbI7Zt68edxyyy2yGOS+++5j/PjxAW9LVDvWVguwP7/DcGEOpXv33XeJiYnh7kmTADgCJBoVrDX9TRD/FizZ2VBcXKN1KapGCYCKOodo/3X274/uY2YbCLt375az+ELwM/v/gRIAFXWLHj16yMdBJwEPGoQeHw9AzPLloRyWQqFowOzcudOrugTqdgowlE8CNgucTZo0kdWCqgJQEW4cDgdPP/00OTk5tG/fnpdeeonZs2cze/ZsJk+ejKZpLFy4kKXGNXOguFwuzj77bG6//XbeeOMN5syZw2effcZrr73GkCFDAI+AIirLFMEj2hzdIUgAFoh1WU3XgEuWLJGPff3/dF1n3rx58vlLL71EvHEtWB1quyrOSxTz0xrbpEkT5s+fz5VXXilfi4uLY9q0abzwwgtB+b7XeruzudoxzD6ALVq0YOzYsQDMmTOHnJwcJvfvj3BKbG6c85YsWcKRGrTvuirxsVSEHiUAKuoUWlYWtk2bgOq3/5orpDIyMgCPACiqAkG1ACvqFuYW4MLCQhwOR+AfjovDYVzU25UAqFAoQsRXX33l9dxqtdbJFmB/AqAIM8nKyqK0tFS+L9qAVQWgItwsWbKEjIwMYmNjmTZtmrxujY2NZdKkSVLw+eijj4IKf3rggQd4+eWXGTt2LK0MUUnTNFq3bs2jjz5Kr169ALzEI0UQlJZKG6OwVAAeOwbGxMuiRYsAT1GDb2Dcp59+Kiua+/Tpw9ChQ2u0fSG6mVtxI0p8vJzM9q0AFJxxxhm8++67pKWl8c0337Br1y4eeOCB4LzrSkuxFBQA3kJcJKms2jEcTJkyBfDcX8yePZsmp05xi/HeAeM+2u128+GHH1Z7G+Z/C1YlAIYdJQAq6hQx336LZpzYSkeOrNY6RMx9fHy8vCgyVwDabLY62aakaLh06dLFa/Zy69atQX1e+ADadu9WM28KhSIkiGRFwVlnnYXVaq2l0VSfM02dBtnZ2QBSGAH8BoHs27cvQqNTNFSWGxN2w4cPly3pZiZMmICmaZw8eZLt27cHvN6ePXtW+J7FYuESw3onIyOjXKKqomrMHn3uUHkAmtalFRWhnT5Nbm6uDGG64oorvK4RCwoKeOKJJ+RzEYRRbRwOjx8dtSeKQZn4WFU4RvPmzRkwYEBAib++aCdPlm3PFDwSSaqqdgw15513nhSQ33vvPbQjR7jHeE/XdXnP/L///c9rQiwYzAKgRQWBhB0lACrqFDHffAN44sJdvXtXax07d+4EPDcjArMA2LZtW+l3oFDUBWJjY73SNZcHWcknfABBVQEqFIrQsHv3bgAp+tXViTXzb6sQ+8zXD8dMN/RCADx06BDFysdIESaKiorYs2cPAP379/e7TLNmzWTLfbCTgpVhDkpwuVwhW29DwTzJGrIQEMq3UC5dulR2g/im/7744oucNIQsi8XC8OHDa7RtswhVW6IYmMIxTCJdqDFX3Om1tK9eFYBhbgEGTwXwLbd4av5+++03Vm7cSBfg8rg4AE4ZxyQrK0tWnQaLu0ULdKMSUwmA4UcJgIq6Q2EhMUbKUOnll0MQfg1mRAtwo0aNAM8PW6dOnVQCsKJO069fP/l448aNQX3Wdc45uIzWPOUDqFAoakpeXh65RkWImFCrqwJgcnIyccaNjhAARQsweAuAIghE13UvWxGFIpSkp6dLf8327dtXuJx47/DhwyHb9o4dOwBo3LhxwKmpijLM7Y0hrQA0VSVbjh5l8eLFgKeC+dxzz5Xv7d+/n1dffVU+P/fcc0lMTKzRtqNBFANTBWAYRTFLtFUARkAABJg4caK8b35j2zYA7jH88gsLC+VvQbXDQGw23MZ5VXUihR8lACrqDDHLl6MVFQFQ6mNmGyinTp2Svn+Cdu3aER8fLysAVQCIoi4yaNAg+VgkmwWMpuG48EIA7CtXghGSo1AoagctNxeOH4c62mI3f/58+ViEbtVVAVDTNOldKARAcwuwWQDs3LmzfCwqIBWKUHPSJEI0rUSEEO+dClGbYHZ2Nt8YnTgjRowIKjhB4UGIG7qmhTYExCQmlh46JMNfLr/8ci/rhWnTpnm1ada0+g+ioy0WIlMBGBX7Gh+PbqTvRkoATEpK4rrrrgPgq+xs9gEX9+ghJ73ERN+aNWuk1VawiDZgq6oADDuqz1FRZ4gxEsfcyck4qmlWaw4AEea3Xbp0IT8/nyzDlFdVACrqIn369JGPzZ5UgeK4+GLiPvsMy4kT2LZswVlBW5FCoQgDBQXEzp1L7DffYFu/3quiwtKyJY0GDeL/2Tvv8Ciqtw3fsyW90lvovYr8EBGkSC8CCiIIUpUmAgqIIOqHKGKjg6LYkKKCIFIUEQFRQEAQpPceOunZzZb5/tiZYROSsEl2s5vk3NfFxWZ35syZs7NT3vO+z5PSsSPmzp1BufH3ZZzLgNQytLzoAKxSrFgxzp8/r51bg4KCCA8PJzY2NtWkYsWKFTEajVgslmw/BAkE98O5vNw/k/OB+lmyMnmeE6xWKx9++CHJyckUK1aMHj163HedJUuWsGzZsgw/7927N88880yW+6KaNuh0OiJzUXNODXiGh4ff43DuchuKkRDFixPpgimSy/saEYHs749kNvP3vn0kKkYVTz31lLbeH3/8oQVwVTp16nRPu1neT6eAYmj58pDN7ySn36ukOiHHxrq8flb3VXL67YVXrOi1faVQIYiOJjA5mQAP7Wtaxo4dy+eff45dlpkDzKhUidEtWvDiiy9y+/ZtdDoddrud5cuXM2fOHCBr+ymVLw979mC8di3Hv2t3/FazirfOS9lBBAAFeQObDb9NmwDF/MNozFYzzgFA1a68Zs2awgFYkOdRnfkAUlJSSE5OJlBxRHOFlJYtkXU6JLsdv02bRABQIMgNkpMJnD+fwE8/zdDNT7p6Ff+ffsL/p58ILlqUpJdewjRwIPiwVq0qQ6DX6zWdsLyaAQjckwEIjizA2NjYVBmARqORypUrc/ToUZ8IAEqxsRh37EB/8qSWuSKVKwe1a4Pi/i4Q3A9Zlpk3bx5HjhzBz8+PcePGuVQ2mpiYyPXr1zP8PCkpKUfGQJIkecVYKEuusWm5dAkAqUyZLPXdpX0tUwZOn2bN/v2AI2urbdu26PV6ZFlm8uTJANokRXBwMI0bN86wXZf30+napS9WDHL4nWT7e1Uc26Xbt7O8fpb3VadDX7gw5ORYIAf7qgQAdXfuZHm8s3v8Vq9enS4dOrBmwwY+B6YUK8aAAQOYPHkysbGxFCtWjKtXr7J06VI+/PDDVM8gLu1n2bKOZS9edNvvOke/1WzirfNSVvDdu0eBwAnD7t3olFmzlPbts92OGgAsVKiQVkJRs2bNVI59ogRYkBeJjIwkODhYm/XduXOn5tbnCnLhwlgbNMC4Zw/GTZtgwgRPdVUgEADGP/8k5KWX0CvyEwC2smVJadkSW7VqBBUvji42FvuBA/Dzz+iuX0d34wYhkyYRsGQJ8fPnY8vEsdNbXLhwgRilLKl48eJcUUre8nIGYHoBwBIlSnDs2LFUAUCAatWqeTcAaLfjt3EjAYsWYfzrL6QMjBp0BgNhLVqQPHAgltatc/wgK8g9VE1KALPZTFBQULrLmc1mgCxNBqbHp59+yu+//45er+eVV16hevXqLq0XHBycykQnLUFBQdkyEtHpdEiShCzLmsRAbiBJkpbllN2sIt3Fi0iAXKYMdhf2PSv7qitTBvvp0/ykXFPat2+P0WjEZrOxbt06duzYATiyom7evEmzZs1STdJkdz+lGzfQoZQ1h4VBNs1hcvq9SpGRDm2zhARsycng53f/dbK6r9evO/a1UCHssuy1fdVFRjqOo1u3XDqOwD3H76hu3VizYQMJwKeHDvFyYCD9+/dnzpw52vUxNjaWFStW0KdPnyztp1S6tOP7i4nBFhsL2XBp1tpyw75mlZx+p7kZNBQBQEGewKiI2cpGo+NGNZuoDsDFixdPFQBUy5V0Op0IAAryLFWrVmW/MvO7ffv2LAUAAVLatHEEAA8cQLp6FdlJ6F4gELgJu53AOXMIevddJOUm0dKwIUkvv4zlsce0QExgZCTo9cg2G3du3MDv558Jeu89DMePYzhyhIj27Ul4913Mzz7rzb25h59++kl7Xb58+XwVALx58yY2mw29Xq/pAKYNAKrBkbNnz+a6E7Bhxw5CXn0Vg1O1AzgezOWICJBlzTVSslrx++03/H77DUu9eiROmYK1SZNc7a8gezjr/t2+fTvDAKB6n5uTcrQvvviC9evXo9PpePnll1PpDd+Pvn370rdv3ww/v3nzZrb0CSMjI9Hr9djtdrfpG7qCXq8nMjKS2NjYbDsgF1ICgKaiRUl0oe9Z2deQ4sXZC1xXZBfatGnDnTt3sNvtTJo0SWvv5s2bADRu3DjdNrO6n0GXLxMEyOHh3ImPv+/yGZHT79U/IIBQ5XXM6dMu3cNmdV9DoqMJAGyRkcTk4NjL6b6GhobiD1hv3CDWxfXdcfw+GBTEg8A+YPaGDTx74wZPP/00c+bMQZZlQkNDiY+PZ+HChXTs2DFL++kXGYlqKxR3+DC2qlWz1Udwz75mlZx+p0WKFPFAr9JHTPcJfB9Zxqjo/1maNEEODb3PChk1I2sz8ursqdFopFKlSloGYNmyZTPVUxEIfJnmipEHwN69e7O8fkrbttprP0VAWiAQuBGrlZAXXyT4nXeQ7HbswcHEz5xJ7Lp1mWdhGQykPP44MVu2kPjmm8hGI5LZTOjLLxP01luQSzPcruBsAFK0aFHA8bCSlx1D1QCg3W7X9IKdA4DOGQZqANBms3Hq1Knc6WByMsFjxxLRtasW/LMXKULSiy8Ss3Ytt86f5/aJE9w+edKRWbF5M/ZRozQ3SeOBA0R060bw+PGgZJELfJcyZcpoGlcXLlzIcDn1s6ioqGxtZ/Hixfz4449IksSLL77Io48+mq12BApmMzrl/OFOB2AVe6lS/Ki8NhqNtFYSJlavXq0lQDhPDLvDAATumm540wEY7pqAANpEh7vR9tXLGm+ycu72pOFJehiuXOFl5fXl69dZu3YtVatWpbEiKaFmvu3YsYPTp09nqW27k0yIThiBeBQRABT4PkePolcCdNl1/wWH5l+8MjOlipJXrVoVo9Go3aSrbkYCQV6kYcOG2uuTJ09meX1bzZrYlJtSVXNTIBC4CbOZ0OeeI+D77wGwVqtG7G+/Ye7b1/XyS6OR5JEjiV2/Hptysxw0dy4hL73kE+7d8fHx/Pfff9rf6rU2uwEIX6G4k1h/Widgs9mcarbfuTzyaJpMPE+gO3+eiPbtCVy8GAB7aCgJU6dye98+kt54A+vDD4NzCWhwMDz2GPKMGdw+eJDEN97ArkysBn71FRGtW6PL4oObIHcJDAzUHKf37duX7jI3b97k4sWLQGqTMFdZtmwZK1euBGDYsGG0atUqm70VqKgOwIB2/nYntlKlWK28frRRI8LCwrDb7cyYMQNInYVdpEgRatSo4Zbtqvqi3nQABrA7BeUkDwXGJOVcb1f0Br2Fun3NVCaX0F26xFNAaWUC4pNPPkGWZQYMGAA4dD/VyYmlS5dmqW2bU1BcBAA9iwgACnyfNWu0lznR/zt06JD2Wp3Br1mzJrIsiwCgIF9Qt25d7XW2ymIkiZQ2bQDw27oVFP0ggUCQQ2w2QocOxV+Rm7A0bOgI4mXzmmOtX5/Yn3/GqjzABSxdSvDEiV7PBPz999+1DIDy5ctrAYi8bq6VWQAQUpcBly9fXqsy8LQOoP7gQSI6dMCgZPektGjBnR07MA0bljrolxGBgSS/+CJ3duwgRckMMpw6RUT79hj//NOTXRfkkBYtWgAOZ1f1ntaZVatWIcsyhQoVSmUS5gorV67k22+/BWDw4MF0yMHku+AueqcAoCcyAP+z2VAVzTv9738A/Pzzz5w4cQKAkSNH8tdffwHw6KOPus0gwWey4pwzAD1UGq7q0Xt9X5UAoC42FpSJttxAd+UKfsAIJdi7b98+9uzZQ6dOnSis9EmVHPj222+1SUBXkIsWRVZMPp1/KwL3IwKAAt9HCQBa6tXL0QXz4MGDgEMXQL2Br1mzJjdu3CAuLg4QAUBB3qZ48eL4KaLHdrtd097KCmoZsJSUhFERjBYIBDlAlgmeMEEL/qU0a0bsihXI4eE5atZesiSxP/2EVTECCfziC4KmTctxd3PCL7/8or1u0aIFZ8+eBfK+uZZzAFB1NS3hpC/lHADU6/VadpYnMwANu3YR3rWrVlKYNH48cd99ly3tVrlECeK+/ZbEyZORJQldTAxhPXvip8ivCHyPdu3aUaJECUwmE1OnTtV+a2azmZUrV2ra1n379sWQxjH8ueeeo0uXLsyaNeuedn/66ScWK9mk/fv3p2vXrp7dkQKEc1aT3QMZgD8dP6697lypErIsM3v2bMAhx/Dggw9y9epVwH3lv+CUFedLGYAeCgD6WgYg5G4WoF45hgdVr65pj86bNw9/f3969+4N3NUevXHjhnYecgmdTnvOFxmAnkUEAAU+jRQdDX//DeSs/BfQypKcS5Fq1KiRSqNHBAAFeRlJklId3z9n4+HN0rQpspK9IsqABYKcEzhnDoFffw2A5cEHifv6a0cZphuQIyKIXbECqxJwCpo1C38lcye3sVqtbNy4Ufu7bt26JCQkAHk/A7Bw4cIYlcwENdiXUQYgoJXWeSoAqD9wgLBnnkGXkICs1xM/axZJr7ySMydfSSJ59Gjiv/oKOTAQyWIhdNAg/JxMXQS+g9FoZPLkyYSHh3Pu3DlGjx5Nr169ePrpp1m8eDGyLNO5c2dNB85VPv/8c8BxP7FmzRr69euX4b/cKHHPT6hBDVmnw+4Bk7X1u3YB0BgolZTE9u3bNWO4YcOG8adTVm9WTeIywyc1AD0RALRaHRl3eD8D0DkAqMvFAKB6DEeUL0+fPn0Ax7PGsWPHeNbJkEx1Hl+0aFGW2tcCgCID0KOIAKDAp/FzmjlI6dgxR22pAcDCTifNWrVqpRIprVSpUo62IRB4m0ceeUR7vW3btqw3EBSERXGC9Nu0yeslhQJBXsa4eTNB77wDgLVSJeKWLYOQELduQy5ShLiVK7EpWWohY8di2LPHrdtwhT179mg6uwDFihXTXuf1AKBOp6OU8mByWXkAKlKkiBYUVLNqVFQdwPPnz2sVBu5Cf/w44T17oouPdwT/Fi3CrDyIuYOUjh2JXb4cOSgIyWoldOhQjJs3u619gfsoW7Ysc+fOpWvXrpQsWRKLxUJwcDD16tVj0qRJDBkyJMttqoY2siwTExOT6T+r1eruXcrXqEENe/HikCYrM6ecPXuWQ4rkwJM4AjVqhmdYWBgDBw5ks/I7rlWrlnY+yzE2G5JiuOHtDEAMBuxKZr0nNACdswq9va+yk2NsrgUA7XZ0ymSXrXRpXnjhBe0aOHv2bCpWrKhJE6hs3LhRkwJxBVUbU2QAehb3nn18nNjYWFauXMnu3bu5desW/v7+VKpUiY4dO/Lwww9nu12r1cq6devYtm2bVnJXunRpmjdvTqdOne5JvVeZNWsWv//+e6Ztly1blnnz5mW7b3kdozLzbKtSBZuTsHZWuX37tnbTrtfrAYdGQfHixbUMwODg4FRlPgJBXqRVq1Z88803ABw4cCBbbaS0a4ff5s3oz51Dd/QoKAFBgUDgOrpz5wgdNgxJlrGHhhK3dKmm2+Nu7KVKEb94MeFduiCZzYT170/M7797JMskI3799Vftdfny5YlVMiXUv/M6pUuX5vz589q9hE6no0SJEly8ePGeDEBnzbV///03yxpsGSHduEFY795axk3C7NmkdO7slradsTZpQuz33xPesydSUhJhgwYR++OPWOvXd/u2BDkjIiKCwYMHM3jwYJfXySwr5yeR8ekx1PJJT5T/btiwQXv9BPDv4cNs374dgEGDBgHwt1JR5c7sPyk2FknRffV2UAwc7ue62FhNGsGdODvuejvb0Xmsc6sEWHf9OpKi6WcvVYrSpUvTs2dPli5dyqpVq5gwYQL9+/dn69atJCcnA46JhC+//JLXXnvNpW2oGYD6y5cdCQiKoYjAvRSYDMALFy4wcuRI1qxZQ3R0NHq9nsTERP7991+mTZvGZ599lq12k5OTefXVV/niiy84ffo0NpsNm83GqVOn+Pzzz5k0aRImkynTNvz8/IiIiEj3X1hYWLb6lR+Qrl/HoGiQpXTpkqOTgLMroVqSVLNmTSRJ0jIAK1eurDkXCQR5lQYNGmivVa2qrGLu0AFZ+S34rV3rln4JBAUKs5mwQYPQKZkR8Z98gt3DGebWBx8kQcn40N24QciIEWCzeXSbzjjr/zVt2lTTJDMajZT2wANvbqM6aF66dEl7T82icX4PUgcA1RK8HJOSQtigQeiVbIqEd97B/PTT7mk7HayNGhH35ZfIBoMjCNi7NzrlOxUIBFlHywB0kg9wF6rWWt3gYCoBHyu6535+fgwZMoRt27ZpGZvudHR2zorzdlksOJlj3Lzp9radswq9Hez0Rgagzuk6Z1fkhl588UV0Oh12u525c+fSrl07LZlGjWF8/vnn2Fy8F1GD41JSEpLTJKLAvRSIAKDFYuHtt98mNjaWcuXKMXv2bL777ju+++47+vbtiyRJrF27lt9++y3LbS9YsIATJ04QHBzMxIkTWbFiBStWrGDixIkEBwdz7NgxPv7440zbaNq0KYsXL0733zQvC3p7E/+ff9ZmlSxduuSoLecAoHqjrmr0CAdgQX6iRIkSmhGI1WpNVZLnKnKJElgVBznjunVu7Z9AUBAImj4dg3LdSRo/HotiruNpzD16kKxke/ht306gIgDvaU6fPp1KT/eRRx7h3LlzAJQrV07LvM/LqEHMy5cva2WSquZq2hKnwoULa8u7KwAY8uqrGBWNr+SBAzFlo7wzq1gee4yEOXMAx0NmWP/+oEyiCgSCrKEFAN08IXL16lX2KLIPXSpW5BrwvZIB9+STT1K0aFGt/Dc0NJSHHnrIbdvW+VBQDMBetCjgmaw4X8oAlIODkf39Ae8EANVS3UqVKtFFeUb/9ttvuXnzJr169QLQ5C8uXLjgcozF2exTlAF7jgIRANy4cSNXr17F39+fN954Q9Oi8ff3p2fPnpq9/ZIlS7KkZ3H27Fn++OMPwBEBb9y4MZIkIUkSjRs3ZuTIkQBs3bqV8+fPu3mv8j9a5lGlStgUl8PsojoAlylTRjsh1axZE4vFon03IgAoyC84G4FkZ2ID0MrKDIcPg9ODvUAgyBzjn38SOH8+AJZGjUgaOzZXt584ZQrWWrUACHr/fQxK2ZcncTb/AGjcuLEWEMzr+n8qagZgcnIyt5QHLvVce+nSJS0oqFK3bl0A9u3bl+Nt+3//PQGKtENKkyYkKrqSuYH5qadIfPVVAAxHjxL64otCG1YgyCpJSZoxhc3NAUBnw7fHGzTgUyBF+fu5555DlmUtANi8eXNNt80d+FJQDBwlwJALGYDeznaUJM0IJLdKgPXOLtZOgboxY8YAkJKSwoIFC3jmmWe0z/yVIOUXX3zh0jZsIgCYKxSIAODWrVsBh+V5UWVmwJnu3bsjSRK3b99OlSl2P7Zt24Ysy5QsWZLGjRvf8/kjjzxCyZIlkWU5e2L8BRjp9m2MqltVjx451gBQv9cSTnpI9erV4/z581rQVxiACPILzZo1016nfTB3FXOnTnf/WL06p10SCAoEUkwMIS+8oOn+xS9YALmd/RYQQPxnnzlMHGw2QkeM8HjWlvN5ply5cpQqVYoTJ04Adw0x8jrOZcyqDqAaADSZTNxIozmllgEfOXLkvlIwmaE7fZqQ8eMBsJUsSfznn4MbH+BdIfmll7Rrgv+6dQTOnJmr2xcI8jp6J1dTu7sMOBRU/b8KFSpQsWZN1Lqzhx98kHr16nHkyBFNp9Sd5b8AklOgzRcyAGXnAKCbJypUXUFZp8v35c7poWYA2osWBcXlFxymMm2VKofFixcTEhKiGRKqPgg//fQTN13op3N2rF44AXuMfB8ATE5O5uTJkwA8+OCD6S5TtGhRbWY3K6L5alZZ/fr109WOkySJ+opgsrqswDX8fv4ZSdUL6N49R20lJCRoOn9qaaSfnx/Vq1dPVbIkMgAF+YVu3bppr/dk0w3UXq4cVlXHatUqN/RKIMj/BE+erN20Jr7/PvayZb3SD1uVKiQoWWL6CxcInjrVY9uKiYnRxOUBWrRowYULF0hKSgKgWrVqHtt2bqLeJ8JdKZH03lNRMwBtNhtHjhzJ3kbNZsKGDEFKSkLW6Yj/5BOPGclkik5Hwrx5WJXvMmj6dIx//ZX7/RAI8ijO2UzuLAG+c+cOfyoJE507d2bNpUuolkRDO3YE0LL/AFq3bu22bcPd4JMsSd45N6VBy4ozmSAx0a1ta/tauHDuT+ylg7qvuVYCrBzDNqfrnsrLL78MQFJSErNnz9ayABOV78BisbBixYr7bkMuVAg5ICDV9gTuJ98HAJ3LMsqVK5fhcupnrlpVy7Ks3exl1m5Z5eY/s3YPHjzI0KFDefLJJ+nVqxcvvfQSS5Ys4Y6TsGpBw18p/7WVKQOKFll2OXLkiHYMqCeiGjVq4OfnlyoAWLFixRxtRyDwFR544AHt9dWrV7PdjpYFuGsXkpiJEwgyxbhlCwHffQeA+fHHMffo4dX+mPv0IUVxewz84ou7WfVu5vfff08l8N28eXOOHTum/Z0fMwDV+7+yTgHetPd5zkYg2Z0EDn77bQzKuknjx2NVsiq8gRwSQtzXX2MPDkaSZUKGDcu10jOBIK/jqQDgr7/+qlUydezYkY8V2ZcyQBfFfV3N0K5Vq1aqSih3oGXFFS4MSraXN7E7m2O4OTNO3Vd7sWJubTe7qPuaayXAagZgOsdvgwYNaNeuHQBfffUVDRo0IDQ0FHA4lYNDai2tVMY9SJKWIasTzx0eI98HAG871esXyiQ1Wf3M1aBbcnKyVtLhSrvJycmaJXZabt68yfXr1wkICMBkMnH69Gm+//57Ro4cmaWMxPyCFBODUdFWtOTQ/RdSG4CoN+jqzLyaHVqqVCmCg4NztB2BwFcICgoiQJlBS0lJwWKxZKsdVQcQwE8pMREIBOmQkEDIuHEA2CMiSJg+3csdAiSJhJkzsSs34SGjR3ukFPjXX3912qTEo48+qgUAJUmiSpUqbt+mNwgJCdEeZNQAoHNQMG0AsGTJkhRWMjSyIi+jYvjrLwI/+QQAyyOPkPzSS9nptluxV6pE4gcfAKC/etVxTAk9QIHgvqjBDNlg0Iwq3IFa/luiRAn0ej3/KNnGIwC/q1e5fv26VgnSUckIdCeSGhRz4z7lBNmpH+4OAPrcvuZ2BqAaAEwnAxDgVUUrVtUCfPLJJwE0M8ITJ06wd+/e+25H1cgUGYCew/uheg/jrLuiClGmh/pZRkG6tDgv50q76jqBTjXzlSpVomrVqjRs2JDChQuj0+lISkpi9+7dfPXVV9y+fZtp06YxY8aMVDeZ6bFkyRKWLVuW4ee9e/dOJcqZHjqdTvs/0ovaBtK6dUhKwMJP6XN4ePj9Zw0yQC29KV68ONeuXQMcAuWRkZFaBmDt2rWztM++MlbOqGXoORkrTyDGynXcOVYVKlTg6NGjgEOEvn379llvpFEj5GrVkI4fJ3DDBvyVFH9v44vHlKBgEzx9OvoLFwBIfOstZF/JEChVisSpUwkdM8ZRCvzOOyS++67b2rdarfz+++/a3w0aNCAiIkILAJYrV46goCC3bc/bREVFERMTwwXluw4ICKBYsWJcv379ngCgJEnUrVuXLVu2ZH0yNzGRUEVY3WtakhlgfuopjFu3EvD99/hv3Ihl0SJMzz/v7W4JBD6NaqBgL1HCbb/lxMRE7fzbsWNH7TnQCAzGEXTcuHGjdp+rml66EzXI5px5503sTmXI7g6MaRmAvrKvSpKRdPs22O2g82BeV0LCfU1sateuTdeuXVmzZg3Lli1j0aJFfP3119hsNgwGA1arlSVLltCwYcNMN6VmAOpFANBj5PsAoC/z+OOP3/NeUFAQLVq0oGbNmowZM4aEhASWL1/OOCWzICMSExO5fv16hp8nJSWhd/GCI0mSy8t6BFVvrHRpdIq5ii4HJ7Xdu3cDjoCIGgD83//+h06n0wIkderUydY+e32s0iEnY+VJxFi5jjvGqm3bttrxvXTpUjo5m3pkhe7dYdo0pG3b0F+7Bm4Wr84JvnhMCQoehn37CPj0UwBSWrTA3KuXl3uUGvMzz+D/00/4/f47AV98gfnpp7E6yQTkhL1796aqnGjevDmAFgCsUaOGW7bjK1SsWJH//vuPM2fOaO9FRUWlGwAEtADgkSNHsFgsLrtvBr/9Nvpz5wBHQNmdJYPuIOG99zDu3Yv+zBmC/+//sDRtii2ffdcCgTtRMwDdaQCyefNmLdGlVatWDB06FIBuYWEUi4vDfPkyGxQzpqioKGrXru22bavofCwrzjk4J6UxZsopmgagj+2rZLcj3bnjUQ3GVCY2GWQAAkyYMIG1a9dis9lYt24dtWvX5tChQ4SEhBATE8OPP/7I22+/rZUHp4d6vdNFRzsyzHNYCSi4F998+nUjahkcgNlsznA59TPnDL3McF7OlXaz0jZAsWLFtAf2vXv3YrfbM10+ODiYYsWKZfgvKCgIm82W6T91hkiW5fsu67F/t24hK1oV9ieeQN1ru92erfZu376tPYioWQgGg4GaNWty7tw5LS25Ro0aWWrXJ8YqzT/1GMnuWHnqnxgr74zVgAEDtPPD9u3bsz9WajBDlrEvX+71MXLHOAkEbsNuJ/iVV5BkGTkoiIQPP/S9m1VJIuH995EDA5HsdoLHjQM3/Q6cy3/BYQBiMpk4fvw4kP8CgBUqVADg3Llz2nVENQJJawICaEZwJpNJm5C5H4a//iJw0SJACSj36ZPjfrudkBDiPv0U2WhESkkhdORIyKbUhEBQENACgG4M5q9ZswZwyE1dvXqVBEXiYWClSgAkXrzIH4qkUocOHdI1rMwpmgagj2TFyYUKISv76dYMQIsFnSIr5ivBTtmD2Y5p0Tld3zILAFapUoWePXsC8MMPP2imMzExMYAjIenHH3/MdFtqhqFkNqdymRa4j3yfAeisz3f79u0MS1FUrUBXy8kCAwMJDAwkOTk5lc5gRu2qy2eFqlWrAo4fS3x8POHh4Rku27dvX/r27Zvh5zdv3ryvvmFkZCR6vR673e41AxL/pUsJTUkBIK5DB+TYWCIjI4mNjc3Wg7t64QOIi4sDHI6EycnJqVwLo6KisrTPvjBWadHr9TkaK08hxsp13DlWpUuXRpIkZFkmOjo62+3py5Qhsm5dOHgQ25IlxPbvn6N+uYOcjlMRH7lRFeR9/Jcvx6iUdya9/DL2TEzBvIm9XDmSxo4l+O23MR44QMAXX7ilbPM3RXAeHBp5DRo04MCBA5oo/YMPPpjjbfgSqlmYyWQiOjqa0qVLpzJ7k2U51UO28/7v379f0x/OkOTku6W/ISEkzJzpewFlBVu9eo5javp0DAcPEjh7Nsn3qVYRCAoksnzXQdVNAcCEhAQ2bdoEONx/1fLf8uXL06xOHdi/n01nz5KiPFN5Qv8Pm00zoPCVoBh6PXLhwkg3b7pVA9A5wOYr++pc7izdvAlK3MATOOvxpecC7Myrr77KmjVrSE5OZufOnVr5b2hoKPHx8SxdupRnn302w/Wds2R1V65g85Hxzk/k+wzAMmXKaDdjqmZLeqifRUVFudSuJEnarK872y3o+K9eDYAtKgrrfTQCXOGff/4BHN+X+l2oN+DOLoVVPXjSFAi8gSRJ2qSBzWbTsl2zhaLFafz3X3SnT7ujewJBnkeKiyP4nXcAsJUvT/KwYV7uUeYkDx+OtVo1AIKmTUOXA4dwcAS8nLPaWrVqhdFoZN++fdp7agZcfkHNAAS0MmD1XjAhIeGeCYnSpUtrrpvO45IRQbNn3y39nTIl00wLXyB59GgsSjl50Ecfoc+m27FAkJ+RYmPRKfdg7vpNb9q0SdOjr1evnva806dPH1CCjD8p56NChQrRqFEjt2zXGenWLSSlIsNXgmJwNzDmzuwxyUlmy2c0AJ0NT9xc7pwW1QFYDgi4b6lx6dKleeGFFwD4+++/Nc0/tSryn3/+0fT508M5S1boAHqGfB8ADAwM1BzoMrr5unnzpqbdUq9ePZfbVgNJ+/fvz3CZf//9N9WyWeGEotsQGBiYaa18fkG6dg3j9u0AmLt1c8ust/rdVKxYUdNIVL9jNQAYFRVFSEhIjrclEPgaderU0V4vX748+w05aZqpQXqBoKAT+NFH2k134tSpkIkhmE/g50fC++8DoEtIIHjy5Bw1p2afqKhGQ+p1NyoqimI+YobiLtQMQLgbACxfvrz23tmzZ1MtL0kSDz30EJD5vSKA7swZAufOBcDSqBHmTDIkfAaDgYR585D9/ZGsVkJffBEykcURCAoiOqdEEZubEkLU8t+iRYtqLuMGg4HevXtjL10aE7BOWbZNmzYYDO4v+nPOsPOpAKASoHNrBqAP7qtcvLj2WpeJD4A7UEuAbaVLu/R8PnLkSG3yS71WpqSkaNrrS5cuzXBd5wCgcAL2DPk+AAgOTRpwlIPeSCdCvmrVKmRZplChQqkemO9Hs2bNkCSJK1eusHPnzns+37FjB1euXEGSJK0PKvdzHr1x44Zm7a4aVuR3/H/6CUnR1DEr1uE5QZZlbUasZMmS2vsNGjQA0DSKqikZEQJBfqN3797a69U5CdyVK4dVmT32/+EHhyivQFCA0Z86RaCT8UdKu3Ze7pFrWB95BJNyXvBfswbj5s3Zbss5AKjT6TStH3WyNb9l/4HjYVudMFSDfc5BwbQBQEALAB47dkzT6LoHWSZk0iSklBRkvZ6E997z2dLftNiqVSPp1VcBMBw5QtCHH3q5RwKBb6F31k9TJANyQnx8vCa/0L59e1Yp5ont2rWjePHi2KKi+AWIU5bv0qVLjreZHs5ZZ75ijAF39QjdGgB03lcfmdiSQ0KQFWkznWJy6SnUY9jVDNbg4GAmK5OM165d0yqSIiIiAFixYkWGHgpyWBh25TqrczIfEbiP/B9VwnFCLFGiBCaTialTp2o3aGazmZUrV7J+/XrAoaOXdobkueeeo0uXLsyaNeueditUqECzZs0AmDt3Lrt27UKWZWRZZteuXcybNw9wBCDLpjnhb926lXfffZddu3Zp2nQAycnJbNu2jQkTJhAfH09gYGCqh/j8jJpZZK1aFVutWjluLzo6Wsv6U7/XgIAAatWqhd1u1zIs85tIuUCg0q1bN+21GvDOLik9egBgOHVKlHkJCjzBr7+OZLUi6/UkvvNOngnWACS++SZ2RR85ZOJEUFwks0JKSgo7duzQ/m7SpAkRERHcvHlTm+3PjwFASZK0MmDnEmD1HsPZHVhFDQDKsswBRS8yLX4bNuCnBGNNgwe75R4oN0kePhyLUuYVOHeuuEYIBE6kygB0QwnwL7/8ogVPChUqpD1Hqrpq9rJl+U5ZNiIo6J4kFHfhHBTzlaw48EwJcKp99aDbblaxK1mAng4Aqpl4WTGxeeqpp/jf//4HOPwM4K43wp07d7REp/RQA416pUJT4F7yvQkIgNFoZPLkybz22mucO3eO0aNHExQUhMlk0lzcOnfurM1eZ4URI0YQHR3NiRMnmDZtGn5+fgCa6Gr16tUZPnz4PevZ7XZ27typZQ4GBgZiMBhITEzU+hQeHs748eM1fZn8jO7CBYx79gBK9p8bHqbU7D9wlHmDo/zXaDRy/vx57WQkMgAF+RWj0Yifnx8pKSk50wAEUrp2JfDVV5FsNvxXrSIpC3IJAkF+wrhpE35K9oVp8GBseUxDVi5cmMTJkwl9+WX0Z88SOH8+yWPHZqmNvXv3atdQcEy0gsNxXKVJkybu6bCPUblyZf777z9tUsVgMFCuXDlOnz6dbgag+gAEjjLge8YlMVErx7YXK0bShAme67yn0OtJmDOHiBYtkMxmQl96iZiNG8EDZYcCQV5DDWLYCxcGN0gOqS6qJUqU4K+//gIckgtqoC8+LIyflGW7Va6sPZu6G+cAm6/o4oHjPApK0M5uBzdU0UlKANAeEQEeGs/sYC9WDP3Zs54tAbbbtUy8rASwdTods2fPpmnTplicXOKDg4NJTExk6dKlPPHEE+lvsmxZOHYsVfBc4D4KRAYgQNmyZZk7dy5du3alZMmSWCwWgoODqVevHpMmTWLIkCHZajcwMJDp06czaNAgKlWqhF6vR6/XU6lSJQYPHsy0adMICAi4Z706derQt29fGjRoQIkSJZAkiaSkJIKDg6lZsyb9+vVjwYIF2dIOzIs464qZMzgZZJW9e/cCjqy/kydPAndvxJ2zoapXr+6W7QkEvojzBMLBHGRlyEWKYGnZEoCAFSvA6WIuEBQYUlIIfv11wPEwl/TKK17uUPYw9+mDRZHDCJo1C93581laf9u2ban+7tChA+CQWgHHBGZ+vX9R7xnOnj2rifCnzQp0JjIyksqVKwPpa1EHzZqllVclTpmCHBbmkX57GlvlyiQpgWTDwYMELlzo5R4JBL6BTgkAuiP7LzY2li1btgDw6KOPas86ffr0Qa/XA/Dr5s2o0zM9lWxvT6AGneyhoZDOs663sCvac5LN5rYsQLWc2JcyHSF3MgB1V68iKff8WTWxadSoUbqJUOC4jzifwb2HTamc1IsAoEcoUFNzERERDB48mMGDB7u8zqJFi+67jMFgoFu3bqnK7e5HsWLF6Nmzp8vL53fUAKDlgQewO+np5IS///4bcDj8qoEPNQCoOhdKkqSZxAgE+ZFWrVppD6Uff/wxH3/8cbbbMvXujd9vv6G7cQO/334jRXnoFwgKCoGLFmFQnLATJ01CVnRt8hw6HQnvvUdE27ZIJhPBr71G/JIlLq+uBvoAateurcmcqBmATZs21R5G8xs1a9YEHCW9J06coF69epoOYHoZgAAPPvggp06duscIRHf6NIHz5wNgeeQRzN27e7Dnnid55Ej816zBcPgwQe+9h7ljR+xOzskCQUFEDWLY3WAAsmHDBi2bymq1Ao5MK2e5KDVDsBjQPCWFpLSNuAk1KCb7UPYf3A0AgiN4ZXODZp8a7PQlrUNwCgB6MANQpzjTA9jKlcvy+tOmTWPVqlVcvXoVgMTERO2z5cuX86qiIeuMuh3drVuQkOCWzFnBXQpMBqDAd9EfP47h8GHAPeYf4Di5qFo7hZ20GtQAoOoAXK5cOYIUAVWBID8yYsQI7bVaKpJdUtq107TD/Jcty1FbAkFeQ7p+nUDF4MBauzbmPn283KOcYatXD9OAAQD4b9yI38aNLq0XHx+vZZ0APKlct8+cOaPN5qv6yPkRZ93gI0eOAHeNQO7cucOdO3fuWefBBx8E4NKlS1xTMzVkmZBXX0WyWPKc8UeGGI0kzJyJrNMhJScTMnasMI0SFHi0DEA3GICowb1SpUppmdiPPfYYpUqVAiAuLk4zCHkK8Peghpqqi+dzWXFpAoDuwGf3VQkASjdvghIQdjd6pyw9u5PrvauEh4czc+bMVO+pz+bLli3DZrPds46zWY7IAnQ/IgAo8Dr+3zmkamVJIiULWZSZsX//fm1mTJ0pK126tGZJ/t9//wGOzAWBID9TpkwZzUX8Wk5LBPz9MStmIH6bNiG56cZKIMgLBL/zDjpFSzNh2jTIBxluSRMnatpNwZMmgVLSmhl//PFHqht2VcNHfTAFxwNpfiUqKorg4GDg7mRiBacst/SyANUAIMC///4LgN/atfht3QpA8tCh2PKJHIm1fn1MQ4cC4Ld9O/7Ll3u5RwKB95BiY9EpJh05zQC8du2aFvSrW7euZqjQx2kyas2aNZoOfS8UF1UPBYa0EmBfC4o5BwDdVBqr7auPOACrqP2RZNmtrsfOqAE42c8v1dhmhR49eqTyWlAnyqKjo/n999/vWd4mAoAeRQQABd7FZsN/xQoALM2bYy9Z0i3N7tq1C3CkxV9QThwNFL2j5ORkTRNQBAAFBYGiys2Z3W7nnFMqf3YwKTeaks3m0AIUCAoAhn//1QIZ5m7dsDZu7OUeuQc5IoLEN98EHDfZQbNn33edTZs2aa//97//UaZMGWRZZtWqVYDjWls+G1kCeQWdTqfpAKbNAIT0dQBr166N0WgEFB3AhARNS9JWogTJ48d7utu5SuKECVoJV/AbbyB52KFSIPBVdE4ZeDnNAFy9erU2+aIG/4oUKULbtm21ZZYr16nyRYrQBMe9mmrg4G500dEAbnt2cxdyoULIyvnWLQHAlJS7GYA+tq9qBiDgsfOsqhFsi4rKtqGKJEl89NFH2uSZ3W7H398fgKVLl96zvN2p1DirGsWC+yMCgAKvYty+Hb2SRWR++mm3tavq/1WrVk0LADqX/6pOy3Xq1HHbNgUCX+XRRx/VXs+dOzdHbdlq1sTywAMA+C9dKsq7BPkfWSZ40iQkWUYODNQCZvkF89NPY2nUCIDAuXPRKRqHGbF+/XrtdQ8lI/jIkSOauVZGrn75CbUM+PDhw8iyTJkyZbQA3+l0xi8gIIBatWoBjgBg0IwZ6JWH8sS33kLOb/pGwcEkKOXyuthYQiZN8nKHBALvoHcKAOY0A/D7778HHNrmqgxDz549NZff06dPs2fPHgCeadcOVVDAIxlUFotmsJHdrDCPIUl3tfHcUKniHET05QCgp4xA9ErigD0b+n/OlCpVivfff1/7W1aeHzZu3Mj1NBqGcmgo9shIx/ZFBqDbEQFAgVdRy3/twcGYO3Z0S5tWq1W7AJZ0OlE3VjI2Dh06pL0nMgAFBQFnHcDNmzfnuD3zM88AYDh9GsPOnTluTyDwZfx/+AGjck1JevHFLLvg+TySRMJ77yHr9UgpKYRMnJhhYP/69eucOnVKWU2iS5cuAFr2n06no2vXrrnTby9Sr149AG7cuEF0dDQGg0HLAjxx4kS669SvXx+A/f/8Q8CCBQCkPPqo26RPfA1LixaYlIld/59+wu/nn73cI4Eg99E5BS9yEgA8dOiQJl9UunRpLZHBufxXzf6TJImn+/dPtw/uQnf9OpJynfC1oBjcDUq6JQCoZDqC7+2rc0mypwKA6vGTHQOQtDz11FOakZZaqm61WrXgtjNqxqwnjt+CToFyARb4FlJ8PP5KJkFKly7gJjOOQ4cOaQ5D6gUyJCREC/apF9BChQqlChAKBPmV2rVrI0kSsiwTHR2NLMtIORCbNz/5JMH/939ISUkEfvkl8Y884sbeCnwdd7i7+pJDrNqXdPuUkEDwW28BYCtThpRRo7zSd49vs25dzM8/T8Ann+C3ZQsBP/+M5fHH71lMdfkFR6lviRIlkGWZ1atXA45s49KlS3u2r/chN74ftaIAHJp+UVFRVKtWjePHj3P8+PF7jim9Xs///vc/vvzyS2Lj4zkNVDYaSX7/ffQG792Ke3qsTO+8g9/vv6O7cYOQCROIbdYMwsIy7YsvnRvS4st9E/gmagagPTIyR5m+SxSXdp1Op00yNGzYkKpVqwJgs9m0IMqjjz5KqXr1kP39kcxmj2RQ+XJQDHBvBqDTvtp8LNtRLlwY2WBAslo94wSclIReCSzmNAMQHMHpRYsW8Yjy3KA+myxdupQXXngh1bOJvWxZOHBAZAB6ABEAFHgNv59+QlIEx01uLP9V9f8ALioX3ocffhiDcpOtZgCqQRGBIL8jSRKFCxfm5s2b2O12Tpw4QbVq1bLdnhwejqlHDwIXL8Zv3Tqkq1eRfeymSOA5IpWyjOyi1+tz3IYnCEsvMPHRR6Dc/OtnzCDSC8GtXBuv996DH3+Eq1cJmTwZuncHRa9HRQ30AQwfPpzIyEh27NihXWv79evn1e82t8aqSZMm+Pv7YzabOXLkCP369aN+/fr89NNPnD59mpCQEK0kGBzHVosWLbS/dwNVXn6Z8Icf9nhfMyJXxioyEubOhV690EVHE/nuu/DJJ5muku7v0Afw1fOWwLdRs5dykv1ns9m07L66detqRkLPKNUYANu2bSNauVb17t0bdDpsZcpgOH06lQ6hu3AOrPlcCTAezAD0tX3V6bAXLYo+OtojGYDOJezuyAAEqFKlCg0bNmTPnj1aGfCpU6f4+++/edjpmqhuT3f+vKMqQTyzuw0RABR4jQCl/NdWtqxbBdXVDIVy5cppWjzqTIPdbufw4cOAKP8VFCyaNm2quXR+/PHHzJo1K0ftmQYNInDxYiSrlYBvvsl3IvaCjFHd27JKWFgYer0em81GnOKK6Avo9XrCwsKIi4tL5W6rO3eOsA8/RAIsTZqQ0KoVZHPfs4M3xsv41luEDBkCFy9ieu01kp30DmVZ1hwo9Xo9rVu35s6dO3z11VcA+Pn58dhjj2X7+MgJ3hirunXrsmfPHnbs2MGdO3coq5QrWa1W9u7dS/Xq1VMdW8UCAwmVJOJlmb+Dg+n4wgu5ejyp5PpYtWlDcPv2+P3yCyxcSHznzlibNLlnsYx+h94ms/ESAUHB/VD102xOTuFZZcuWLVy+fBlAm1gICgqim5N8wOLFiwFHxVNHRVLJHhUFp0+j94CJgs9nAKoBwBs3HC7IOci0VoOI9rCweybFfAF78eKOAKAHMgCdDThyamLjzLhx43g6TfLPkiVLUgUA7WoJcGIi0u3byIULu237BR0RABR4Bd358xgV7TBzz57ZdhVKi8Vi4a+//gIcrnznlROXGgA8e/YsSUlJgAgACgoWzz33nBYAdHbxzC62WrWwNG6McedOAr/6iuTRo0ERohbkb9zxcO5LD/gqNpstVb+CXn8dyWxG1ulIePttbIqkhLf6livb6dYNv8WL8fvzT/znzye5Z09sSonZ4cOHNXmNBx54gKCgIMxms3Zead26NSEhIV7/bnNr+/Xr12fPnj3s37+flJQUrRQP4OjRo1SpUiVVn4I+/JD/yTJbgF3Fi2MLDIQCMlYJ771HxF9/oYuPJ2jUKO5s2waBgRn2ydvHUEb4ar8EPordfjcAmANn9G+++QZwBP0OHDgAQLdu3QhRSoqvXLnCL7/8AjhMQYIUSSV1mzqlD+5EcwAOCfFJEyO1BFiy29HdvJmjzD1fdTtWsZcsCf/+6xG3Z+fgsT0Hx3BamjdvTqlSpbji1Ocff/yRadOmaVngzgFH/YULWEUA0G0IExCBVwj49lvttalnT7e1u2/fPu0BRacEFYODg6lbty4ABw8e1JYVAUBBQaJhw4Zayfv169dJVsrvc0Ly4MGAQwzaz8kZVCDI6xj/+EPTqDX164etoFwvJInE6dM1TaHgV1/VDEE+cSrdHDRoEODIuL9x4wZQMNx/nWnQoAEACQkJHDlyhIoVK2pSI6ojsoruyBECFy7kIeXvg5cvawLoBQF7qVIkKdmk+rNnCfrgAy/3SCDwPLpr1zSpo+xmAMbHx/PDDz8AUL16de284Wz+sXjxYi04rZ6bAWyKMZH+2jVISMjW9jNCLTf1uZJYBed+STksjdWrGYC+GgBUpEn0ly65vW01AGiPjER2ozyDXq93lKo7YTabtWA3pA6aeyKIXZARAUBB7mO14r9sGQCWxo2x5yAtPi1q+a8kSVxSToQPPfSQljK/f/9+wDGL5jxbLxDkd3Q6HSWcboh+/fXXHLeZ0rGjJogcuGhRjtsTCHwCi4Xg114DwB4eTtKrr3q5Q7mLrVo1kocNA8Bv+3b80mQO6/V6eioTd+qDaXBwMG3bts39znqRR5zMj/766y/8/Pw0J+BUAUBZJmjCBCSbjYaKiYTZbObo0aO52l9vY3r2WSzKmAUuWIBeyWQSCPIrujNntNfZDQB+9913WmKDKq+gaqiBw0lVDZo0adIklb6zXTkfgSPw7k58PivO6X5X71SunB20ffXVYGeZMoBS7mwyubVtzQHYjeW/Kr169brnvY8++kgz8LRHRSGr5lBOvyVBzhEBQEGuY/z9d/RKyq/JyabeHaj6RLVr19ZuwJ1v0vft2wdAvXr1hJuboMCh6sIAfP755zlv0GjENGCA4+Xu3Rh27855mwKBlwn48ksMx44BkDRhQoHUnUkaOxZbqVIABL/+OucOH+bWrVsA1KpVC71ej8lkYsOGDYDj3KKWnRUUSpQoQaVKlQA06RH14TtVAHDpUozK5/UGDtTe/ueff3Kppz6CTkf8jBnIAQFINhuhY8aAxeLtXgkEHsM56OYcjMsKi5TJ1aioKM4q7fXp00er6NiwYQPXFe23gU7nF7ibAQjuD6D4fADQqV85Ko2V5bsagD66rzYnczJ3lwGrx407HIDTUr58eR599FEALXs+Pj6eqVOnOhbw89N0AEUA0L2IAKAg1wlQhGrtkZGYO3VyW7sJCQns3bsXgNJOJ8PmzZsDDmFutQT4wQcfdNt2BYK8wgAlWAeOh0/VfSsnmAYNQlYe/APnzctxewKBN5Fu3iTovfcAsNaogSnNA1WBISSEROUmXH/tGgtHjNA+6tevHwC//fYb8fHxQMEr/1VpophZ7Ny5E5vNRvXq1QGHo6HZbEaKjYWxYwGwRUUR8frrWia2OiFZkLBXqkSSYhhlOHSIwPnzvdwjgcBzqAFAOTBQ06TLCv/99989zzUGg0HLwIa7AcLixYunmuQFh4uqrMgh6RVTRLcgy1oih69mxcnh4dgVbcKcuCBLt29rZdx2ZVLM11AzAAH0ilmMW7DZtGPYVrmy+9p1QnWytlqtWlD7448/5owS8LMpk2xuPX4FIgAoyF10V67gp5QRmZ9+GgIC3Nb2zp07sVqtAJq+WeHChalXrx4Ax44d096vX7++27YrEOQVqlWrps2ypaSkaI7YOUGOjMTUty8A/j//jP7EiRy3KRB4i+B33kGnOH0mTpuWI+fAvE7K44+T0qIFdmDVkSPa++oNu1r+W6hQIVq0aOGFHnofNQAYGxvL4cOHNW1hq9XKsWPHCHj7bVCycxLffReCgrQJSFWSpKCRPGIEVkWXOejDD9GfOuXlHgkEniGVA7AS3MgKammvwWDgv//+A6B9+/YULVoUcEzk/v333wD0799fkzvS8PNzOAHj3gwq6c4dJMVQUW3f55Cku/uegwCg87qeKIN1B84BQJ0bdQB1ly4hKZqTngoAdurUSTP9KK4EyW02G4MGDcJisdwNAJ46pekRC3KOCAAKchX/ZcuQlNp+07PPurXtLVu2ABAQEKAFNpo3b66ZgTjfbIsMQEFBRJIkatasqf29TNHizCnJw4drOh0iC1CQV9Hv34//0qUAmLt0wdK0qZd75GUkiYTp09mu13NbeatEiRKULFmSuLg4TROwS5cu9z54FhCcJUb+/PNP6tSpo/19eP16/L/4AoCUDh1IadcOuHv/cfLkSeKUYHOBwmAgftYsZL0eyWwm5KWXwIsO2wKBp9Cyp7Kh/5eUlKRNstSpU0fTAXQu852n3G8FBgamMv9wRjMCcWMA0DmjzuYUfPI1NG28HATFVA088N1gp71YMWTlGqxzYwag8+SMGohzN4GBgXTv3h2Amzdvau8fPnyY9957T9uuLjYW6fbtdNsQZB0RABTkHjYbAUuWAGB5+GFsbjThkGVZMzWoV6+edhJp2bKltoxablOkSBHK+PAFSyDwJM6lI6tWrXJLm/YyZTA/+SQA/itXatowAkGewW4n6NVXkWQZOTCQxClTvN0jn8BeqRKfVqmi/d1RyQJYv349ZrMZgCeV335BpESJEpru3+bNmylTpgyRkZEAHP3mGyRZhsBAkt99V1tHDQDKssy///6b6332BWx16pD8wgsAGHftIuDrr73cI4E30Ov12frnjjZysm2XltXp7pYAV6yY5e2sW7dOmyCIiYkBoHLlyrRo0QK9Xs/58+dZrzjVP/PMMxQrVizdduzKOVt/5ozb9tPoHGQqX96tY+vO71XVrdNfupTtfTU472u5cr65r0ajVp5suHw52/t6z/fsbBxTtarH9rOvUkVktVqp4BQsnzNnDtuUyj0A49mzWd62u76v3PhOc5OCW9siyHWMmzdr2gTuzv47fvw45xWr8kKFCmnvO5clqRmA9evX13QGBIKCRvfu3Zk8eTIAt27d4vTp05qQfU5IHjmSgBUrkCwWAufOdZRPCgR5haVLMezZA0DS6NGpSmoKMomJiaxSytgAuhw8CDExrFy5EnDoUjVq1MhLvfMN2rRpw/Hjx9m5cyeJiYnUqVOHP/74gwNqNsPrrzuEzG02AB544AEkSUKWZfbt20ezZs282HvvkTRuHH7r12M4fZqgt94ivl07UIKngoJBZA6/b71en+M2soNaspgp165BQgIAAbVqEZDFfi5VstFLlCihmX8MHz5ce8b54osvkGUZnU7HxIkTMx4HRZZAd+sWkZIEEREu9yHD/XTK1AqvUweCg11u0xXc9r0qiSa6a9eIDAzMVHYqw31VJBwoXpxID2gAum1fy5eH8+fxv3YN//u059LxC6BmehYrRkT58jnqXmb72bJlS+rWrcvBgwexKddJcEySDf34Yw4AhYGwq1ezfI1weV/diLfOS1lBBAAFuUagIlRrj4zE/Pjjbm1bzf4DuHbtGuBwKlTFthMSEjh69Cgg9P8EBZsiRYpQuHBhzdHzu+++Y9KkSTlu11azJub27fH/5RcCFi8meeRInxVMFghSERcHr7wCODR+kp0MLwo669evx2QyAY6SkZZxcVwbN45t27YBDvMPVWajoNK6dWvmzZuHxWJh69at1KlUyREABFIqV8Zv7FhQyvcAQkNDqVq1KsePHy+QRiAagYEkzJxJeNeu6BISCHrhBVCOK0HB4M6dO9laLywsDL1ej81my9Uyer1eT1hYGHFxcakCFelh2LOHUOV1fKlSWLOwrwcOHGDHjh2AQxft6tWrBAQE0K1bN+7cucP169f58ssvAejcuTOFChXKcCwNJUpo/Yj75x9sLkgg3W8/A48fJwCwFy5MbEoKKDpxOcXd36uxcGFClNex//2nZUM6c799DT51Cj/AWro08dk8XtPD3fsaVKIE/oDt3DniMuhnVo5fgJDDhzEClooVSfDwb7VXr14cPHiQCxcuUKRIEa2S7/LVqwzR6Vhpt2M6eBCTi/3I6r66g5x+p7kZNCzYd22CXEN/8iR+ikafqW9fCAx0a/sbN24EoGbNmlpJTevWrbXP9+7di13RmHnooYfcum2BIK/Rvn177fW3337rtnaTlCCKZDYTOGuW29oVCDxJ4DvvwNWrACS+9Zbbr095GefzQ6PwcMKAFV98oV1PC3L5r8pDDz2kZRls2rSJhooGcRJwcPRo8PO7Zx11ItJdbux5FWvjxpiGDQPA+OefMGeOl3skyE1sNlu2/rmjjZxs25XlpGPHtD6mVKqUpW0sXLgQAKPRqCUv9OzZk7CwMGw2G7Nnz9ZMDUeOHJlpWxankkrp1Cm37Kek6OLZoqLcPrbu/F6tinMyAOfPZ2tfdXlkX23KhLvu0iVsVmu29vWefVecd21ZPH6zs589evQgQMnQLJHGWXqV3c4iQJeF4zer++oL32luIgKAglwhQMn+k/V6TBkI1WaXW7dusXfvXgDKli2rPZh06tRJW2bXrl2AY0agQYMGbt2+QJDXGDBggPY6Ojqa08pFPqfY6tTB3LkzAAFLlqQSihYIfBHDvn34K9enlLZtSenY0cs98h3OnTvH9u3btb8ffeopZH9/likBq6pVq2qutwUZo9Go6Q1v3rCBhrt3a5/t9/dPdx31PuT69etEF3DN1MRJk7CqmtATJ6I7fty7HRII3ID+xAkA7BERyIprryvcuHFD02euWbMmKUp23dChQwG4evWqlv3Xtm3b+1Y12aOikBU3e72b7vVUZ1xfl8pwNijJ1v2oLN8NAPqoA7CKuq9ScrJ7zDKSktAr5imeMgBxJjIykm7dugFw4sQJ/JVrZ1BQEAAvARecguqCnCECgAKPI8XFEaBkEaR07Oj2C8Zvv/2mBf1iY2MBKFmyJA888IC2zM6dOwGHQUhISMg9bQgEBYl69eppM20A33//vdvaTpowAVmSkCwWgmbMcFu7AoHbsVoJGTv2rlHD+++D0IfVUDWoVJp168axAQPYqfzds1w5oaer0KZNGwCuxcQQBwQp7x88eDDd5Z0f2v/55x8P987HCQggfsECR5DCZCJ4xAiwWLzdK4EgR+hPngTAVqVKlq4r33zzjRb0UyWN6tevr1UvzZ07V5NleEWpusgUg0FzIVaDkjlFddX19aCYXKwYsnKvq3dy83UVKTYWnaLj6OvBTuf+6RVN/Jzg7BqdGwFAgMGDBwOQkpJCrVq1ADCZTEhAIjDk9GnsVmuu9CW/IwKAAo/jv2wZUlISAMnPP+/29teuXQtAsWLFND2dDh06aA8mZrNZe//hhx92+/YFgryGJEk0b95c+3vJkiVuK0OzVa+O+YknAPBfvtxtN5wCgbsJWLQIw6FDjj/+7/8cRg0CACwWC8uWLdP+Dg4O5sEHH+Rrpwm0ftu3o3N2CSzAtG7dGr1yz/EjUKdiReCu+VhaatasqU3CZLRMQcJWrx6mceMAMOzfLyQkBHkevZLJalOzW13AYrFo2X2VK1fmqiJNMWrUKCRJIjo6mq8Vx+wOHTpQr149l9q1Va/u6JMbMqik2Fh0SrKFrwfFkCRsinmFPhvXKr2TAZavBzttTqXe2dnXtBicjhWr4nTvaR544AFtckw99u12O/WiogDYarfz1cyZudKX/I4IAAo8i9VK4OefO17Wro3VzQG42NhYtijagnXr1sVsNgPQ0amM68CBA9psmQgACgQO+vXrp72+fv26VkbvDpJeeQXZYECy2Qh+8023tSsQuAvdpUsEv/suANaaNeGll7zcI99i06ZNXFfdD4EmTZqg0+lYomTzPwpUMZkIffFFzd22IFP85ElaKJMoKwIDqa9kBO7fvx9rOhkLRqOROnXqABRsIxAnTC+9BP/7HwBBH32EQYyLII8ixcejV0r7sxI8WbdunRb4UCdlixcvTu/evQGYOXOm9pwzfvx4l9u11qgBKCXAyvrZxTm45Bx08lVsymRMdsqfndfJrSy47OJc6q1zyt7LLvojRwCQAwOx59ABOCsMHDgQgCtXrmjBwJM3b1JF+XzK7NmccwrMCrKHCAAKPIrf2rXaDErykCFuL6/6+eeftVR59aIYHh7OI488oi2jlv8CNGrUyK3bFwjyKs2aNUOv12t/q7PK7sBeqRImJZXf77ffMCpBeoHAJ5Blgl99VctMT5oxA4xGL3fKt1i8eHGqv5s3b87vv//O5cuXARjQti0Axr//JvCTT3K9fz6FyUTISy/RQ/nzTHIyxRUR86SkJP777790V3tQceP8999/c10A3CcxGuGbb5ADApBsNkKHDkXKRYdXgcBdqOW/oJQAu4Asy8ydOxeAIkWKaNrMI0aMwN/fn2PHjmnn5U6dOmkTCK6gZgBKVmuOdQBTBcWU4Jovowbu9GfOQBYrXdR9lY1G368QMBi0ProlA1Axn7FWrQpOzwqeplu3bkRERACg0znCVInJybTFEbRKMpsZPXq0Jv0lyB4iAFhA0Ov19/2X1eXv+0+nI0hxdLOXKoW1Z89stZNZf9asWQM4NP/27NkDQJcuXQgICNCWUQ1AqlevTtGiRd2yb24fKzf987X+iLHy3bEKDg6mSZMm2vbWrFlDSkqK28bKPGECdsXSPuSNN9DLss+Mk6Bg479yJf6Kc3xy//7YhDN8Ki5dusTvv/+e6r3mzZvzzTffABAREUH7Tz7RskqCpk1zS2lZXiVo+nQMp07xBGjSI1euXNE+V+9B0qIGABMTEzkhpBIcVK9O0jvvAI7yu5CxY7P80C4QeBtn6RNXS4C3bdumTRaoLqgBAQGa+ceECROw2WwYDAZef/31LPXHppyrIedlwFpQzCng5MuoWYpSUhI6RVPRVfSnTt1tIw/cO2rZju7IAFSOE+djJzcIDAzkmWeeARz6uNWV4PUavZ4xyjI7duzgiy++yNV+5TcM3u6AIHeIVB7EXUGv12dp+Qz55RdQ9JV048cTWbx4tpsKCwu7571bt26xdetWwGFq8MsvvwAwaNAgrf9ms5kdO3YA0KpVK/fslxNuGys3kt5Y+QJirFwnt8ZqzJgx/PHHH4BDaHfbtm1aqUlasjxWkZEwZQqMGoX+2DEiV6yAESNy2uVU+OIxJfBtpKtXCZ40CQBb6dIkvfGGmAlNw9KlS1NpgpYoUQJJkrRrbL9+/QiMiCB+3jwi2rVDSkkhdPhwYn7+GZzMhQoCxr/+InDBAgAKPfIID8syO3fuZOvWrZQsWZLo6Gh27txJr1697llXDQCCowy4Ri4/aPkqKQMGYNiyBf916/D/8UdSmjXD/Oyz3u6WQOAyagBQDgx0WSdvjpIwERYWxhGl/PLpp5+mSJEibN68mfXr1wOOZ5xKWSxHtZUvj+zvj2Q2Yzh6lJQsrZ0atbzUVr48GHw/jOBcuqs7fRq7Elx1BTXY6evlvyqa2UsOMwCluLi7DsBeuC7179+fBcp1NSoqimPHjnHJZqM6UM3Pj+MpKUydOpU2bdpQrly5XO9ffsD3f7kCt3Dnzp37LhMWFoZer8dmsxHnhrKLkKlTMQL2yEhie/QAF/qQFr1eT1hYGHFxcfeUyHzxxReats7NmzcBRyZgnTp1tP3dvn07SUqZV5MmTVwaB1dw91i5g8zGypuIsXKd3B6rxo0b4+fnp5XRv//++7Rv3z7VMjkaq6efJmzuXPQnT2KfOJG4li2Rs3DzlRE5HScRNCygyDIh48ahi4kBIGHmTGQfnQTwFhaLhSVLlgBov7HWrVszf/58ZCWLd8yYMQDY6tYlafx4gt99F8OhQwT/3/+ROH26F3ufu0hxcYSMHIkky9hDQoifN4/Hf/mFnTt3cvLkSZo3b050dHSGGYDlypWjUKFC3L59m3379tGnT59c3gMfRZJImDULw8GD6C9cIGTSJKwNG2pljAKBr6OaS1mrVwfd/aeY9u3bx/bt2wGoUKECBw4cAGDo0KHYbDbGjh0LOLKvxylmOVnrkAFblSoYDh3SzEmyixoUs+eB8l9IXaasP3MGq1PlS6bIMro8GgDU3b6NFBODrJTSZhW9Uv4Ld/Ujc5OKFSvSqlUrNm/ezK5du4iKiuLixYt8CHxus9FMkkhKSmLs2LGsWLFCy7wXuI6Y+C4g2Gy2+/7L6vKZ/ZN27sSoZN4lP/88toCAbLeVUX+WLl0KOE4Uqoj2k08+iSzL2jKbN28GwGAw0Lhx4xzvlyfGyp3/fK0/Yqx8e6wMBgOdOnXStvnvv/9y6NAh942VTkfC++8DoIuLI3DiRJ8YJ0HBxP/77++W/vbrh6VlSy/3yPdYu3atJkKv/lZq167Nd999BziusRWchN+TR48mpWlTAAI//xw/JUulIBA8caKWJZE4fTr2qCg6d+6sfa7qF508eZJbt27ds74kSZrIuTACSY0cHk78p586zKRMJkKfew4SErzdLYHg/sjy3QCgizp9avZfQECAlv33+OOPU6VKFRYtWqQFBMeOHZvtCUw1kGNwCu5kGVnWykvzSlBMLl4ce3AwkLXSWOnaNXSJiUDe2ddUwc4cZAE6OwB7IwMQYPjw4QDEx8dr2fIngEs2G8OeegpwlM2rsQBB1hABQIFHCPrgAwDkoCDNDMCdHDp0SLsgVqhQQRMD7dGjR6rlVIfghx56iJCQELf3QyDI66TNOvn000/d2r6laVNMSvmb/5o1GH/91a3tCwSuoLtyheDXXgPAFhVF0pQpXu6Rb6L+/oOVByY/Pz9+/fVXbcJAzUTR0OuJ//hj7EWKABAyejS6Cxdytc/ewG/NGgK+/x4Ac+fOmHv2BBxVCA0bNgTQRPzBoWWUHg0aNADg6NGjWrWCwIG1QQOSlN+s4fhxQseMEXqAAp9HunYN3Y0bANhq177v8kePHmXDhg2AI6HBYrEA8PLLL3Pt2jUmKZIV1apVY9CgQdnul5pBqzt/Hik+PlttSDdvolOqLvJKUAxJwq701ZCF7EdDHnIAVkkVAMyBrqzqAGyPjMSeA/munNCsWTNq1aoFOK6fpYoWBeBtYHLTppRXnInffPNNohXHbYHriACgwO0YduzAT9HmSx48GLlQIbdvY/ny5YCjROm4ckKvX78+tZ0utjdu3NAEdVu0aOH2PggE+YGmTZtSyOk3+t133xEbG+vWbSROmYK9cGEAQiZMQBKZHILcxGYjdPhwdMpxnTBrFrKYELqHvXv3aoEqf39/AGrWrKkZggwYMICq6QjayyVKED9/PgC62FhChwwBszmXep376M6cIUQpg7YXK0bChx+CUwlS165dAbhw4YJmOqSalKVFzQC02WwcPHjQg73OmySPGIG5QwfAMYEUOG+el3skEGSOmv0HrmUAvvfee8iyjNFo1CYNOnToQO3atXnjjTe0+7F58+bh5+eX7X5Z69UDQJJlDNk816RyN84jJcBwN/tRn4XsRzUIBq4buXgbe7lyyEFBQM7MXtTjw1qrVqprW24iSRIjFN3wS5cu0eyxxwA4DGz7+WdmzpwJQFxcHOPHj0+lWyy4PyIAKHAvskzwu+8CYA8JIXnkSLdvIjk5mZUrVwKOm+dLSglOv379Ui23bds27fVjyolDIBCkRq/Xp5pVtlgsbk+plwsVInHqVMf2Ll3SMrEEgtwgcNasu5IUw4ZhadbMyz3yTdTsP39/f27fvg3cdbONiIhg/PjxGa5reewxkkaNAsD4zz+EjB+fP7O1TCbCBg9Gl5CALEnEf/wxsjK5odK1a1et/LeIkhn5999/p9ucsxHI/v37PdTpPIxOR8L8+VirVAEg6O23MSqVHQKBL2JQEg9kSbqvftqBAwc0c48qVapgViZOxo4dy5YtW1i1ahXgeL5pmUPJCjUACGDI5rnG4GVtuOxiVZJD9JcuIbk4wa0Gcm0lS95zjvdZdDqs1aoBOSj1tljulrArE1Teolu3bpoj9tFjxyiumM68v307TZo00Z77N27cyOrVq73Wz7yICAAK3IpxyxaMiuC1afhwj2T/rVq1Sns4UYU/Q0NDeeKJJ1Itt1HReipSpAh1XNThEAgKImnLgGfPnq0Zg7gLc48emBWDkYBlywqUVpjAexh27SJI0aG01qlD4uTJXu6RbxIdHc3atWsBUmXSX79+HYDx48enyhROj6SJE0lRgqsBy5cTsGiRh3rrPYJff117OEoaPz7dYHKJEiVoqugiqmW9e/fuxWQy3bNsoUKFtFImoQOYPnJoKPGLF2MPCUGy2wkdMgTduXPe7pZAkC5a4KhyZVCkFDLivffeAxyTLieUks22bdtSqVIlbcIlMjKSDz/8MMf9kiMiNJMIw7//ZqsNrTS0WDFkZXIjL2CrWVN7rT982KV11OVsShlqXkEt9c5KtqMz+mPHkJRrlXPQ2Bv4+fnx/PPPA45geZfKlQH4NyGBdWvX8uabb1KqVCkAJk2apBmCCu6PCAAK3IfdTvA77zheRkaSPGyY2zchyzKfffYZAGXKlNHKlXr06KFpFgGYzWZ+++03ANq1a6fNxgsEgnspU6ZMqizZ27dvs2LFCvduRJJImDEDu6LjEfLyy0iK2YBA4AmkO3cIHTYMyW5HDgoi7rPPQCltFaTmiy++wGq1AmgaVOp1s0aNGq5pTxkMxH/2GTYloBX8+usYFWfL/ID/998T+NVXAKQ0b07yyy9nuKw6IRmvaG2ZTKYMA3xqFqAIAGaMrXJlEj7+GABdTAxhffogKW7eAoEvoQUA76P/t2fPHjZt2gRAVFQUVqsVnU7H5MmTefPNNzl//jwA77//PkWV+6acYlEyurIbADQoAUCrU0AtL+DcX4NTaW/GK1g1IwxrHgsAqvuqv3LF5WxHZ5yPDW9nAAL0799fe74/brdTSnl/2ltvERQUpAXHb926pellCu6PiIoI3Ib/8uWabkDyqFHIYWFu38bOnTs5rMzKREVFaeYf6gyByh9//EGCojPWsWNHt/dDIMhvDBw4MNXf06dPd7tjrly0KPGzZgGgu32b0JEjQbjyCjyBzUbosGHoL18GIOG99zQhcEFqkpOTWbx4MQAPP/ywpp2rXl/fffddDErpzf2QCxUibvFi5KAgJJuN0MGDU+lG5VUMe/cS8tJLANiKFyd+wQJQ9P3So3Pnzvfode1QytDTogYAL1y4wA3FPEBwLynt25P46qsAGE6cIKx//3ytNSnIe0gxMZrTbGb6f7Is89ZbbwEO599Tp04B0Lt3by5duqSdj9u0acOAAQPc1j/rAw8AoD9/HkmppHIZu/1uADCPBcXkIkWwKWYWrgQA9adOISnnlry2r2oGIGRPB9CgGGzaCxfGHhXltn5ll/DwcG0C8o8TJ+irvH/q/HmWL19OmzZteEpxBV69ejU///yzl3qatxABQIFbkOLjtew/W/nyJKcJyLmLj5UZ4KCgIP5VZinat29PFUUfRkV11AoODqaZ0HsSCO5L27ZtqaCUhwBcvXqVNWvWuH07lrZtSVZuaP22bSNo+nS3b0MgCJo+HT/FvMLUsyfmp5/2co98lxUrVmiyGtWqVUslpt21a1eaNGmSpfZsNWo4AmSA7s4dwp5+Gl0ezvbVXb5MWL9+SCkpyP7+xH/9NXKxYpmuExERQatWrQC04Olff/2V7rJCB9B1kl9+WXOVN+7Y4TBjyY9ak4I8icHJ7duiOHynx7p169ilyCWp0gqBgYEMHTqUMYrBUKFChZg5c6YmdeQO1AAgZD0LUHf+PJIiaWDLYxmAcLfPemWCKzMMTmXCrjg5+xJWpwCgS9mOaTAqx7C1Xj2vGYCkZcSIEQQp5ib7dDrUJ/4PPviA5ORk3n77bS1Ldvz48W43MsyPiACgwC0Ezpyp2d4nTpnikTKrQ4cO8csvvwCOkqTk5GQARqYxGrFYLNpyrVq1IiAgwO19EQjyGzqd7p7f0htvvKGVBbqTxKlTsSjaIkGzZuEnZuwEbsRv7VqClExTa92697i0Cu5is9mYrzj4VqpUiZNpsvVeeeWVbLWb0qkTCarxz8WLhPXqhRQXl7POeoOEBMKefVa7v0mYNQtrJg/2zqhlwOo5dO/evZrIvzO1a9fWgoSiDPg+SBIJH310V2ty5UqClONMIPA2xr17AZANhlTBNmdMJhNTpkwBICwsTDNaeuGFF5g6daqmu/r+++9TXMlacxfWunWRFWkHta+u4hwUy2slwHC3nNVw6BAogcyMMCjnYTkoKE+5HQPIxYtrUjtZNXuRYmM17UPLQw+5vW/ZpUiRIgwePBiA3+x2+ivvR0dH89lnn1GoUCHeVQxIr127xhtvvOGlnuYdRABQkGP0J08SuHAhACmPPkpKhw4e2c6MGTMAMBqN2kNKw4YNadSoUarltmzZogmBdu3a1SN9EQjyIz179tRcK8FxIV3kCSH/gADiv/wSuzLzHfLCC+gVAWyBICfoDx92lJbjKGGJ++orCAz0bqd8mF9++YUzSslav379tKwUcASwqlatmu22TcOGkaR8F4bDhwnr2xcSE3PW4dzEbCZs4EDN1TNp1CjMPXq4vHq7du1SaRNnpAMYGBhILaXMTAQAXcDPj/gvv9RcSIPmziVw5kwvd0ogAMOePYBSNqpkLKXls88+0/T91MmBChUqYDAYNE3Anj17eub5JThYM3YwZCBJkBFaUMzfH1sOrgveQg1oSVbrfQNjht27Hes0aJCp1INPIkla9qkhi9cTw99/IykZ1ZbGjd3etZzgnAX4B/A/ZVJ3xowZXL16lS5dutCpUycAli1bxhbhFp8pIgAoyBl2OyEvveQojTEYSHz7bY9kWhw9epR169YBjuy/OCWTYMKECfcsu3LlSsAxs9a2bVu390UgyK8EBAQwLI15z9tvv63paboTe1QU8QsXIksSuvh4R4ZQHi4TFHgf3eXLjuMoKQlZryd+0SKf0LDxVWRZZt68eQBa+Yyq+wcwevToHG8j6fXXMfXsCYBx507Ce/cGD5xP3I7NRugLL+C3dSsA5s6dSXrttSw1ERQUdI8G8f10APfv35+qBFuQPnJYGHHffoutbFkAgqdNI0CZiBYIvILNppUAW//3v3QXuXz5Mh999BHgkAlQXcL79+/P+4pbffXq1bXXnsDyyCOAkgGYjjN5RhiVoJi1Xj1Io2+aF7A2bIisPJ8a//474wUTE7VJH6sPZcFlBTVLXX/iRJYy743KBKDs54fVSZrCFyhSpIimBfgr0E+5TiYmJvLWW28hSRLvvfceERERAIwZM8Yjzy75BREAFOSIgK++0k6kySNHekwXYurUqciyjMFg4ISSKdS0adN79P3i4+M1AdAuXbqI8l+BIIs899xzqRznkpKSGDdunEe2ZWnRgkSnMsHwPn3yRnBA4HNIsbGE9e6NXgkiJ773HpamTb3cK9/m77//Zq9SBjZkyBB++OEH7bN69eppWWk5QqcjYdYszJ07A0oQsFcvJF/+ndvthIwfj7+igZrSrBnxn3wCuqzfMvdIkzH4xx9/pLtcfaU8LSYmRsvIFGSOvVQpYn/4AVuJEgCETJ6M/zffeLlXgoKK/vBhdMp5zdqwYbrLTJw4kUQlCzpGcbFu27YtCxYswG63ExQUxOeff54qc9jdqAFAyWx2PUMsJUUzh/Cl0tCsIIeFac+oajAzPYz//oukmNNZMvgefR01ACjJcpbKgNUAoPXBB8EHn59HjhxJaEgIAF8BvZTvc8WKFezcuZPixYszVXmmuHjxonAFzgQRABRkG92lSwQpLlbWypVJGjvWI9vZsmWLpulXqVIlTMqM1aRJk+4Rx/3xxx+1z1VXIIFA4DrBwcGMTfNb/vTTTzX3bXdjGjqUZCXr0HDwIGGDBglnR0HWMJkIHTgQw9GjACSNGYOpf//7rCRQs/+CgoJo3LgxBw8e1D7r06eP+zZkNBL/6aeYH3/c8efffxPWoweSItXhU9hshIweTYASSLI88ADxX3+dbV3jFi1aUEIJUAHs3r1bq2BwpoGTruDuTB5OBamxly9P3KpV2BXpitCXXybg00+93CtBQcRv+3bttSUd46T169drCQqqQ3jRokW5cOGCpvs3c+bMHMkuuIL14Yfv6gBmYEyUFsOhQ0jKs1VGwc28gBq8NOzZAxnoWxuV0lHZYMiz+2qtX1/LdnQ2pskMKSZGCwj7WvmvSuHChXnp5ZcB2Ac0Sk4mRAkITpw4EavVytNPP81jjz0GOO5xnGVNBHcRAUBB9rDZCB0xAp0yk5Uwc6ZHZgvsdruWfRQcHMzx48cBePzxx2mY5sQsyzKff/454NDTePjhh93eH4GgIPDss89Svnx57W9ZlunVq5fHStMSp0zRggN+W7YQNnCgCAIKXEPRaVMfvkxPPUWSmPW9L8ePH2fjxo2AQ/tvw4YN2md+fn6agYXbMBqJX7gQs6JrZfznHyI6dkTnS9luFgshI0YQ8O23AFhr1ybu22+RlQeM7GA0GhmguJ6DQ/Nr27Zt9yxXpUoVLfN6u1MgQXB/bFWqELtiBfbChQEIee01AmfMEO7AglzFqGT3WqtVw+4U9AeIi4tj4sSJjuWMRlJSUgCIiori2LFjgENy4cknn/R4P+WwMM0Qw++331xax+A0KWHJoLw5L2B59FEAdHFxGDIoA/b7/XdAKRkOC8u1vrkTOSTkbraji0Fe49atWuZjiuJg74s8//zzlA0NBWDG2bOMeeEFAA4fPswnn3yCJEl89NFHhISEIMsyo0aN0kxDPYVh/36Cpk1D99RTEB3t0W25CxEAFGSLwBkzMO7cCUDysGFYPRRs+/LLLzVR7FDlBx8UFKSl+Dqze/duLUtp0KBB6LJRriMQCBwBgGnTpqV67/Lly+lqbroFnY74BQtIadnSsf1NmwgdPBiUm2SBIF1SUgh97jntISblscdImDVLOP66wIIFCwDQ6/UMGjSI77//Xvusc+fOmo6OWzEaif/kE5IHDnRs++xZIjp2zLIYvSeQYmMJe+YZAlatAsDy4IPErl6NrASVcoKqW6SyefPme7cvSTyqPJz+8ccfQgcwi9hq1yb2p5+wlSwJQPC77xI0ZQo4aVoKBB7DbNbKJ9UgkzOvvvoq0UpgwGKxAFCzZk3t+ebxxx/P1XLFFEUf3bhvn0vay37KpIWtYkXkYsU82jdPYmnRAtloBBz3mWnRXb2q6f+lKFlkeZWU5s0BpazXBfMtdTzskZEZalj6AgEBAbyhVHhcBJJOn9bkSqZPn87JkycpU6YMb775JgCnTp3igw8+8Ehf9AcOEPbEE0S0bUvQzJlIq1fDhQse2Za7ERESQZYx/vknQR9+CDgs5RMnT/bIdqKjo5kyZQrgSPu9qlykxo4dS+nSpe9ZXs3+CwwMpFevXh7pk0BQUGjTpg2dFd0ulS+//FLLGnI7AQHEff01KS1aAOC/cSNhffr4tlaYwHuYzYQOGYK/Ig+R0qKFw/E3D4qT5zZXr15lxYoVADz55JPs37+fm07luL179/bcxg0GEt97T7tv0N26RfiTTxI4d67XMrZ0Z88S3rGjZvhhadyYuJUrkd0UBK1SpQpNnfQof/vtt3QDfGoA8Nq1a5w8edIt2y5I2KpWJXbtWmxK9nrQ/PmEPvccKEYLgnxGUpLPZHka9+xBUo4zixJ4UVm9erV2vlUpWbIkR44cARz6n/PmzcvVpIWUdu201+kFwlJhMmlZZHk9KCaHhmoaiP7r1t0zQeC3erX2OiWPm0halAl1KSVFS9jJEJtNy3xMeewxn3c+7jJmDI8oE71zV61i3LhxGAwGzGYzo0aNwmazMXDgQM0nYMGCBRxQNCzdgt1O4EcfEdG+PX5//gmArNcjP/CAz5yT7ocIAAqyhO7cOUIHD0ay25GDgoj79NNsa+NkhizLvPLKK5qDjyqWW6dOnXtcSgHOnDnDGkWwu3v37p7JXhAIChjvvPMOYWlKIAYOHOi5h9PAQEcQULlo+23dSli3bkiKPo5AACDFxRHWqxf+69cDkNK0KXFffw2BgV7uWd5g3rx5WhbKiBEj+Oyzz7TPSpUqpQWiPIYkkTx6NHGffYYcFIRksxH81luOgH8uO4H7rVlDRKtWGBRzMdNTTxG7YgWyUnHgLp599lnt9bVr19LVVHU2NcvILESQOfZy5YhduxarkhHiv3Yt4V27Cof5/Ejz5ujCwwnr0QP/b7/NkqOtu/FTtP1kP79U+n+XL19m/PjxqZYNDQ3VsgGrVavG8uXLCQoKyr3OAraaNbFFRQFKICwTjDt3IikllHk9AAhoMhT68+cxOmefyzIBSia8tVYtj5la5haWhx9GVu6J/BRdw4ww/vknOmUSMC8EPqXwcOY1aIABsNjtLFy4kNGjRwOwd+9e5syZg06nY9GiRQQEBGCz2Rg6dCjx8fE537jJROjQoQRPn45ktSIHBJD00kvcPnwY+969kEfkx0QAUOAyUkICYf36obt9G4D4efOwV6rkkW199dVXmvFHeHg4NpsNf39/FixYoInnOjNnzhzsdjs6nY4XX3zRI30SCAoapUqVYubMmanes1gstG/fnosXL3pmo0FBxC1bhrlLFwCMBw4Q0akTeuUBXVCwka5dI7xrV23WNaVFC+KWLIFcfoDKq1y7do2vv/4agHbt2pGSkqI5AYMj+0+fS7P/Kd26EbNpE1ZF9N5v0yYimzbFf/lyj8+iSzExhIwZQ9hzz6GLj0eWJBJffZWE+fM9Mqn5+OOPU6hQIe1v1QzAmbJly2raq+npBApcw16iBLHr1t0tc/z3XyLatXMI/wvyDzduICUl4bdtG6Evvkhkw4b4rVqV+xk4soyfoqFqadZMmzwwmUwMHDiQ2NhYbVE/Pz8tCFGhQgVWrlxJYTfIDGQZSbpryrR1K7pMdMv8f/oJADkwUMuey8ukPPEEsnK/ELBokfa+4a+/MBw6BIA5P5hIBgRo35ffhg2ZyiH4K4FPOSgoVXaoL1OlRw9eUV7v2rWLyMjIVKXAO3fupEqVKlop8OnTpxk9enTO5DWSkgjr3Rv/H38EwFqzJjGbN5M0aZJb5EJyExEAFLiGyURov36ay2LiK6+Qolw83M3Ro0d54403AIfen3rxnDx5MtWrV79n+fPnz/Pdd98BjnKmihUreqRfAkFB5IknnmDw4MGp3ouLi6Ndu3ac8ZSAv78/8Z99RvJzzwGgP3eO8LZt8VMyvgQFE/2BA0S0b6/dpJu6dydu6VIIDvZyz/IO8+fPx6RkyowbN+6eAH9uy2fYqlYlZuNGTEqGnC42ltBRowjv3BmDU2DSbdjt+K9cSeQjjxCwdKnjraJFiVuxguSxYz2mHxkQEJCqeuFbxWgkLS2Vsq1t27aRJEpXs40cEkLc4sWaw7z+yhXCu3QhcMGCPFOiJbgPb7yBfdQoLZNNf/UqYUOHEjpwIJJSNZQb6A8eRH/pEgDmjh2Bu1VM+/fvv7ucXq+Zf5QrV45Vq1alcgjPbcyK1INkt+OvPEPdQ0oKfkqGYEq7dvniWiuHhGB6+mkA/NevR79nD9jtBCi61/bQUEx9+nizi25DnUjXX7qUysglFQkJWhao+fHH88x3nNKuHZOBKsrfb7/9NpMmTSIoKAi73c5zzz3H9evXGTJkCI8r8Yq1a9eycOHC7G3QZCKsf/+7k88tWxK7bh02D7t2ewoRABTcH4uF0CFDNJdF8xNPOG6UPcDNmzd59tlnMZlM6HQ67Qa4a9euDB06NN11pkyZgtVqRafTMWbMGI/0SyAoyMydO5cHH3ww1Xs3btygXbt2moi129HpSJw2jYS33kLW6dAlJhI2YABBU6eC1eqZbQp8Fv/vviOic2ftQSt56FASFiwQmn9Z4MaNG3z11VcAtG7dGkmStEx7gEceeSSV+3euERJCwowZxK5cia1sWQCMu3cT0aEDoX37OkxCchq0sdvx27CBiMceI3T4cHQ3bgBg7tCBO1u33qPb5QkGDhyoVTBcuHCBo8qEqjMdOnQAIDk5WZQB5xS9nsSpU4mfMwc5MBDJaiX4zTcJ69sXSfn+BXmYQYOQZ8zgzp49xH36KTZFG9x//XoiWrVCr7jrehp/RTdO1ulIad8egM8++4zly5dry+h0OmyKw2rNmjVZt24dZcqUyZX+ZYStenUsDRoAEPDNN6DIQjhjXLcOnRJMNeeCQ3FukfTyy1oWYPDgwfD005qJi2nIELfpv3qblM6dkZWM9oBly9JdJmD5ck2/0qwERvMC9jJlMDz4IEsBA46M22nTpjF9+nTA4SPQq1cvLBYLs2fPppJSsThlyhS2K/EMl7FYHIZzik6wuUMH4pYudbtUSG4iAoCCzDGZCB00CH+lXCWlVSvi580DD4jVms1mBgwYwPnz5wGwK+nKtWrVYu7cuUjpzMzv2LGDtWvXAg6NnWrVqrm9XwJBQScwMJClS5fec8MaExND165dWaU4Z7odScI0fDhxK1diV9Lrg+bMQdeiBZw965ltCnyLxESCx40jdORIJJMJ2Wgk/qOPSHz7bY9ch/IzH3zwAcmKltO4ceN49913U33+zDPPeKNbGpbmzbnzxx8kvvKK9nDmv3EjEV27EtGqFYELFqC7fDlLberOnSNwxgwiH3qIsP79MSjae7bSpYlbvJj4xYtzzdUyIiIilRZg2uxLgCZNmhCqPFRsUMoKBTnD3Ls3MRs3Yq3iyBXx+/VXIh991CH4L7IB8z56PSlPPEHMn39i6t7d8daFC4R36oQxqw/6WcVi0XTjLC1aIBctytdff81rr72mLaLT6bTnmUaNGrFmzRqvZv45YxowAHCMl//Klak/lGUCFLd4W8mSpLRuncu98xxyiRIkKpVm+kuXQNl3a40aJClacvkBOSxMK/X2/+EHpGvXUi9gNhP48ceAY98tTmZVeQFzz540BKYofx8+fJhdu3Zp19ktW7bw8ssvExISwpdffklQUBBWq5UBAwakOwGXLlYrocOG4a8YIKa0bEn8Z5+B4iadVxF3z4KMsdkIe+YZzWXR0rgxcV984ZGMC4vFwrBhw/j7779TvV+6dGl+/vlnQkJC7lknOTmZcePGAQ5R3QkTJri9XwKBwEHx4sX5/vvvKZbmYdlkMjF06FBeeeUVzGazR7ZtefRRYn77DUv9+o43DhwAD21L4DsY9u4lsmVLAhXNOluJEsSuWYO5Xz8v9yzvcfz4cRYvXgxAp06duHHjBps3b9Y+DwkJucf12ysEB5M8fjy3//6b5CFDsCvlSIb//iP4zTcp9MADRDZqRMjo0QR8/DF+GzZg2LUL/v4bduyAn34iYOFCQkaNIrJRIwo1bEjwu++iVycWixYlYepU7uzcSYqSbZebvPbaaxgMBsBRjpRWlNzPz482bdoA8Msvv3jsnFrQsNWoQcyvv2JSyh51t24RNmQIoQMGoBMGIfkCOSSEhI8/JmHaNEfVQFwcYU8/rembeQK/TZu0bOLE3r2ZNGmS9lyiogb/+vXrxw8//OBTJoXm7t2xlSsHQNC0aUhxcXc//OEHDEqFh+n55/N8wCMtpkGDSJg6FXt4OOBwzY1dsSLfmYklDx8OONyAAz74INVngZ98gl7R805+8UWPSWB4CvMTTyD7+TEBaKEE1ZctW0alSpV4RNE/XLZsGR999BE1atRg4cKF6HQ64uLi6N27N1fvd+632wkZPVrTwUxp0oS4r77yiE5wbiMCgIKM0eu1G+SUVq2I/fZbjwitW61Whg0bxro0TlSFCxfmhx9+IErR90jL9OnTNTfSiRMnUrRoUbf3TSAQ3KVKlSr8+OOPFC9e/J7PvvzyS1q3bp1K88ad2MuUIXb9epLGjEGeMQPS0QMV5A+k+HiC3nyT8E6d0CuZnimPPUbMb79hbdjQy73Le8iyzGuvvYbNZsNoNDJmzBgmTpyYapkePXoQ7EPaP3KJEiS+8w53DhwgccoUrLVra5/pz5whYNkyQt54g7D+/Yl4/HH0TZpAkybon3ySkMmTCVi+HL2TRqmlYUPiZ8/m9t69mIYN89pDXmhoKE8qpXRWqzVdaZNu3boBcOfOHX799dfc7F7+JiSEhDlziF26FFvJkgD4b9hAeJs2oGizCfI4koTp+eeJ//prR9m3xULoCy8QOGuWR7I9Az79FBn4ISSEelOmpHJUV/H39+fDDz/ko48+wt/XAgdGI4mTJwMODcWQF18EiwXdhQswciTgmHgzDRzozV56BknCNGwYsceOQXw8CT/8gJzOvW1ex1a3LmalNN3/yy9BuaYY9uwhSAkIWurVy5Ml3nKhQqR07IgeWHH7NuWVeMFbb71Fv379qKro87333nvMmTOH9u3b88477wAOh+5u3bplHASUZULGjbub4duwYb4ynBMBQEGmmJ5/nrgvvyRu8WKPHPQJCQn069ePn5ToukrRokVZuXKl9uNNy6+//srHStpykyZN7jEpEAgEnqFKlSr8/PPP1KxZ857Pjh07Rvv27XnrrbdISEhw/8aNRpJeew35+efd37bA+8gy/itWEPnwwwQtWIBktyMHBZHwwQfEffttvrw5zw2WLFmiuco+99xzzJkzh0uKlqKKc2mqLyGHh5M8YgQxW7ZwZ8cOEt56C3PHjtjvM+FnK1UKc7t2JEybxu1du4jdsAHzM8/4xM379OnTNaflTZs28fnnn6f6vHXr1hQpUgTI2CxEkH0sbdsSs327JvSf/MILQks0n5HSvj2xa9ZgV35Hwe+8Q/CECaDo8LmD5K1b+fyvv6gH9EhI4GKacypAnTp1+O233+jfv7/btutuUrp2xdypE+AIiEc2bkxoy5aglIsmvvMOcjpVWPkGf3/Iz/uH8h0GBSHJMjz+OMEDBxLevTuS2Yzs70/CRx+Bck3KayS/8AIARVJSWNGiBSEhIdjtdkaNGsWkSZMorWiDTp06lZkzZzJ48GBefPFFwOEMnG4QUJYJnjTJoY2JI0Aat3x5vjpORABQcF9SOnf2yM3RxYsX6dy5M5s2bUr1fvny5Vm/fj21nWb8nTlx4gTDhg1DlmXCw8OZPXs2OqEFJRDkGlFRUaxfv56OiuOdM3a7nblz59K4cWO+++47rfxFIMgQWcbvl18cBg0jRqC7fh2AlBYtuPP77w6dojxWmuIrHDx4UNOjKleuHDabTdPNDVKCYfXr16du3bpe66Or2KpUwTR8OPFff83tI0e4efYsd/74g5j167H99hts3Yrt4EFunTzJnQMHiF+yBNPzz2NXxL99hdDQULorWmUAkyZNSqWjajQa6dGjBwCbN2/mwoULud7H/I4cHk7CrFkOB2rFbV6Qv7DWr0/Mhg3YKlQAIPDLLwkdNAgUHdTskJSUxA8//MDzzz9PzV69GAH8l85yQUFBTJw4kV9++YXqvl6tIEnEz5+PpVEjAPTnz6O7cweA5NdeI0VxkhXkXexlyxL3+efIBoPD2XnNGqTkZGSDgYTZs7HVq+ftLmYb6wMPkPLoowA0+OEHls6ZQ0BAACkpKQwbNozx48dTUsn4njZtGuPHj2fixIm8oAQOT58+TadOne5qAtrtBL/xBoGLFjnar1mTuO+/R1ZKxfMLBm93IDeJjY1l5cqV7N69m1u3buHv70+lSpXo2LEjDz/8cLbbtVqtrFu3jm3btnHlyhXAoV3XvHlzOnXqpOm9ZMSZM2dYvXo1//33H3FxcYSHh1O7dm2efPJJKigXrvzG6tWrGTduHHHOehNAs2bNWLhwoTb7nZazZ8/SvXt34uPj0el0fPrpp5RT9CsEAkHuERISwldffcWyZct45ZVXSElTQnX16lVGjhzJZ599xrhx42jXrl26Rj4FEV+9FuU6KSn4r11LwMcfYzxwQHvbVqYMiW+/TUrHjiLwlwOOHDnCM888Q3JyMnq9nsqVK/Ppp58CULJkSaKjowEYNGiQN7uZfUJCsNWo4XgdGenIYLDZkJWHV19mzJgxfK+UFtntdoYNG0ZcXBwDFFH+/v37s3DhQmw2G/PmzeP999/3Ym/zL9Y07vZ5EXE9yRh7hQrEbNhAWJ8+GPftw3/DBnTduxO3ZAlyoUL3XT8lJYX9+/fz559/8tdff7Fnzx5MJlOGy0uSxJNPPsnrr7+uZR7lCYKDif3xRwK++gq/X3+F0FD8hg/H1KiRW7MmBd7D0ro18Zs2EfbBB9gOHsRWpQpJ48fnC1mVpIkT8du+HSkpibY//8zXX3/Ns88+i8lk4uWXX2bs2LGsXLmSs2fP8vXXX3PmzBnmz5+PTqdj7ty5XLhwgY4dO7Jw/nye3LCBgO++A8BapQqxK1e6dK7Ia0iyXDAssC5cuMBrr71GbGws4HC1NJvNWnbK448/zvPZKCtLTk7m9ddf58SJE4BDwBnQHoarV6/OW2+9RUBAQLrrb9u2jdmzZ2O1WgEIDg4mMTERAIPBwEsvvcSjSmQ7J9y8efO+y0RGRqLX67HZbNzx0A30hQsXeOONN1i/fn2q9yVJYvTo0bz66qtaaQyAXq8nMjKSO3fu8M8///Dss89qqbrvvvsuz3lp5jY3xiqrOI+VzYcu2GKsXCevjtWlS5cYM2aMVmaYHrVq1eKll15yy4NDTscpowmG3MBXr0VZwZXrSXpo39vp05g+/ZTAr77Ssv0A7EWKkDRqFKb+/XO1VDO/nQ9u377N8uXLef/990lKSgIgLCxMm3CrWLEikiRx+vRpypQpw+7duzG6KPCe38bK02Q2Xs8//zw//vhjqvdGjBjBG2+8gV6vZ+DAgaxbtw5/f392795NqVKl3NKnvDhW3iSz8fLmtQTy/vUkx9cSV4/hxETCnn8eP6XiyFamDPGffpoq+GGxWDh+/DgHDhzg4MGDHDx4kMOHD2vO6fejY8eOvPbaaxlKF2UXb/xevfVbFPvqWbyxr7m1nyHDhxOguDnHffYZmwsXZsCAAdp9T5cuXbh8+TL//PMP4PAZ+PDDD4mOjmby5MnaOXMU8B5gqFmT2O++Q86CY3deejYpEAFAi8XCCy+8wNWrVylXrhwvv/wyFSpUwGw2s2bNGpYuXYosy4waNYrWWbQ5/+ijj9i2bRvBwcGMGjVKm23btWsXc+bMITExkZYtW/LSSy/ds+6FCxcYM2YMVquVpk2b8txzz1GoUCFu377NZ599xl9//YXRaGT27NmUKVMmR2Pg7QDg9evX+fjjj1m4cCEWiyXVZzVq1GDWrFk8mM5MrF6vJyIigvnz5/PKK69oF+LXX3+dUaNGubWPWcEXb6Dz4s2ztxBj5TpZGauNGzcyZsyYTM83JUuWpF+/fvTt25cSWbiwOpOXLrLO+Oq1KKtk96Gt0MqV6L75xuHW6oStZElMzz9P8qBB4AUjirx4PpBlmSNHjvDnn39y+vRpzp8/z9WrV7ly5QoxMTEZttmqVSuaNGnCW2+9BTj06LKioZsXx8qbZDZex48fp3nz5thsNvz8/LTgSps2bVi4cCFnzpzRzgOPP/44X3zxhUvblGWZs2fPcuPGDQICAihfvjzhTuVLeXGsvImvBgDzw/Uk1wKAAFYrwRMmELh4MSnAfzodO9u25Z+iRTlw6BBHjhzJlut27dq1WbhwodsDfyoFJVAEYl89TX4OAErXrxPZogW6GzewBweTsHo1F0qWpEOHDprmcVRUFNWrV08lPdamTRser1KFNz/+mDtKSKxyQABT582jddeuWepDXno2KRDCaRs3buTq1av4+/vzxhtvaGW1/v7+9OzZkw6K0+2SJUu0TDxXOHv2LH/88QcAL774Io0bN0aSJCRJonHjxoxUHJS2bt3K+fPn71l/6dKlWK1WKlSowNixYymkpJgWKlSIcePGUaFCBSwWC0uXLs3R/nsLWZb5999/GTp0KPXq1WPevHmpgn/h4eG89dZb/Pbbb+kG/wCOHj1Khw4dePHFF0lOTsZoNDJr1iyvBv8EAkH6tGvXjqNHj/J///d/BGbgshkdHc17771HvXr16N69O9988w23b9/O5Z56B1+9FuUW0oYNqYJ/locfJm7RIu788w/JL77oleBfXiMmJoa5c+fyv//9jxYtWjB58mS+/PJLfv/9d44cOZJu8E+SJBo1asSiRYv44IMPmDVrFgDVqlWjX79+ubsDAo1q1aoxfPhwwJFZpWb4bdq0iQ4dOhAQEEDfvn0BWLt2LSuV7IaMOHLkCC+//DLVq1enUaNGdO7cmdatW1O1alXat2/PokWLiI+P9+xOCXKNgn49cZX4+Hj+/vtvvvzmG4bKMvXLlCEE+J/dzou//MJX33zD/v37sxz8i/DzY9GiRWzZssVjwT+BQOAacrFixH/yCbJejy4xkdDu3al9+jRbt26lk2Jyc/HiRTZt2kStWrWIiIgAHNfbMQsW0FyWUfOBT5lM9H7uOZ588km2bt1KfsyVKxABwK1btwIOfbmi6TjHde/eHUmSuH37Nv/9l56ca/ps27YNWZYpWbIkjRs3vufzRx55hJIlSyLL8j2lcYmJiezZsweAbt26pSp7BUeUvlu3bgDs3r1bK+PxdaxWK9u2bWPYsGFUr16dNm3asGrVqlQ3HxEREYwbN459+/YxfPhwrbRAxWazsWXLFgYNGkTTpk3ZuHEjAGXLluWHH36gj+LcJhAIfJMXXniBkydPMmHCBM1oIC12u50//vhDe2Bt2rQpU6ZM4e+//87WLHxewBevRbmJ3Ls3VKuG/f/+z+HMunYtKV27govlpwWZM2fOMGHCBOrVq8dbb72VyhgivZJ6nU5H06ZNee+99zh48CDr1q2jZcuWDBw4UCuJmT59usulvwLPMG7cOCopJiVXrlzRJkOPHz9O69atqVSpknauGDNmjHYOUbHZbGzYsIEnnniC5s2bpzuhYrfb+eeff5g4cSJ16tRh1KhRWmmnIO9S0K8naUlJSeHEiRP8+OOPTJs2jb59+9KgQQMqVqxI586deeWVV/jmm2/499IlLPdvTiOtyaARGFe1KvsOHaJrFjOEBAKB57A0a0bC/PnIOh1SfDx060bZoUNZ2q0bc994g6KFCwNw+PBhYmJiKAZIgB34EdiDI9YQrExGb9++naeeeoqWLVsyf/58TQs1P+D7Cq45JDk5mZMnTwJkmGVWtGhRypQpw8WLFzlw4AD169d3qe2DBw8CDge99MTtJUmifv36REdHa8uqHDlyRAuKZdQv9X2LxcLRo0dp0KCBS/3KLa5du8bevXvZv38///zzDydPnuTGjRsZun7WqFGDYcOG8eSTT6bSDTGbzZw4cYJDhw6xfft2tm7dyo0bN7TPjUYjgwYN4tVXXyUkH1lwCwT5GX9/f8aNG8eIESNYsWIF8+fP5+zZs+kuK8syx48f5/jx48ybNw9wpMJXqFCB2rVrU69ePerXr0/VqlXzhPB4evjqtSg3kXv0gF69kO127D5UeuirmEwmNm3axNdff82aNWtSzUJHRESQkJCA1WpNNcH28MMP06NHDzp16pSqnOTQoUOMHDmSw4cPA47MnqZNm+bezgjSJTg4mCVLltCuXTvi4uLYt28fDz74IAcPHsRkMjFlyhQqVqxITEwMZrOZXr168dJLL9GhQwc2btzI0qVLuXz5staewWCgc+fOPPbYY5QvX57ExET27dvHTz/9xPHjx0lMTGTBggUsWLCA9u3b07dvX5o1a5ZhxrbANyno1xNZlpkzZw7Hjx/nyJEjnDlzhosXL+Y4UycACAESANXqQ32mCQGGAGOef56Qd97BJgyqBAKfw9y9O/aICEJfeAHdrVsYN28mfPNmRgLPAtOA+UAicD2d9Z0nV3U6HXa7ncOHD3P48GH+7//+T0tYeOihh6hevTqVK1fOkxOpefNJKgtcunRJuyBk5hZbrlw5Ll68yMWLF11qV5ZlraY8s3bLli0LcE+76t8RERGptFmcCQ8PJzw8nNjYWC5cuOCVAOC6dev48MMPSUxMJDExEZPJhNlsxmKxuHShLVq0KI0aNeKBBx7A39+f6Ohopk+fztWrV7l69SrR0dGcP38+XS2CkJAQnnrqKd58803CwsJ8ShNGIBC4RlBQEP3796dfv378+++/rFmzhtWrV993Ju3mzZvcvHlTy5RW0el0hIaGZqpz5ov46rUoN/nt9985fPgwsiyTmJiILMvamKT3f2afw90HM+f30q6TdkLK+W/n9QICAjCZTNp1Jr1tp9e/jLab0ToZ7QM4JsPi4+OJi4vj8uXLREdH36OZq+J8/JcoUYLmzZvz6KOPUrx4cQD+++8/bt68yfnz5zUHS5UePXrw2muvpduuIPepXLkyq1atonfv3ty4cYN9+/ah1+u1Y/LMmTPasjabjQ8//JAPP/wwVRshISE0adKEZs2aaTpE169fR6fTUaNGDapXr87x48fZvHmzJoL+yy+/8Msvv2AwGKhSpQplypShWLFihIaGEhISgtFoRKfTodfr0ev1Hndx1+v1BAYGkpycnOFEcnrktF+1atXKc8Hwgn49kSSJ8ePHa7qZWUWn0xEQEIAkSZhNJqzKed/E3cAfOLKDmgPPAN0aNiTgzTcJ7dTJoe8lnkkEAp/E0qoVcTt3ErFwIfYvvkCnTDiH4zD4eBVYGBzMlwYDJxQDpfRI7zp07Ngxjh07xqJFiwDHuSg4OJjQ0FAiIyP54IMPaNeunQf2yr3k+wCgcylEoUxsnNXPXBVtTE5O1qzgXWk3OTmZ5ORkbZZV3U5m66qfx8bG3rdfS5YsYdmyZRl+3rt3b5555plM21DT3HU6HZGRkQD88ccfWsZAdrhx4wbr1q1j3bp1Li1ftGhRWrduTYcOHejWrRvBwcFaBN6XavDTGytvo94Eh4eHi7G6D2KsXMedY/XYY4/x2GOPMWvWLE6dOsXWrVvZtm0b//zzD6dPn3bpoc9ut2sljL40TvfDV69F6eGO60l69OvXj+vX05tzFeSEq1ev8t133/Hdd99lupyfnx+TJk1i4sSJ98iOuIo4d2YNV8erRYsW7N69mzFjxrBmzRpsNluWJj0TEhLYuHGjJpmSFaxWK0ePHuXo0aNZXjc/EBUVlWF2OvjmsZVXrieeupbodLoMJ0dcwW63ZyitVLF4cZqVKsVjpUrxWKVKlHzgAeRmzaB8ea+c/7xx/HnrPC/21bMUlOMXQCpUCD78EN55B9u+fUinT4PZjBwaSlitWoyvWpVxksSBAwdYs2YN27Zty5YEkSzLJCQkkJCQQHR0NNu2baNDhw4+c63IiHwfAFQvZOAoScsI9TNX7d6dl3OlXXUd9SKprp/ZulnpV2JiYqYPVklJSS7f8EuSpC2bXZfOjDAYDISGhlKyZElKlSpFqVKlqFixInXq1KFu3bpUrFjxHr0NuFeDw1dwHitfQYyV64ixch13j1X16tWpXr06w4YNAxznuCNHjnD69GkuXLjAhQsXOHXqFBcvXuT69evEx8djNpux2+2EhoYCvjlOGeGr16L0cOf1ROBddDodtWrVonPnzgwfPpyoqCi3teuL+Oo5wZXxKl++PD/++CMHDhxg6dKlbN++ndOnT2tOqQaDAVmWs2ToIHANV44ZXzq28sr1xJPXkvDw8CxXAoSGhhIWFkZ4eDilSpWiTJkylC5dmnLlylGnTh1q1qxJWFjYfdvxxvnPG8eft87zYl89S0E5fgF0/v7QuLHjXzo0aNBAq7A0mUwcPXqUw4cPc+TIEc6fP8+VK1e4ePEi0dHRJCcn3zdwWqpUKZ+6VmREvg8AFhSCg4MpVqxYhp8HBQXddzZZp9MhSVKqsqkxY8bQpEkTdDrdPf8kSUr3fed/BoOB4OBgQkJCCAkJucfwIy2yLKfqp7oNX8wATDtW3kaMleuIsXKd3BorPz8/HnjgAR544IFMlzObzanKNLMzTr5+YfY27riepMebb77Jzp07AUcGhuosCaT637mkL71l4O4NbNpl036eXptpP3P+3aW3zaz2J73l067j3Af1tZ+fH5GRkdrDdVhYGJGRkQQFBaXqmzOZ/V2oUCFKlSqVSp8mp1Ia4tyZNbIzXrVr1+bdd9/V/k77WzGbzVy+fJmYmBgSEhK4du0aN27c0M6Ndrv9ngxC5207H3tpx8psNpOUlERycjJWq1Xrt91uz5VxVcfKVdxxDLZs2TLT30Vmx5a4lmSOp64lOp2ODRs2YDKZkCQJg8GQ4T8/Pz/CwsK0iqL7kVl/vHH+88a5zVvnebGvnqWgHL+QvX01Go3UrVuXunXrpvu5LMuYzWYSEhKIj4/HZDJhsVgwm83ExsaSmJhI8+bN88SzSb4PAKY1m8jIkVJN+XRVCNl5uczSRZ0/c15HfX2/VFNX+9W3b1/69u2b4ec3b968bwmAqhtjt9u1ZXU6HY0aNcp0PVdRdQSzgl6vJzIyktjYWJ/SAExvrLyNGCvXEWPlOr44VmpqfXbHydkcIbfw1WtRerjjepIeQ4cOZcSIEdhsNp85vuHuMX7nzh2fOcbh7vkgJ+OVkJDg1j754vkAfPPcCZ4br8jISO08WKdOnSyvm9PjyhN483eY2Thkdmx541oCeed64qlrSWRkJI0bN3b5GLZarcRmovXlKt44/3nj3Oat87zYV89SUI5f8Oy+6vV6IiIi7nk/p9fW3Lye+GYNhxtx1rBw1sxIi/qZqzXbgYGB2kXPlXadl3fuV2brZqdfAoFAIPA9fPVaJBAIBIK8hbieCAQCgSC75PsAYJkyZbSyCWdr57Son7mqjyNJEmXKlMl2u+rfMTExmqB9WmJjY7UZK9VxSyAQCAR5D1+9FgkEAoEgbyGuJwKBQCDILvk+ABgYGEiVKlUA2LdvX7rL3Lx5U7Oyr1evnsttqzXi+/fvz3CZf//9N9WyKjVr1sRgMGTaL7Vdo9FIjRo1XO6XQCAQCHwLX70WCQQCgSBvIa4nAoFAIMgu+T4ACNCiRQsA/vjjD27cuHHP56tWrUKWZQoVKpQlLZVmzZohSRJXrlzRhM2d2bFjB1euXEGSJK0PKkFBQTRs2BCANWvW3FOfbrPZWLNmDQAPPfRQhvoeAoFAIMgb+OK1SCAQCAR5D3E9EQgEAkF2KBABwHbt2lGiRAlMJhNTp07l7NmzgEPEduXKlaxfvx5wiNWqWXkqzz33HF26dGHWrFn3tFuhQgWaNWsGwNy5c9m1axeyLCPLMrt27WLevHmA4yKdXglvnz59MBgMnD59mhkzZmiCkXfu3GHGjBmcPn0ao9FInz593DYWAoFAIPAOvnotEggEAkHeQlxPBAKBQJAd8r0LMDhKaCdPnsxrr73GuXPnGD16NEFBQZhMJs2muXPnzrRu3TrLbY8YMYLo6GhOnDjBtGnT8PPzAyAlJQWA6tWrM3z48HTXLVu2LKNHj2b27Nls376dP//8k6CgIM0p12AwMHr0aE2PQyAQCAR5F1+9FgkEAoEgbyGuJwKBQCDIDgUiAAiOYNvcuXP54Ycf2L17Nzdv3iQ4OJiKFSvSqVMnHn744Wy1GxgYyPTp01m3bh3btm3jypUrAFSqVIkWLVrQqVOne2benGnevDlRUVGsWrWKQ4cOERcXp6XrP/nkk1SoUCFb/RIIBAKB7+Gr1yKBQCAQ5C3E9UQgEAgEWUWSZVl2V2PPPPMMw4YN01LHBb7DzZs377tMZGQker0em82mlSN7G71eT2RkJHfu3LlHJ9GbiLFyHTFWriPGyjVyOk5FihTxQK8KDq5cT9LDF49v8M1jHHxzvMRYZQ1fHC8xVlkjs/ES15KckdeuJd44Rr2xr976LYp99SwF5fiFvLmvuXk9casG4LfffkvLli2pUaMGs2bN4vbt2+5sXiAQCAQCgUAgEAgEAoFAIBBkEbebgMiyzIkTJxg7dixlypShX79+/Pnnn+7ejEAgEAgEAoFAIBAIBAKBQCBwAbcGALdu3UqvXr3w8/NDlmVMJhNLly6lefPm1KpVi7lz5xITE+POTQoEAoFAIBAIBAKBQCAQCASCTHBrALBZs2YsW7aMS5cu8cEHH1C1alXNOv7YsWOMGTOG0qVLM3DgQHbu3OnOTQsEAoFAIBAIBAKBQCAQCASCdHB7CTBA4cKFGTt2LMeOHWPLli08/fTTWlZgcnIyixcvpmnTptStW5cFCxYQFxfniW4IBAKBQCAQCAQCgUAgEAgEBR63ugBnxq1bt/jyyy9ZtGgRJ06ccGxckgCH3XyvXr0YMmQIDz30UG50R5AOS5YsITExkeDgYPr27evt7vg0YqxcR4yV64ixcg0xTnkT8b1lDTFeriPGynXEWGUNMV6+R0H6TsS+5k8Kyr4WlP2EvLWvuRYAdGbLli18+umnrF69mpSUFEdHlGBg3bp1GTFiBH379iUwMDC3u1ag6dixI9evX6dYsWJs2LDB293xacRYuY4YK9cRY+UaYpzyJuJ7yxpivFxHjJXriLHKGmK8fI+C9J2Ifc2fFJR9LSj7CXlrXz1SAnw/WrZsyfTp0xkwYABwN/gnyzIHDx5k2LBhlC1blpkzZ2K3273RRYFAIBAIBAKBQCAQCAQCgSBfkKsBQLvdzo8//kiHDh2oVKkSn332GeAI/IWEhNCmTRuMRiOyLHPr1i3GjRvHY489RnJycm52UyAQCAQCgUAgEAgEAoFAIMg35EoA8Pz580yePJmoqCi6d+/Or7/+it1uR5Zl6tSpw4IFC7h8+TIbN27k4sWLvPPOOxQtWhRZltm+fTszZszIjW4KBAKBQCAQCAQCgUAgEAgE+Q6PBQBtNhurV6+mffv2VKpUiXfffZfo6GhkWcZoNPLMM8+wfft2Dhw4wLBhwwgJCQGgaNGiTJw4kaNHj1KrVi1kWWb58uWe6qZAIBAIBAKBQCAQCAQCgUCQrzG4u8Fz587x2Wef8dVXX3H16lXAUeILUL58eYYOHcrgwYMpUqRIpu0UKlSI0aNHM2TIEM6ePevubgoEAoFAIBAIBAKBQCAQCAQFArcGANu1a8fmzZuRZVkL+ul0Ojp27MiIESNo3769ZvjhCmXKlAHAZDK5s5sCgUAgEAgEAoFAIBAIBAJBgcGtAcBNmzZpr4sVK8bgwYMZMmQI5cqVy1Z7QUFBlC1bFp3OK2bFBY5nnnmGxMREgoODvd0Vn0eMleuIsXIdMVauIcYpbyK+t6whxst1xFi5jhirrCHGy/coSN+J2Nf8SUHZ14Kyn5C39lWS1VQ9N6DT6Xj00UcZPnw43bt3x2g0uqtpgUAgEAgEAoFAIBAIBAKBQJAN3BoAPHz4MLVq1XJXcwKBQCAQCAQCgUAgEAgEAoEgh7g1ACgQCAQCgUAgEAgEAoFAIBAIfAu3iuvpdDoMBgM//fRTltbbuHEjer0eg8HtpsQCgUAgEAgEAoFAIBAIBAJBgcbtEbfsJhSKRESBQCAQCAQCgUAgEAgEAoHA/Qh7XYFAIBAIBAKBQCAQCAQCgSAf4xM1t0lJSQAEBAR4uSf5h2XLlvHtt99mukxAQADff/99treRnJzM6tWr2bFjB9euXcNgMFC2bFnatGlDq1atkCQp223nJpcuXWLXrl38999/nD9/nri4OIxGIyVLlqRBgwZ07tyZyMjIbLX933//8dprr913uY8++ogqVapkaxu5RWxsLCtXrmT37t3cunULf39/KlWqRMeOHXn44Yez3a7VamXdunVs27aNK1euAFC6dGmaN29Op06d8pQ0wI0bN9i5cycHDx7k3Llz3L59G4PBQNGiRXnggQd4/PHHKVGiRJbbvXbtGs8///x9l5swYQJNmjTJTtdznc2bNzN79uz7LrdkyRLCwsKy3H5+Oq7yI1evXmX9+vXs27ePmzdvAhAZGUmVKlVo0qRJjs4p+YGDBw+yf/9+Tp48yfXr14mNjcVisRAREUHlypVp3bo1Dz30kLe76XU8dV3Kb5w6dYrdu3dz8uRJrly5QlxcHGazmdDQUCpWrEizZs1o3rw5Op3IC3AmJiaGdevWsWfPHq5fv47FYuH/2bvv8Ciqt43j391NIYWE0EPv0qtKE+lNmoiAKK+KvaCCDQVEBREVC1IUGzYUBAQpFpo0qYIU6QTEAAGSUBLSk82+f8SdX3rdsJvk/lyXl7s7M2eenSw7O8+c85yAgABq165N27Zt6d69u7NDLHGuXLnCoUOHOHHiBCdPnuTkyZNER0cD8Nlnn1GpUiUnR+gYJeG7LSoqioMHDxIUFMTJkycJCgoiIiICgKlTp9KsWTMnR+g4hXV94IpK+vnmjTfeYNeuXQB069aNMWPGODegTLjEFdCOHTsAqFixopMjKX7c3Nzw9fXNdFlBEq6XL1/m5Zdf5vz580Zb8fHxHDlyhCNHjrBr1y7GjRuHxWLJ9z6uh8OHD/PSSy+lec3Hx4fY2FhOnTrFqVOn+O2333j55Zdp2rRpgfZVpkyZLJe5ejIiODiYCRMmGCdmLy8voqOj2bdvH/v27WPAgAG5SlClFxsbyyuvvMLx48cB8PDwAFJOHkFBQWzdupXJkycXiZsDYWFhPPTQQ2nKGXh7e5OQkMCZM2c4c+YMq1evZsyYMdxyyy353o+fn1+WJ0378StKzGZztgm+/NxIKE6fq+Lot99+4/PPPychIQEAT09PAEJCQggJCeHq1avF5gInv3788Uf27t1rPPf29sZsNhMeHk54eDg7duzglltu4dlnn3X580dhKazzUnG0Zs0afvvtN+N5qVKlcHNz48qVK+zZs4c9e/awdu1aJk6ciLe3txMjdR07d+5kxowZRnLJw8MDi8XCxYsXuXjxIqdPn1YC0Al+/fXXHDs4FHUl5btt586duboRXNRdr+sDV1GSzzdbt241kn+uLN+/Gg8cOMC+ffsyXfb7779z9erVbLe32WxER0fz119/MX/+fEwmEzfddFN+w5EsNGzYkDfffNPh7b799tucP3+e8uXL8+yzz9K0aVOSkpJYv349n376KTt27OCHH37g7rvvdvi+HclqtWKxWGjXrh1dunShWbNmeHt7k5iYyN69e/n0008JDQ1l6tSpfPTRR/nuCQjwzTffODDy6ycxMZE33niDiIgIatasybPPPkvt2rWJj49n+fLlfPfdd6xcuZLatWvTo0ePPLX90Ucfcfz4cXx8fHj66aeNi/4dO3Ywc+ZMjh49yscff8zYsWML4605VHJyMgCtW7emW7dutGzZEj8/P6xWK0eOHOHTTz/l9OnTvP/++1SrVo1atWrlaz/vvfdesbnDDVC+fHk+//xzh7ZZnD5Xxc369ev56KOPMJlMDBo0iH79+hl3vSMjI/n7778JDQ11cpTO17p1a9q2bUvjxo0JDAw0kqRhYWGsWLGC5cuX88cff1CrVi2GDRvm5Givv8I8LxVHN9xwA1WrVqVx48ZUrVrVuOi6evUqa9eu5bvvvuPgwYPMmzeP0aNHOzla59u3bx9vv/02SUlJdO3alSFDhlCjRg0gpdfSsWPHOHr0qJOjLJlMJhMVKlSgbt261KtXDy8vLz777DNnh+UwJe27LSAgwPhbVqlShffff9/ZITnc9bo+cBUl9XwTHR3NZ599ho+PDwEBAZw9e9bZIWUp3wnAZcuWMXny5Ayv22w2Zs2alae2bDYbJpOJxx57LL/hyHW0a9cujhw5gslk4uWXXzaGrrq5udG7d29iYmL48ssvWbZsGf3798/X8L3rJTAwkI8++ojAwMA0r7u7u3PzzTcTGBjI2LFjiY6OZvXq1dx1111OitR5Vq9ezYULF/D09GTSpElUqFABSOm1M2zYMC5fvswvv/zC/Pnz6dKlS657o/zzzz9s3rwZgKeeeor27dsby9q3b09ycjJvv/02Gzdu5I477qBmzZqOf3MO5OvrywcffECdOnXSvG6xWGjatCmvv/46Tz/9NBERESxfvpxnnnnGSZEWb8Xtc1WchIWF8emnnwLw6KOPctttt6VZ7ufnV2SGsBe2QYMGZfp6hQoVePDBB7l69SqbNm1i3bp1JTIBWFjnpeIqq55qZcqUYejQocTHx7No0SI2btzIY489VqKPV2xsLDNnziQpKYk77riD+++/P81yX19f2rRpQ5s2bZwTYAk3bNgwRowYYTw/deqUE6NxvJL03dalS5c0301RUVFOjKbwlLTrg5J6vvnqq6+4fPkyjz76KFu3bnXpBGCBBl/bbLY0/2X1ek7/VapUic8++4xu3boV+A1J4du4cSMAzZs3z7Ru3W233YaXlxfx8fFs27btOkeXN+XLl8+Q/EutevXqNGjQAEgZPlgS2f/et956q/FDJLUhQ4ZgMpm4fPkyf//9d67b3bRpEzabjcDAwDRJGrsOHToQGBiIzWZj06ZN+Y7/evHx8clwck8tICDAuGA4efLk9QqrxClun6viZOXKlcTGxlK/fv0MyT/JG/t56fLly06OxDkK67xUUtl/yyUkJHDt2jUnR+Nc69evJzw8nHLlynHPPfc4OxxJx9VLCxVUSfpuK+5/SztdH6RVHM83hw8fZs2aNdSvX5++ffs6O5wc5Tvlevvtt2foojpq1ChMJhOjR4+mdevW2W5vNpvx9fWldu3aNGvWrMR8CRQHBw4cAMjyb+zp6UmTJk3YvXs3Bw4coE+fPtczPIez92C0d+EuSWJjYzlx4gSQ9d+7QoUKVKtWjTNnzrB//35atWqVq7btn6NWrVplWufNZDLRqlUrzp8/b6xb1Nk/S1ar1cmRFF8l8XNVVKS+sJGCsQ8/LE7lAHKrMM9LJZX981SqVKls6xWXBPbvqQ4dOuDu7u7cYKRE0XdbyVWSrg+K2/kmMTGR2bNnYzKZeOKJJ4rE5Cb5TgC2aNGCFi1apHlt1KhRQErXz4EDBxYsMnGI4OBgnnzySS5evIjFYjFmG+rfv3++ZhuKiIggMjISwKiHkpkaNWqwe/duzpw5k+/YXYG9PgNk/35z44UXXiA4OBir1UqZMmVo1KgRffv2pXHjxo4ItVCcPXvW6N2b3VDJmjVrGoVsc8Nmsxldo7Nr137Mi/rnyO7gwYNA9u85J++88w4hISHEx8fj7+9PgwYN6NGjR5GtoRoREcGYMWM4d+4cAOXKlaNp06b0798/z3VQSurnqii4cOGCURu4bt26HD9+nMWLF3P48GHi4uIoV64crVu3ZsiQIZn2ehCIiYnhwoUL/Pbbb2zZsgWAAQMGODmq66+wzkslTXx8PGFhYWzYsIFly5YB0K9fv3xNvFRcJCQkGENK69aty9mzZ/nhhx/Yv38/UVFRBAQE0KxZM+64444C/yYUSU/fbSWXI64PXFlxPt8sXryYs2fPMmDAAOrWrevscHLFoYOuv/zySyDruxZy/UVGRhIVFYW3tzcxMTEEBwcTHBzMb7/9xlNPPUXnzp3z1F7q4UZly5bNcj37sqI+PGnVqlVcuXIFs9lc4CHqx44dw8fHh6SkJEJDQwkNDWXTpk0MGDCAhx56yCW/BPP6975y5Uqu2o2NjSUuLi7X7cbGxhIbG4uXl1eu2ndFO3bsMIaRF2TmwBMnThgzgl66dInt27ezfft2OnbsyLPPPlvkeizEx8fzzz//4OPjQ1xcnDET7Lp167jvvvsYPHhwrtsqiZ+roiIkJMR4fPDgQX744QesViteXl5YLBYuXLjAL7/8wqZNm5g4cSJNmjRxYrSu49SpU4wZMybD6x4eHtx1111Fvod9fhTWeakkiIqKynRyNjc3N/r378/IkSOdEJXrCA0NJSkpCUj5zvr444+Jj4/Hw8MDDw8PwsLC+P3339myZQtjx44tFjN2iuvQd1vJ5KjrA1dTEs43Z86cYcmSJZQtW7ZIlYxwaALwvvvuc2RzUgBVqlRh1KhRtG3blkqVKmGxWEhISGDv3r189dVXnDt3jhkzZhi9bXLLfnENGLMSZsa+LDY2Nv9vwslOnjzJt99+C6TcpcjP3V4fHx8GDx7MLbfcQo0aNfD09CQ5OZmgoCAWLFjAnj17WLlyJf7+/i5ZyL2w/t6p18tNu/ZtimqiJiwsjDlz5gDQtm3bPBcP9/Dw4LbbbqNTp07Url3bmFErODiYH3/8kQ0bNrB161Z8fHyKzIxaZcuWZcSIEXTo0IEqVarg7u5OUlIShw8f5ptvvuH48eN8+eWXlC1bNtc3Kkra56ooSV3ce+HChQQGBvLUU0/RuHFjbDYbhw4dYubMmVy4cIG33nqLjz/+GF9fXydG7Brc3NyMITJRUVEkJSXh5ubG8OHDS2TyD0rW7xBHM5vNxucpJiaGhIQETCYT/fv3Z/DgwSW+HE/q76klS5bg7+/PuHHjaN26NWazmVOnTjF79myCgoKYMWMGderUoUqVKk6MWIoTfbeVPAW9PnBlxf18Y7PZmDNnDklJSTz00EPGtVlR4PqDlCVfunTpwuDBg6lSpYrxD8zDw4O2bdsyffp0KleujNVq5ZtvvnFypK4pLCyMqVOnkpCQQIMGDTLMApdbderUYdSoUdSvX984YZvNZho0aMCkSZPo0KEDkPJDs7jOflXSRUVFMWXKFCIiIqhcuTJPP/10ntsICAjgscceo0mTJmlOMDVq1GDs2LHGjKFr16516VmnUmvVqhUjRoygZs2aRq9FNzc3mjdvzrRp07jhhhsA+Prrr0tk/c3iJvVEYQDjx483yh+YTCaaNm3Kyy+/jNlsJiIigjVr1jgjTJdTo0YNvvnmG7755hsWL17MRx99xK233sq3337L2LFjNQRM8sTb2zvN5+mzzz5jwIABrFy5ktGjR3P48GFnh+hUqb+nkpOTGTNmDDfeeKNR06lOnTpMnDiRUqVKkZCQwIoVK5wVqogUcY64PnBlxf18s3r1ag4fPkybNm2KXG/w4jHvcgnz5ptvGgU0U+vUqRMPP/xwjtv7+voydOhQZs2axbFjx4iMjDSKj+akVKlSxuP4+Pgs17Mvc3bPmvwcq8uXL/PKK68QHh5OjRo1mDRpUqEMqzSZTNx3331s27aNuLg4Dhw4YCQEXUX6v3dWdzfy+vdOvV5uPkd5aduVxMbG8vrrr3P69GnKli3L5MmTKV26tMP3c8899/Drr7+SkJDAn3/+SbVq1Ry+j+vJ3d2dkSNHGv8OT506Rb169XLcrqR8rlxRTt+1qY9z69atqV69eoZ1a9euTfPmzdm3bx/79+/njjvuKNSYnSW/53CLxUK1atUYM2YMvr6+rFixgg8++ID33nvPJUtIFJbCOi+VNCaTiUqVKvHQQw9RsWJFPv/8c6ZPn87cuXOz7X1UnKX+rFSvXj3TCRbKli3Lrbfeypo1a9i/f//1DK/YK+j1TVGn77aS43pdH7iK4na+uXz5Ml9//TUeHh48+uijzg4nz/KVALRPZW0ymdJMV53dFNe5kb49yVxUVJRRTD216OjoXLdh711js9m4ePFirhOA5cqVMx5fvnyZ2rVrZ7qevY5FdjUsroe8HqurV6/yyiuvEBISQmBgIFOmTMn1scmPwMBA/Pz8iIyM5MKFC4W2n/xK/fe7fPlylj9G7H/vgICAXLXr5eWFl5cXsbGx2daJtC+zr1+UxMfHM3nyZI4dO4a/vz9TpkzJ18Q7uVGqVClq1KhBUFAQFy9eLJR9XG/27yhImUAitwnA4v65clU5fdem/i6pWrVqlu1Uq1aNffv2ER4e7vAYXYUjzuEDBgxgxYoVBAUFcfLkyVz9+yguCuu8VJL16dOHr7/+mkuXLrFnzx6Xuxl5vaT+bGV3I82+LCwsrNBjKkkc8d1YlOm7rWS4ntcHrqg4nG+++eYboqOjGTp0KP7+/hmG49tHLlmtVmOZp6eny8wQnK8E4OnTpwEy3HE+ffo0JpMpw1Cf3CpJd7AL4s0333Tavv38/PD39yciIoLg4OAsaxUEBwcDZNrL43rKy7GKjIzklVde4cyZM1SsWJE33nijxJ9cq1WrZvybDg4OzvIHcV7/3iaTiWrVqnHixAljW0e06yri4+OZMmUKhw4dwtfXl8mTJxe591AUFffPlSvL6bu2evXqmM1mDefGMefw1DfjcpsgLy4K67xUknl4eFC6dGkuX77M+fPnnR2O0/j5+REQEJDryRV03eJYzry+cQX6biv+dH1QPM43oaGhQMoMwIsXL85yvU2bNrFp0yYAo26sK8hXGrJGjRrUrFkzw6QINWrUMJbl57/8TLIg+XPs2DEg5cdLxYoV87Rt8+bNAfjrr78yXR4fH2+M67ev6+qioqKYNGkS//77L2XLluWNN96gQoUKhb7fCxcuEBkZCUClSpUKfX955eXlRf369YGs/97h4eFGHaoWLVrkum37Z2Pv3r1ZrrNv37406xYFiYmJvPnmmxw4cABvb29ee+21LHvKOkpcXJzxg9AVP0f5Yf+Ogry9p+L6uSrqPD09adiwIQDnzp3Lcj17Dcvi8jkuLKl7jKceNlYSFOZ5qaSKjY01fouU9F7RLVu2BMi2nq59WV5/P4tkR99txZszrg9ckc43zlegHoC5fV2uL5vNlu1dyejoaJYsWQJAgwYN8Pf3z1P7nTt3ZsuWLRw4cICgoKAMPQ9+/fVXYmJi8PT0LBLdemNiYnj11Vc5deoUZcqU4Y033nBYV+yc/hZff/01kHJx7Kon8i5dunD8+HE2b97M8OHDMyRGly5dis1mo2zZsjRr1izX7d56660sXbqUkJAQtm/fTvv27dMs37ZtGyEhIZhMJrp06eKIt1LokpKSeOutt9i7dy+lSpVi0qRJNGjQoMDt5vQ5WrBggTG71k033VTg/RW2nN5PUlIS3333HZDS06lu3bq5brs4fq6Ki27dunH48GH++usvgoODM9z0O3XqFAcOHADgxhtvdEaILsFqteY4O97SpUuBlLqA9sRqSVJY56XiyGq1Yjabs/3OXb58OUlJSQA0adLkeoXmkrp168aGDRs4c+YMf/31F61bt06z/PLly2zevBko2d9TUjj03VY8Fdb1gaspKeebnHorjx8/noMHD9KtWzfGjBlzfYLKA9cYiCwOdejQIV555RU2bdrEpUuXjNcTExP5888/efHFFzl//jxms5n77rsv0zYGDhzIwIED+f777zMsu/nmm2nUqBE2m41p06Zx8OBBIOUf/Zo1a/j2228BGDx4cKHWz3OEuLg4Jk+ezIkTJ/Dz82PKlCl5nkAhu2M1evRoli9fztmzZ42hbzabjRMnTvDGG2+wdetWAIYOHYqvr2/B31Ah6N27N5UrVyYuLo4pU6bwzz//ACk9PZcsWcLPP/8MwMiRI3FzS3tP4aGHHmLgwIHMmDEjQ7u1a9fm1ltvBWDWrFns2LEDm82GzWZjx44dzJ49G0j5MVQUegdbrVbeffdd/vzzTzw8PJg4caIxy2luZHesxo8fz6JFi/jnn3+wWq3G68HBwXz44YcsW7YMgJ49exaJCUBCQ0N5/vnnWb16dZqahVarlYMHDzJ+/HijEPh9992XoWZGSfpcFSfdu3enZs2aJCcnM23aNI4cOWIsO3ToEG+99RbJyclUrlyZ7t27OzFS5zp8+DDjx49n06ZNaYYiWq1WgoKCmD59OuvWrQOgf//+LnvuKEwFOS+VNOHh4YwdO5Y1a9akqVlns9k4c+YMc+fOZcGCBQC0b9+emjVrOitUl9CiRQujvM2HH37Inj17jN9v//zzD1OnTiUuLo7SpUszaNAgZ4ZaIiUnJxMZGWn8l7o+YFRUVJplRbHkREn7bkv994qKijJej46OTrPMnjAqigp6fVCU6HxTNBT9bw7JwGazsX//fmN2Mk9PTzw8PIiJiTGSB15eXowePZqmTZvmax/jxo3j5Zdf5vz584wfP55SpUqRlJRkfEG3a9eO4cOHO+YNFaJt27YZw5Xj4+N55ZVXsly3fPnyvP/++3lq/8yZM3zxxRd88cUXuLm54e3tTVxcHAkJCUDKEOxBgwYxbNiw/L+JQubu7s7EiROZMGECp0+f5plnnjHeh/3HVf/+/enRo0ee237iiSc4f/48x48f580338TDwwPAOD4NGzbk8ccfd9ybKURHjhxh27ZtQMq/wXfffTfb9b/55ptctx0WFsb8+fOZP38+FosFb29vEhIS0sxm27lz5yI1E9Xx48c5fvw4kFIPpFSpUsTExBjfIW5ubtx333356qVXnD5XxYnFYjG+S86dO8e4cePw8vLCZrMRFxcHpHzPTpw4sUjOCudIBw8eNG6ueXp64unpmebfB6Qk/O+//34nRehchXleKo5OnTpl3Pywf9+m/i0CcNNNNzF27FhnhehSnnvuOSZOnMipU6d4/fXX8fDwwM3NjZiYGAB8fX15+eWXnT7RXUkUFhaW5YzA6T+/n332WZErJ1HSvttGjhyZ6evpe1hNnTq1yPZ4LMzrA1ek843rUwKwGKpZsyajRo3iyJEjBAcHExkZSUxMDF5eXlSpUoWWLVvSt2/fNEXE86ps2bLMmDGDZcuWsW3bNi5evIinpyf169enR48e9OjRo0gUR049YU18fHyahEp69iRCXjz55JMcOXKEkydPcvXqVaKjo3F3d6d69eo0btyY3r17F4ni7TVq1GDWrFn8+OOP7Nq1i/DwcHx8fKhTpw79+vWjXbt2+WrXy8uLt956i1WrVrFp0yZCQkIAqFu3Ll26dKFfv35F5g5n6s9SYmJipjPZ5df999/P/v37OXHiBFeuXOHatWtYLBYCAwNp2LAh3bt3L1L17MqUKcMjjzzCkSNH+Oeff4iIiCA6OhpPT0+qV69Os2bN6Nu3b7azxWanOH2uiptKlSoxc+ZMfvrpJ7Zv387Fixex2WzUrFmTdu3aMWjQoBLZoy21unXrMmbMGA4cOGCcO6KiovDw8KBq1arGv/mSOPQ3tcI6LxU3ZcuW5cUXX+TAgQMcP36cK1euEBkZibu7O1WrVqVBgwZ07tw5w1DXkszX15fp06fz888/s3nzZs6dO0dSUhJVq1alTZs2DB48uEC/oUWyo++24qUwrw9cjc43RYPJlt8pe/MpNjaWuXPnsmXLFpKSkmjZsiWPP/44gYGB1zMMERERERERERGREsGhCcC9e/dy3333YTKZmDt3bobi65GRkXTq1MkY1mJXtmxZ1qxZQ6tWrRwVioiIiIiIiIiIiODgSUCWLFnCwYMHCQ0NzbR78oQJE/j777+Nguz2/y5dusSQIUOyHX4pIiIiIiIiIiIieefQBODOnTsxmUz07NkzQ/23a9eu8cUXX2AymahRowbLli1j3759PPLIIwD8+++/zJ8/35HhiIiIiIiIiIiIlHgOTQCeO3cOINOhvL/++qsxy98XX3zBoEGDaN68OXPnzjWK1//000+ODEdERERERERERKTEc2gCMDw8HCDTCT02bdpkLOvevXuaZUOHDsVms3HgwAFHhiMiIiIiIiIiIlLiOTQBGBERkdKoOWOz27dvx2QyZUj+Qcp05wBhYWGODEdERERERERERKTEc2gC0NvbG8iYyIuIiDB693Xo0CHDdqVKlQLAarU6MhwREREREREREZESz6EJwFq1agHwxx9/pHl91apVJCcnA9CxY8cM2126dAkAf39/R4YjIiIiIiIiIiJS4jk0AdipUydsNhsrVqxg//79AERGRvLOO+8AUKVKFZo2bZphu4MHDwJQu3ZtR4YjIiIiIiIiIiJS4jk0Afjwww9jNpuJi4vj5ptvpl27dtStW5eDBw9iMpl4+OGHM93u999/x2QyGbMBi4iIiIiIiIiIiGM4NAHYvHlzXn31VWw2G4mJifz5559cunQJm81Gs2bNeOGFFzJs8/fff3P06FEAbrnlFkeGIyIiIiIiIiIiUuKZbDabzdGNrlixgs8++4ygoCB8fHzo1asXL730En5+fhnWfeSRR/j8888BCAkJoXLlyo4OR0REREREREREpMQqlASgiIiIiIiIiIiIuAaHDgEWERERERERERER16IEoIiIiIiIiIiISDGmBKCIiIiIiIiIiEgx5lZYDe/bt49ff/2VgwcPcuXKFeLi4nLcxmQysX79+sIKqUQ7fvy4s0MQEXEJDRo0cHYIRZrOJyIiOpeIiEjR4/AE4Pnz5xk1ahRr167N03Y2mw2TyeTocEREREREREREREo0hyYAo6Ki6Nq1KydOnECTC4uIiIiIiIiIiDifQ2sAfvDBB8bQoGrVqvHxxx8TFBREXFwcycnJOf5ntVodGY6IiIiIiIiIiEiJ59AegMuWLQOgcuXK/Pnnn1SqVMmRzYuIiIiIiIiIiEgeObQH4MmTJzGZTDzxxBNK/omIiIiIiIiIiLgAhyYAk5OTAbjhhhsc2ayIiIiIiIiIiIjkk0MTgDVr1gTg2rVrjmxWRERERERERERE8smhCcCBAwdis9nYunWrI5sVERERERERERGRfHJoAvCpp54iICCA7777jqNHjzqyaREREREREREREckHhyYAAwMDWbhwIW5ubvTs2ZPNmzc7snkRERERERERERHJIzdHNjZ58mQAevTowfLly+natSstW7akffv2lC9fHrM553zjpEmTHBmSSJFw1113cfHiRcaNG0efPn2cHY7LGTNmDPv37+e+++7j/vvvd3Y4IiLF1ldffcXXX39NixYtmDFjRoblsbGxfP311/zxxx+EhoaSmJgIwIYNG65zpCIiIiKSFw5NAL722muYTCYATCYTNpuNffv2sW/fvly3oQSgiIiIiGuaNGkSu3fvBqBUqVL4+vo6OSIRERERyQ2HJgABbDZbts+zY08eioiIiMj15+/vT/Xq1alYsWKGZadPnzaSf6+//jq33nrr9Q5PRERERPLJoQlADf8QERERKboGDx7M4MGDM132zz//AODn56fkn4iIiEgR49AEYOfOnR3ZnIiIiIi4iPj4eAC8vLycHImIiIiI5JXDhwCLSMrQ97Vr17J69WpOnjxJVFQUPj4++Pv7c8MNN9CxY0e6dOmSq7asVivvvvsuv/32G76+vkybNo2mTZsay6Oiovjxxx/ZunUrISEhJCQkUKFCBdq0acPw4cOpWrVqmvbef/99Vq5cyYABA3j22WfTLDt27BiPPfYYkDKZz4QJE9IsDw4O5r777sNisbBy5coMF4GXLl1i8eLF7Ny5k4sXL5KcnEzlypVp27Ytw4cPp2zZslm+z40bN7J06VKCgoIwm83UqlWLQYMG0bNnz1wdp5wcOXKEJ554ArPZzMKFC6lQoUKm61mtVoYOHcqVK1d49tlnGTBgAABJSUns2LGDbdu2ceLECcLDw4mOjsbf359GjRoxePBgWrVqlWmb6Yvqr127llWrVnH69GkiIyOZMmUKt9xyi0Pep4gUD7mZHCqzdS5cuMCIESMAWLBgARaLhfnz57Njxw6uXLlCmTJlaN++Pffffz8BAQEZ2sxsEhD7a3YXL16ka9euxvP0MUZERLBo0SK2b9/O+fPnAQgMDKRDhw4MGzYMPz+/DPvdt28fY8eOBVJGlBw+fJgffviBgwcPcvXqVQYPHszo0aMzxGc/d5w6dQqz2UyjRo144IEHuOGGGwCIjo7mhx9+YOPGjVy8eBFfX186derEQw89VOD6hffffz///vsvDz30EPfcc0+W63300UcsXryYJk2aMHv2bOP1U6dOsXHjRvbv38/Fixe5fPkynp6e1KxZk86dOzNo0CA8PDwytJf+bxwfH8/333/P3r17uXz5Mu3ateONN94o0HsTERGR4kcJQJFCMG3aNNauXWs89/HxITY2lsjISM6cOcO+fftylQBMSEhg8uTJbN26lbJlyzJ9+nTq1KljLD969Cjjx4/nypUrALi5ueHm5kZISAghISGsXbuWSZMm0b59e2ObFi1asHLlykwn50n92v79+7Nc3qBBgwzJv+3btzNlyhRiY2MBcHd3x2Qy8e+///Lvv/+yevVqpk2bRqNGjTK0O2fOHJYsWQKk1AL18fHhyJEjHDp0iKCgoByPU240atSIqlWrcu7cOTZs2MCwYcMyXW/Pnj1cuXIFd3f3NH+jgwcP8sorrxgxent7YzabCQ8PZ8uWLWzZsiXHi0CAmTNnsmzZMsxmMz4+PrmaHV1EJD9OnTrFO++8Q0REBN7e3iQnJxMWFsaKFSvYvXs3n3zySa6SYF5eXgQEBJCQkEB0dDRmsxl/f39jeeokVVBQEC+++KJxXipVqhSQMnz4n3/+4ddff+Wdd96hbt26We7v999/580338RqtWb7Pfn555/z3XffYbFY8PT05Nq1a+zatYsDBw7w3nvvUaVKFZ577jlOnTpFqVKlsNlsXL58meXLl3P06FFmz56Nm1v+fwr36NGDL774gvXr12f53Z+cnGyUyOnRo0eaZePHj+fixYtAynEqVaoU165d49ChQxw6dIj169fz/vvv4+3tnWUMBw4c4IMPPiAuLg5vb28sFku+34+IiIgUb4WeADx79iyHDx/m8uXLJCQkcO+99xb2LkWc6sCBA6xduxaz2cyjjz7Kbbfdhq+vLzabjatXr7Jv3z727NmTYzsxMTFMmDCBffv2ERgYyPTp09P05gsLC2PcuHFERkbSp08f7rrrLqpXr47ZbObcuXN8+eWXrF+/nilTpjBv3jwqV64MQMuWLQE4c+YMly9fTtMrz57g8/HxISwsjHPnzqXZp325vQ27oKAgXn31VaxWK8OHD+f222+nUqVK2Gw2/vnnH+bOncvu3bt55ZVX+Prrr/Hx8TG2/f33343k38CBAxk1ahRlypQhMjKS+fPns2jRojTrF0SPHj34+uuvWbduXZYJwHXr1gHQtm1bSpcubbzu6enJoEGD6NKlCzfccIORAA0NDWXJkiUsXryYL774glatWtG4ceNM2z5+/DgHDhzg/vvvZ8iQIfj6+hIdHU1CQoJD3p+ISGpvvfUW9erV46mnnqJ27dokJCSwbt06ZsyYQUhICN9//z2PPPJIju0MHz6c4cOH89tvv/H2229ToUIFFi5cmGG9qKgoJkyYwJUrV6hWrRrPP/88LVq0AFLOH9OnTyckJIQJEybwxRdfZPnd/u6779KxY0cef/xxKleujNVqJSwsLM06QUFBHDp0iCeffJL+/ftTqlQpTp06xWuvvcaZM2eYM2cOAQEBJCYmMnPmTJo2bUpSUhJr1qzhgw8+4NixY/zyyy8MHDgwH0c2Rffu3fniiy/4559/OHnyZKZJzb179xIeHo6bm1uaXpOQci5t06YNrVq1onz58gDExcXxxx9/MHfuXI4dO8ann37KmDFjsoxhxowZ3HDDDTzzzDPUrl0bm81GSEhIvt+TiIiIFF+F1vVk3rx5NGnShJo1a9K3b1/uueceRo0alWG9qVOn0qtXLx588MHCCkXkujp06BAAbdq0YdiwYUbvCpPJREBAAF27duX555/Pto2rV68yduxY9u3bR+3atZk1a1aGobxffPEFkZGR3HHHHYwbN46aNWsavSSqVq3KxIkTufnmm4mNjWXRokXGduXKlaN69epA2h5/ycnJ/P3335QqVYq+fftmWA7/6xWYPgE4e/ZsEhMTeeyxx3jssceoXLkyJpMJs9lM3bp1efPNN6lTpw6XLl3i559/Nraz2Wx8+eWXQEoN0bFjx1KmTBkgpcj8E088QZ8+fYiOjs72eOWWvffFiRMn+PfffzMst194pV7XrlGjRowZM4aWLVum6f1YsWJFnnjiCfr164fNZmPlypVZ7j82NpYRI0Zw3333GZ8LHx+fTIfhiYgUVLly5XjrrbeoXbs2kNJT77bbbqN///5ASukFR/rpp58IDQ3Fy8uL6dOnG8k/SDlvvPPOO3h6enLx4kVWrFiRZTt169bl1VdfNW5cWSwW47FddHQ0I0eO5M477zR6GdapU8c4vx4+fJidO3cybdo0mjVrhslkwt3dnX79+tGrVy+g4O8/MDCQJk2aAP+7eZTe+vXrAbjpppvS9JoEeOmll+jZs6eR/IOUnoA9evTg1VdfBWD16tXExcVlGUNAQABvv/228Tc2mUwZfi+IiIiIQCEkAGNjY+nXrx8PP/wwR48exWazGf9l5sYbb2TdunV89dVXHDlyxNHhiFx39h4NV69eJTk5Oc/bX7x4kaeffprjx4/TuHFjPvzwQ8qVK5dmnfj4eH7//XcgpWdGVrp37w7A7t2707zevHlzIG2C78SJE0RHR9O0aVPatGmTYXlwcDCXL1/GYrGkqUEYEhLC/v37KVWqFIMGDco0Dnd3d2OSoNSxnDx5krNnzwJkOXxq5MiRWb6/vKpWrRoNGzYEMr9Y27ZtG7Gxsfj4+KQZNp0b7dq1A1KGCmfFbDZn2fNQRMTRhg4dmmkNuY4dOwJw/vx5o2yDI9gTar17986QsIOUm1P25Jt9WGxmhg0blmN5BHd3d4YOHZrh9aZNmxrvuXPnzpkmw1q3bg38b1bjgrDfLPr9998z/NZNSEhg8+bNadbLrWbNmuHr60tcXFy2pTBuv/12PD098xi1iIiIlEQOHwJ877338uuvvwJQq1YtRowYwZUrV5g7d26m6/fs2ZMKFSoQHh7OqlWrMq0PJlKUtG7dGnd3d06cOMGYMWPo168frVu3znLSidT+/fdf5s2bR1hYGDfeeCOTJ0/OdLbF48ePk5iYiMlkMibtyExSUhKQMkw1tZYtW/Lzzz9nWvOvZcuWNG/eHLPZnKYOoH3d+vXrp6lHZO/xmJiYyF133ZVlLPZhrqljOXbsGJCSNK1fv36m21WtWpWKFStmeA/51b17d44ePcr69esz9Dy299To3LlzphfNkZGR/PTTT+zatYszZ84QFRWVIckbHh6e5b6rVq2aoQeIiEhhsd/wSC/1+SgqKsohs/omJiYaCbWsJkSClN7xK1eu5OTJkyQlJWVag8/eqy47lStXzrQ2nr0+YVhYmNErLj17r+tr167luJ+cdO3aldmzZxMaGsr+/fvT9JDfsWMH0dHReHt7G0nX9DZu3Mi6des4ceIEV69ezbQkxKVLl7Lcf26OlYiIiAg4OAG4fv16fvzxR0wmE3fddRdfffUV7u7uLF++PMsEoNlspmfPnnz//ff88ccfvPDCC44MSeS6q1atGmPHjmXmzJn8/fff/P3330DKBdeNN95I3759adasWabb2msqVa5cmalTp2aahIL/XQzYbDaj0Hp24uPj0zzPrA5g6vp+3t7eNGjQgKNHjxp1ALMa/muPxWq15iqW1EOZIiIiANIMf8pM+fLlHZYA7NatGx9//DHnz5/n4MGDRm/GyMhIdu3aBWTeU+P06dM8++yzad6jl5eXMfQsKSmJa9euZTtUyz68WUTkeshq8ojU5xar1eqQfV27ds24IZLdd7o9+ZicnExkZGSms8Pn5kZJdrPK23sPpu89b2efKMMR793f35+bbrqJHTt2sG7dujTnSHtP81tuuSVDLz2r1crrr7/Oli1bjNfc3d3x8/Mz4ouIiCA5OTnbXpq6qSQiIiK55dAE4FdffQWk1GCxJ/9yo0WLFnz//fcaAizFRt++fWnXrh0bN25k7969HDx4kLCwMH799Vd+/fVXBg4cyNixYzNs17lzZ7Zu3cqFCxeYO3cuTz/9dKbt2y+y3N3dWbNmTZ7jK1++PNWqVePs2bPGjMT2+n/2HiMtWrTg6NGj7Nu3L00CMHVNp9SxVK9enW+++SbPsVxvZcuWpU2bNvz555+sW7fOSABu3LiRpKQkKlSokOE9Arz99ttcuXKF8uXL88wzz9CyZcs0s2fu2bMnx9qOmvFXRCRnRW0m2549e7Jjxw42b97MM888g7u7O1FRUezYsQPI/KbSqlWrjOTfvffeS58+fYz6uXbDhg3LMPlJekXtWImIiIjzOPRqdOvWrZhMJu69995cJ/8AqlSpAsCFCxccGY6IUwUEBDB48GAmT57M0qVL+eyzz+jZsycAK1asMC4MUmvXrh2TJk3CYrGwbNkyZs+enWXbkDLkKje97jKTembGoKAgoqKiaNasmXExYR/CtW/fPs6cOcOlS5cwm81G/cD0sYSHh+e5N4W950J2w5vsbTuS/WJs48aNRsz24b/dunXLkKi7ePEiR48eBWD8+PHccsstaZJ/QL7/DiIimbF/F2c3S7ijJkhyhNKlSxvfndl9Z9sTWmazGT8/v+sSW2Hr0KEDXl5eXLt2jZ07dwKwefNmEhMTKVu2rFFzMLVNmzYB0KtXL0aNGkVgYGCa5J/VajV6yYuIiIg4gkMTgBcvXgTghhtuyNN29iF02Q2dEynq6tWrx/jx46lTpw6QcYZdu06dOvHKK69gsVj48ccf+eijjzKs07BhQ6Nu0vbt2/MVT+oEYOrhv3b2ZOD+/fuN5Q0aNMgwpMxefyg2NjZNzcDcsH9XREVFZVnkPCQkxGHDf+06depEqVKliIiIYNeuXVy8eNEYqp1ZT43UPTCyqqmV1d9TRCQ/SpcuDZBlD7Bz584RFRV1PUPKlru7u3F+++uvv7Jcb8+ePUDKTL+Z1f8rikqVKsUtt9wC/G/Yb+qbSpn10rP/XbM6pxw+fDjb5K+IiIhIXjk0AWj/gZPXmU8vX74MqD6WFA+JiYnZLrfXXspuvc6dOzNhwgTMZjOLFy/OUEPTy8vLmFX3m2++ybGXQGaFzlPXAbTPxpg6Aejt7U39+vUJCwvjl19+ATIO/wWoUaOGkQT85JNPMtQbTM1ms6W5YK1Xrx7VqlUD4Lvvvst0m/nz52fzzvLHy8uLDh06ACkXafbZG2vXrk29evUyrG+f2RlSZkNOLzg4mLVr1zo8ThEpuewTWGzbti3T5d9///31DCdXunTpAsCaNWuMm8KpnTt3zihb0bVr1+sZWqGz3zzavn07wcHBxk2hrGb/tZ9XMjunJCcn8+WXXxZOoCIiIlJiOTQBWKlSJYAse/JkxX43uHr16o4MR8QpPvzwQ6ZMmcIff/xBZGSk8XpERATz5s0zhpK2bds223a6du3K+PHjMZvN/PDDD3z22Wdplj/yyCOUKVOGixcv8uSTT7Jly5Y0vQVCQ0P59ddfGT16ND/99FOG9itUqGAMvz969CheXl4Zeu/aE4L2mDNLAAI888wzeHp6cvz4cZ5++mn27NmTZjjwuXPnWLZsGQ8++GCGHoujRo0CUobjfvjhh0Yy89q1a8ydO5dff/01TQLOUewXZVu3buW3335L81p6NWvWNArXT58+nVOnTgEpQ7S2b9/Oc889Z/RkFhFxBHuC7NSpU8yaNcu4eXLlyhVmzpzJ2rVrXe57Z9CgQVSsWJHY2FheeOGFDDPJv/jii8THx1OpUiUGDRrkxEgdr02bNgQEBJCQkMAbb7xBcnIyNWrUyHJUTJs2bYCUWoCrV68mKSkJSDlfTpo0iYMHD7rc31dERESKNoeOvejQoQMnT57kp59+YuLEibnaJjo6msWLF2MymYzhEyJFWVJSEr///ju///47kNKTzmQypanVdPvtt3PzzTfn2Fb37t1JTk7mrbfe4vvvv8dsNvPggw8CULFiRaZPn87EiRONCwaz2Yyvry/x8fFpeuK1a9cu0/ZbtmxJSEgIAE2bNs0wTKlly5bGzMSZ1f+zq1+/PlOnTmXy5MkcP36c559/Hjc3N7y9vYmNjc22t2O3bt04cuQIS5Ys4aeffmLFihX4+PgQHR1NcnIyw4YN49ixY3keXpyTm266CT8/PyIjIwkODsZkMtG9e/dM1zWbzTz11FO89tprnDx5kgcffBAvLy+SkpJITEykUqVKjB49mjfffNOhMYpIyXXzzTfTpUsXNm7cyNKlS1m6dCm+vr5ER0djMpkYN24c8+bNc6nyKb6+vrzxxhuMGzeOM2fOMGbMmAxlXsqWLcvUqVOznKG4qLJYLHTt2pWlS5dy4sQJIOubSgDDhw9n48aNhISE8NZbbzF9+nRKlSpFdHQ0ZrOZF154ga+++sql/r4iIiJStDm0B+DQoUMB2Lt3L/PmzcvVNo8//rhRPP+ee+5xZDgiTvF///d/PPnkk3To0MHo1RofH0/58uXp1KkTb731Fs8880yu2+vZsyfjxo3DbDYzf/78NMOC6tWrx1dffcWTTz5pzEobHR2NxWKhTp069O3bl9dff53hw4dn2nbqIb+pH9s1b97cSArWr18/2554bdq0Yf78+Tz44IM0btwYLy8voqKi8PDwoH79+gwaNIh33nkn0yTbk08+yauvvkrTpk3x9PTEarXSqFEjxo8fz+OPP57LI5U3bm5uxnA1SKl5aO/FnJlOnTrx3nvvceONN+Lt7Y3VaqVSpUoMHz6cTz/91OghKCLiKBMmTOCRRx6hZs2auLu7Yzabadu2LR9++CG9evVydniZql+/Pl9++SV33303NWvWNF6vVasWd999N/PmzaNu3bpOjLDwpE/4ZXVTCcDPz4+PPvqIgQMHUqFCBUwmEx4eHtxyyy3MmDGDPn36FHa4IiIiUsKYbDabzZENdujQgR07duDm5sbrr7/OU089xfr16xk8eDAmk8kYFrh3714mTpxoDL3r27cvq1atcmQoksrx48edHYKIiEto0KCBs0Mo0nQ+ERHRuURERIoehycAz5w5Q9u2bblw4QImkwlPT08qVarEv//+i8lkonXr1pw9e9aY1dNms1GjRg12795N+fLlHRmKpKILNhGRFLpoKxidT0REdC4REZGix6FDgCFlIo+dO3fSrl07bDYbcXFxRn0tgL/++ouLFy9is9mw2Wy0bduWbdu2KfknIiIiIiIiIiJSCByeAISUJOC2bdtYvnw5d9xxB+XKlTMSfjabDV9fX/r168eiRYvYvn27MROpiIiIiIiIiIiIOJbDhwBnJSYmhqtXr+Lr64ufn9/12KWkoiFbUpz88MMP/PDDD3naZu7cuVSsWLGQIpKiRMO2CkbnEyluQkNDeeyxx/K0zfDhw7OcYEtKBp1LRESkqHG7Xjvy9vbG29v7eu1ORIqx2NhYY/bw3EpOTi6kaEREpChLTk7O8zklNja2kKIRERERKRzXrQegOJd6bIiIpFCvjYLR+UREROcSEREpevLVA3Dy5MmOjsMwadKkQmtbRERERERERESkpMlXD0Cz2WzM6utoVqu1UNot6dRjQ0QkhXptFIzOJyIiOpeIiEjRk+8agLnJG5pMpmzXS7+8sJKKIiIiIiIiIiIiJVW+EoAbNmzIdvmsWbNYunQpZrOZXr160b17d+rVq4ePjw/R0dEEBQWxfv161qxZQ3JyMnfccQejR4/O1xsQERERERERERGRrOUrAdi5c+csl40dO5Zly5bRqFEjFi5cSLNmzTJd79lnn+XgwYMMHz6cpUuXUqNGDd577738hCMiIiIiIiIiIiJZcOgswGvXrqV3796UK1eOgwcPUqlSpRy3uXjxIk2aNOHKlSusXr2aHj16OCocSSU8PNzZIWTKYrEQEBDAlStXXLb+Y0BAABaLBavVypUrV5wdTpaKwrGEonE8dSwdy9WOZ/ny5Z0dQpGWn/OJK35WXe1zCTpOueVqx0nHKHeK23HSuURERIoasyMbmzt3LiaTiQcffDBXyT+ASpUq8eCDD2Kz2fjkk08cGY6IiIiIiIiIiEiJ59AE4O7duwFo2bJlnrZr1aoVALt27XJkOCIiIiIiIiIiIiWeQxOAoaGhAMTHx+dpO/v69u1FRERERERERETEMRyaAAwICABg06ZNedrOvn6ZMmUcGY6IiIiIiIiIiEiJ59AEYLt27bDZbMyfP5/t27fnapsdO3Ywf/58TCYT7dq1c2Q4IiIiIiIiIiIiJZ5DE4CPPvooAFarld69ezN37lwSExMzXTcxMZFPPvmEPn36kJSUBMDjjz/uyHBERERERERERERKPDdHNta7d28efPBBvvjiC6Kjo3nyyScZP348HTt2pF69enh7exMTE0NQUBBbt24lIiICm80GwIMPPkivXr0cGY6IiIiIiIiIiEiJ59AEIMCnn36Kt7c3s2fPxmazcfXqVX755ZcM69kTfyaTiaeeeooPPvjA0aGIiIiIiIiIiIiUeA4dAgwpCb0PP/yQzZs3c/vtt+Ph4YHNZsvwn6enJ4MHD2bLli3MmDEDk8nk6FBERERERERERERKPIf3ALTr2LEjHTt2JCEhgf379xMSEkJUVBS+vr5UrVqV5s2b4+HhUVi7FxEREREREREREQoxAWjn4eHBTTfdVNi7ERERERERERERkUw4fAiwiIiIiIiIiIiIuA4lAEVERERERERERIqxQh8CLHI9RUVF8dtvv1GjRg1uvvlmZ4cjIpJGWFgY27dv58CBA5w+fZrLly/j5uZGhQoVaNmyJQMGDKBy5cr5bj8pKYlVq1axadMmQkJCAKhatSqdO3emX79+uLnptF/cXL16lR07dhAXF0fbtm0JDAx0dkgiIiIi4oJ0JSDFRmRkJP369ePo0aMAvPfee9x7771OjkpEJEVYWBgPPfQQNpvNeM3b25uEhATOnDnDmTNnWL16NWPGjOGWW27Jc/uxsbG88sorHD9+HMCYaMb0IRwAAPAISURBVCsoKIigoCC2bt3K5MmTKVWqlGPekDjdggULmDhxIpGRkQC4u7vz5JNP8tJLL2GxWJwcnYiIiIi4EiUASwhXvRCwx+WI+N59910j+Qfw+uuvc/vttxMQEFDgtu1c9TiCY4/l9eKqsepYOlZRPJ6FITk5GYDWrVvTrVs3WrZsiZ+fH1arlSNHjvDpp59y+vRp3n//fapVq0atWrXy1P5HH33E8ePH8fHx4emnn6Zdu3YA7Nixg5kzZ3L06FE+/vhjxo4d6+i3Jk7w1Vdf8cILL6R5LTExkRkzZnDmzBk++ugjzGZVehERERGRFCZb6q4IIkVUaGgotWrVIjY2Fjc3N5KSkgCYO3cujz76qJOjExGB6OhoLl68SJ06dTJdfuXKFZ5++mkiIiLo3r07zzzzTK7b/ueffxgzZgw2m42XXnqJDh06pFm+detW3n77bUwmEzNnzqRmzZr5fh/h4eF53iYgIACLxYLVauXKlSv53rcjWSwWAgICuHLlClar1dnhALk/Tvv376dv374kJiZSoUIFPvzwQ/z9/Rk/fjz79+8H4OWXX+bZZ58tcExF+ThdLzpGuVPcjlP58uULKSoREZHCoR6AJYSr/PhLz2Kx4OfnR2RkZIF+DH788cfExsYC8Ouvv/LII4/wzz//sGDBAoYNG1agGP38/Iwfh/ZhVq7IUceysBWF46lj6Viudjwd2Ss4L3x8fLJM/kFKXG3atOH333/n5MmTeWp706ZN2Gw2AgMDad++fYblHTp0IDAwkPPnz7Np0yaVRyjCkpOTeeGFF0hMTMTT05NFixbRtGlTAJYtW0a/fv04cuQI06dPp0+fPjRu3NjJEYuIiIiIK1ACsIRwhYvu7Fit1gLFuHjxYgBatGhBy5Yt6du3Lx999BE7duwgJiYGT09Ph8Xp6gp6LK8nV49Tx9KxitLxdBY/Pz8g73/PAwcOANCqVStMJlOG5SaTiVatWnH+/HljXSmaVqxYwd69ewF47rnnjOQfQOnSpfn888/p2rUrCQkJPPfcc/zyyy+ZfiZEREREpGRRcRgp8k6cOMGhQ4cAGDJkCIBR+yo+Pt4YDiUi4uoOHjwIkKchujabjbNnz+a4XY0aNQA4c+ZMASIUZ7LZbMyZMweAwMBAHn/88QzrNGjQgDFjxgCwe/dufvnll+sZooiIiIi4KPUAlCJv3bp1xuMBAwYA0LZtW+O1v/76i5tvvvm6xyUikhc7duwgKCgIgO7du+d6u9jYWOLi4gAoW7ZsluvZl8XGxhIbG4uXl1em682fP5/vv/8+y3ZGjBjB3Xffnev4AGMyCrPZ7LQh2OnZe8X5+/vjKuWQczpOW7ZsYd++fQA888wzBAYGZtrOhAkT+Oabb7hw4QLTp0/n7rvvzveEIEXxOF1vOka5o+MkIiLiXEoASpG3fv16ABo2bEi1atWAlAtde72r1DMDi4i4orCwMKNnV9u2bWnTpk2ut7XXPwWyLXeQell2CcDo6GhCQ0OzbCcmJibfMzqbTCaXmw3aFWfKzeo4ffbZZ0BKPclHH300y2Pp5+fHhAkTeOqppzh06BBr1qyhX79+BYqpKB0nZ9Exyh0dJxEREedQAlCKtOjoaLZv3w5At27d0ixr2LAh58+f59ixY84ITUQkV6KiopgyZQoRERFUrlyZp59+2qnx+Pj4ULFixSyXe3t757lGodlsxmQyYbPZSE5OLmiIDmEymTCbzSQnJ7tUb6SsjlNUVBQ//fQTAMOGDaN06dLZ/h3uv/9+XnvtNS5dusQHH3xAnz598hVTUTtOzqBjlDvF7TgpYSgiIkWNEoBSpG3dupWEhAQg8wTghg0bOHr0KDabTUXQRcTlxMbG8vrrr3P69GnKli3L5MmTKV26dJ7aSN2TLz4+Psv1Ui/LqvcfwMiRIxk5cmSWy8PDw/M8s3xAQAAWi4Xk5GSXmZXeYrEQEBBARESEy0xOk91xWrx4MTExMUBKuYvcHMf/+7//Y8aMGaxfv55t27bRqFGjPMdU1I6TM+gY5U5xO07ly5cvpKhEREQKh+v1wRfJA/vwX29vb2PiD7uGDRsCKb0mzp07d91jExHJTnx8PJMnT+bYsWP4+/szZcoUKleunOd2vLy8jITe5cuXs1zPviz1+lJ02Hv/Va5cmQ4dOuRqmwceeAA3t5R7vV9++WVhhSYiIiIiRYASgFKk/f777wDccsstGWpf2ROAAMePH7+ucYmIZCc+Pp4pU6Zw6NAhfH19mTx5MtWrV89XWyaTyah/GhwcnOV69mX53Y84T2xsLFu2bAGgX79+uR56GBgYaAz9XbZsmTFZjIiIiIiUPEoASpF16tQpTp8+DWQc/gtQq1Yt43F2F8UiItdTYmIib775JgcOHMDb25vXXnuN2rVrF6jN5s2bA7B3794s17HPHmtfV4qOrVu3GpO99OzZM0/bjhgxAoCrV6+yevVqh8cmIiIiIkWDEoBSZNmH/0LmCcCAgAB8fHwAJQBFxDUkJSXx1ltvsXfvXkqVKsWkSZNo0KBBgdu99dZbMZlMhISEGBMjpbZt2zZCQkIwmUx06dKlwPuT62vt2rVAyvDt3A7/tevatSsVKlQAYOHChQ6PTURERESKBiUApciyD/+tVatWpr1nTCYTNWrUAJQAFBHns1qtvPvuu/z55594eHgwceJEGjdunOvtH3roIQYOHMiMGTMyLKtduza33norALNmzWLHjh3YbDZsNhs7duxg9uzZAHTp0sX4XpSiwWazsW7dOgA6deqU5/qN7u7u3HnnnUDKefPChQsOj1FEREREXJ9mAZYiKS4ujq1btwLQvXv3LNerUaMGR44c4cyZM9crNBGRTB05coRt27YBKUmdd999N9v1v/nmmzy1/8QTT3D+/HmOHz/Om2++iYeHB4AxU3rDhg15/PHH8xG5ONOpU6eMm1g9evTIVxvDhw/n448/Jjk5mRUrVvDII484MkQRERERKQKUAJQiaceOHUY9pOwSgPZi9+oBKCLOZrPZjMeJiYlcvXrVoe17eXnx1ltvsWrVKjZt2kRISAgAdevWpUuXLvTr18+YEVaKDnvSGDB6eeZV48aNqV+/PidOnGDlypVKAIqIiIiUQLoSkCLJPvzX09Mz23pI9qFu4eHhREVF4evre13iExFJr1mzZqxYsSLf23/++ec5ruPm5sbtt9/O7bffnu/9iGvZsWMHABUrVqROnTr5asNkMjFw4EDee+89du7cyYULF6hcubIjwxQRERERF6cagFIk2ROA7du3Nyb6yEy1atWMx/beMCIiIkWFfVKX9u3bYzKZ8t3OwIEDgZSeqKtWrXJIbCIiIiJSdCgBKEXO2bNnOXbsGJD57L+pBQYGGo8vXrxYqHGJiIg40pkzZ4watu3bty9QW40aNaJevXoABeqJKiIiIiJFkxKAUuTYe/9BzgnA1EOcNPOhiIgUJfbhvwDt2rUrUFv2YcD2dnVOFBERESlZlACUIseeAKxatSoNGjTIdt2KFSsaj3WxIyIiRcnOnTsB8Pf3p1GjRnnaNjw8nI0bN7Jw4UIWLlzIli1b6Ny5M5AyDHjNmjUOj1dEREREXJcmAZEiJTExkU2bNgEpvf9yqofk4eFB+fLlCQ8PVwJQRESKlL/++guANm3aYDbnfM/WZrOxYcMGZs2axdatW9PMPG3n4eFBQkICP//8M/fee6/DYxYRERER16QegFKk7Nq1i6ioKCDn4b92lSpVAtQDUEREio64uDiOHDkCQKtWrXJc/8qVK4waNYrhw4fzxx9/ZJr8A0hISABSetO/8847xMXFOS5oEREREXFZSgCKSwsPD2fs2LE89dRTXLhwgfXr1wPg5uZmDGXKib0OoBKAIiJSVBw8eJCkpCQg5wTg2bNn6d27Nz///DMAZcuWZezYsaxcuZK///6bAwcOsHz5cl544QWqVatmbDd9+nQ6duzIunXrCu+NiIiIiIhL0BBgcWlPPPEEGzZsAOD48eNGT4W2bdtSunTpXLVh7wEYGhpaOEGKiIg42N69e43HLVu2zHK98+fPM2jQIIKDgwEYOnQo06ZNw9/fP816gYGBdOjQgWeeeYb69esTGxsLQHBwMCNGjOCBBx7g1Vdfxdvb2/FvRkREREScTj0AxWXt2bPHSP5BSi2kw4cPA9C9e/dct5O6B2BWQ6JERERcyb59+wCoUqWKcSMrvfj4eEaNGmUk/55//nnmzJmTIfmXmqenJ7169QKgdOnSlClTBoB58+bRu3dvTp8+7bD3ICIiIiKuQwlAcVn2oUyZyUsCsEKFCkBKPSV7/UARERFXZu8BmN3w30mTJrFnzx4AHn/8ccaNG5fj5FgAvXv3BuDatWvMnj3bKKlx9OhRevfuzdatWwsavoiIiIi4GCUAxWXZaxLVq1cvzetubm7UqFEj1+2UL1/eeBweHu6Y4ERERApJVFQUQUFBQNbDf7dv3868efMAuOWWW5g0aVKu2+/RowcWiwVI6W2/aNEixo0bB8Dly5e58847WbZsWQHegYiIiIi4GiUAxSVFR0dz9OhRAM6dO5dmWVJSEu+9916u20qdALx06ZJjAhQRESkkBw8eNEpWNGvWLMPy+Ph4nnvuOQB8fX2ZM2cObm65L+scEBDAzTffDMCaNWswm808//zzzJs3D29vb5KSknj00Uf55ptvHPBuCiYpKYkTJ06wefNmli1bxrJly1ixYgX79+836hiKiIiISM40CYi4pEOHDhkXP5n9wP/000954IEHqF69eo5tlStXznisHoAiIuLq/v77b+NxkyZNMiz/+uuvOXHiBAATJ06kSpUqed5Hnz592L59O4cOHSI4OJgaNWowYMAAAgMDueuuu4iIiOC5554jNjaWCRMm5P/N5FFSUhK7du1i3bp1bNu2jUOHDhkTgKXn5uZGu3btuOOOO7jzzjvx8vK6bnGKiIiIFDXqASgu6cCBA2melypVKs3zhIQE5syZk6u2lAAUEZGixJ4ALFeuXIYJQKKjo5kxYwYAjRs35v7778/XPux1AAHWrl1rPL7xxhtZvny5UT934sSJzJ07N1/7yIuTJ0/y2muv0axZMwYNGsSsWbPYs2dPlsk/SEkW/vHHHzz77LO0adOG77//XpN9iYiIiGRBCUBxSfYEoNmc8hEtXbq0sczT0xOA77//PldDesuWLWsURdcQYBERcXX79+8HUhJ86Sf1+OKLLwgLCwPgpZdeMmr55VXdunWpU6cOkDIMOLUmTZqwcuVKKlasCMATTzzBokWL8rWfnBw5coRRo0bRrl075syZY9yoc3Nzo2PHjjz11FN8+umnrF69mt27d7Nnzx7279/PTz/9xAsvvECtWrUACAsL45lnnuGuu+7i6tWrhRKriIiISFGmBKC4pGPHjgGQnJwMQEREhLEsPj4eSBkabC+Anh03NzcCAgIA9QAUERHXZrPZjB6AjRs3TrMsISGBTz75BEiZHbhPnz4F2levXr0A+OOPP4iKikqzrG7duixZsoSAgABsNhtPPvlkhkRhQVy+fJmnn36azp07s2rVKgBMJhPdu3fns88+4/jx4/z0009MmjSJwYMH07p1a2rWrEmNGjVo0qQJgwYNYtq0aezcuZOvvvqKmjVrAvD777/Tu3dvzp4967BYRURERIoDJQDFJZ0+fTrN84SEhDTPGzVqBMDnn39OTExMju3ZhwGrB6CIiLiy4OBgIiMjgYwJwOXLlxMaGgrAU089laF3YF7ZhwEnJCSwefPmDMsbNWrE4sWLKV26NFarlYcffpiDBw8WaJ8AK1asoEOHDixYsACbzYa7uzsPPPAAe/bsYeHChdx+++1pev5nx2w2069fPzZv3sywYcMAOHXqFIMHD+bChQsFjlVERESkuFACUFxOZGQkly9fNp5ndoHTpk0bIKUHQW5mKbQnANUDUEREXFnqGripJwCx2WxGLb7q1avTt2/fAu+rbdu2RqJt9erVma7TunVrli5disViISYmhnvuuSffibWEhARefvllHnzwQeOG3KBBg9i1axdvv/12rib2yoq3tzezZ89m7NixQMqNxLvvvlszBYuIiIj8RwlAcTn//PNPmuf2i5PKlStTrVo1ABITE40Lo1mzZuX4A798+fKAegCKiIhrS10Dt0GDBsbre/fuNZY9/PDDuLm5FXhf7u7udOvWDUiZCMRediO9Hj16MH36dABCQkIYOXJkrnrfp3b16lWGDBnC559/DkCFChWYP38+n3/+uXFuLyiTycTLL7/M448/DqRMpjJu3DiHtC0iIiJS1CkBKC4n/fBfuxYtWhjDoY4ePcpzzz0HQGhoaI69AO0JQPUAFBERV2ZP8tWtWxcvLy/j9R9++AFISdoNHz7cYfuzDwMOCwszJh/JzP33328k1vbv38+LL76Y6xl3L1y4wMCBA9mxYwcA7dq1M2r1OZrJZOLVV1+la9euACxYsIAVK1Y4fD8iIiIiRY0SgOJy0icAr127BkDLli2pX78+AEFBQdx2221GQnDmzJkZCpinlroGYG4vWERERK63Q4cOAf+rdQspk18tW7YMSJm4o2zZsg7bX/fu3TGbU34OZjUM2O7VV1+le/fuQEpCcv78+Tm2f/HiRQYOHMiRI0cAGD58OEuXLqVy5coFjDxrFouFuXPnUqlSJSBltmSNABAREZGSTglAcTnBwcFpntsTds2bN6du3boAREdHExYWxgsvvACk9AJ85513smzT3gMwPj6e6OjowghbRESkQJKSkjh+/DhAmuG/a9eu5cqVKwDcddddDt1n2bJluemmmwBynOXXYrHw8ccfG7X6Xn755Wx7DV65coWhQ4capT1Gjx7NrFmzcHd3d1D0WStbtizvvvsukNK7cfLkyYW+TxERERFXVvACMiVIREQES5YsYdeuXVy6dAlPT0/q1q3LbbfdRrt27fLc3qVLl9i8eTMnTpwgODiYq1evEh0djZeXF9WqVaNt27b07dsXb2/vQng3riur4uItWrTg5MmTxvOgoCD69etH586d2bRpE59++ilDhgyhRYsWGba19wCElAsBX19fxwcuIiJSAP/88w+JiYkARo93gEWLFgEp5zJ7zT5H6tWrFzt37uTvv/8mJCSEKlWqZLluQEAA8+bNo1+/fsTHx/PAAw/w+++/4+/vn2a9+Ph47rnnHqPn3+OPP86kSZMKPHNxXvTp04eBAweyYsUKFixYwCOPPJJmYhURERGRkkQ9AHMpODiY0aNHs3z5cs6fP4/FYiE6Opp9+/bx5ptv8tlnn+W5zUOHDvHll1/yxx9/EBwcTExMDKVKlSIqKoqjR4/y9ddfM3r06Aw94oq7zBKA5cqVo1KlStSrV8947eTJk5hMJt5++208PT2xWq089thjmQ4FTj1cKiIionACFxERKYCjR48aj+3nu6ioKNavXw/A7bffjoeHh8P326tXL+Px2rVrc1y/ZcuWTJ06FUj5ffTSSy+lWW6z2Xj++ef5888/ARg5ciSvv/76dU3+2b366qt4eHhgs9l47bXXrvv+RURERFyFEoC5kJiYyBtvvEFERAQ1a9bkww8/5IcffuCHH35g5MiRmEwmVq5cybp16/LUboUKFbjrrruYMmUK8+fPZ+nSpSxYsIDFixfz3HPPUaZMGcLDw5k2bRpWq7WQ3p3rSZ0AtFgswP96QlSoUAE/Pz8gpQcgpBRKnzhxovFaZoXJy5QpYzy2D6MSERFxJZklANevX09CQgIAAwYMKJT93nDDDdSsWRPIeRiw3X333cfAgQMBWLJkCUuXLjWWffLJJyxcuBCAzp07M336dKck/wBq1KjBI488AsDGjRvZuXOnU+IQERERcTYlAHNh9erVXLhwAU9PTyZNmkTt2rUB8PT0ZNiwYfTt2xeA+fPnk5SUlOt2GzVqxN13302LFi2MpJa93c6dO/Pss88CcO7cOY4dO+bAd+S6kpKSCAsLM57bLxjstZBMJpNRB9CeAAR49NFH6dOnDwCLFy82LjzsUicAr169Whihi4iIFIj9XF+zZk2j/Mevv/4KpPRkb9u2baHs12Qy0bNnTwA2b95MTExMrrZ59913jck8XnjhBc6ePcv27dt59dVXAahduzafffYZbm7OrTjz1FNPGcfzww8/dGosIiIiIs6iBGAubNy4EYBbb72VChUqZFg+ZMgQTCYTly9f5u+//3bYflMXAC8ps9eFhYWl6b1nT6imroVk7xWROgFoMpmYOXMm1apVA1IKk//777/G8oCAAOOxegCKiIgrsvcAbNiwIQAJCQnGkNxevXoVaiLNPgw4Li6OP/74I1fbBAQEMHv2bAAiIyN59NFHefzxx0lOTsbHx4f58+enOf86S9myZbnvvvuAlCHO9pmWRUREREoSJQBzEBsby4kTJwBo3bp1putUqFDBSDxlNxteXtkLZwPGHfbiLqsJQFInAO09AIODg41hUZByIfLRRx9hMpmIjo7mqaeeMpKJpUuXNoYTKwEoIiKuxmazGQnAG264AYCtW7cSGRkJwG233Vao++/QoQM+Pj5AysiH3OrcuTOPPfYYALt27eLcuXMAvP3222luZDrb448/btRPnDVrlpOjEREREbn+NAtwDs6ePWskkez1cTJTs2ZNzpw5w5kzZwq0v6SkJK5cucKePXuYP38+kNITIHUCrDjLSwIwOTmZ06dPp7nAaN++PaNHj2bWrFls376dn3/+mf79+2MymShTpgyXLl3SJCAiIgVgv5nirO0dxR6Hq8QTGhpqlKho2LAhFovFqMfn5eVFt27dCjVWb29vunbtyqpVq1i7di1msxmTyZSr4zRp0iSWLVvGxYsXgZRk5YgRI65L3b/cHpNq1aoxfPhwvv32W1asWMHUqVOpWLGiQ2Nwlc9Seq4Sl46TiIiIcykBmIPLly8bj1PPJJuefVl+e5c988wz/PPPPxleb9WqlVELMDvz58/n+++/z3L5iBEjuPvuu/MVW2GyXxz4+/tjs9mMng6peXt706xZM8zmlA6rrVq1MpaFhoZmqIn0xhtvsGTJEs6fP8+bb77JiBEjcHNzo1y5cly6dImYmJg8DUmy79dsNrvEUKaspD+WrqooHE8dS8cqKsdTcqcgnzWLxeJyn9XUNXid6cCBA8bjJk2aEBAQwKZNmwDo1q0bVatWLfQY7rjjDlatWsX58+f5999/05xvsztO//77L9euXTOe28+zhZ0AzOvn6dlnn+Xbb78lMTGRpUuX8vLLLzs0Hlf5LKWmf3O544rHSURExNGUAMxBXFyc8djT0zPL9ezLYmNj87UfPz8/ypQpQ0JCglF8u02bNtx33334+/vnuH10dDShoaFZLo+JiXHpO5v2REZmPQDr1KmDu7u78dw+NArg5MmTGd6Xn58fr7/+Oo888ggnTpxg1apVDBkyJE2SNj/HInVPCFdmP5aurigcTx1Lxyoqx1Oyl58bXX5+flgsFqxWa6Y3epzBYrHg5+dHZGQkVqvV2eGwZ88e43H9+vXZv3+/UYLklltuuS7lKzp06IDJZMJms7Fo0SJq1aqV43Gy2WyMGjUqzcQhGzduZM6cOdxzzz2FEmd+P081a9bkxhtvZPfu3cydO5eHH37YId+drvZZAv2by62CHCclDEVEpKhRAtBFTJkyxXgcGRnJ5s2bWbBgAWPGjOGhhx6if//+2W7v4+OT7VAWb29vl/mxlZrJZMJsNpOcnIzNZjNqB6VWq1atNLF7eXkRGBjI+fPnOXHiRKbva+TIkUyaNIkLFy4wY8YMbr/9duOH2qVLl/J0LOzDoGw2G8nJyfl4l9dH+mPpqorC8dSxdCxXO55FIVnqygp6LnG1c5HVanWJmOwzAAcEBFChQoU0s9l37tz5usRYrlw5WrduzZ49e1i9ejXPPfecsSyr4/T999+zYcMGAO6//342btzI6dOnmThxIl26dCm0GsY2m43w8HCuXbuGv79/rnsb3nfffezevZvg4GDWrl1rzH7sCK7yWUrP1WLScRIREXEOJQBzUKpUKeNxfHw83t7ema4XHx8PpCSnCsrPz4/+/fvTqFEjnnvuOT7//HMaNWpk1L7LzMiRIxk5cmSWy8PDw11y8gv7kIuIiAisVmuamXvtKleunCH2mjVrcv78eY4cOZLl+/q///s/pk+fzh9//MFff/1lFDfP67EICAjAYrGQnJzsksfQLv2xdFVF4XjqWDqWqx3P8uXLOzsEkQzsvf0aNWqEyWQykmpVqlShXr161y2OXr16sWfPHvbu3cuFCxeyHXp84cIFJk2aBECNGjV49dVXGThwIHfccQcRERG89NJLfPXVVw6N7+jRo3z55ZcsX76cS5cuASm/E/r378/TTz9NYGBgttsPGjSIiRMnEhERwcKFCx2aABQRERFxZRqPlYPUdf9S1wNMz77MkcMB6tatS+PGjUlOTmbdunUOa9eVhYeHZ3itRo0aGV6rU6cOAKdOncqyrWHDhhmPly5dSpkyZQCMIusiIiKuwl4HuH79+litVrZs2QJAly5drstkGna9evUyHq9duzbL9Ww2Gy+++KIxsdYHH3yAr68vnTp1Mob+/vzzz8ZEJgWVlJTE5MmT6dKlC/PmzTOSf5CSiPz8889p164dP/zwQ7bteHl5cfvttwMpsx27yvBYERERkcKmBGAOqlWrZvzwDg4OznI9+7Lq1as7dP/lypUDsp4dt7hJ/YPeLrNjak8Anjt3Lk2dxtRq1arFjTfeCMCKFSuM5OzVq1ddYhiiiIgIQEJCgvE7on79+uzZs8e4WdWlS5frGkuTJk2M8+7KlSuzXO+nn37i119/BVJGIdx6663GsldffdX4/TJ+/Pg09QHzIyIiguHDhzNr1iysVivu7u7cddddzJ49m2nTphlJy5iYGEaPHs0777yTbXt33nknkDJ6I7v3KCIiIlKcKAGYAy8vL+rXrw/AX3/9lek64eHhnDlzBoAWLVo4dP/2xF/qocjFlc1my3UCsHbt2sY2mQ0btuvXrx8Ahw8fNiYgiI+Pz/dkLSIiIo525swZo45nvXr12Lx5s7GsU6dO1zUWk8nEwIEDAdi8eXOmox8uXbrE+PHjgZTht6+//nqa5QEBAbz66qtAygzBH374Yb7juXbtGsOGDTOOSZs2bdi/fz8LFizgscce46GHHuK7775j5cqVxvDf6dOnM2fOnCzbvPnmm43fFkuWLMl3bCIiIiJFiRKAuWC/+75582bCwsIyLF+6dCk2m42yZcvSrFmzXLebUy2sgwcPcvz4cSDljnxxFxMTk2lvvuyGAMP/hk1lpmvXrsbj1BOMaBiwiIi4itTnsbp16/LHH38AKb0BnVGzctCgQUDK75RVq1ZlWD5hwgSjZMd7772Hn59fhnXuuusu2rVrB8CsWbMICgrKcxwJCQmMHDnSuAF75513snz5cho0aJBh3Xbt2vHLL79Qs2ZNACZPnszGjRszbddsNjNkyBAAtm7dSkhISJ5jExERESlqlADMhd69e1O5cmXi4uKYMmWK8UM9Pj6eJUuW8PPPPwMpQ2Dc3NLOq/LQQw8xcOBAZsyYkaHdl156iUWLFhEcHJwmGXj58mWWLVvGlClTsNlsVKhQge7duxfeG3QRmfX+8/X1NWr3pVarVi3jcXZ1ABs3bkylSpUA0lx8uPKECSIiUrKcPn3aeFy7dm22bdsGYCTQrreWLVsaN99++umnNMvWrFnDjz/+CMCQIUPS1AxMzWQy8c4772CxWEhMTGTcuHF5Lr8xYcIE41gMGTKE2bNn4+npmeX61apVY+HChfj6+pKcnMyjjz5KaGhopuvaE4A2m834HSciIiJSnCkBmAvu7u5MnDgRf39/Tp8+zTPPPMNdd93F8OHD+eabb7DZbPTv358ePXrkqd0rV64wf/58Ro8ezZ133sk999zD8OHDuf/++/nyyy+JjY2latWqvP766w6ZXdjVZZYArFGjRqbFz319fY3EXnYJQJPJZPQCPHjwoPG6egCKiIirsN9YLFeuHBcuXDCG3TorAWgymYxegFu2bDFGP0RGRvL8888bsU6dOjXbdho1asRjjz0GpIyiSJ9MzM4333xjzCDcvn17Zs2ahcViyXG7evXqGcN/L1++bAxVTq9hw4bG7MpKAIqIiEhJoARgLtWoUYNZs2YxaNAgAgMDSUxMxMfHhxYtWjB+/HgeeeSRPLc5ZswYhgwZQqNGjQgICCA+Ph6r1Ur58uW5+eabefrpp5k5cybVqlUrhHfkejJLAFatWjXL9e3DgLMbAgz/q58UFRVlvKYEoIiIuAr7eSz18F+Atm3bOiukNMOAly1bBsDrr7/O+fPnAZg2bZox0Ud2nn/+eapUqQLAxIkTczXrblBQEBMmTABSevV98cUXuLu75zr22267jWHDhgGwfPlyVq9eneV6ANu3b8/0N4iIiIhIceKW8ypiV6ZMGR588EEefPDBXG/z+eefZ7msadOmNG3a1BGhFQuZ/fi2F/TOTO3atdm+fXu2PQABbrrppgyvaQiwiIi4itQJwC1btgAp57/MauBeL82bN6dWrVqcPn2aBQsWULlyZb755hsA+vTpw+23356rdnx9fZk6dSqjRo0iNDSUadOmMW3atCzXt1qtPP3008TFxWGxWJg3bx4VKlTIc/xvvPEGGzZsICwsjEmTJtGtW7cMScT+/fszc+ZMkpOTWb16NXfffXee9yMiIiJSVKgHoLiMzGYarFy5cpbr23sAnjt3LtPJQ+xq1aqVoYi6egCKiIgrsFqtxmz2qXsAtm3bNtMSGNeLyWRi8ODBAGzcuJEnn3wSAD8/P6ZPn56n2Pr162fUMp43bx4HDhzIct1PPvmEP//8E4BnnnmGVq1a5Sv+gIAAXn75ZSClVMjXX3+dYZ2WLVsavRM1DFhERESKOyUAxWXYZxRMLTcJQJvNZlw8ZcZkMnHjjTcCKTP/gXoAioiIawgJCSExMRFISVrZz2fOqv+X2l133WU8Pnv2LACvvfZatufmzJhMJqZNm0apUqVITk7mxRdfJDk5OcN6QUFBRu/Axo0b89xzzxUgehgxYgQNGzYEUmYrjo6OzhCXfRjwpk2b0pQKERERESlulAAUl5HZEGD7RB+ZqV27tvE4p2HA9gSg/YJDPQBFRMQVpK5je+3aNeOxM+v/2dWpU4cGDRoYz3v27MnIkSPz1Vbt2rUZM2YMAHv27OG7775Lszz90N+ZM2fi4eGR79gB3NzcjFqC4eHhfPvttxnW6devHwDx8fFs3LixQPsTERERcWVKAIrLyOsQ4NQJwJwmAmnTpk2a57kpQi4iIlLYUp+/QkJCAPDx8aFRo0bOCskQEhJi9PyDlB6BBRmW/OSTTxq99ydPnpym5/+nn36aZuhvixYt8r2f1Hr37k2TJk0AmDNnDvHx8WmWt23bltKlSwOwfv16h+xTRERExBUpASguI69DgH18fIwegjn1ALT/+LdTAlBERFyBPQHo6+vLwYMHAWjdujUWi8WZYREXF8eoUaOIiYkxXitonbxSpUrx1ltvASk98SdPngykDP198803AWjUqBHPPvtsgfaTmslkYuzYsQBcuHCBhQsXplnu7u7OrbfeCsDvv/+OzWZz2L5FREREXIkSgOIy0vcAtFgsGSbvSM/ekyCnHoABAQFGoW9QAlBERFyD/fxVq1Yt9u3bB/yvbIWz2Gw2XnzxRf766y8AmjVrBsDKlSu5cOFCgdru2rUrgwYNAmDBggVs3bo1zdDfWbNm4enpWbA3kE7//v2pX78+AHPnzs1Qf9A+QUlISAhHjx516L5FREREXIUSgOIy0k/MUbFiRWPSjqzYE4A59QCEtL0AIyIi8hGhiIiIY50+fRqA8uXLG73tbrrpJidGBDNnzmTBggUAdO7cmS+//BKAxMRE43FBTJkyBR8fHwAeeeQRY+jv008/7bChv6lZLBYeeeQRIKW34aZNm9IstycAQcOARUREpPhSAlBcQnJycoaJOXIzy6C9DuC5c+eIi4vLdt3UCUD1ABQREWez2WxGD0A3NzfjdWcmAL/88kveeOMNIKVX4hdffEGbNm2MYbJff/01sbGxBdpHYGAgL730EgChoaFAytDfgs76m50777wTPz8/AL744os0y6pUqULjxo2BlGHAIiIiIsWREoDiEqKiojIMyclNAtDeA9Bms/Hvv/9mu27qBKBmARYREWe7ePGikUyLjo4GoFy5ctSqVSvLbY4ePcq4cePo2LEjNWvWpGbNmrRr144nnniChQsX5vsGl81mY+bMmbz44osAVKpUiUWLFlG2bFkAHnvsMQAuXbrEokWL8rWP1O6//368vLyM55MmTXL40N/UfH19GTFiBABr1qwxel7adevWDYAdO3YQFRVVaHGIiIiIOIsSgOISMkvI2Sf4yI49AQg5DwNu2rSp8Tg+Pp6EhITcBygiIuJgZ86cMR5fvHgRSOn9l9lMuzExMYwbN45OnToxb948jh8/TkxMDDExMZw8eZLFixfz1FNP0aRJEx577DE2bNiA1WrNVRyRkZE88cQTTJkyBUgZjrx48WKjlz1Ar169qFevHgAffPBBhtl08+rjjz9O05PQPuS4MD3wwAOYTCZsNhtfffVVmmX2YcCJiYls2bKl0GMRERERud6UABSXkFkCsEKFCjlul7qXRE4TgdSsWTNNTUENAxYREWcKDg42Htt7sd98880Z1ouIiGDIkCHMmzcPSBku3LNnT8aOHcszzzzDoEGDjHNmXFwcP/74I8OGDaNVq1ZMmTKFY8eOZTq7bXR0NF9//TUdOnRgyZIlQMp59eeff6ZRo0Zp1jWbzbzwwgtAStmNb7/9Nt/v+++//2b69OlAyiRdACtWrCj04bd16tQxevr98MMPJCYmGstuvvlmoy7hhg0bCjUOEREREWdwy3kVkcKXWQKwXLlyOW7n4+ND5cqVuXDhQo49AN3d3alYsaIxg2FERESOswyLiIgUFnsC0Gw2G7310tf/i4uL46677mL37t0AdOnShffff5/q1aunWc9ms7Fz504WLlzI8uXLiYqK4vz588ycOZOZM2cSGBhI69atqVSpklF7cNeuXcbEI5AyW+77779vJOXSu/3225kxYwZHjhzh/fffZ+jQofj7++fpPUdFRfH444+TmJiIp6cn33zzDffeey9Xrlxh3LhxbN68Oc3QYEe75557WL9+PeHh4axdu5bbbrsNAA8PDzp27MiaNWv4448/Cm3/IiIiIs6iHoDiEtLPAAy5SwDC/yYCyc1MwDVq1DAeX7t2LZfRiYiIOJ59CLB9cgqAG2+8Mc06L730kpH8Gz58OAsXLsyQ/AMwmUy0a9eOGTNmcOjQIT7++GO6dOliDCc+f/48P//8M/PmzePLL79k48aNRvKvbt26zJs3j3nz5mWZ/IOUROWECRMACAsLY+rUqXl6vzabjeeee45jx44BMGHCBNq1a8crr7wCpMyIbO8ZWFh69+5t1DX8/vvv0yzr1KkTACdOnDBuFoqIiIgUF0oAikvIrAdgbnvn2esA5jQEGEhTzyizpKOIiMj1Yu8B6OHhAaRMfpV6Aqw1a9bw3XffAdC5c2dmzJiBxWLJsV1vb2/uvPNOFi9ezN69e3n33Xe54447aNasGZUqVaJq1aq0adOGUaNG8eOPP7J161YGDBiQae3B9Hr37k3v3r0B+Oqrr9ixY0eu3+9HH33E0qVLAbjtttuMiUXuueceOnToAMCcOXPYs2dPrtvMKw8PD+68804A1q1bZ9ReBOjYsaPxWL0ARUREpLhRAlBcQkRERIbXctsD0J4APHfuHHFxcdmue8MNNxiPc5o1WEREpDDZE4BJSUkANG/e3FgWHR1t1NwrV64cc+fOxc0t75Vbqlatyn333ccnn3zC77//zsGDB9m3bx+//fYb77zzDrfeemuukoqpTZs2DW9vb2w2Gw8//DBhYWE5bvPjjz/y2muvASl1BmfOnGkkHM1mMzNmzMDb25vk5GSefvrpHM/nBWGfDdhqtbJ48WLj9SZNmhg9IDURiIiIiBQ3SgCKSyhID0B7rz6bzZZjUi91UfOgoKDcBygiIuJAycnJnD17FvjfTbAWLVoYyz/77DNCQkIAmDp1qkvVrK1evTrvvvsuABcuXODee+/NtqzGd999xxNPPAGkJDMXLlyYoXZg7dq1mThxIgDHjx8v1KHATZs2NZKtCxYsMCZIMZvNRi9A9QAUERGR4kYJQHEJ6ROAJpPJqNGTE3sPQMi5DmDq3hXqASgiIs5y4cIFYxZa+wQg9gTg1atXmT17NgCtW7fmjjvucE6Q2Rg6dCijRo0CYPfu3QwaNIiTJ0+mWefatWuMGzeOMWPGkJycTOnSpfnuu++oW7dupm0++OCDtGvXDoDZs2fz119/FVr89l6Ax48f5++//zZet9cBDA4O1u8EERERKVaUABSXkD4BGBAQkOshSbVq1TIe55QArFixovH4/PnzuY5PRETEkezDf1OzJwA//PBDo1fghAkTclWbzxnefPNNhgwZAsDff/9Np06dePDBB3n33XcZO3Ysbdq0Yd68eQBUqFCB5cuX06ZNmyzbsw8F9vLyIjk5mccff5yoqKhCiX3QoEHG7wx7XUL4XwIQNAxYREREihclAMUlpJ+QI7f1/wB8fHyMoum5mQjE3d0dIFc1i0RERAqDfQZgu1KlSlG/fn3i4+P55JNPAGjfvj233nqrM8LLFTc3N+bMmcMLL7yA2WwmMTGRFStW8PbbbzN//nzj3N6lSxfWr19Ps2bNcmyzbt26TJo0CUi5qffyyy8XSuwVKlQwju2yZctITk4GoF69elSqVAnQMGAREREpXvJeTVqkEKSfBCQvCUBIGQZ84cKFHHsAAnh5eZGYmJhp3UERkcISFRXFwYMHCQoK4uTJkwQFBRnffVOnTs1VciQzFy9e5OGHH85xvXHjxqWZ5VScy94D0GQyYbPZaNSoEW5ubnz//feEhoYC8OijjzozxFyxWCy8+OKLDBgwgI8//pgtW7Zw/vx5/P39ad++Pffddx9dunTJUy/GBx98kI0bN7J69WoWLlxI165dC2UY9B133MGGDRsICQlhx44ddOjQAZPJRKdOnViyZAl//PEHNpvNZXtgioiIiOSFEoDiEtIn4/Ja7LxOnTps27YtVz0AfX19iYyMJCYmhoSEBDw8PPK0LxGR/Ni5cycffvhhoe7Dz88Psznzzv36rnMt6ROATZo0AWDWrFkAVKtWjd69ezstvrxq1KgRM2fOdEhbJpOJDz/8kM6dO3Px4kWef/55WrdunabkhyP069eP559/nvj4eJYtW0aHDh0A6NixI0uWLOHixYsEBQVRv359h+5XRERExBmUABSXUNAEoH0m4HPnzhEbG4uXl1eW6wYEBBgzK549ezbNJCIiIoUpICCAunXrUq9ePapUqcL777/v0Pbfe+89Y/iiuDb7EGD70NOmTZvy999/8+effwJw//334+ZWcn+mlStXjo8//pghQ4Zw7do1Hn74YVauXEmpUqUcto/SpUvTq1cvVq5cyfLly5k6dSoeHh5GIhBgx44dSgCKiIhIsaAagOJ0ycnJBR4CXK9ePQBsNhtBQUHZrluhQgXjsWb4E5HrpUuXLnz99ddMmjSJu+++mxtvvNHZIYkTpa8B2KRJE77//nsgZTKM4cOHOyMsl9KpUyfGjBkDwL59+3jxxRex2WwO3Yd9aPGVK1fYuHEjkHJT0T5p2I4dOxy6PxERERFnUQJQnC4yMjLDD/q8JgAbN25sPD58+HC266buHXP69Ok87UdEJL9yO7O5FH9Wq5WzZ8+mea1Ro0YsXLgQgG7duhmTW5V048aNo0uXLgAsWLCAL7/80qHt9+jRg9KlSwP/mw3YZDLRrl07QAlAERERKT6UABSnu3z5cobX8joEuEaNGnh7ewM5JwDtd/VBPQBFROT6O3/+PElJScbzWrVqcfDgQaNX4N133+2s0FyOxWLh008/pWbNmgBMmDCBLVu2OKz9UqVK0a9fPwB+++034uLiAIwEYHBwsFE2RERERKQoUwJQnO7KlSsZXstrAtBsNhu9AHNKAPr5+RmPczNpiIhIUfHOO+8wYsQI7rjjDkaNGsW0adOMmnLiOuwTgNg1bNiQlStXAikJqdtvv90JUbmugIAAvvrqK7y8vEhKSmLYsGGcOnXKYe0PHDgQgOjoaGMYsD0BCOoFKCIiIsWDEoDidJklAHMcAmyz4b51K16zZ+OxciUkJdGoUSMg5wSgv7+/8diRFxAiIs524sQJbDYbZrOZS5cusX37dqZMmcLbb79NYmKis8OT/6Sv/9egQQNWr14NQM+ePdPcqJIUTZs2NWbRDgsLo2/fvly6dMkhbXfu3Nk45vZEbOPGjY2hwUoAioiISHFQcqeXE5eRWQKwbNmyWa5vioig9MMP47Fhg/FaUrNmNOnfH4DQ0FDCw8Oz7EWYOgEYHByMzWbDZDLlN3wREafy8PDgtttuo1OnTtSuXdsohxAcHMyPP/7Ihg0b2Lp1Kz4+PowePTrH9ubPn29MRpGZESNG5HmIqtlsNv4fEBCQp20Li/1739/f3+ETS+QkNDQ0zfOKFSsaNQEHDhyo45SFBx54gAsXLjBp0iSOHz/OHXfcwerVqx0yM/CgQYP49ttvWb16Nd7e3nh6etKxY0d+++03du/ene3fw5WOkZ3+zeWOKx4nERGRwqIEoDhdZGRkhtdSJ+nSiI3Fb+hQ3PfuTfOy299/c1Oq3i1HjhyhU6dOmTZhv6MPEBMTw+XLl/M86YiIiKsICAjgsccey/B6jRo1GDt2LH5+fixfvpy1a9dy++23U61atWzbi46OzpCgSi0mJibfE5qYTCaXmwzFngC4ntIPAU5dY65fv346TtmYOHEiwcHBfP7552zdupVRo0axcOHCAsc3dOhQvv32WyIiItiwYQP9+vXj1ltv5bfffuPgwYNERkbmmCBylWOUmj5LueOKx0lERMTRlAAUp4uIiEjz3MPDAy8vr0zX9XnlFSP5F3fnnURPmYL3O+/g9eWXtDp61Fjv0KFDWSYA0ycX//33XyUARaTYuueee/j1119JSEjgzz//zDEB6OPjk2aypPS8vb2xWq15isFsNmMymbDZbCQnJ+dp28JiMpkwm80kJydf995IqSegMpvN7Ny5E4Cbb76ZwMBAHacczJkzh7Nnz/Lbb7+xePFiKlSowIcfflig3vzdunWjdOnSXLt2jcWLF9OnTx86dOgAgM1mY/PmzfT/b6RBeq54jPRvLncKcpyUMBQRkaJGCUBxuvQ9AFP30EvNbds2vL7+GoCELl2Imj0bLBai33gD9507CTh8mGpmM2eTkzly5EiW+0ufADx79iytW7cu4LsQEXFNpUqVokaNGgQFBXHx4sUc1x85ciQjR47Mcnl4eHimpRuyExAQgMViITk5Oc/bFhaLxUJAQAARERF5TmgW1OnTp43HVatWZc+ePQBGgknHKXsBAQEsWrSILl268Ndff/HRRx/h4eHBhAkTCtRur169+PHHH/npp5948803qVevHp6ensTHx7N+/Xo6duyY6Xaueoz0by5nBTlOeZ2wTkRExNlcrw++lDjpE4CZDv9NTsb3pZdSHpYuTdTMmWC/8+rhQcy4cQA0/+/u7aFDh7LcX/ri6ufOnctv6CIiInmSnJycZshv6mGlt912mzNCKpJKly7NqlWrqFevHgAzZsxg1qxZBWrTPhtwREQEf/zxB56enrRq1QrQRCAiIiJS9CkBKE6XfghwmTJlMqzjsXw5bv/16osZN47kwMA0yxP69MFaqxat/nt++PBh4uPjM91f+gRg+tkYRUSKk7i4OKPmXKVKlZwcjYSHh6c5P9lnZy5XrhzNmzd3VlhFUsWKFfnxxx+pXr06AJMnT+arr77Kd3tdu3Y1JtGxzwbcrl07APbt20dsbGzBAhYRERFxIiUAxenS9wDMUI/PasX73XdTHlapQtx992VsxGwmbvhwbvrvaWJiIocPH850f97e3mnqtthnXhQRKYpyqqW1YMECEhISMJlM3HTTTdmuK4Uvfa/zCxcuANCxY0eXnBzB1VWpUoUlS5YYdStffPFFfvzxx3y15eXlRa9evQD45ZdfSEpKMhKAiYmJ/PXXX44JWkRERMQJVAOwhHDVQsUWiyVDD8AKFSqkidf9119xO34cgLhnn8Xi45NpW0nDhnHT228bz/fv38+NN96Y6br+/v5cvnwZSLkYy+3xcdXjCP+LzZVjTM9VY9WxdKyieDwLS+obHjExMcbj6OjoNMu8vb1xc/vfKfqhhx4iNDSUbt26MWbMmDRtjh8/nlatWnHTTTdRo0YN4zgHBwezbNky1q9fD0DPnj1znABECl/6BKC97titt97qjHCKhTp16rB48WIGDRrE1atXefLJJ/Hx8aFPnz55bmvAgAH89NNPXL58mW3btnHzzTcbE1fs2LEjyzqAIiIiIq5OCcASInWNIVeTvgdg5cqV08ZrH85TsSI+o0fj4+mZeUMBAfg3bEiVo0cJIaUOYFbvu0yZMkYC8OzZs7k6Pvbi1a4u/RBnV1UUjqeOpWMVleNZmLKaXOPNN99M83zq1Kk0a9YsV22GhYUxf/585s+fj8Viwdvbm4SEhDTDTDt37syjjz6a/8DFYbLqdZ7VzPWSO40bN+aHH37gjjvuIDo6moceeohFixYZM/nmVvfu3fHy8iI2NpaVK1dy66230qhRIw4dOsSuXbsKKXoRERGRwqcEYAnhKjPApWexWDIkAL28vIx4zUeP4v/77wDE3nsvcTExkKrXTHpe3btz09GjLAd2bNuW5ftOPdPw5cuXOXPmDL6+vpmu6+fnh8ViwWq1ZojVlVgsFvz8/IiMjHSZ2fUyUxSOp46lY7na8SwKydK8uP/++9m/fz8nTpzgypUrXLt2DYvFQmBgIA0bNqR79+6qLedCUvcA9PHxITo6mqpVq1K7dm0nRlU8tG7dmvnz53PXXXcRHx/PyJEjWbFiBU2bNs11Gz4+PvTo0YOVK1fy888/89Zbb9G2bVsOHTrEn3/+idVqVW9mERERKZKUACwhXOGiOyvphwD7+/sb8Zb6/HMAbBYLsffeS3IO7yO+SxdumjOH5cDxoCAiIiIyTeylTgBCylC5G264IcdYXfk42lmt1iIRJ7j+8dSxdKyidDwLy4oVK/K13ef/fRdm5pZbbuGWW27Jb0hynaXuAWifAKRTp06YTCZnhVSs3HLLLXzyySc88MADXLt2jWHDhvHLL79Qq1atXLcxYMAAVq5cSVhYGDt27KBdu3bMmzePa9euceTIkTwlFEVERERchapNi9Ol77lkzAIcH4/n0qVAyiy/6Wf+zUzSjTdy439F1JOTkzlw4ECm6/n7+6d5rolARETkekh9vklISACgffv2zgqnWOrXrx/v/jd5WFhYGEOHDuXixYu53r5nz56UKlUKSEnat23b1limYcAiIiJSVCkBKE5ltVqJiopK85o9Aeixdi3mq1cBiLv77ly1Z/P1pWWjRsbzffv2Zbpe+h6ASgCKiMj1EBwcnOG1m2++2QmRFG//93//x4QJEwA4ffo0w4cPz3WpBF9fX7p16wbAqlWrqFSpkjGBzs6dOwsnYBEREZFCpgSgOFX65B/8rz6X56JFACSXL09i1665btOvY0fq/ff4rz17Ml8n3WQEZ86cyXX7IiIi+REfH29MQGUXEBBA3bp1nRRR8fbMM8/w2GOPASkTgz300EMkJSXlatuBAwcCEBoayq5du4xegEoAioiISFGlBKA41bVr1zK8VqZMGUyXLuGxdi0A8YMHg7t7rttMbNsW+2CdPTt2ZLqOfQiwveZS6qLsIiIihSEkJCTDazfddJPq/xUSk8nE66+/zpAhQwDYsGEDkyZNytW2vXr1wsPDA0g7DPjcuXMaNSAiIiJFkhKA4lSZDccpU6YMnitWYPrvLn3c8OF5ajOpTRsjAXg2NDTTuj/2HoA2mw1QD0ARESl8md1suummm5wQSclhNpuZMWMGN954IwCfffYZX331VY7blS5dmq7/jT5YtWqVsT2oDqCIiIgUTUoAilNllgD08/PDY+VKAJLq1sXavHme2kyuUoWbUg3x/euvvzLdR2rqASgiIoUts55jSgAWvlKlSvH1119TtWpVAF566SU2b96c43b2YcAXLlwgOjra+O2wI4vRBSIiIiKuTAlAcar0Q4C9vLywXLmC+7ZtACT07w95HRplMtGkeXM8/nu6e/fuDKukTwCeP38+13WBRERE8iP9zSaLxUKrVq2cFE3JUrFiRb777ju8vb2xWq08+uijnD9/Ptttevfujft/JUhWrVplJGvVA1BERESKIiUAxanS9wD09vbG49dfMVmtwH8JwHywtGhB6/8eZzYRSPoEoNVqzfFCQEREpCBOnTqV5nmzZs3w9vZ2UjQlT5MmTZgzZw4A4eHhPPTQQyQmJma5vr+/P507dwZg5cqVxmzNhw8fzvWMwiIiIiKuQglAcar0PQB9fX3x/G/4r7V6dZJatMhXu9amTY06gPv27sX6X0LRzj4JSGqZFWcXERFxlJMnT6Z5nrqunFwf/fv3N2YG3rVrF1OnTs12ffsw4JCQEMqUKQOk1A/+888/CzVOEREREUdTAlCcKv0ddD8fH9y3bAEgoV+/vA///U9Ss2ZGAjAqJobjx4+nWV66dOkM2ygBKCIihSl9DcDWrVtnsaYUpkmTJhnDeefMmcNvv/2W5bp9+vTBzc0NgKCgIGNI8M6dOws/UBEREREHUgJQnCp9D8CApCRM/w3Hic/n8F8Aa9263Pzfj3TIWAcwsx6AGgIsIiKFxWazcfny5TSvtchnL3cpGHd3dz777DPKlSsHwNixYwkNDc103YCAADp16gTAb7/9RvP/JiZTAlBERESKGiUAxanSJwDLRUUBkFyhAkkFmRnRzY0adetS/r+n6WcCTl0D0F5/ST0ARUSksFy9ejVNvTlvb2/q1q3rxIhKtqpVqzJjxgwgpR7g2LFjsdlsma5rHwZ85swZatWqBcDevXtJSEi4HqGKiIiIOIQSgOJU6ROAlcLCAEjo3h3MBft4JjdoQLv/HqdPALq7u+Pl5QWAj48PoASgiIgUnvQzADdr1gyLxeKkaARShveOHDkSgDVr1vDtt99mul7fvn2Nv1VsbKzx/7///vv6BCoiIiLiAEoAilOlTwBW/K93RELPngVu29qggVEH8OjRo0T917vQzt4L0J4I1BBgEREpLMHBwWmet2zZ0jmBSBpTpkwxevW98sorGWZqBihXrpwxDPjAgQPG6xoGLCIiIkWJEoDiVOknAakE2NzcSOzSpcBtJ6VKACYnJ7Nv3740y+0JQHtBb/UAFBGRwpK+t5jq/7kGX19fPvroI8xmMzExMTz77LOZDgUeMGAAkDKRS7Vq1QAlAEVERKRoUQJQnCp9D8AKQGLbtthS1ejLL2uDBqSuIrhnz540y+0JQPN/Q40vXrxIUlJSgfcrIiKS3tGjR9M8VwLQddx00008+eSTAGzdupXvvvsuwzp9+/Y1fi/Yfz/s2rUry7qBIiIiIq5GCUBxqvQ9AMsCiQ4Y/gspMwH7m800+u95VhOB2H+8W61Wwv6rQSgiIuJI//77r/FYE4C4nueff94YCvzqq69y4cKFNMsrVKhAx44dAYwZg8PDwzMdMiwiIiLiipQAFKdK3wPQH0jo0cMxjZcqRXKNGsYw4N27d6e5U29PAFqtVuM1DQMWEZHCkDqhpAlAXI+3tzfvv/8+kHJz8uWXX86wjn0YcHh4uPHajh07rk+AIiIiIgWkBKA4VfoEoG9gINYGDRzWvrVWLSMBGBoammYWRn9/fwDi4uKM15QAFBGRwhAREWE81vBf19SpUyfuvvtuAFatWsUvv/ySZvltt92GyWQC/jeB2K5du65vkCIiIiL5pASgOE1iYiKxsbFpXvPq0gX++3HtCNbatY0EIKStA2jvARgTE2O8ppmARUTE0ZKSkkhISDCeN2vWzInRSHZef/11KlSoAMCECRPS/EaoVKkS7du3BzASgZoIRERERIoKJQDFadL3/gPw6t3boftIrlWLZoDXf89T1wEsXbq0EYf9sRKAIiLiaEFBQWmeN27c2EmRSE7KlCnD5MmTgZQZf2fOnJlm+eDBg4H/3Tw8efKk6geLiIhIkaAEoDhN+glAzIClc2eH7sNauzZuwI3/Pd+9e7exzD4EODk5mcqVKwMaAiwiIo6X+txjMplo4MBSF+J4Q4YMoW3blPEDs2fP5p9//jGWDRgwADc3tzTrqxegiIiIFAVKAIrTpO8B6GEyYfP1deg+rP/N6GcfBnzgwAESExOB/w0BBihfvjygBKCIiDjewYMHjcdVq1alVKlSToxGcmIymXjrrbcwm83Ex8fzyiuvGMvKlStH165d06yvBKCIiIgUBUoAitOkTwB6eng4fB/WmjWB/yUA4+LiOHbsGPC/HoAAZcuWBTQEWEREHO/kyZPG41atWjkxEsmtpk2bMmrUKABWr17NmjVrjGVDhgxJs65mAhYREZGiQAlAcZr0CcBSPj6O34m3N9bKlUk93+KRI0eA/9UAhP/1Bjx//jzJycmOj0NEREqsM2fOGI+bN2/uxEgkL1566SVjhMCECROIi4sDoHfv3nh7exvr7d+/P81kISIiIiKuSAlAcZr0CUDvVENyHSm5dm3qAN7mlI/74cOHgbRDgH3+Sz4mJCRw6dKlQolDRERKptDQUOOxJgApOsqUKcPEiRMBOH36NJ999hkAvr6+9OnTx1gvKSmJP//80ykxioiIiOSWEoDiNOknAfFxcP0/O2utWliAJv8V7T506BCQdghw6npMqgMoIiKOFB0dbTxu0qSJEyORvBoxYgQtWqSMI/jggw8IDw8HMg4D/uOPP657bCIiIiJ5oQSgOE1UqiFRkLZHniPZJwJpnpAAZN4D0CNV/UHVARQREUeJjo42SktYLBaqVKni5IgkL8xmM5MnTwZSRi688847AHTp0oWAgABjPSUARURExNUpAShOE/NfLT67wkoAJv83EYi9DuDFixcJDw/H19cXk8kEpPzAt1MPQBERcRT7xFOQMuGU/bwjRUeHDh3o168fAN988w3Hjx/Hw8ODgQMHGuts3boVq9XqrBBFREREcuTm7ACk5IpKNSsipNTaKQzWatUASF12/ciRI3Tq1InSpUsTGRlJfHw83t7exMTEKAEoIpINi8Xi1O0dxR5HYcezb98+43GdOnVyvb+Sdpzy63rF9dprr7FmzRoSExN5/fXXWbhwIUOHDuXrr78GUnoHHj9+nEaNGl2XePLCVf52+iyJiIg4lxKA4hzJyUSlS7SlHkrj0F1Vrw5As1SvHTp0iE6dOuHn50dkZCTXrl0jMDCQkydPagiwiEg2CvJdbbFYCu27Pr8Kq/e53f79+43Ht9xyS67ef0k8TvlxPY/TjTfeyOjRo/nggw9Ys2YNu3fvpm/fvlSpUsW4cbhv3z46dOhwXeLJLX2WcscVj5OIiIijKQEoTmE5dozI/2ry2ZUtW7ZQ9pVcqRI2d3fKJiZStXRpzl27ZtQB9Pf35+zZs0RERFClShVOnjypHoAiItm4cuVKnrfx8/PDYrFgtVozTADlLBaLxbgJVJhDN1P3AGzZsmW2x68kH6e8cNZxGj16NF9++SVXr15lzJgxbNq0iREjRvDee+8BsGrVKkaMGHHd4smOPku5U5DjpIShiIgUNUoAilO4b9tG+p9ZFSpUKJydWSwkV62K5fRpmvn6pkkAli5dGkiZkTgwMBDQJCAiItkp6IW7q1z421mt1kKNKfU5pW3btrneV0k7Tvl1PWPy8/Pj+eefZ+LEiRw+fJj58+czdOhQIwHoqnUAXS0mfZZEREScQ5OAiFO4b92aIQFYsWLFQtufvQ5gk/8m+zhx4gTJycnGMJTIyEhjZsbz589js9kKLRYRESk5rl27BoDJZFKPoWJg1KhR1K5dG4Bp06ZRqVIlatWqBaT8ljhz5owToxMRERHJmhKAcv3ZbLjv2EFEupcLrQcg/6sD2CguDsCY7MPf3x9ImwCMiYnh6tWrhRaLiIiUDLGxsSQlJQHg4eHh5GjEETw8PHjttdcACA0NZfbs2QwbNsxY/v333zspMhEREZHsaQhwHkRERLBkyRJ27drFpUuX8PT0pG7dutx22220a9cuz+3FxMSwc+dO9u3bR1BQEKGhoSQnJxMQEEDDhg3p27cvTZo0KYR34lyWEycwh4Vl6AFoT8YVBut/CcDGqRJ7x48fz3QIMKT0AlRPDRERKYh///3XeFxYM93L9de3b1/at2/P9u3b+eijj1izZg3vvPMOAMuXL2fcuHFOjlBEREQkIyUAcyk4OJgJEyYQEZHSb83Ly4vo6Gj27dvHvn37GDBgAA8//HCe2hw7dmya2kAeHh6YzWZCQ0MJDQ1l8+bNDB48mFGjRjn0vTib+7Zt2CBDD8DCnBXO3gOwYar6LidOnDCSjhEREWkSgCEhITRu3LjQ4hERkeJv7969xuNq/5WikKLPZDIxefJkevbsSWxsLB999BGBgYGcP3+ekydPEh0djY+Pj7PDFBEREUlDQ4BzITExkTfeeIOIiAhq1qzJhx9+yA8//MAPP/zAyJEjMZlMrFy5knXr1uWpXavVSq1atXjkkUf45JNPWLJkCYsWLeLjjz+mffv2ACxbtoz/Z+++w5uquwCOf2/SNN2DvfeSKVNR2UOGAoIgS5TlRBFQX3GgooAoKogCDgRkyRBkbwRUQED2km0po7RAWzrTJPf9o8k1aQt0Jmk5n+fh8ebe5ObkWmhycn7nrFu3Li9eltsYdu4kGUhJs98VCcBQoJitCuPMmTPacyYkJDj1IJRBIEIIIXJq9+7d2nadOnXcGInIbffffz89e/YE4Oeff6ZRo0YAWK1Wli5d6s7QhBBCCCEyJAnATNiwYQNXr17FaDQyZswYrfmz0WikV69edOzYEYB58+ZpvX4y47XXXuOrr77iscce06rPFEWhdOnS/O9//9M+LCxfvjyXX5EbqWqGA0B0Oh0GgyHPntbiUHlR3ZboO3XqlFPS0dvbW4tBEoBCCCFy6ujRo9p2w4YN3RiJyAvvvPMOPj4+qKpKWFiYtn/WrFlujEoIIYQQImOSAMyEbdu2AdC8efMMB1X06NEDRVG4ceMGR44cyfR5a9eufdtjOp2O1q1bA3D16lXi4uKyFrSH0p07h+7atXTLf7288nY1urVUKVTbBOBqtmU5p0+fdkoA3rp1S0vESgJQCCFETl26dEnbrlq1qhsjEXmhdOnSvPDCCwAcOnQIRVEAOHbsmFNCUAghhBDCE0gC8C4SExM5ffo0AA0aNMjwPkWLFtV6+xw6dCjXntsxOWVx6F2Xnxl27gRIVwGY59MRDQastuTefXo9AJGRkeht25A6CKREiRJAag9AIYQQIifsfYMhNVkkCp7hw4drXw47rmSYP3++u0ISQgghhMiQJADvIjw8HFVVAShfvvxt72c/dvHixVx7bvvSoZCQkDztj+dKhr/+AuBmmmmIRqMxz5/bakvS1jCZtH3RDlOBY2NjKVWqFCAVgEIIIXLGZDI5tQXJaAWByP8CAgIYPXo0kPr/3G7+/PlZagsjhBBCCJHXJAF4Fzdu3NC2CxUqdNv72Y/dvHkzV543KiqK9evXA9CmTRttWUl+Z9i7F4CblSs77ffx8cnz57bYBoHcF/tf/WFUVJS2LQlAIYQQueXw4cPatr+/v1PFuShY+vfvT82aNZ32RUREsGnTJjdFJIQQQgiRXt42XisAkpKStO07VanZjyUmJub4Oc1mM5MmTSIxMZFixYrx5JNP3vUx8+bNY8GCBbc93qdPH/r27Zvj2HIkKgr9uXMAxFeuDH//rR0KDAwkNDQ0T59esSUdy0dE4O/vT3x8vFOC12KxUKlSJSC1MtDb2xt/f390tt6BOp0uz2PMCXuSODg4WKta9UT54XrKtcxd+eV6CpGbdtpaXgBOU+ZFwePl5cWkSZPo1KmT0/45c+Zog+KEEEIIIdxNEoAeRlVVvv76a44fP463tzevv/46/rahFXcSHx/PtWvXbns8ISHB/dUHe/Zom7dslXZ2gYGBeR9fhQoA6BMTqV63LvsPH3Zq0h0bG0u5cuW021evXqVatWrabUVR3H8NM8GeFPJ0+eF6yrXMXfnlegqRGxx7AssAkIKvQ4cOtGzZUhscB7B161YuXrxIWdsKBCGEEEIId5IE4F04Lk1NTk7Gz88vw/slJycD4Ovrm6Pn++6779i6dSt6vZ4333yTGjVqZOpx/v7+d6ww8PPzc/sgEeXPP9EBqsFAdJqehkFBQXkfX+nS2FMkNUqVYv/hw/zzzz8YDAZSUlK4efMmDRs21O4eFhZG5cqV0el0KIqCqqpYrda8jTEHFEVBp9NhtVo9usoqP1xPuZa5y9OuZ35Ilor878yZM9q2JAALPkVR+Oijj2jWrJm2T1VV5s2bp/UIFEIIIYRwJ0kA3oVj378bN27cNgFoX0qak2V4P/74I2vWrEGn0zFy5EiaNGmS6cf279+f/v373/Z4VFRUrvUnzK7g339HB5jr1eOaw9JbSE1Q5nV8+pAQ7P93Ktr+P164cIHg4GBu3LhBREQEAQEB2v1PnTrF/fffT2hoKHq9HqvV6vZreCd6vZ7Q0FBiYmLcnuy9k/xwPeVa5i5Pu55FihRxdwjiHuA4TV4mAN8batWqRYsWLdi+fbu2b/78+bzxxht4eclbbiGEEEK4l6zHuosyZcpo/ascl4umZT+W3WUeP/30E7/++iuKovDKK684fYNcIKSk4HXwIADmRo24deuW0+GQNFOB84J9CjBANW9vILXvnz2pGxsbS/HixbX/3zIIRAghRHbFOgyckgTgvWPChAlOt2UYiBBCCCE8hSQA78LX11dburN///4M7xMVFcXFixcBqFevXpafY8GCBSxduhSAF154gTZt2mQzWs+lP34cJSEBgJTGjZ0+GMGdJyznFjUwEKtt6XFVh+WS9m/lY2NjMRgMFC1aFHCu3hBCCCEyKyoqymlZviQA7x1Vq1alVJo+x3PmzHFTNEIIIYQQ/5EEYCa0bNkSgB07dhAZGZnu+LJly1BVlUKFClGnTp0snXvp0qX8/PPPAAwePLjATosz7N2rbZsbN05XAVi4cGGXxGGvAqweH6/ts1f82ZOS9jfuUgEohBAiO3bv3u10O21CSBRsTz75pNPtrVu33nEViRBCCCGEK0gCMBMeffRRSpQoQVJSEh999BHnz58HUgd/LF26lDVr1gCpffjS9ngZMmQIXbp0YfLkyenOu3LlSn766ScAnnnmGbp27Zq3L8SNvGwJQEuZMlhLlkyXAHRVTy6rrQojMCJCq8gwm82AJACFEELkjn379mnbXl5e0nfyHtO2bVun26qqMnv2bPcEI4QQQghhIx2JM8FgMPDuu+/yzjvvcOHCBYYPH46fnx9JSUnaEp/HHnss3Ru+u5k5cyaQWoG2YsUKVqxYcdv7jh49mvvuuy/7L8LNDLbl02bblN20CcA7TTDOTRZbBaAuPJwq1atz6dIlkpKSgP8SgCVKlABkCbAQQojsOXHihLZdsmRJrdJc3BsaNmyIn58fCbbWJ5C6DPiNN97A19fXjZEJIYQQ4l4mCcBMKleuHFOnTuWXX35hz549REVF4e/vT6VKlejcuTMPPvhgls+pqqr23+jo6Dve116llh8pN2+iv3ABAHODBkD6BGDx4sVdEot9CbAuIoLKHTqwfft2LZa0FYCRkZGkpKS4JC4hhBAFxwXb7zzI/nAwVBXdpUvoz5xBFxaG7tYtSEpC9fNDDQ7GUqEClurVUV3UQkNknre3Nw899BCbN2/W9sXGxrJs2TL69evnxsiEEEIIcS+TBGAWhISEMHjwYAYPHpzpx/zwww+3PbZy5crcCMvjeR06pG2n2IakpB0CYq+6y2v2CkBFVali+9DkWAGoqiolS5YEUhOzERERLqtOFEIIUTBcu3ZN287SAJCEBFizBmXNGkK3bEGfiVYU5qpVSWneHNOjj5LSvDno9dkJWeSyFi1aOCUAAT7//HP69u0rFaFCCCGEcAvpASjynD0BqCoKlrp1UVU1XQVgcHCwS2KxOnwQqx4Q4HTMZDKRlJTk1KxdlgELIYTICqvVSlxcnHY7MwNA9MePEzB8OLrSpaFPH3Tz5mWY/FO90n9v63X6NL4zZxLcqxeh9erhN3YsOvnd5XatW7fWto1GIwAXL15k+/bt7gpJCCGEEPc4qQAUec7r4EEALFWqoAYGkhAfr/VOhNQeiF5eXlgsljyPxb4EGKCaLn3+OzY2VqsABBkEIoQQImsuXrzodPtOFYBeu3fj98UXeP/2m9N+tWhRTI88QsrDD2OuWRNLxYqoISHg5QUmE7obN9CfOYPX4cMYfv8dw86dKAkJ6CMi8Js6Fd8ZM0ju0YPEV1/FUrVqXrzM/CcxEf2//6KLjESJiUGJiQGLBXQ68PJCDQrCWqRI6p8yZcDbO0dPV7VqVSpUqMCFCxeoVKmS1hfyf//7H3/99VduvCIhhBBCiCyRBKDIc/YKQLNt+W/a6j+9C5crWYsXR9XrUSwWyickYDQaSU5O1o7funXLqVpDEoBCCCGyYs+ePU63M0oA6k+dwu+jjzCuX6/tUw0G1CefRPfMM1hbtkz3u1Lj7Y21RAmsJUqQ8sgjJL70EiQkYFy3DuPChXhv346SkoLPzz9jXLKEpP79SXjjDVQX9dr1BEpUFIa//8Zr/3689u9Hf/Ik+qtXM/14Va/HWr485qpVsdSpQ0rjxpgbNkTNwmoFRVFo27YtP/zwA+fPn6dkyZJcuXKFc+fOsXbtWjp16pSdlyaEEEIIkW2yBFjkKSUqCr2tGuJ2CUCDweC6gLy8sNoq/AyXL1OpUiWnwzExMfj5+RESEgJIAlAIIUTWHDhwwOm2Y1W5EhuL/5tvEtKsmZb8swYEkPDKK9z8+2/UuXPh0UdTK/2yws+P5B49iF26lJvbt5PUqxeqlxeKxYLvnDkUatIE30mTIDExx6/PI1mteO3di98nnxDcrh2FatYkqH//1OrKbduylPwDUCwW9OfOYdywAb9Jkwh+6ikKVa1KSIsW+H34IYY//4RMDAlr164dkNpr+JlnntH2v/baa1r/YSGEEEIIV5EKQJGnHAeAmO+/H0g/AMQ7h8tssspaujT68HB04eFUrlxZW5bjGFupUqWIjo6WHoBCCCGyxPF3CvxXAWjYtImA119Hb/u9onp5kfTssySMGoVapEiuPb+lZk3ivvmGhFGj8B83DuPKlSgJCfhPnIjPokXEjR9Pii0xla+pKhw8iN+sWRiXLcu4Z6LBgLlWLSx16mCpWBFLhQpYS5XCGhKCGhgIBkPqMmCzGV1sLEpkJLpr19CfO5e6xPqff9AfP45isaCoKl7Hj+N1/Dh8/TXWwEBS2rQhuXt3LLe5ng899BB+fn4kJCQQERFBpUqVOHfuHDdv3mTixIm8//77eX2VhBBCCCE0kgAUeUobAKLTYa5dG0hfAejj4+PSmCxlymD46y90ly5RJc0SnOjoaCB1KvHx48clASiEECJLwsLCtG1fX18KAQEvv4zP4sXaflP79sR99BHWNFXouclaqRK3Zs4kcd8+/MeMwbB3L/oLFwju25fkzp2J//hjp764+YUSHY0yezbMmoX++HH8HI6pOh3mhg0xtWlDSosWqe87Mvkew1KiBFSrlv5AQgJeBw9i2LMntd/irl0oKSnobt3C+OuvGH/9FWtwMDz5JF6PP46ladPUvoKkvr9p0aIF69atY+PGjXz44YcMGTIEgG+++YZu3bpRz7Y6QgghhBAir0kCUOQpewLQUq0a2Kbupk0A+vr6ujQm+yRgfXg4VSpXdjoWExMD/De18WoWlw0JIYS4t0VGRmrbpYODKfTII+hs+6yFChE3YQKmJ54ARXFJPOZGjYhZvRrjwoX4f/QRuuvXMa5Zg/dvv5EwciSJL76Y44EXrqA/dAhfW7Wf4rCUWdXpSGnRguQePTC1b48aGpq7T+znh/mhhzA/9BCJr72GcusWhh078N6wAe+1a9HFxKCLiYGZMwmcORO/ChVI6t+fpD59UIsVo127dqxbt45Lly5RsWJFihcvTkREBKqq8vLLL7Np0yaXvw8SQgghxL1JEoAiT3kdPgyAuW5dbV/aJcD+/v4ujcle8aAkJFC1RAmnY/YKQHvPpitXrmC1Wl06qEQIUTDFxcVx9OhRzpw5w9mzZzlz5oz2pcO4ceOoU6dOjs5vNptZvXo127dv16qXS5cuTYsWLejcuTNeWe0rJ7IsMTGRRIfkVPmrV7Vmy8lduxI3YQJq0aKuD0ynI7lfP0ydOuE3bhw+P/2Uuiz4448xLlxI/LhxpLRp4/q47iY5GePKlfj8+COGffucj91/P9Znn+Vmu3aoxYq5LCQ1MBBT586YOneGzz7D+7ff8Fm+HO/16yEhAf2FC/h//DF+n3yCqWNHOjz2GCNtj920aRMvvPACH374IQD//PMPY8eOZcKECS6LXwghhBD3Lvk0IPKMEh2NPjwcQFv+C+krAAMDA10al8VhImPVNFUPaROAKSkpREZGOk0GFkKI7Pjrr7+YMmVKnpw7MTGR9957j1OnTgH/9VY9c+YMZ86c4c8//2Ts2LEub7lwrzl/7pzT7bKAtWhR4j77LDVh5GZqaCjxkyaR3LcvAW+8gdfhw3idPUtw794kd+xI/NixWCtUcHeY6C5dwmf2bHzmzUMXFaXtV729Se7SBcPw4egffhjVakW9edN9gRqNmDp0wNK5M94GA/GzZuE9ezaG/ftRzGaMq1Zx36pVNPHxYU9SEqtWrmTFypVMmjSJ+Ph4AH744Qdat26tDQwRQgghhMgrMgVY5Bn98ePatqVWLW07bQIwKCjIZTEBTj2PCsfGUsSh+fpN2wcJx4TfpUuXXBecEKJACw0NpVGjRvTu3ZuRI0fe/QGZNG3aNE6dOoW/vz+jR49myZIlLFmyhNGjR+Pv78/JkyeZPn16rj2fSE935QrHXn7ZaV+JmjW5+eefHpH8c2Ru0IDojRuJmzQJq23JrHHdOkIfeQS/8eNR0lTqu4SqYvjjDwKffZbQBg3wmzxZS/5ZSpcm/u23uXHwIHHTp0PTpi5bQp1pAQGY+vcnZsMGbm7dSuLAgVhtrU962ib+Hjt+nLhPP6V/jx5ODx0+fLjT0nEhhBBCiLwgCUCRZ7yOHdO2zTVrattpE4DBwcEuiwnAWrastm2fBGyXtgIQJAEohMgdLVu2ZM6cOYwZM4a+ffvSqFGjXDnv+fPn2bFjBwCvvPIKTZs2RVEUFEWhadOmDBs2DIBt27bx77//5spzCgeqinH+fEIeeYSDDr/3AIoOHpz7Pelyi15P0jPPcPOvv0gcOBBVp0NJTsbvyy8JbdgQ3y+/hLi4PA9DiYnBZ9YsQpo3J/iJJzCuWYNitQJgatGC2DlzuLlvH4kjRrhn+XQ2WOrUIf7TT7l55Ahx48fTzWHlwbrvvuPNn39G55DAjIyMZNiwYVhtr1sIIYQQIi9IAlDkGXsC0FK8OKpDlV3aBGDhwoVdGpcaGIjVVnWou3SJKlWqaMekAlAIkVfyqpfo9u3bUVWVkiVL0rRp03THH3roIUqWLImqqmzfvj1PYrhX6cLCCOrVi8DXXkMXG8uxNMfzQ/sINTSU+E8/JXrzZlIeeggAXXQ0/uPHU6hhQ3zGjoXcThybzRg2byZwyBAK1apFwJtv4nXyJABWf38SBw/m5p9/Ert0KaZOnSCf9q9UAwJIGjqUkL//pn7FigAsBSqZTHRXVQD0tkTg1q1b+fzzz90VqhBCCCHuAZIAFHnGvgTYcfkvpB8CUqhQIZfFZGdfBqxPUwF448YNILUq0c/PD4BwWx9DIYTwRIdtw5bq16+PksGySEVRqF+/vtN9RQ5ZrfjMnElos2Z4b9sGgKVCBc6l+X1W2qHyy9NZ6tQh5tdfiVmyhJSGDQHQ3biB7+TJUKkS/r17Y/z5ZxRbpXxWKXFxeK9aRcCwYRSqXZvgPn0wrliBkpwMgLlKFeImTODmkSPEf/IJlmrVcumVeQC9nsf69wfgb+BkixaMsh2yqCr2cWSfffYZmzZtckeEQgghhLgH5M+vVIXns1i0b/PNaRKAaSsAi7phSY+1dGk4fhxdeDhVunfX9kfZ+g0pikKJEiU4d+6cVAAKITyWqqralxTly5e/7f3KlSsHwMWLF10SV0GmO3uWwNdew7B7NwCqopD03HPEjx7N9TRJq/yUAARAUUhp2ZKYFi0wbN6M73ffpSY4rVa8N27Ee+NGVC8vzPffj7lxY8y1a2OpUAFrqVKofn7g7Q3x8ShxcegvXkR//jz6Eycw7NuH/tgxbWmvnTUwEFO3biT17o25cWPP6+uXix5//HE++ugjABa1asWr77/Pgz16sPvmTcxAMBCjqrw0cCCb16yhfL16bo1XCCGEEAWPJABFntCfO4eSmAikrwBMmwAsVqyYy+Kys9gqAHXh4U5LgB2rE0uVKiUJQCGER0tMTCTJNmDgTtXU9mOJiYkkJibi6+vrkvgKFIsF32+/xW/CBBTbNTdXqULclCmYmzThxo0bmEwm7e7+/v4un3KfaxSFlHbtSGnXDsPZswQvXIh10SJ0V6+imM0Y9u3DsG9ftk5tDQ7G1KYNpg4dMHXoAPfIz2LFihWpU6cOR44c4ZdffuHll1/muc8/Z/egQUQBw4EpQHRyMoPat2fD66/jNWzYPXN9hBBCCJH3JAEo8oTecQDIXRKAxYsXd0lMjqy2qgxdRATlS5ZEURRUVSUlJUX7cGwfBCIJQCGEp0q0fdECYDQab3s/x2N3SwDOmzePBQsW3PZ4nz596Nu3b5bi1Ol02n9DPWQohn25dHBwMKqtH9ttnTyJbtAglD17AFD1etRRo1DGjCHQxweAEydOOD2kXLlyWW5x4ZHXqXFjeOABmDQJy+7dKKtXo+zaBXv3al/03YkaEgKNG6M2bYrarBk88ggGgwED4J/NmDztOmX2Z+npp5/mzTff5MiRI4SHh9OvXz8++ugjzp8/z+bKlXlPVfno3DkOW60M+fRTls+bh378eNR+/bJcHelp1wiy+HfORTzxOgkhhBB5RRKAIk/YB4CoRiMWhwo7SJ8AdEeTdHsPQEVV8bl+nSJFihAZGQlATEyMUwIwPDzcY96oCiFEXouPj+fatWu3PZ6QkJDtgSaKouTZMJTssicAMmS1wpQp8PbbYKv6o25dlB9/RLH1ybM7ePCg0+2yZcsWrOvk5QWPPJL6B8BshkuX4OxZuHoVEhIgORn8/SEwEEqXhipVUAoXBkUhLxb3etp1uuPPEqkJwNGjR2OxWJg3bx6TJk1i5MiRvPLKKxw7e5aPly+nx5df8suOHawBRl2+zFfPPgvffQdTp0KDBlmOydOuEdz9OrmDJ14nIYQQIrdJAlDkCW0CcPXq6ab3pR0CUqpUKaxp+gLlNYtDXyZdeDilS5fWEoA3b96kRIkSWmIyPj6e2NhYAgICXBqjEELcjWMlX7JtmEJGHI/dbfmvv7//HVsz+Pn5YbFYshBl6gd+e6W1q/+9vx1FUdDpdFit1oy/5Dl3Dt3gwSi//w7Yqv5Gj0Z9++3UXndprsHevXudbpcpU6ZgXydFgTJlUv/cSR68Dk+7Tnf9WbIpWrQo7du3Z926dcybN49x48bxzDPPMHbsWCIjI5kwYQKbN2/mYtu27Nmzh6lAFeDVnTtRGzVCHToU9aOPoHDhu8bkadcIMn+dXCkn10kShkIIIfIbSQCKPKG3DwC57z6n/RaLhbi4OKd9gYGBxMTEuCw2+K8CEEB/6RIVK1bUqjdu3rwJoFUAQmoVYI0aNVwaoxBC3I2vry++vr4kJiZqU8wzYj9mv/+d9O/fn/62iaUZiYqK0v6dzKzQ0FD0ej1WqzXLj80rer2e0NBQYmJinBN1qopx7lwC3nsPJSEBAHP16tz65hss9epBfHzqnzSOHDnidLtIkSIF+zq5kaddp6xco+7du7Nu3ToiIiJYtmwZ7dq147nnnmPcuHHs2bOHLVu2MGvWLDp27EhYWBivAcUNBp5KSUH57jusixcT/957JPfvD3eopPO0awQF72epSJEieRSVEEIIkTc8rwZf5H+26X8AljQJwLTJP/u3wa5mLVEC1d73JTycqlWrascuXLgAOC9Nlj6AQghPpCgKZWxfaISFhd32fvZjZcuWdUlc+ZUSG0vgkCEEjhqFkpCAqigkvPIK0Zs3pyb/7sA+jdnOHe0thOfr0KEDwcHBAFqvzUGDBmkDYyZPnkyxYsVYsGBBaq884GlVZVXjxgDooqMJHDWK4C5d0J865ZbXIIQQQoj8SRKAItd5nTmjbZurVXM6lrb/n9uWT3h5YbVV+OkuXaJmzZraodOnTwNQokQJbV/aD3ZCCOEp6tatC8CBAwduex97hbP9viI9rwMHCGndGuPKlQBYKlQgZtUqEsaMAdugj9uxWCzpKjAlASgy4uPjQ/fu3QFYt24dly9fJigoiEGDBgGwfft2Dhw4QPXq1Vm4cCF+fn6kmM08dfQo68eOxVKpEgCGv/4ipFUr/D79NLX3ohBCCCHEXUgCUOQ6/T//aNuW6tWdjqXt/+fl5b5V6PZJwPrwcKcPxfYKwKJFi2rxSQWgEMJTNW/eHEVRuHz5Mrt27Up3fOfOnVy+fBlFUWjZsqXrA8wHfObMIbhzZ/T//gtActeuRG/ZgvmBBzL1+EuXLqXrH1baodesEI4GDx4MpCaO58yZA8Dzzz+Pjy3RPGXKFAAaN27MnDlzMBgMJCYm0uuzz9j+zTckjByJ6uWFYjLh99lnhLRqhVcGf/eFEEIIIRxJAlDkOnsCUPXzc+q1B+kTgN7e3i6LKy2LLTbdpUvaEjqAy5cvA6nVifYqQKkAFELkhtjYWO2PY0sE+7Ah+x+z2ez0uCFDhtClSxcmT56c7pwVK1akefPmAEydOpXdu3ejqiqqqrJ7926+/vprAFq2bEm5cuXy7sXlR2Yzvv/7HwGvv46SkoJqNBI3aRK3vv8eNSgo06c5e/Zsun1SAShup3r16jRr1gyAuXPnkpycTNGiRbXem2vWrOEf23upli1b8u2336LT6bh16xa9+vdnX9euRG/dSkqjRgB4nT5NSJcu+I8aheLinspCCCGEyD9kCIjIdfaeNOaqVdM1qE6bAPS5y7KqvGRPTurCw1EAg8FASkoK165d0+5TsmRJwsPDJQEohMgVtxuuMX78eKfb48aNo06dOpk+70svvcSVK1c4deoU48eP175cMZlMANSoUYMXX3wxm1EXULGx0KsXPps3A6nT4WPnzsWShetul3YASEhIiEyOF3c0ePBgfv/9dyIjI1m5ciU9e/bk5ZdfZvbs2ZjNZr788ktmzJgBwOOPP84XX3zBa6+9xvXr1+nevTvLly/nvjVr8Jk9G7+PPkIXF4fvTz9hXLeOuHHjYOBAN79CIYQQQngaqQAUuc7L9q112uW/kH4IyN2mUeYlLQEYH48SE4O/vz+A0xQ4+yRgWQIshPBkvr6+fPLJJwwaNIjKlSuj1+vR6/VUrlyZwYMHM378eLd+4eJplMhIArt0AVvyL6VxY6I3bsxW8g/g8OHDTrfLpKl+FyKtRx99VPs5mTZtGqqqUqZMGZ566ikAli1bxsmTJ7X79+vXj0mTJgFoScAT//xD0qBBRO/cSXKnTgDoIiMJeu45dJ07w7lzLn5VQgghhPBkUgEocldiIjpbDyVLmgEgkL4C0M/PzyVhZcTi0J9JFx5OcHAw0dHRxMfHYzKZ8Pb21pZwSQWgECI3rLQNmMiqH3744a738fLyolu3bnTr1i1bz3Gv0F26RNCTT2oDq5J79uTWl1+C0Zjtc55KM41VEoDibry8vHjuuecYM2YMR48eZfPmzbRr146RI0eyePFiUlJS+PTTT/nxxx+1xzzzzDOoqsobb7xBVFSUVglYo0YNbs2ZQ/LatfiPHo3+8mWUjRuhVi2U995LrQY0GNz4aoUQQgjhCaQCUOQq/ZkzKKoKZFwBmDYB6M4lUo79CfXh4RQuXFi7/a8tiWmvALx+/TpJSUmuDVAIIUSu0l25QnDXrv9Nqx82jITp03OU/IP0VeIyAERkxoABAyhUqBAAX3zxBaqqUq5cOfr16wfAqlWr0i0vf/bZZ/n0008BtCSgvV+gqVMnov/8k8TnnkPV6SApCd077xDSpg1ee/a48JUJIYQQwhNJAlDkKi+HKghzJioAAwMD8zym23FMAOrCw50attsbutsTgCDLgIUQIj9ToqII6tFDm/SbOGoUfPVVul61WZWYmJjud1vZsmVzdE5xb/D39+eFF14AYN++fWzfvh2AESNGYLQlpe3JPkcDBw5k4sSJAERGRvLEE09oVahqQADx48Zh3bkTGjQAwOvECUI6dyZg+HCUq1fz/HUJIYQQwjNJAlDkKm0CsNGItXz5dMdv3brldDskJMQVYWVIDQrCaktA6i5dcvrAdsZWHeKYAJRlwEIIkT8psbEEP/UUXqdPA5AwfDhJ77wDipLjc58/fz7dPqkAFJk1ePBggoODARg7dixWq5VSpUoxYMAAANavX8/BgwfTPW7QoEF88sknQGoSsFu3bpy2/XwD0KgR/PUX1s8/R7W1W/FZsIBCDzyA76RJEB+fty9MCCGEEB5HEoAiV9knAFuqVAG9Pt1xT0oAwn9VgPrwcIoWLartt3+T7lgVePnyZdcGJ4QQIufMZgIHD8bLNqgjceBAEt55J9dOb//CyJH0ABSZFRQUxIgRI4DUadJLly4FYPjw4dqgtHHjxmX4WPuAH/ivEtC+ggEALy/U4cO5uXMnybbeoEpCAv4TJxL64IP4zJwJiYl59MqEEEII4WkkAShylb0C0JxB/z9IvwQ4NDQ0z2O6E6utSkN36ZJTLPZ+OiVKlND2SQWgEELkP/5jxuC9bRsAyU88Qfwnn+RK5Z/d8ePH0+2TBKDIisGDB1OuXDkgNdkXHx9P8eLFGTJkCADbtm1jy5YtGT526NChfPTRRwBERETwxBNPcC7N9F9r6dLc+v57otetI6VxYwD0V68S8NZbFGrYEN9vvkFJ8wWtEEIIIQoeSQCK3JOcjN62FCqjCcCQPgHoWHXnDhbbhzRdeDhFihTR9p85cwZVVfH29qZYsWKA9AAUQoj8xjh3Lr7ffw9ASqNG3MqFnn9ppR3SYDAYtN8bQmSGj48P7777LpC62sDe32/48OHakJD3338fs9mc4eNfeOEFPvzwQwCuXLmSYRIQwNyoETFr1hA7c6b2Ra0uMhL/Dz6gUO3aBIwYgdeBA2Ab5iaEEEKIgkUSgCLX6M+fR7FYALBUrZrhfdIuAXZMurmDVgF49SqFbT14IDVReeXKFeC/Sg5JAAohRP6hP3yYgLfeAsBSqhSxs2eDj0+uP0/aJcClS5dGl8tJRlHwdevWjebNmwPw7bffcuDAAYKDg3nzzTeB1JUJ8+bNu+3jX3rpJcaMGQOkJhHbtm3LhQsX0t9RUTB16UL0jh3Ezp5NSr16qbsTEvCZN4+Q9u0JbdIEvw8+wGv3bjCZcveFCiGEEMJt5B2qyDV6h74zlipVMrxP2gRg8eLF8zSmu7H3AFRUlaJWq9Mxe1WHvZm7LAEWQoj8QYmLI2joUBSTCdXbm9iffkLNo983afvDyvJfkR2KojBp0iR8fX2xWq28+uqrJCQkMGDAAKravlSdOHFiupUUjl555RXefvttAMLCwmjVqhVhYWEZ31mnw9S5MzGbNhG9YgVJPXqgensDoL9wAb9vviHk8ccpXLkywY8/jt+HH2KcPx+vv/5Cd+UKJCfn7gUQQgghRJ7zcncAouBwSgBWrJjhfdK+cXV3BaDFYVJj0YQEp2OHDx/m0Ucf1RKAMgRECCHyB////Q+9bQlk/PvvY7FVOeW269evk5SUBIBOp8NqtcoEYJFtFStWZPTo0YwZM4aTJ0/y9ttvM3nyZD744AP69etHVFQUX3zxBR988MFtzzFixAgsFgsTJ07kwoULtG3bluXLlzsNNXOiKJgfeoi4hx4iftw4jCtX4r12LYY//kAxm1GSkjDs3o1h9+50D7UGBKAGB4O3d2ry0P5foxHVx0f7g48P1tBQKFMGatRAV7Jk6vtEqZQVQgghXEoSgPcIfQYTeXObl+3DlqVMGfQBAemOq6p62yEgrogvI0r58tp24ZgYDAYDKSkpQGoFoF6v1z7MXblyBVVV8fLyzL829mvormuZHZ4aq1zL3JUfr6fIv7xXrsRn8WIAkjt2JGno0Dx7LseJq6qtb5pUAIqceP7559m2bRtbt25l/vz5NGnShD59+tCiRQu2b9/OjBkz6NmzJ7Vq1brtOV5//XUMBgMff/wx586do1u3bqxatequqy7UwoVJGjiQpIEDUaKjMfz5J1579mDYswev48dR0nxRqouLg7i4LL/GYMAaFIS5USNMHTuS3LFjnlXoCiGEEOI/npnJELnOJdN2//0XAH2NGhk+X0JCAhZbj0A7+zfSQUFBeR9fRgICUr+BtloJuHGDokWLapV+R48eJTQ0lLJlywJgtVpJTk52++CSu3HbtcwivV7v9inQdyPXMnfll+sp8i/l+nWt75+1WDHiJk/O1Ym/aTn2/7MnAKUCUOSETqfjm2++oXXr1ly5coVRo0ZRsmRJJk6cSPPmzTGZTIwaNYq1a9fesdfk+++/j9VqZfz48Zw/f55evXqxYsUKQkJCMhWHGhKCqXNnTJ07p+6wWtFdvYr+zBl0V66g3LiB7vp1lNhYFJMJUlJQkpPBZEJJTkZJSoKkJJSkJJTERJTr19E5fAmsi43Fe+tWvLduxf+ttzA99hiJL76IuWHDnFw+IYQQQtyBJADvETdv3szz5wj+5x90QFL58iRm8HxXr15Nt8+eEIyNjU2XHHSV4JIl0V26RPLp0xQuXFhLAF68eJHTp09TsmRJ7b4nTpzA39/fLXHejV6vJygoyK3XMjOCgoLQ6/VYLJY79jJyJ7mWucvTrmd+SJaK7PF/9110kZEAxE2ahGqboJpXTp48mW6f/UsjIbKrSJEi/PTTT3Tt2pWEhAQGDhzI4sWLGTFiBBMnTuTvv/9mzpw5DBw48LbnUBSFjz/+mPj4eKZMmcLx48fp27cvS5Ysyd77GJ0Oa6lSWG+3lDgT9PHxhMbGEv/nn+j27sV761b0Fy6gWCwYV6zAuGIFyZ07E//++1hv00pGCCGEENknCcB7RF5/6FZiYrQPXeaKFTN8vujoaKfber1eq5iwWCxuSwxYSpdGd+kSysWLFC5c2OnYgQMHqF27tnY7PDyc+vXruzrELHHntcwqT49TrmXuyk/XU+Q/hk2b8Fm6FIDkJ57A1LFjnj+nfViUI1kCLHLD/fffz8yZM+nfvz/x8fH07NmTmTNnUqVKFc6cOcPYsWNp3bo15R1amaRlHyxy7do1Fi5cyN69e3n22WeZN28eRqPRha/GJigIypfHVKYMliefJF5V0R89is+cOfgsXoySmIhxzRq8t2wh/oMPSBo0KE8reIUQQoh7jXTfFbnC3mwdwFK5cob3SVuh5Cm99Cy2D2u6S5fSJQD//vtvp+VcV65ccWlsQgghMiEpiQDb9FNr4cLEjR/vkqc95/C7z+62wxaEyKK2bdvy3XffYTAYSEhI4Omnn6ZVq1YoikJcXBwvvfQSZrP5judQFIUvvviCzralvNu2beOFF1646+NcQlGw1KlD/KRJ3Pj7bxIHDkTV6VCSkgh46y0CBwzIVo9BIYQQQmRMEoAiVzhNAL5NAvDWrVtOt729vfM0psyy2hJ8OocKQHtycs+ePQQEBBAcHAxIAlAIITyR7/Tp6C9cACD+3XdRXTBh3mKxEBER4bSvSJEi+Pn55flzi3tHly5dmDNnDr6+vpjNZr7//nuqVKkCpL5HmTJlyl3P4eXlxbfffkvLli0BWL16NSNHjsRqteZl6FmiFi1K/KefErN+PWbb+0jj+vWEPPYYOltrFiGEEELkjCQARa6wJwBVgwHrbfofpa0A9PHxyfO4MsNqrwCMj6eIrS+OfZni3r17MZvN2pKuS5cuuSdIIYQQGdJduoTf5MkApNSvT3Lfvi553vDwcO13hcFgAGQAiMgb7dq1Y926dVSoUAGA06dPa1PVP/vsM3bt2nXXcxiNRmbNmkWjRo0AWLhwIe+//77WisVTmOvXJ3rLFpIfewwAr2PHCO7aFZ28/xJCCCFyTBKAIlfYE4CWChXgNkt70yYAfX198zqsTLE49GsqYus1Y39DHB8fz+HDh7Wm7pIAFEIIz+I3dixKQgIA8RMmpE52dwHHCcD2qnHp/yfySq1atdi0aRNdu3YF/vui0mKx0L9/f8LDw+96joCAABYuXEjNmjUBmDFjBl988UXeBZ1d/v7cmjmThGHDANBfuEBwt24oGQyTE0IIIUTmSQJQ5AqdrQ/S7Zb/QvolwJ4yTdfqULFRLIMBBX/88YfWZDszb7CFEEK4hv7wYXyWLQMgqXdvzA0buuy5zzq2vrD97pAEoMhLISEh/PDDD8ydO9ep2jQ2NpamTZsya9YskpKS7nqOxYsXU9E2ZfeTTz5hzpw5eRp3tuh0JIwZQ8KIEUBqEjCof3+Ij3dzYEIIIUT+JQlAkXOq+l8FYH5MADpM0Cvq8MayZMmSAGzatElLAF69epWUlBTXBiiEECJD/uPGAaAajSSMHu3S5z558qS2bTKZAEkACtfo0KEDu3fvZuzYsVo7laSkJN58803uv/9+xo0bR1hY2G0fX7x4cZYsWULx4sUBePPNN1m1apVLYs8SRSFh9GgSn38eAMOhQwS++CJ4UO9CIYQQIj+RBKDIMeXaNXS2KW13SgCmXQIcFBSUp3FllhoQgLVYMQCKX7+u7a9VqxYAv/32m5YMtFqtXJZm1EII4XZef/6J99atACQOHozVxdN3jx8/nm6f9AAUruLj48OLL77I0aNHtSW9ANevX2fy5MlUqVKFbt26sXHjxgyHfZQvX55FixYRFBSE1WrlhRde4I8//nDlS8gcRSH+ww9Jtk0xNq5bh+/06W4OSgghhMifJAEocsxpAnClSre9n6cmAOG/xGUJh/4y9mbbSUlJREVFaftlGbAQQriZqmrVf9bAQBKHD3d5COfPn0+3r+xthmAJkVeCg4PZsGEDjzzyiNN+q9XKihUr6NSpE02bNmXGjBlER0c73adWrVrMmzcPHx8fTCYTTz/9NIcPH3Zh9Jmk13Prm28wV68OgN/HH+O1b5+bgxJCCCHyH0kAihxzSgBmoQKwcOHCeRZTVtkTl4X//Vdr5h4cHKwNKjly5Ih234sXL7o+QCGEEBrDpk0Y9u4FIPHll1ELFXLp8yckJHDjxo10+6UCULiDj48Pc+fOpXHjxtq+UqVKERAQAMC5c+d47733qFu3Lq+99ppTkq9p06Z8//336PV64uLi6N27d4bJbbfz9+fWDz+g+vqimM0EPvccim31iRBCCCEyRxKAIsf0tgEgVn9/VFs/mYzEpXmjVsjFH9juxJ649Lp8maJFigBw48YNWrVqBcCaNWvQ6/WAVAAKIYRbqSp+X34JgLVwYZJs/cFc6Zzt9x78N9HeaDRSxPb7QwhXCwgIYOnSpbRt2xaAy5cvExgYyKhRo7SWJomJicyfP582bdrQsWNHlixZQlJSEh06dODzzz8HIDIykl69ehEREeG213I7lho1iBs/HgD9xYv4ffSRmyMSQggh8hdJAIocs1cAWitVAkW57f3SVgB60gclx6XLJUNCAIiIiOCpp54CUnvq2BOWUgEohBDuY9i5E4Nt+V/ic8+h2qqcXMlxArA9AVi6dGmUO/wOFCKv+fn58dNPP/HMM88AcOXKFb788kuaN2/O0qVL6dGjBwaDAYB9+/bx0ksv0aBBA77++mu6devGu+++C8CFCxd46qmn0r1v8wTJ/fphatMGAJ9Zs/DavdvNEQkhhBD5hyQARY7pL1wA7tz/D9InAIsWLZpXIWWZ49LlEraJelevXqVt27ZaotJisQBw6dIl1wcohBACAF979V9gIEmDB7slhjNnzmjb9urwcuXKuSUWIRwZDAYmTZrEnDlz8PPzw2q1Mn36dF577TWaN2/Ovn37ePvtt7Xl6pGRkXz44Yc0atQInU7HoEGDADh27BhPP/00SUlJ7nw56SkKcZMmYfX3R1FVAkaMANsUbiGEEELcmSQARc6oKvp//wXAUr78He+aNgHoUUuAK1RAtVVulNCl/rWIiIjA29ub/v37A2j9nqQCUAgh3MNr/368t28HIGnQINTgYLfE8c8//2jbycnJQOpUVSE8Rb9+/Th06BBtbNVy4eHhDB8+nCeeeIJChQqxY8cOZs+eTd26dQGIiopi7NixrFixQtu3c+dOXnjhBe0LUE9hLVOGhPfeA8DrzBl8Zs50c0RCCCFE/iAJQJEjSmQkSkICkJpEu5Nbt2453Q4MDMyrsLLOxwdrmTIAlE5JAeDatWtYrVZGjBiBt7e3dtfw8HCsVqtbwhRCiHuZ75QpAKg+PiS6ofef3YkTJ7Rt++82mQAsPE2VKlVYv3493377LRVs79HOnTvH66+/Tv369dm1axfTp09n/vz51KtXD0hteXL48GF8bKsh1qxZwxtvvIGqqu56GRlKevZZzLbehn6TJqFERbk5IiGEEMLzSQJQ5Ii9+g/Aeofqh6SkpHTLSDwqAch/y4BL2T7MpaSkcOPGDUqXLs1LL72k3c9kMhEZGemWGIUQ4l6lO3sW49q1ACT174/qpjYSqqoSFhbmdBtkCbDwTIqi0L17d3bu3MkXX3xBZdt7ndjYWL799lsefvhhpk6dytChQ5k1axa1a9cGcHrPNnfuXD755BO3xH9bej3x48YBoIuNxW/iRDcHJIQQQng+L3cHIPI3xwTgnZYAx8TEpNsXFBSUJzFll6ViRdi2jdK2pb6Qugy4atWqjB07lgULFnDt2jUAvvvuO9555x10OsmhCyHuLfaed65+vO+PPwKg6nSYXn451+LI6nkiIyNJsFW+K4qiJQArVqyY45gyis/dsnudXMUT4soP10iv1/Pss88yYMAAtm/fzvfff8/GjRuxWq3s3r2b3bt3ExwcTK9evejatSuzZs3i8uXL2jm++OILfH19GTVqVI7icPxvTlmbN8f02GN4r16Nz08/YXrxRaxVq+Y4PiGEEKKgkgSgyBGdLQGo6vVYbQ2lM5JRAjDADZMb78ReAVjaoVfh1atXgdRqxWnTpvHkk08C8NVXX7Flyxa6du1KmzZtqF27tiQDhRD3hNDQ0Gw/Vq/XZ+/xMTGwYAEASpcuBN9/f7ZjSCurX0YdO3ZM2w4ODiY6OhqAunXr5ujaOMr2dcpDnvalHXjedcov16h79+50796dixcv8uOPPzJz5kwuXrxITEwM33//PQBNmjThwQcfZMOGDcTHxwMwbtw4rly5wvfff5+j9zy5ep0mT4Z161AsFoKnTIH587N1Gk/7WRJCCCHygiQARY7YJwBby5YFr9v/OKVNAOp0OoxGY16GlmWW6tUBKOmwLyIiQtvu0KGD0/2PHTvGsWPHGD9+PEWKFKFVq1YMGjSIRo0auSJcIYRwi5s3b2b5MUFBQej1eiwWS7qBUJlhnDYNv7g4AG4NGoQ5GzGkpdfrCQoKIjY2NktDDvbv369tBwUFER0djZ+fH15eXtm6No5yep3yQnavU17ytOuUX69RQEAAr776Ki+//DJbt27lp59+Yv369VgsFvbs2cOePXsICQmhRo0anDx5EoAff/yRnTt3snDhwiwPvsmT61SoEH59+2KcOxd14UJiX34Z6333ZfrhOflZkoShEEKI/EYSgCJHMjsB2F4hYWcwGPIqpGwz294wFgN0ioJVVbUKQAAfHx+KFi1KZGQkTZo0ITk5mUOHDgGp0/OWLFnCkiVLeOKJJ5gwYQKFCxd2x8sQQog8ldMP7ll+vMWC0VaVZK5Vi+QHH4RcTLJYLJYsxXTq1Clt2z4gqly5crk+HMpTEkl2Wb1OruJJMeXna9S6dWtat27N1atXWbhwIfPnz+fff/8lOjqa6OhogoODtS9zT548ycMPP8wXX3xBjx49shVPbl6n+Ndew/vnn1FSUvCZOJFb2ZwK7In/74QQQojcJGsWRY7oMpkATPutqqdV/wGoxYphLVQIPVDMNv3OsQIQ/pvyGBoayubNmzl69CjTpk2jV69e+Pr6ArB8+XI6dOjA2bNnXRq/EEIURN4bN2pfNiU+9xwoilvjcZwAbDKZAJkALAqOEiVKMGLECPbs2cP8+fOpZZu0m3YlR0JCAi+88AKvvvoqycnJ7ghVYy1XjqR+/QAwrlyJ3mGZvhBCCCH+IwlAkX1JSeiuXAHuPAEY0lcA+tgSbB5FUbQqwJK23jZpE4BlypQBIDw8HIDixYvTs2dPvvnmG/bv3699E37hwgW6devGxYsXXRW9EEIUSD626j9rkSIkd+/u5micKwDtSRGZACwKGp1OR/v27dm6dSszZsygRIkSGd5v4cKFdO/encjISBdH6CxxxAhUW0Wu79dfuzUWIYQQwlNJAlBkmz48HMU2/fBuFYBpvzn29/fPs7hywlKjBgClbFUdt0sAhoWFaZMf7YoUKcL06dMZM2YMkDpApHfv3lrzbCGEEFmjO3sW799/ByDp6afBzV8emc1mrti++AJJAIqCT6fT0aNHD/7880+effbZDO+zZ88eOnTowPnz510bnANrqVIk9+wJgHH5cnTyBawQQgiRjiQARbbpbANAACwVKtzxvmkTgJ42AdjOYqsALJWSAuDUAxDQGl7funUrw2bviqLwyiuv8MYbbwCplSKjR4/Oy5CFEKLA8pk3DwBVUUjq39/N0aR++WPvE+bYy1YSgKKgCwoK4rPPPmP+/PmEhISkOx4WFkaXLl04c+aM64OzSXzpJQAUiwXfb791WxxCCCGEp5IEoMg2e08muPsS4LQJwKCgoDyJKafsS4BL225fvXrVqSl0BYdE5wWHBGhab7zxBu3btwdSl8esWrUqt0MVQoiCLTkZn4ULAUhp1QqrByTZHHu7Fi1aVNuWBKC4V9iXBdetWzfdsatXr9KlSxe3VQJaqlUjuUMHAHzmzkVJ035GCCGEuNdJAlBkmz0BaA0ORs3g22BHaXsABgcH51FUOWNfAmxPZ6Zd7pXZBKCiKHz11VcUL14cgLfffpu4uLjcDlcIIQos73Xr0F2/DkDSgAFujiaVYwLQcdK7JADFvaRs2bKsWLGCli1bpjsWGRlJr1693NYTMPHllwFQEhLwmTXLLTEIIYQQnkoSgCLb7BOA71b9B+mnAIeGhuZJTDmlBgVhKV8ex1f0r0OlY9myZdHr9QB3/Ya7cOHCjBs3Dkj9VnzixIm5Hq8QQhRUPnPnAmAtVgyTraLa3U6fPq1t24dZBQUFZbgkUoiCLCAggAULFtCtW7d0xy5cuEDfvn1JTEx0eVzmBx4gpVEjAHxmzwaz2eUxCCGEEJ5KEoAi2+wVgHcbAALpKwAdKyc8jblePacEYFhYmLZtMBi0QSB3qgC069Kli/YN+cyZM52SiUIIITKmO38e7x07AEjq2xcc+u2507Fjx7Rte3sIqf4T9yqDwcD06dPpYFt26+jgwYO89dZbrg9KUUgcOhQA/eXLeK9f7/oYhBBCCA8lCUCRPaqqDQG52wAQSF8B6Ng7ydOY69enDKDYbqdN2tmXAWcmAagoCh9//DE6nY6UlBQ+/fTTXI1VCCEKIvvwD8Ajhn/YOS4BvnXrFiAJQHFv8/LyYubMmTRt2lTbp9OlfrxYsGAB8+fPd3lMps6dsdreZ/r8+KPLn18IIYTwVJIAFNmi3LiBLj4eyNwS4HxVAXj//XgDpWy3HSsAIWsJQIDq1avTs2dPAJYsWcLJkydzJ1AhhCiIUlK04R+mli0z9TvGFWJiYpx+l9l7nEkCUNzrvL29WbRokfb+yGq1au1S3nrrLU6dOuXagIxG7YsD799/R+/q5xdCCCE8lCQARbY4TgC+2xJgq9WargIwMDAwT+LKDeZ69YD/BoHcrgLw6tWrme5v88Ybb2AwGFBVlUmTJuVWqEIIUeAYfvsNnS25ltSvn5uj+Y9jEiMkJERLBpYtW9ZNEQnhOXx9fVm5ciX+/v7Af0vkk5KSePXVV7XbrpL0zDOotkpEGQYihBBCpJIEoMgWXRYSgLdu3UJVVad9npwAVAMDMVepoiUAL1686HTccRJwZnv6lS9fnj59+gCwatWqTFcPCiHEvcZn0SIgdcK8KYPeYu7iOACkVKlS2nZ5D6lQFMLdSpYsydKlS1EUxWn/33//zYwZM1wai7V0aUwdOwJgXLQI4uJc+vxCCCGEJ5IEoMgWvS2Bpep0WG1DMW4nJiYm3b6AgIC8CCvXmO+/36kC0DGB6ZgAzEoi76WXXkJRFKxWK9OnT8+dQIUQogBRoqPx3rABgORu3cA2adcTOCYAixcvrm1XyEQfXCHuFY0aNcpw+MeECRM4d+6cS2NJGjgQAN2tWxh//dWlzy2EEEJ4IkkAimyxLwG2lilz1+mMafv/gWdXAAKYGzWigm07Pj6eqKgo7Vh2E4CVK1emc+fOACxcuJDr16/nPFAhhChAvFeuRElOBiC5Vy83R+PMcQKw0WgEUgc9SQWgEM5GjBhBo0aNnPYlJyczZswYl8aR0qyZNqjOZ8EClz63EEII4YkkASiyxb4E+G7LfyH9BGDw/ARgStOmVHa4febMGW07ICBAm2J8/vz5LJ132LBhACQmJvKjTKYTQggnPj//DIClYkXMjRu7ORpnjgOc7P3MSpYsiY8HVSkK4QkURWH+/PlaP0C7tWvXsmnTJtcFotOR1Ls3AIa9e9E7VPEKIYQQ9yJJAIps0SoAszEBGCAoKCi3Q8pVlho1qBIcrN1OO8HOXgWY1eUsDRs25MEHHwRgzpw5pKSk5CxQIYQoIHTnzmHYuxeApKeegjR9xNwpKSmJq1evarftX2xVrFjRXSEJ4dEKFSrEtGnT0u1/7bXXXPreJ7l3b1TbvyVGqQIUQghxj5MEYBbExMQwc+ZMnn/+eZ588kn69evHmDFj2L17d7bOZ7FYOHToEL/88gsTJ07kueeeo0uXLnTp0oUFnvwmxWRCd+kSkLkKwLQ9AHU6nbZ8ymPpdBRv2hR7XcfpNN8aV61aFXCuDMyswYMHAxAREcG6detyFKYQQhQUPkuWaNvJTz7pxkjSO3v2rNYL1tfXl8uXLwPS/0+IO+nUqRNt2rRx2nf8+HF+tlX6uoK1dGlSWrUCbAOG5ItXIYQQ9zBJAGZSWFgYw4YNY8WKFVy5cgW9Xk98fDwHDx5k/PjxfP/991k+Z1RUFO+99x5z5szhzz//dKou8GS68HAUqxXIXgIwvyyXsjz0EFVs26cOH3Y6Zk8AhoeHE5fFyXKdOnXSlhDPmjUrx3EKIUS+Z7ViXLwYSG3BkJnqcldyrAKvWLEi4eHh2rYQ4va++eYbfH19nfZNmjQJk8nkshiS+vYFQBcZifeWLS57XiGEEMLTSAIwE1JSUvj444+JiYmhfPnyTJkyhUWLFrFo0SL69++PoiisWrWKzZs3Z/ncvr6+1KpVi65duzJy5EhKliyZB68gd9mX/wJYM1H9kDYB6Ofnl9sh5YmUhx6iqm37dJoEYLVq1bTts2fPZum83t7ePP300wD88ccf6ZYXCyHEvcZr9270YWGAbfmvh3GsAq9QoYJWDSgVgELcWeHChfnkk0+c9l28eNGlK11MHTpgDQ0FZBmwEEKIe5skADNhw4YNXL16FaPRyJgxY7Rv/I1GI7169aJjx44AzJs3D7PZnOnzFi1alJ9//pkJEyYwePBgWrZsmS+q4xwTgJmpAEzbAzC/JAAttWtT1bZU+dSlS9oHPvivAhDSLw/OjAEDBqDTpf71mz17ds4CFUKIfM7HVv2n+vhg6tLFzdGkd/z4cW071JZIAKkAFCIz+vTpQ/Xq1Z32ffHFFyQlJbkmAKNRayvgvXEjyrVrrnleIYQQwsNIAjATtm3bBkDz5s21pZuOevTogaIo3LhxgyNHjmT6vDqdDsWDmpxnln0CsDUwENXhg9DtpJ0CHOwwXMOj6fVUrFkTgASzmcu2JV8A5cqV0/oYZqeCr3Tp0nTo0AGARYsWkZCQkAsBCyFEPpScjPfq1QCYOnZE9cAp8Y4JQPuXNyAJQCEyQ1EUvvnmG6d9V65cYbEt8e8KSX36pMZisWD89VeXPa8QQgjhSSQBeBeJiYlahVeDBg0yvE/RokUpU6YMAIcOHXJZbO6iv3ABAGu5cpma0njz5k2n2yEhIXkQVd6o2KKFtn3C9gEVQK/XU7lyZSB7CUBIrQKE1ATp2rVrcxClEELkX97btqGztYpI7t7dzdGkZ7FYuHjxonbb3rusSJEiBHpgslIIT1SvXj169uzptG/atGlYbT2l85qldm3MNWoAYFy61CXPKYQQQngaSQDeRXh4uLb0s/wdlrvajzl+SCio7EuALZnsfZQ2AVioUKHcDinPVHHoRXXMIQEIOZsEDNCyZUut56NHT30WQog85L18OQDWoCBMtmmdnuTff//V2nt4e3sTFRUFSP8/IbLqo48+wtvbW7t99uxZ1q9f75onVxRtGbDhwAF0WezfLIQQQhQEXu4OwNPduHFD275T4sp+LG2yy1XmzZt3xyRSnz596GubgpYjqqotATZUq+bUC+l20g4BKVOmjPY4+xLo4OBgpx57niK0cWPKeXsTZjJx5O+/nV5vnTp1WLFiBefOnSMwMBAvr6z/dXr22WeZMGECv//+Ozdv3qRSpUrZjtXTr6WdffmcTqfL1M+PO8i1zF355XoKN0hIwLhuHQCmzp3B1lrBkzj2eS1Xrhznz58HZPmvEFlVrFgxRo4c6TQUZMqUKXTq1Mklz5/cvTv+H38MgM/SpST8738ueV4hhBDCU0gC8C4cGxQb7/DBxH4sMTExz2PKSHx8PNfu0NQ4ISEBvV6f8ye6cQNsPf10VapAJs55/fp1p9vFihVLF4tjTyVPU7dCBcJOneJQVBT6y5ehbFkAateuDaROiT537hz33Xdfls89ePBgJkyYAMDcuXMZO3ZsjuP15GvpSFGU3PmZzENyLXNXfrmewnW8N21CsfVATX7iCTdHkzHHBGDNmjVZZ0tYSgWgEFn3v//9j6lTpxIfHw/A/v372bt3L40bN87z57aWLUtK06YYdu3CuHQpCW++mefPKYQQQngSSQAWEP7+/hQrVuy2x/38/LBYLDl/otOnsacZLOXLw13OaTab000BDgoK0mJRFAWdTofVavXYyqC6LVuy+tQpjgGmn39GP3IkALVq1dLuc+DAAapVq5blc1eoUIEWLVqwfft2Zs+ezbvvvpvtRE5+uJbw3/AbVVVd1vsnq+Ra5i5Pu575IVl6rzDal/8WLkxKs2ZujiZjJ06c0LbLlClDSkoKIBWAQmRHSEgIr7/+Oh9++KG2b9q0acyaNcslz5/05JMYdu1Cf+ECXn//De3aueR5hRBCCE8gCcC78PHx0baTk5Px8/PL8H7JyckA+Pr6uiSutPr370///v1vezwqKipXlid7HzlCkG07pkgRrHc5p71XkiODwaDFotfrCQ0NJSYmJncSlHmgTqtW8N13mIDjP/1EmYEDgdThL76+viQmJrJ7927at2+frfP36tWL7du3c/HiRX799Vdat26drfPkh2sJEBoail6vx2q1um3J/N3ItcxdnnY9ixQp4u4QBKDcuoX35s0AJHfpAtloo+AKhw8f1rYd3wNIAlCI7Bk6dChTp07V2uysWbOG69evU7hw4Tx/blOXLqijR6OYTBiXLJEEoBBCiHuKrMe6C8e+f479ANOyH/PkPly5wT4ARFUUrLbJx3eSUVIiP00BBqhbt662fezoUXRXrgCpSQ37st+jR49m+/yPPfaYNklShoEIIe4V3uvWodi+PEvu1s29wdyG1Wrl3Llz2m17P0uQJcBCZJefnx+jRo3SbquqyrRp01zy3GpICCZb0s+4YgXYKnqFEEKIe4EkAO+iTJky2hv+sLCw297PfqysrT9cQWVPAFpLlcpUs/aMEoBBQUEZ3NNzValShaCAAAB2A94rV2rH7H0Ac5IA9PPzo3v37gCsW7fujolmIYQoKOzLfy0lSmB+8EE3R5Oxf//9F5PJBICXl5c21CowMNAl1UpCFFT9+/d3+tJ85syZLmtlkdyjBwC669dh40aXPKcQQgjhCSQBeBe+vr5UrVoVSG1UnJGoqCguXrwIQL169VwWmzvYJwBby5fP1P0zSgAGBwfnakx5Ta/X8+BDDwGwEzAuXaodsycAIyMjiYiIyPZz2Cc0m0wmlixZkv1ghRAeLyYmhpkzZ/L888/z5JNP0q9fP8aMGcPu3buzdb6IiAi6dOly1z9//vlnLr+S7FNu3MCwbRsApm7dwEMHxJw8eVLbrlChglYNWKVKFadqQCFE1vj5+TFs2DDtdnx8PAsXLnTJc5vatcNq+zJacdFzCiGEEJ7AM99xe5iWLVsCsGPHDiIjI9MdX7ZsGaqqUqhQIerUqePi6FzLXgFoyWQCMKNqtvyWAAR4yJYAPAQkHzyI/p9/gP8SgACHDh3K9vnr16+vLSdesGCBRwxKEELkvrCwMIYNG8aKFSu4cuUKer2e+Ph4Dh48yPjx4/n+++9zdP6goCBCQkIy/OPt7Z1LryLnvNesQTGbAc+d/gtw/Phxbbtu3bqcOXMGSE0ACiFyZuDAgQTYVlgATJo0yTVP7OOD6bHHAFBWrgTbRGIhhBCioJMEYCY8+uijlChRgqSkJD766CPOnz8PpA7+WLp0KWvWrAFSlzN4pWliPmTIELp06cLkyZMzPHd8fDyxsbHaH/vyh+TkZKf99iEjbpWSgi48HMh8ArAgVADCfwlAC7AXMC5aBKQmAA0GAwD79u3L9vkVRdGqAI8fP87BgwdzEq4QwgOlpKTw8ccfExMTQ/ny5ZkyZQqLFi1i0aJF9O/fH0VRWLVqFZttgzGy4/PPP+enn37K8E/jxo1z8dXkjPHXX4HU3yXm+vXdG8wdOLZ3qFmzptbuo3Llyu4KSYgCIzAwkBdeeEG7HR4enqMvU7PC/sWDkpAAq1e75DmFEEIId5MEYCYYDAbeffddgoODuXDhAsOHD6d379489dRT/PTTT6iqymOPPUbbtm2zfO5x48ZpE3z79+/Pv7YKu+XLlzvt/+WXX3L7ZWWZ7tIlFNsET2smm5+nrQBUFAV/f//cDi3PPfDAA9pyrz8gdXKcxYKvr682JGTv3r05eo6ePXtqFTrz58/P0bmEEJ5nw4YNXL16FaPRyJgxY7QpskajkV69etGxY0cA5s2bh9lWHVcQKRERGP74A7AN//DgpbRHjhzRtgsVKqR9SScVgELkjqFDhzpVJ7/zzjsued6URx7BWrQoauXK4AHT6YUQQghXkARgJpUrV46pU6fStWtXSpYsSUpKCv7+/tSrV4+3336b5557zt0h5jn78l/IfgWgv79/vuybFBQURMOGDQHYAOivXsWwfTuAVlWzf//+HH1oL1y4sJYA+OWXX4iXJSlCFCjbbD3vmjdvTtGiRdMd79GjB4qicOPGDafEU0FjXLUKxV7t7sHLf00mk9bfF0Dn0KdQEoBC5I5ChQrRr18/7fZff/2VYbudXOflRfTmzVhPngTbCgwhhBCioPO6+12EXUhICIMHD2bw4MGZfswPP/xwx+Pjx4/PaVguo8tGAjBtBaBjr5f8pn379uzbt49dwE3Ad9EiUlq3pkmTJsyYMYOEhASOHTuWo0Ew/fv3Z8WKFcTFxbFy5Ur69OmTa/ELIdwnMTGR06dPA9CgQYMM71O0aFHKlCnDxYsXOXToEPU9eGlsTtin/5qrVcNSs6abo7m9M2fOaBV/AQEBREVFAamV7JUqVXJnaEIUKM8//zyzZs3Sbk+YMIEvvvgiz5/XWqqUR1cgCyGEELlNKgBFpukvXABA9fNDLVIkU4+Jjo52up0f+//ZdejQAQArsAkwrl2LEhvr1Fdr165dOXqO5s2bU7ZsWUCWAQtRkISHh2vDfcrf4QsU+zHHyrOs+PTTT+nTpw/du3dn4MCBTJgwIcftCXJVWBiGPXsAW/WfB3/4dpwAXK1aNW0ASJkyZfD19XVXWEIUOJUrV6ZVq1ba7UWLFskqCCGEECIPSAWgyDRtAnCFCpn+0JZ2CXBoaGhuh+UyDzzwACEhIURHR7MK6JWUhHHZMko8+yxVq1bl9OnTbNmyxamhdVbpdDr69u3LxIkT+euvvzh9+jRVq1bNvRchhHALx2roQoUK3fZ+9mMZDVDKjNOnT+Pn54dOp+P69evs2rWLXbt28fDDDzNy5EhtaNGdzJs3jwULFtz2eJ8+fbShRZllXz6rW7pU2+czYAA+bvydYG9HERwcnOHk9XPnzmnbTZs25e+//wagRo0aefa7TLtOOp3H/L6823VyB0+7TnKNMudO1+mdd97ht99+A1KX3y9evJiRI0fmeUyeeJ2EEEKIvCIJQJFp9iXAmV3+C+mXABcuXDhXY3IlvV5P+/btWbx4Mb8qCgmqinH+fJKefZa2bdty+vRpdu3aRXx8fI4GnfTp04dPP/0UVVVZsGAB77//fi6+CiGEOyQlJWnbRqPxtvezH0tMTMz0ub29venUqRPNmjWjYsWK+Pn5ARAWFsYvv/zCb7/9xp9//om/vz/Dhg276/ni4+O5du3abY8nJCSg1+szHZ8jxTZBnfr10XvI8l/H3n6O7Ak/gPvvv5+FCxcCcN9992X79WeWoih5/hxZdbvr5E6edp3kGmVORtepdevWVKxYkfPnzwMwceJERowYgZeXaz6qeOJ1EkIIIXKbJABFptkrAK1ZSAAWpApASJ3Uu3jxYuJUlV+BvgcPoj96lDZt2jB9+nSSk5P5888/ad++fbafo3Tp0rRu3ZotW7awaNEiRo8e7TQhTwghHIWGhmZYeVyuXDlGjBhBUFAQK1asYNOmTXTr1o0yZcrc8Xz+/v4UK1bstsf9/PywZHFqpk6nQzlzBmxJNWuvXqhunrypKAo6nQ6r1Zph1ZbjIJbSpUtrX2hVrVo1y68/s3Q6HYqioKqq1n/Q3e52ndzB066TXKPMudt1eueddxgyZAgA169fZ9myZfTo0SNPY8rJdZKEoRBCiPxGEoAiU5ToaHS2fn6ZrQBMSEhwqnqB/N0DEKBZs2aUKFGCq1evMgfoC/jMn8+DH3yAn58fCQkJrF27NkcJQIB+/fqxZcsWIiMj2bhxI4899liuxC+EcA8fHx9tOzk5WavSSys5ORkgV3vM9evXj3Xr1mEymdi7d+9dE4D9+/enf//+tz0eFRWV5SXKoaGh6O3Vf0B0+/ZYs7nMObfo9XpCQ0OJiYlJl9CLi4sjIiJCu52QkKBtlypVKttLtO8mNDQUvV6P1WrNs+fIqjtdJ3fxtOsk1yhz7nadOnTogNFo1P4d/Oyzz2jdunWexpST61Qkk/2whRBCCE/heWsVhEfKzgTgjN5IBQUF5VpM7qDX6+nZsycAG4EjgHHpUoyqyqOPPgrAypUrs7R8LyOPPvqo9sZy3rx5OTqXEML9HPv+pW2N4Mh+LDerpX18fChXrhyAU1LL5X7+GYCUxo2x2uLxVI4DQIoVK0Z4eLh2u0qVKu4ISYgCz2g0On3huW/fPg4dOuTGiIQQQoiCRRKAIlP0DglAa4UKmXpMVFRUun35vQIQYMiQIVoj/c8AXXQ03uvW8dRTTwFw69YtVq9enaPn8Pb21s63detWwsLCcnQ+IYR7lSlTRmuAf6e/z/Zj9mngBcbRo3DsGADJ3bq5N5ZMOHr0qLZdp04dbQKwn58fJUuWdFdYQhR4b731ltPtH374wU2RCCGEEAWPJABFpjgmAC2Z/GAaGRmZbl9ISEhuheQ2pUqV0nrSLCC1CtBn3jxatmxJ6dKlAfj6669z3Afo6aefBkBVVWbPnp2jcwkh3MvX11eb6L1///4M7xMVFcXFixcBqFevXq49d1JSkpZYLF68eK6dNyvswz9URSG5Sxe3xJAVBw4c0LabNGnCiRMnAKhevbqWyBVC5L4KFSpQweGL5qVLl2b4flIIIYQQWScJQJEp2gTgkiXBoZfVnWRUAZjfh4DYjRgxAm9vbyzAcMCwYweG8HBeeuklAI4fP87SpUtz9ByVK1emZcuWAMyfPz9dP0UhRP5i//u8Y8eODD/QLlu2DFVVKVSoEHXq1Mn0ee/2ZcPChQsxmUwoikLjxo2zFHNuUQcMgA8/RB00CLVECbfEkBX79u3TtuvVq8c///wDpCYAhRB56/nnn9e2zWYzP/30kxujEUIIIQoOSQCKTMnOBOCCnACsVKmS9gb1N2Aa4LNgAf3799eqAN99913Onz+fo+cZPHgwkNoXbMWKFTk6lxDCvR599FFKlChBUlISH330kfbvQ3JyMkuXLmXNmjVA6hAOLy/nGV1DhgyhS5cuTJ48Od153377bRYvXsz58+edGuuHhYUxZcoUli9fDkC7du3uOgAkz1StCmPGoH77rXuePwvMZjPnzp3TbleqVEnrAVijRg13hSXEPWPgwIFO/wb++OOPmEwmN0YkhBBCFAySABSZor9wAcj8ABAo2AlAgJEjR1KpUiUARgEHfvoJP6ORzz77DEhN2nXr1o0tW7Zkezlwu3bttF5gP/74Y67ELYRwD4PBwLvvvktwcDAXLlxg+PDh9O7dm6eeeoqffvoJVVV57LHHaNu2bZbOGxkZybx58xg+fDhPPvkk/fr1o2fPngwbNowtW7YA0KJFC6eqGnF7Z8+exWw2A6l9ax2HtkgCUIi8p9freeSRR7Tb165dy3FvZSGEEEJIAlBkhtmMztaXypLJASCQcQ9Ax0mY+V1AQADfffcdBr2eZKBrVBTn582jXbt2vPPOOwBcvnyZ3r1707p1a+bOnUtCQkKWnkOv1/PMM88AqX3DDh48mMuvQgjhSuXKlWPq1Kl07dqVkiVLkpKSgr+/P/Xq1ePtt9/mueeey/I5n332WR599FEqVapEUFCQNoW8ZMmStGrVio8//phRo0Zpw4vEnTkOAKldu7bTRGBJAArhGmmHgUgvZCGEECLnvO5+F3Gv04WHo9iWlWV2AjCkrwDU6XQEBgbmZmhuV69ePb6ePJnnX3mF68Bjb7/Ngvvv57XXXqNEiRK88847xMbGcvToUUaOHMmHH37Ie++9x4ABAzLdSL5fv358+umnmEwmZs6cydSpU/P2RQkh8lRISAiDBw/Wlvhnxp0mYT7yyCNO1TIiZxwHgDzwwANaAjAwMJBSpUq5Kywh7ikNGzYkJCSE6OhoAHbt2sXJkyclCS+EEELkgFQAiruyL/+FrFUApk0ABgcHF8jpid1792bSAw8AcM1kolvXrmzatInevXtz8OBBPvzwQ22iXUxMDK+//jrvvfdeppcFFylShG7dugHw66+/Oi1HE0IIkbv27Nmjbd9///1aAlAmAAvhWl27dnW6PWfOHDdFIoQQQhQMkgAUd+WUAMxCD8C0S4ALUv+/tAaNH8+PgB6Ii4+nX79+fPnllwQEBPDSSy/x119/sWDBAsrbrt+3337Ld999l/nzDxoEQFJSEgsWLMiDVyCEEEJVVU6dOqXdrlu3rkwAFsJNhg0b5nR70aJFxMfHuykaIYQQIv+TBKC4K519ArC/P2qRIpl6jKqq6SoACxcunOuxeQpL3bo8Xbcuq4BgnQ5VVRk/fjyDBg0iLi4OnU5Hu3btWLNmDRUrVgTggw8+cOotdScNGjTg/vvvB2DWrFlOkz6FEELkjsuXL2sJBj8/P/z9/bly5Qog/f+EcLUKFSo4TS6/desWv/76q/sCEkIIIfI5SQCKu9KfPw/Y+v9lcvlTbGwsKSkpTvsKcgIQIKlfPzoCe61WapQrB8Dq1avp2LEjZ8+eBaB48eLMmjULg8GA2WzmnXfeydRSYEVRtH5hYWFhbN68Oc9ehxBC3KscB4DUqFHDqRpQEoBCuN7TTz/tdFuGgQghhBDZJwlAcVf2JcA56f8HBXsJMEByjx6oPj5UBXY0aULnzp0BOHnyJG3btmX16tUA1KpVixdeeAGAHTt2sGnTpkydv1u3btoU5TsNBBBCCJE9jpPWHQeAgCQAhXCHPn36ON0+ePCg099TIYQQQmSeJADFnamqtgQ4KwnAtP3/AC15VVCpwcEkP/44AEXWrmXWV1/x9ttvo9PpiIuLY+DAgXz44YeYzWZGjhypVUROmTLl7udWVafpd9u2beONN95g9+7dWK3WvHtRQghxD/njjz+07SZNmnD8+HEgdXJz8eLF3RWWEPeskiVLUrNmTad9MgxECCGEyB5JAIo7Uq5fRxcXB9iWAGdSRhWAISEhuRSV50ru1w8AJSEBnxUrGDFiBIsXL9aSfV9//TXdu3cnPj6eoUOHAqkTJ//666+Mz5eczMKFC2nVqhXt2rVj586d2rHZs2fz+OOP065dO3bv3p3Hr0wIIQo2VVWdlgA3bNiQI0eOAFC7dm2ZACyEmwwYMMDp9rJly4iNjXVTNEIIIUT+JQlAcUdOE4BzmAAs6BWAACkPPYTFNuTD98cfQVVp0aIFW7ZsoVGjRgDs2rWL5s2b4+/vj6+vLwAzZ850Ok9ERASTJk2ifv36vPrqqxw7dkw7Zn+M3eHDh+natStffPFFpvoJCiGESO/SpUvE2b7wCg4Opnjx4tq/vXXq1HFnaELc07p06eKUgE9ISGDx4sVujEgIIYTInyQBKO7IKQFYvnymH3cv9gAEQFFIHDQIAK+jR/GyVeaVLl2aFStWMGTIEABu3LjBe++9h06X+ldw1apV/Prrr8yaNYtnn32W+vXrM3HiRG0pdfny5fn44485fvw48+bN056uU6dO+Pv7Y7Va+fjjj3n11VdlSbAQQmTD/v37te26dety/vx5bSJw7dq13RWWEPe8okWL0rRpU6d9c+bMkS89hRBCiCySBKC4I3v/P1Wvx1qmTKYfd+3atXT77oUKQIDkvn1R/fwA8P3+e22/t7c3EyZM4Oeff6ZSpUoA2odLs9nM0KFDefPNN1mzZo02QfmBBx5g1qxZ/PXXXzz//PMULVqUZs2aUbVqVQDOnj3L5s2bqVy5MpC6xPjdd9912WsVQoiCYteuXdp2y5YtnZYDSwWgEO7Vs2dPp9snT568bfsUIYQQQmRMEoDijvTnzwNgLVsWDIZMP+7q1avp9tn74BV0alAQSU89BYD32rXoLl1yOt6mTRt27NjBlClTtGXBjkqVKsWzzz7L1q1bWb16NY899hh6vV47rigKgwcPBuCff/7h6tWrrFq1ilq1agEwY8YMZsyYkVcvTwghCiTHHquNGzfW+v8ZjUaqVKnirrCEEEDnzp2d3guBDAMRQgghskoSgOKO7EuAs9L/DzJOABYpUiQXIsofkmxLfRWLBZ9Zs9IdNxqN9O3bl3Xr1jFmzBht/88//8zBgwf57LPP7lhx8tRTTxEQEADADz/8QNGiRVm6dCkVbP+fxowZw5YtW3LxFQkhRMFlsVg4ffo0kPolS7169bQE4H333YchC1+ACSFyX2hoKK1bt3bat3LlSq5fv+6miIQQQoj8RxKA4o509gRgFvr/QfoEoKIo90YPQBtLtWqYWrYEwGfuXEhMvO19+/Xrp3243LhxY6YmTQYEBPCUrcpw3bp1hIeHU7x4cdavX09wcDCqqvLiiy8SHh6e8xcjhBAF3OnTp7XWC2XKlMHPz09bAiz9/4TwDN27d3e6bTKZ+Pnnn90UjRBCCJH/SAJQ3F5CAvqICACsWagAtFgs6XoAFi5cON3SjYIucehQAHQ3buAzf/5t71eoUCHat28PwPLly0lOTs7U+e3LgK1Wq7YMpnr16kybNg2AmzdvMnjwYEwmU7ZfgxBC3AscB4A0btyYiIgI7feY9P8TwjN06NABo9HotG/OnDky/EwIIYTIJEkAitvSh4Vp21lZAhwVFYXFYnHaV6xYsdwKK99IadsW8333AeA7dSrcIbFnr+a7efMmGzduzNT5q1atSosWLQCYO3cuSUlJAHTs2JFXXnkFSP1QO2HChGy/BiGEuBc4tkxo3bq10wAQqQAUwjMEBATQrl07p33nz5/n999/d1NEQgghRP4iCUBxW/b+f5C1BOC93v9Po9ORMGIEAPrLlzEuXnzbu7Zp00YbkrJo0aJMP4W9CvD69eusWLFC2//222/z4IMPAvDNN9+we/fuLIcvhBD3Csdpog899JDW/09RFGrWrOmusIQQaTzxxBPp9s2ePdv1gQghhBD5kCQAxe0lJmIpXhzI2hLgCNuyYUf3ZAIQMHXpgrlyZQD8pkwBW4+ptLy9vbXeNlu2bCEyMjJT52/fvj1ly5YF4Pvvv9f2e3l58fXXX+Pv74+qqrzyyivExcXl5KUIIUSBFB0drf3eCgoKomzZshw4cACAKlWqaAOXhBDu17ZtW3x9fZ32rVu3LsMvn4UQQgjhTBKA4rZMTzzBzaNHifr3X9QsfACSBKADvZ7E115L3fz339SBILfRu3dvAMxmM7/88ksmT69n4MCBQOpy3z179mjHypcvzwcffADAhQsXGDt2bDZegBBCFGyO1X8NGzZEVVX+/vtvABo0aOCusIQQGfDz86NTp05O+ywWC/Pv0GtZCCGEEKkkASjuzs8vS3eXJcDOkp98EnO1agD4ffopSmxshverU6eOttQsK8uA+/Xrh4+PD5C63Bdg69atdOrUiTfeeAOdLvWv+ezZs7WqFiGEEKk2bNigbXfo0IErV65oX2Q1bNjQXWEJIW4jo2XAc+fOTdd/WgghhBDOJAEocl1GCcCiRYu6IRIP4eVFvK0ST3f9Or5ffpnh3RRF0YaBHD16lGPHjmXq9IUKFdLeDP/888+89957PPXUU+zduxdAm46nqirPPfecvEEWQggHjgMEmjVrplX/gVQACuGJWrZsSVBQkNO+S5cusXnzZjdFJIQQQuQPkgAUue7KlSvp9t3TCUBSJwKbbBN7fWfMQO8wYdJRjx490Ov1QPaGgZhMJq0KMCQkhOHDhzNo0CCtCvDChQt89NFH2X4dQghRkCQnJ3P+/HkAfH19qVKlCvv37wfAx8dHBoAI4YGMRiOdO3dOt1+GgQghhBB35uXuAIRr2JNKrnDp0qV0+4oVK5ZhDPZ9rowvJ3ISZ+Inn2Bo0QLFZCJw+HBubdoEBoPTfUqVKkXr1q3ZtGkTv/zyCx988AGGNPfJSIMGDahevTr//PMPABUqVGDFihXagJBOnTrRs2dPVFVl2rRpDBkyhPLly2f7teQWT/3/nt9+LsGzY82P11PcG/bv369VSdeuXRtFUbQEYJ06dTL1768QwvWeeOIJFi5c6LRvy5YthIWFUa5cOTdFJYQQQng2SQDeI0JDQ132XOHh4en2ValS5Y4xpF3K4Yn0en3OruODD8IHH8Dbb+N1+DChU6dCBtV4Q4YMYdOmTVy7do09e/bw2GOP3fXUV69edaq8fP3116lbt652u0ePHowaNYpJkyahqipPP/00R44cyf5ryQU5vp4ukB9+LiF/XEvIP9dT3DtWrlypbbdv3x6LxcLBgwcB6f8nhCdr1qwZhQsX5vr169o+VVWZO3cu77zzjhsjE0IIITyXJADvETdv3nTJ88TGxhKbwZALb2/vDGPQ6/UEBQURGxvrsb3pgoKC0Ov1WCyWDF9blgwZQuCSJXgdOAAff0xc9eqkpFnG0qxZM4KDg4mJieH777/n4YcfvuMprVYrvXv3doptwYIF9O3b1+l+o0ePZvbs2URFRXH06FFmz55N165dc/Z6siFXr2ceyQ8/l5A/riV43vXMD8lS4RqrVq3Stjt37szJkydJSEgApP+fEJ7My8uLxx9/PN2y3/nz5/PGG2/g7e3tnsCEEEIIDyYJwHuEqz50X7hwId2+4OBgjEbjHWOwWCwekRi4mxzHqCjEfv89Ie3aobt5E//nnyd2wQJSHJJ8BoOBJ554gtmzZ7N+/XquXLlCsWLFbnvKyZMns337dgAaNWrEvn372LlzJ4cPH6ZWrVpO9502bRq9evUCYNSoUXTq1EnrD+gOnv7/PL/8XILnX0vIX9dTFHwmk4mTJ08C4O/vT5UqVZg1a5Z2vFGjRu4KTQiRCd26dUuXAIyMjGTdunVu+YJTCCGE8HQyBETkqoz6/5UsWdINkXgua/ny3PrhB1QvL5SEBIL69MHbYRkaQP/+/YHUD6hTp0697bn27NnDJ598AkCtWrVYvHix1rPqhx9+SHf/Vq1aaUnBGzduZHgfIYS4F+zZs0dLSDds2BBFUdi1axcAZcqU0XqoCiE804MPPkjx4sXT7Z8zZ44bohFCCCE8nyQARa7KqP9fiRIl3BCJZ0tp3pxbs2ahGgwoiYkEDR5MwMsvo7NVUNarV4927doBqVPtMkqsRkZGMnjwYCwWC35+fsycOZOKFSvSpUsXAH755ZcMl11//fXX2vaECRMwmUx58AqFEMKzLVmyRNvu3r07qqpqCcCmTZu6KywhRCbp9foMK/1+//13Tp8+7YaIhBBCCM8mCUCRqzJKAEoFYMZMHToQu2gR1qJFAfBZvJjQJk0I7twZv7Fjea9+fQCSkpJ4/fXXUVVVe2xiYiKDBw/m6tWrAHz22WdUq1YNgKFDh2r3mT9/frrnrV27tra0LS4u7o4VhkIIUVD99ttv2naHDh24cOECERERgCQAhcgvnnjiiQz3f//99y6ORAghhPB80gNQ5CqpAMyalGbNuPnbb/h/+CHGpUtRVBXDnj0Y9uyhGfACMAPYvHkz46tWZXzDhkQ2asQz27axa88eAJ599lmtrx9A48aNqVevHocOHWLWrFm8+OKL6PV6p+f9/PPPadGiBQBTpkzhxRdfxM/Pz0WvWgiRn6X998TVj88NcXFxWmV18eLFKVasGJs2bdKOP/zww26P093Pb2ePw1PiScsT4pJrlDl5cZ2aNGlC2bJluXjxIjqdDqvVCsCiRYt49913szT0yVOukxBCCJFXJAEocpVUAGadWrw4cdOmkThyJMZlyzBs3YrXiRMoCQl8CvwBHAUmx8Tw89atxG7dSoLtsY/Wr8+4jz92Op+iKAwZMoRXXnmFsLAwVq9enW6JTM2aNWnSpAl79uwhMTGRL774gnfffdcVL1cIkc/lZIqyXq/3iCnMmzZt0qqqW7VqRWhoKH///TcAxYoVo3HjxiiK4rb4POU6OQoKCnJ3COl42nWSa5Q5uX2d+vTpw6effqol/wASEhJYsmQJ//vf/zJ1Dk+8TkIIIURuU1THdYWiwIqKinLJ89SqVYtr16457Zs7dy4dOnTI8P72N1w3b9702OmgoaGh6PV6LBZLhj318oTViu7SJfRhYVw+eJCnvvmGI5GRTnd5GvgO0DdqRPyYMaiPPKJdy4SEBBo2bEhERAR169Zl8+bN6T7MHjt2jJYtWwLg7e3NiRMnXPLhxS3XM4vyw88l5I9rCZ53PYsUKeLuEPK17PysBQUFaT+rsbGxeRBV1vTq1YvNmzcDsGrVKh5++GEaNGjAhQsXePzxx902RMDTrhOk/v0NCgoiNjbWI/7+guddJ7lGmZNX1+nIkSPaqgZHpUqV4sCBA9pwtIzk5DpJwlAIIUR+IxWAItfExcWlS/6BVABmi06HtWxZrGXLUvThh1k7eDCLFy/mzz//JEhR6A2027oV3c2bsG8fIV26YOrYET7/HEqUwGg08uKLL/LBBx9w+PBhtm/friX77GrVqqVVAZpMJj799FM+TlNNKIQQaeX0g7snJEjswz4MBgMPPvgg586d44JtCFPTpk09IkZPiMGRxWLxuJjAs66TXKPMye3rVLNmTerUqcORI0fw8/MjISF1ncTly5dZsWLFbfsEZhSXEEIIUZDJEBCRa86fP5/hfukBmHM+Pj4MGDCAb7/9ls9mzKDhjBncOHCA+NGjsQYEAOC9bh3UqYPfqFEo167xzDPPEBwcDKT2+cvIuHHjtO2ZM2cSmabKUAghCpoTJ04QHx8PQMOGDdHr9Wzbtk073qpVKzdFJoTIrv79+wNoyT+7b7/91h3hCCGEEB5JEoAi12SUANTr9bLcLq/4+5M4ciQ39+4lccgQVC8vsFgwzppFaJMmFP32WwYPGADAH3/8ofW3cnT//fdrE4HNZjOffPKJS1+CEEK42g8//KBtDxw4EPhvInDZsmWpXLmyW+ISQmRfjx498PHxASAwMFDb//fff7N37153hSWEEEJ4FEkAilyTUQKwZMmSMlUtj6lFihA/YQKxu3ZB9+4A6OLj8f/kE95csABfW++biRMnZvj4Dz/8UNueN29ehoNchBCioLBP+1UUhX79+mE2m9mxYwcALVu2dOvwDyFE9gQHB9OlSxcAkpKSnI5NmzbNHSEJIYQQHkcSgCLXnDt3Lt2+cuXKuSGSe5O1cmX45Rdi164lpXFjAIpfv84rKSlAaoXLHw7L3OyaNGlC/fr1U89htTJhwgSXxSyEEK5048YNrly5AkDFihXx9/dn37593Lp1CyBdr1QhRP7Rr18/AFJSUvD399f2r169mlOnTrkrLCGEEMJjSAJQ5JqMKgDLly/vhkjubZYHHyRmzRpi58zBfN99/A8Ith0b368f3osWQZpG12PGjNG2lyxZwtmzZ10XsBBCuMj06dO17Z49ewL/Lf/V6XQ0b97cLXEJIXKuadOmVKpUCXBeBgy374UshBBC3EskAShyjSQAPYiiYOrUieht2/D67jveKFQIgL0mExuHDSO4Wzd0Fy9qd3/44YepU6cOAKqqyjRgIUSBtHTpUm37hRdeAGDjxo0ANGjQgJCQEHeEJYTIBYqiMMDW+/jq1av4+vpqx3755Rf+/fdfd4UmhBBCeARJAIpccevWLa5evZpuvywBdjOdDtMTT/D03r2UCAoCYCSQvHs3IS1bYti+HUh90/z2229rD1u9ejVHjhxxR8RCCJEnrl+/rvU4rVixIsHBwfz7778cOnQIgA4dOrgzPCFELujXrx9+fn4AlC5dWttvsVj4+uuv3RWWEEII4REkAShyxcmTJzPcLwlAz+AXFMQHn34KwEXgI0AXG0tQ794YbRUxbdq0oWbNmtpjHIeDCCFEfjd58mRtu2/fvgD8+uuv2r7OnTu7OCIhRG4LCQnRlvefO3cOb29v7diCBQsy/LJaCCGEuFdIAlDkitslAGUJsOfo3r07zZo1A+ALvZ79Pj4oZjMBL72E97JlKIrC//73P+3+27dvZ8OGDe4KVwghctWyZcuA1Irn559/HoDly5cDUK1aNapUqeK22IQQuWfIkCFA6mCzGjVqaPtNJhNfffWVu8ISQggh3E4SgCJX2BOAiqJo+3x8fChevLi7QhJpKIrCp59+itFoxGyx0KdoUeKCg1FUlcCXX8awaRMdOnTQegECvPXWWyQmJroxaiGEyLmTJ09y7do1AGrWrImvry9RUVH8/vvvAHTq1Mmd4QkhclGNGjW0gT5hYWEYjUbt2Jw5cwgLC3NXaEIIIYRbSQJQ5Ap7AlBVVW1f2bJlnRKCwv2qVKnCe++9B8Cpixd59eGHUf38UMxmAocOxfDPP04DQMLDw5k6daq7whVCiFzx0UcfadvDhg0DYO3atVitVgAee+wxt8QlhMgbzz33HADR0dE0btxY228ymZg4caK7whJCCCHcShKAIlecOHEi3b6KFSu6IRJxN0OHDqVly5YAzFq7lqn9+6Pq9eji4wkaMICHa9SgY8eO2v0nT57MhQsX3BOsEELkkMVi4bfffgNSK9N79OgBwKJFiwCoUKECdevWdVt8Qojc165dO+677z4ATp8+jb+/v3Zs8eLFHD9+3F2hCSGEEG4jCUCRY9evXycyMjLd/mrVqrkhGnE3Op2Or7/+mlKlSgEw6scfWffsswDoL1wgcMgQ3n/nHby8vABISUlxmhAshBD5yY8//khKSgoAjz76KIqicOHCBXbt2gXAU089JdXqQhQwOp2O1157DYCIiAgefvhhp+Pjx493Q1RCCCGEe0kCUOTYoUOHMtxftWpVF0ciMqt48eLMnTsXPz8/zGYzPRcuZGu7dgB4//47dX/8keHDh2v337RpExs3bsz8EyQm4nXwIF579qBEROR2+EIIkWmObQzGjBkDwJIlS7R9Tz31lMtjEkLkva5du2qrUf755x9CQ0O1Yxs2bGDHjh3uCk0IIYRwC0kAihw7cOBAhvulAtCz1a1blxkzZqDX60lISKDLzp1st03L8/3xR94KDqZSpUra/d988827DgTxOniQwCFDKFy5MiHt2hHSuTOFa9cmpFUrjEuXgkOPSCGEyGu7du3iypUrQGoP1HLlyqGqKosXLwbgkUceoUKFCm6MUAiRV/R6Pa+++ioA//77L+3bt3c6Pnr0aK06WAghhLgXSAJQ5Nj+/fsB0i2hkgpAz9exY0e+++479Ho98fHxPHruHAsLFwag8Acf8PXTT2v3vXTpEl988UWG51Hi4vB/801C2rXDuGIFSpo31F5HjxL44osE9egBly/n3QsSQggH7777brrt33//XetrOmDAAHeEJYRwkV69elG2bFkA/vzzT60vIMCpU6dk0JkQQoh7iiQARY6oqqpVADpOAC5evDjBwcHuCktkQZcuXfjuu+8wGo0km0z0vX6dD729Ua1WOnz2GcO6dtXu+9VXX3H69Gmnxxu2bCHkkUfwnTULANXXl8QBA4idN4+Y5cuJHzMGS5kyQOryYt2DD8K+fa57gUKIe9I///zD4cOHAShUqBCdOnUC4IcffgAgICCA3r17uy0+IUTe8/b2ZvTo0QCEh4fz4IMPOh0fO3Ysl+WLSSGEEPcISQCKHLl06VKGA0Dq1KnjhmhEdnXp0oVffvmFwrbqvw9MJjopClEJCUxav56atoEhVquVwYMHo6oqSkQEAc8/T3Dv3ugvXQLA1LYtN3ftIv7zzzE9+igpjzxC4iuvcPPPP0kcOhQA5fJlaNUKfv/dPS9WCHFPsA8AABg+fDiKovDvv/+yYcMGAPr27UtgYKCbohNCuEqPHj2oXbs2AMuXL6dz587aMS8vL86ePeuu0IQQQgiXkgSgyJE9e/ZkuF8SgPnPAw88wPr166lZsyYAG1SV+4E9ycmsvnwZo22J94kTJ/imXTsKNWmCz7JlAFhDQ7k1bRqxCxZgLV06/cn9/IgfP55bU6ag6vUQF4euc2cM0oBbCJEHDh06xD5bpbGfnx9DhgwBUqv/rFYrAENtX0oIIQo2nU7H+++/D0B0dDRBQUGEhIQAEBgYSP369d0YnRBCCOE6kgAUOWKfoJa2/1/dunXdEY7IoQoVKrB+/XqetvX+uwy0AhYDix2WeH906BCHEhIASOrVi5t//klyz56Q5ucgreS+fbEuWgQGA0pCAkF9+2LIynRhIYS4C1VVGTZsmHZ7xIgReHt7ExkZyZw5cwBo3749lStXdleIQggXa9myJe3atQPg559/1r4UuHbtGrt27XJnaEIIIYTLSAJQ5MjvtmWcaprprlIBmH/5+vryxRdfMH36dPz8/LAAbwHfe3tjr5exAs30eg7MnEncN9+gFi2a+Sfo1g2WL0c1GlGSkwkaMADjkiW5/jqEEPem5cuXc/LkSQCCgoJ46aWXAJg+fbo2yXzUqFFui08I4R6ffPIJvr6+qKrK+vXrGTZsGH///beWGBRCCCEKOkkAimy7cOECYWFh6fYXKVKEcuXKuSEikZuefPJJNm/eTI0aNQBYbTKxoVQpytn6AcZZLLR7802OHTuW9ZN37ox11Sqs/v4oFguBL72Ez4wZkCaRLIQQWREXF8frr7+u3X7vvffw9vbm6tWrzJw5E4BWrVrRoEEDd4UohHCTcuXKaf8+HD16lJCQEO09jhBCCHEvkASgyLbt27c73dbpUn+cHnjggXRLgkX+VLVqVdavX8+TTz4JQNjly1yJjESv1wNw/fp1OnXqxIoVK7J+8tatiV2+HGuhQgAEvPceAS+8gBIXl2vxCyHuLaNGjeLWrVtA6od9ezuDcePGkWBrW/C///3PbfEJIdzrxRdfpFatWkBqRaC9V6gQQghxL5AEoMi21atXA/8l/uyN1R988EG3xSRyn7+/P9OmTWPSpEl4e3uTkpKCxWLRjickJDBkyBCee+45IiIisnRuc/36xKxahaV8eQB8li0j5OGH8f71V6kGFEJkybp161hmG0wE8O2336LX6zlw4AA///wzkDoNtGHDhu4KUQjhZgaDgRkzZuDj44PZbKZ///7EyRePQggh7hGSABTZcuPGDa3/nz3xZ9e0aVN3hCTykKIoPPPMM6xatYqit+n3t3z5cho3bsyYMWM4f/58ps9tqVaN6C1bSO7UCQD95csEDR1KSLNmGOfORbFV8wghxO2EhYXx4osvareffPJJGjVqhMlkYvjw4UBqf9P33nvPXSEKITxEjRo1+PDDD4HUqcCnT592c0RCCCGEa0gCUGTL2rVrnarA7Et+ixYtKgNACrAGDRqwfv16qlev7rTf398fgMTERKZPn06TJk3o0qULc+fO5ebNm3c9rxoczK3Zs4n97jssJUoA4PXPPwSOHEmh++4j8Jln8F62DCUmJvdflBAiX4uLi6NXr17Ex8cDqX1oJ06cCMCkSZM4ceIEAG+99RalS5d2W5xCCM8xcOBAXnvtNfbs2UP9+vXdHY4QQgjhEpIAFNmyYMEC4L/lv/aecG3bttX2iYKpXLlyrFmzhhYtWmj74uPjuf/++2nTpo22b9euXYwcOZJatWrRr18/li1bpn1Az5CiYHriCW7u3k3cJ59gqVAhdXdyMsa1awl6/nkK1ahB0BNP4DN9OrqzZ/PqJQoh8onk5GQGDBjAWdu/B4qiMGfOHIKCgti6dSuTJ08GoHHjxjz//PNujFQI4UkUReGdd96RoXVCCCHuKZKpEVl26NAh9u7dC/y3/NdsNgPQvn17t8UlXCc4OJiFCxfSr18/bd/Bgwfx9vbmr7/+4vXXX6e8ra9fSkoKGzdu5Pnnn6dmzZo888wzHDx48PYn9/cnafBgbv71F9ErV5I4aBBW27JjxWzG+48/CBgzhkIPPkhI06b4ffABXjt3gu1nUAhxbzCZTAwaNEhrRwEwevRomjRpwrlz53jhhRdQVZWgoCC+/vpr7YsqIYQQQggh7kVe7g4gP4mJiWHp0qXs2bOH69evYzQaqVy5Mp06dcrR4Auz2czq1avZvn07ly9fBqB06dK0aNGCzp074+XlWf+bvvvuOyD121NVVfH29sZkMhEUFETbtm3dHJ1wFYPBwJdffkmJEiX4/PPPgdQm/FFRUSxevJg333yT/fv3s2zZMn799VeuXbtGQkIC8+fPZ/78+XTo0IGXXnrp9j0jdTrMTZtibtqU+PHj8fr7b7w3bMB740a8Tp4EwOvMGbzOnMHvm2+whoRgatOGlObNMdepg6V6dfD2dtXlECLT5HdJzkVHR/PMM8+wc+dObV/Pnj157bXXuHLlCk8++aTWfuCbb76hUqVK7gpVCCGEEEIIj6CoqozazIywsDDeeecdYmw9yHx9fUlOTtYq4B5//HGGDh2a5fMmJiby3nvvcerUKQC8bQkLk8kEpDYqHjt2LD4+PjmKPyoqKkePtzt27BitWrXC8cdGp9NhtVp55plnmDRpUpbOp9frCQ0N5ebNm049BT1JaGgoer0ei8WSqX527uLOa/njjz/y1ltvaT8XISEhjBkzhk6dOlG4cGEsFgsbNmxgzpw5bN++3Sk+vV6P0WikfPny1KhRg2bNmtG+fXuKFy9+2+fTXbiA98aNeG/ciGHnTpSUlHT3UQ0GLNWqYa5bF3O9eqn/rVUL/Pzu+nqyfC1TUvA6ehSvPXvQX7iA7vJllORk0OmwhoRgLV0aS7VqpDRogLVSJbD1zMwp+dnMniJFirjtufP77xLI3u+T3PxZPXr0KIMGDXIaNtSiRQsWLFjAxYsXeeqpp/j3338BeP/99xk2bFiG5/G0n0vwzL/Tcp3uTq5R5hS06+TO3yVCCCFEdkgCMBNSUlJ4+eWXuXr1KuXLl2fkyJFUrFiR5ORkVqxYwfz581FVlVdffTXLFXCff/4527dvx9/fn1dffVWr/ti9ezdfffUV8fHxtGrVihEjRuToNeRGAtBqtdKzZ0927NihVf8ZDAZSbMmX3377jdq1a2fpnJ74ZjAtT3wTnRF3X8uNGzfyzDPPaMvB7QICArBarSQkJGT6XHq9nvbt29O/f3/atGlzx6V7yq1bGH77LbU6cMsWdNev3/a+qrc3KQ8+SErr1pjatcNStWqGybhMXcvkZLy3bcP711/xXr8eXVxcpl6bNTSUlCZNMDdtSkrTppjr1AGDIVOPTUt+NrPHXR/aCsLvEnBfAjAlJYUZM2Ywfvx4p39n2rVrx48//siePXt47rnnuG77N2D48OG8++67tz2fp/1cgmf+nZbrdHdyjTKnoF0nSQAKIYTIbwrOeqA8tGHDBq5evYrRaGTMmDEUtfUjMxqN9OrVixs3brB27VrmzZtHy5YtM73M6vz58+zYsQOAV155xWkpZNOmTbFarUycOJFt27bRvXt3raeau3z77bdavPa8sb1qpX379llO/omCpX379mzdupWuXbs6vYmOyyAxVqZMGSpXrsytW7c4ceIEiYmJTsctFgvr1q1j3bp1BAcH06xZMzp27EiFChUIDQ0lODiY0NBQDAYDamAgpi5dMHXpAqqKLiwstRrvyBG8jhxBf/gw+qtXAVBMJrx37MB7xw78P/gAS8WKJHfsiOnRRzE3aQJ3+7trNmP4/XeMy5bhvXYtutjYdHexFimCpXTp1EpDqxXl+nX04eEoSUkA6G7exLhhA8YNGwBQ/fxIadIkNTH54INYqlZFLVIEZJhOgSO/S7LHarWyfv163n//fS5cuOB07Omnn+bdd99l/PjxTJ8+Xdv/wQcf8NJLL7k4UiGEEEIIITyXJAAzYdu2bQA0b95c+8DmqEePHqxbt44bN25w5MgR6tevn6nzbt++HVVVKVmyZIZ90B566CFKlizJlStX2L59OwMGDMjR68iJlStX8uGHHzrt8/HxISkpCS8vrztWWYh7x3333ccff/zBSy+9xPbt24HUJeL3338/nTt3pkGDBjzyyCMUKVJE+7bd3hdw3rx5HD9+PN05Y2JiWL16NatXr3babzAYqFatGnXq1OGhhx6iZs2axMXFcebMGe3P2bNnuRgVhVWnw1uvp6y/P1XNZh6Ii6MF8MD58/hNm4bftGlYQ0MxtWuHqW1bqFEDKlVCuXEDr0uX0J88iWHnTry3bUMXGekUhzUoCFOnTpjatyelSRPUjJYuW63oT5/Ga/9+DHv34rV7N16nTwOgJCSkVhLa/p2B1OXL1sKFwccH1WBITUzqdKDXo+r1oNeDTofOxwf8/ND5+xNgMKD6+6P6+aX+1+EP9m37+YxGVG9v8PFJfR6jMWf/40WmyO+SrImOjmb58uVMnz7dabkvpP7+ef/99wF45JFHiLT9vQwKCuLLL7+kS5cuLo9XCCGEEEIITyYJwLtITEzktO2DeoMGDTK8T9GiRSlTpgwXL17k0KFDmf7QdvjwYQDq16+PksEyREVRqF+/PleuXNHu62omk4mpU6cyceJEp75/er2eJFtF06uvvsp9993nlviE5ylWrBiLFy9m+vTpjBs3jpSUFPbv38/Zs2cZOHBgur9Hfn5+DB06lKFDh3Ly5Em2bNnC33//zbFjx7h8+bL2c5ZWSkoKx44d49ixY/z88893jSvJauV0dDSngbW2fb46Hc1UlXaqSvubN6mzeDE+ixdrjwm5zblUPz+SO3XC1K0bppYt755A0+mwVK+OpXp1kvv0AUCJjMSwe3fqn1270B89imL7O6akpGhVi5mhADnp7GYtVAhr8eJYS5XCUqYM1lKlsJYpg6V0aaxlyqCGhqYmIFUVJToa5cYNdFFR6CIj0V27hu7aNRTbtr33oWowoBYqhLVYMShRAipXxisoCIoXx1qiBGpQkPPya4sFJTo69bwREannjYhAFxGBcu0aSnx8auJTr8dSvjwJY8bk4BW73r3+uyQzrFYrp06dYvfu3axYsYKdO3dqVeaO6tSpQ40aNfjkk0+0XoqQmgj86quvKFu2rCvDFkIIIYQQIl+QBOBdhIeHa4mvOy2bKl++PBcvXuTixYuZOq+qqoSHh9/1vOXKlQPI9Hlz24svvsjKlSud9imKovVuadu2LW+++aY7QhMeTKfT8fLLL/Poo48yevRotm3bRkxMDJMnT2bKlCk8/PDDdOjQgdq1a1OvXj0CAgKA1EEFNWrUcDpXQkICe/bsYf78+WzevDnDJcUZURSFIkWKUK1aNUqWLElISAjR0dH8888/HDt2DKvVSqLVykZgI/AGUFxRaKuqtAMeACoB9jnC1qJFSXnkkdTEX/v2mRomcidq0aKYHn8c0+OPp8YbE4PXgQPowsPRXbmS2sswJQXFZAKzGcViAfsfqxXFYsGgKChJSahxcVhiYlDi41ESElDi4lLvn0m6GzfQ3bgBJ07k6DXdTaDDtr1SEUh9fTExKBkkezJirlUr3yUA7/XfJXZWq5XIyEgiIyOJiIjgxIkTHDx4kNOnT3P27Nl07QAcBQYGkpKSwpEjRzhy5Ii2v3r16rz99tt07NgxwwSoEEIIIYQQQhKAd3Xjxg1tu1ChQre9n/1YZhsIJyYmapVNmTlvYmIiiYmJ+Pr6Zur8uSWjGTH2fd26dWPq1Kl3HNAg7m1VqlRh8eLFbN/+//buPSiq8/7j+HsXdmFBRVCJREERtcZrrZqoiWiDiVWMRmvT8TLTdKqp7eSiia1TrZlfNeY2rdXotI7ttI1V01rU2qittWpwvKDpJN6i8UrFBBUQBOWmLOf3B90tCguHhWWX5fOaYQTOOQ/Pfn2ec/Z893mek86aNWvcUxUPHjzIwYMH3ft16NCBhIQEYmJiaNu2Le3atcPhcBAaGorVaiUkJISePXvSq1cvcnNzuX79OoWFhZSXl7vLKCkpobCwkJycHJxOJ4ZhuBMNLjabjTZt2hAXF4fFYqG0tJTi4mJ3X7xhGGwENlZ7DeF2Oza7HXtlJbYjR7AePYrl//4Pq9WK1WqtkXBozgRE9b7ndDohPLzq67/nDUtlJVRWgmH8798HvixOJ1RUVCUWKyqwuL5viOrTk/87UhDDqPr7FRVVf/tBJSVVX2bLdo1ABGKvX2d7w2rod639WgLQv39/PvvsM6+Pv337tvv78PBwUlJSeP755xk9erQSfyIiIiIi9VACsB7Vpx+G1THNz7WtrtEL1VXfz0y5rmM83bRt2LCBTZs2eSxn+vTpzJgxw1Tdqps8eTIffvjhfb/r27cvS5YsYdq0aY2+6XIdHxUVVWuyMRBY//swBqvVSnR0tJ9r41kgx3LKlClMmTKFzz77jLS0NLZt28bp06fd22/evOl+cqcv3bt3j4KCggY96a/s7l3K7t4FkyMPWyVXovG/TwT3SdnVXMrPD+i+WJuWci0B31xPrFZro55Gb7PZ+OpXv8qIESMYNWoUTz/9NJGuEaReCsRzZiBebxSn+ilG5ihOIiIi/qUEYJAoLi4mJyfH4/aSkhKvRuqlpKQwdOhQ+vbtS9++fUlJSWHIkCFNPtrC2gKeeGqxWFrEaMdAjuXAgQMZOHAgS5cu5datWxw9epSzZ8+SmZnJlStXKCgooLCwkKKiIoqLi3E6nTidTioqKtz/1rYmWF1cNxnVbzYC5cZDvNNS+mJL5avrSc+ePcnLy8NqtWKz2bDZbDgcDtq2bUubNm3o0KEDnTt3JiYmhg4dOhAbG0uPHj3o2bMnCQkJpp+K3FCBeM4MxDauONVPMTJHcRIREfEPJQDrER7+v6X1y8vLifCw7pdrKqLZaVXV96s+jdFTufWVHRkZSWxsrMftERER7nX7GiI+Pp6MjIz7ftfQBExdLBYLVquVysrKgE3KuKZ5GobRpK+9qbWEWML/4hkVFcXYsWMZO3asv6tUQ0uLZWtsm96cz1z8cZPXUq4l4JvridVq5eDBg41qq435P69NIPbzQOzTilP9FCNzgi1OShiKiEhLowRgPaqvqZSfn+/xps21vpPZ6QMOhwOHw0Fpael9a0N5Kte1vyezZs1i1qxZHrfn5eU1aNpjcwkJCSE6OprCwsImv7lrKtHR0YSEhFBZWRmQMXRpCbGElhFPxbJpBVo8O3bs2Ox/s6VcS8A315NAbKuB1i5BcTIr0OKkGJkTbHHyx7VERESkMQJvDH6A6dq1q3u6a1ZWlsf9XNvi4+NNlWuxWOjatWuTlysiIoFH1xIREREREfEnJQDr4XA46NWrFwCffPJJrfvk5eVx9epVAAYNGmS67IEDBwLw6aefetzn+PHj9+0rIiItj64lIiIiIiLiT0oAmjBmzBgADhw4QG5ubo3tW7duxTAMYmJiGDBggOlyk5OTsVgsZGdnc+TIkRrbDx8+THZ2NhaLxV0HERFpmXQtERERERERf1EC0IRx48bRuXNnysrKWLZsGZmZmUDVouppaWns3LkTqFo36cGnFM6ePZtJkyaxcuXKGuUmJiaSnJwMwOrVq8nIyMAwDAzDICMjgzVr1gBVN40JCQk+fIUiIuJrupaIiIiIiIi/6CEgJthsNn7605+yePFi/vOf//DKK68QERFBWVmZ+4lhEydO9Opppj/84Q+5du0a58+f580338RutwNw9+5dAPr06cMPfvCDpnsxIiLiF7qWiIiIiIiIvygBaFJCQgKrV69my5YtHDt2jLy8PCIjI+nRowepqakMHz7cq3IdDgdvv/02O3bsID09nezsbACSkpIYM2YMqampNUaCiIhIy6RriYiIiIiI+IPFMAzD35UQ38vLy/N3FWoVEhJCdHQ0BQUFOJ1Of1enVtHR0YSEhOB0OikoKPB3dTxqCbGElhFPxbJpBVo8O3bs6O8qtGjeXE8Csa0GWrsExcmsQIuTYmROsMVJ1xIREWlptAagiIiIiIiIiIhIEFMCUEREREREREREJIgpASgiIiIiIiIiIhLElAAUEREREREREREJYkoAioiIiIiIiIiIBDElAEVERERERERERIKYxTAMw9+VEAlkGzZsoLi4mMjISGbNmuXv6rR4imfTUSylpVBbNUdxMkdxqp9iZI7iJCIirYkSgCL1mDBhAjk5OcTGxrJr1y5/V6fFUzybjmIpLYXaqjmKkzmKU/0UI3MUJxERaU00BVhERERERERERCSIKQEoIiIiIiIiIiISxJQAFBERERERERERCWJKAIqIiIiIiIiIiAQxJQBFRERERERERESCmBKAIiIiIiIiIiIiQSzU3xUQCXQzZsyguLiYyMhIf1clKCieTUexlJZCbdUcxckcxal+ipE5ipOIiLQmFsMwDH9XQkRERERERERERHxDU4BFRERERERERESCmBKAIiIiIiIiIiIiQUwJQBERERERERERkSCmBKCIiIiIiIiIiEgQ01OARR6wd+9eVq1aVe9+GzZsoF27ds1Qo8B2584dTp8+zcWLF7l06RIXL16ksLAQgOXLlzNgwIB6yzhy5Ah///vfuXTpEuXl5XTs2JFhw4bxrW99q1XFuDGxnD17Njk5OXWWP2HCBObOndukdZbgU1hYSFpaGseOHePmzZuEhYWRlJTEhAkTGD58uNflVlRUsGPHDtLT08nOzgagS5cujB49mtTUVEJD635LcvnyZbZt28apU6coKioiKiqK/v37M3XqVBITE72ulzeaOkYlJSUcPXqU48ePc/HiRXJycqisrCQ6Opo+ffowfvx4+vXr5/H4lStXsm/fvjr/RkJCAmvWrGlw3RqjqeN048YN5syZU+9+Cxcu5PHHH/e4PZDaEjR9nBYtWsTp06dN7ZuSksIrr7xy3+8CqT01xXuMugTTeUlERKQ+SgCKeGC1WutMPlkslmasTeA6evSoqYSpJ2vXrmXXrl1AVczDwsLIzs5m+/btpKens3z5cuLj45uqugGtsbEEiIiIwG63e9wmUpesrCwWL17svsF2OBwUFxdz/Phxjh8/zjPPPGMqAfOg0tJSlixZwvnz5wHcbfTixYtcvHiRQ4cOsXTpUsLDw2s9Pj09nVWrVlFRUQFAZGQkN2/eJD09nUOHDjF//nxGjRrlzUtuMF/EaP78+Vy7ds39s91ux2q1kpOTQ05ODgcOHGDKlCl897vfrbMcu93usZ8394cpvmpLLu3atcNqrX0ii6dzIARWWwLfxKlNmza0b9/e4/aKigru3LkDQFJSksf9AqE9NcV10ZNgOi+JiIiYoQSgiAcdO3bkt7/9rb+r0SJER0eTlJREz549efjhh1mxYoWp43bv3s2uXbuwWCzMnDmTyZMnExYWRmZmJitWrODKlSu88cYbrFmzBpvN5uNXERi8jaXLnDlzSElJ8VHtJJjdu3ePN954g8LCQrp168arr75KYmIi5eXlbN++nY0bN/Lhhx+SmJjI2LFjG1T2r371K86fP09kZCQvv/yye1RTRkYG7733Hp9//jm//vWvmT9/fo1js7Ky3DfZTzzxBLNnzyYmJob8/Hx+85vfcOjQIVauXEliYiJdu3Ztklh44qsYOZ1OunfvztNPP82QIUOIi4vDMAyys7NZv349R44cYdu2bXTu3Jnx48d7LOeJJ55g3rx5TfBKG8eXbcnlF7/4BQ899FCDjgmktgS+i9OiRYvq3L5582Y2bNiAzWZj9OjRHvcLlPbU2OuiJ8FyXhIRETFLawCKSKOMGTOG999/n9dff50ZM2YwdOhQU8fdu3ePTZs2AVVTU5977jnCwsIASExMZMmSJYSFhXHt2jX27Nnjs/oHEm9jKdIUdu/ezfXr1wkLC+P11193T18LCwvjueeecyeeNmzY4B7xYkZmZiYHDhwA4KWXXmLEiBFYLBYsFgsjRozgxRdfBOCjjz7iypUrNY7fuHEjFRUVJCYm8tprrxETEwNATEwMCxYsIDExkXv37rFx48ZGvX4zfBWjefPm8d577zFx4kTi4uKAqlHmXbp0YeHChe5pjtu2bWviV+QbvopTYwVSWwL/xWn//v0ADBs2jLZt2zZZub7gq+tiMJ2XREREzFICUEQaJSQkxKvjTp48SUFBARaLhalTp9bYHhsbS3JyMlD1Brw18DaWIk3B1c+Sk5Pp1KlTje3f/OY3sVgs5Ofnc+rUKdPlpqenYxgGcXFxjBgxosb2kSNHuke8paen37etuLiYjz/+GIBnn322Rh8JCQnh2WefBeDYsWOUlJSYrpc3fBWj/v37e9xmtVp58sknAbh+/bp76mYg81WcGiPQ2hL4J05nz57lyy+/BPB69GVz8tV1MZjOSyIiImYpASgifnHy5EkA4uPja73xARg8eDAA586do6ysrNnqJtLalJaWcuHCBQC+9rWv1bpPp06d3FPZTpw4YbpsV18fPHhwrWunWiwWd1937ety5swZ98gnT/Vy/f7evXucPXvWdL0aypcxqk/19dacTmeTlesL/oxTXQKpLYH/4rR3716gaqSaq9+1RsFyXhIREWkIrQEo4kFhYSHz5s1zf1LeoUMH+vfvz8SJE+nevbt/KxcErl69CkC3bt087uPaZhgGX3zxBT179myWurVk27Zt449//CNFRUVERETQvXt3Ro4cydixY+tcGF9aty+++ALDMID6++TVq1fd/bc+rr5bX7kJCQkANcp1/dy+fXuioqJqPTYqKoqoqCgKCwvJyspiyJAhpurWUL6KkRmuJ7q2b9++zocvnDx5ku9///vk5uZit9uJi4tjyJAhpKamEh0d3WT1qUtzxendd98lOzub8vJyoqKi6N27N2PHjmXYsGG17h9IbQn8057Ky8s5dOgQUDW1tr7RdYHQnnwhmM5LIiIiDaERgCIelJeXk5mZic1mw+l0kp2dzT//+U/mzZvXYtZhCmT5+fkA7nVzalN9W0FBgc/rFAyysrK4c+cOYWFhFBUVcfLkSdauXctrr71Gbm6uv6snAcrVH8FcnzTbH0tLS92jd82UW1paSmlpqfv3rr9T17He1MsbvopRffLy8vjHP/4BQEpKSp1PoM/LyyMnJ4fw8HDKysq4dOkSmzdv5sUXX2y2kXbNFacLFy5gGAZWq5WbN29y5MgRli1bxjvvvMO9e/dq7B9IbQn8054yMjIoLi4GMPWwqEBoT74QTOclERGRhtAIQJEHxMTEMH36dEaOHMnDDz+MzWajoqKCM2fOsH79es6fP8/vf/97YmJi6nx6ntTN9ebb9eCP2lTfpjV06vbYY4/Rr18/+vfv7x4hlJ+fz549e/jzn//MlStX+NnPfsYvf/nLVvNEZTGv+hR7M32y+s1wXarvZ7avl5aW4nA47ju+rmO9qZc3fBWjulRUVPDzn/+c0tJSYmNjmTZtWq37JSUl0bt3b4YNG0aHDh2wWq2UlJRw7Ngx/vCHP5Cfn8+bb77JihUr6NKlS6PrVRdfxslutzNhwgRGjRpFYmIiERERQNUHH1u2bGH//v0cOnSIyMhI90McXAKpLYF/2tO//vUvAHr37k18fLzH/QKpPflCMJ2XREREGkIjAEUeMHjwYKZPn063bt3ciZLQ0FAGDhzIW2+9xVe+8hUA3n//fSorK/1ZVRG3OXPmMHLkyPumB8bExPDtb3+bhQsXAlU3ya71n0QksBmGwZo1azhz5gx2u50FCxYQGRlZ677PPPMMEyZMoFOnTlitVW/tIiIiGDNmDO+++y5t2rShtLSUDz74oDlfQpOLjo5m7ty59OvXz538g6qpmvPnz2fy5MkA7Nmzxz3FU6rk5ua6HyRS3+i/1tKeREREWhslAEUawGazMWvWLKBqaszly5f9XKOWKzw8HKiaau1J9W3Vb/akYR577DH69u0L4H5yoUh1rv4I5vqkayRMfarvZ7avVz/G9X1dx3pTL2/4KkaerFu3jn379hESEsKPf/xj+vTp41U5sbGxpKamAvDvf//b5x9cNXecqps5cyZ2ux3DMGqc6wKpLUHzx2n//v1UVlZit9sZNWqU1+U0d3vyhWA6L4mIiDSEEoAiDeQaAQhw/fp1P9akZXOtjVN9HaQHVd/WkhccDwSudqs2K7WpvpaVmT5ptj86HA73za+ZcqvvX71edR3rTb284asY1eZ3v/sdO3fuxGq18uqrr/Loo496XRZUTfmEqqUUbt++3aiy6tOccXpQeHi4+8ENN27cqLVegdCWqtenvjo1VX327dsHVH0g1KZNm0aV1ZztyReC6bwkIiLSEEoAiohfuNYfysrK8riPa5vFYqFr167NUi+R1qhr167uh0uY6ZN1rR9WXfW+6025rp9v3bpFUVFRrccWFhZSWFgI/O+pnb7gqxg9aP369fz1r3/FYrHw0ksvNWq0lj80V5waKpDaEjRvnM6cOUN2djYAY8eO9bqcYBFM5yUREZGGUAJQpIHOnTvn/v6hhx7yY01atoEDBwJVb7Dz8vJq3efTTz8FqkavVZ8uJQ3nardqs1Ibh8NBr169APjkk09q3ScvL4+rV68CMGjQINNlu/q6qz/X5vjx4/ft69K3b19CQ0PrrJerXJvNxiOPPGK6Xg3lyxi5bNq0ibS0NADmzp1r6kmtZpw/fx6oeg1t27ZtkjI9aY44eVJWVuZO2jx4rguktgTNGyfX2q8dO3Zskng3Z3vylWA5L4mIiDSEEoAi1RiGUef2iooKNm7cCECHDh1ISkpqjmoFpYEDBxIdHY1hGGzbtq3G9tzcXA4cOADAmDFjmrl2LUt97fbjjz/mzJkzAI2eSijBy9XPDhw4QG5ubo3tW7duxTAMYmJiGDBggOlyk5OTsVgsZGdnc+TIkRrbDx8+THZ2NhaLpUZfj4iIYNiwYQBs374dp9N533an08n27duBqrbt67VCfRUjgLS0NP70pz8B8L3vfY/x48ebOq6+/p+bm8uuXbsAGDp0qPuhDr7kqzjV91o/+OAD7t69i8Vicbcbl0BrS+Db9uRSXl7OoUOHAPj6179e7/9/ILYnXwim85KIiIhZLfOqLeIjOTk5LFiwgN27d9+3fpDT6eT06dMsWrSIzz//HIDvfOc7LfaNb1MrKipyf925c8f9++Li4vu2VVRUuLfZbDZmzJgBwI4dO0hLS3MvmJ2ZmcmyZcsoKysjLi6Op556qnlfkB95E8t169axbt06Tp8+fd+i5AUFBfzlL3/hnXfeAaqmITXViCIJPuPGjaNz586UlZWxbNkyMjMzgaoEQlpaGjt37gRg1qxZ7tEvLrNnz2bSpEmsXLmyRrmJiYkkJycDsHr1ajIyMjAMA8MwyMjIYM2aNUBVMqS2qXIzZ84kNDSUS5cusWLFCgoKCoCq9r1ixQouXbqEzWZj5syZTRYLT3wVo7/97W+sX78eqLq2uJ5ma8ZHH33EW2+9RUZGxn3TEUtLS0lPT2fhwoXcvn0bh8PB9OnTG/qSveKrOC1atIjNmzeTmZl5X9IlKyuLVatWuT9Meuqpp2pdNiKQ2hL4Lk7VHT58mJKSEqD+p/9CYLYnb66L0HrOSyIiImZZjPo+6hNpRW7cuMGcOXPcP9vtdsLDwykpKXG/sQwNDW3wDVqwmzRpkqn9li9fXmMUw9q1a92jCUJCQggLC3PfrLRv357ly5c32xpRgcCbWK5cudK9wLvFYnGPNiguLnbv36NHDxYvXkynTp2auMYSTLKysli8eLF77aqIiAjKysrcT/qcOHEiL7zwQo3jZs+eTU5ODk8++STz5s2rsb20tJQlS5a4pw7a7XYA7t69C0CfPn1YunSpx6n+6enprFq1ioqKCncbd7Xv0NBQ5s2b576Z9zVfxGjy5MkYhoHFYiEqKqrOv/+Tn/zkvimFe/fuZdWqVe6fHQ4HoaGhFBcXu+sUFRXFj370oxpTGX3JF3FybYOq60VERAR3796974OP0aNH8/LLL2Oz2WqtVyC1JfBdn3NZsmQJJ06c4JFHHnF/GFSXQGxP3r7HaE3nJRERETNC699FpPVo3749L7zwAmfPniUzM5PCwkKKi4sJCwsjPj6eAQMGMH78eLp06eLvqgaNuXPnMmjQIHbt2sXly5fdo/4effRRpk2bVu/NsMA3vvENoqKiOHfuHDk5Ody+fZvKykpiYmJISkri8ccfJzk5ucYIEpEHJSQksHr1arZs2cKxY8fIy8sjMjKSHj16kJqayvDhw70q1+Fw8Pbbb7Njxw7S09PdDyRISkpizJgxpKam1tk+R48eTXx8PFu3buX06dMUFRW5p0VOnTqVxMREr+rlDV/EyPVZrGEY3Lp1q859HxzlNGDAAGbNmsXZs2f58ssvKSoqoqSkhMjISOLj4xk6dCjjxo1r9rXafBGn559/nhMnTnDhwgUKCgq4ffs2ISEhxMXF0adPH1JSUupNSgVSWwLf9Tmomq576tQpwNzoPwjc9uQLwXReEhERMUMjAEVERERERERERIKYFjATEREREREREREJYkoAioiIiIiIiIiIBDElAEVERERERERERIKYEoAiIiIiIiIiIiJBTAlAERERERERERGRIKYEoIiIiIiIiIiISBBTAlBERERERERERCSIKQEoIiIiIiIiIiISxJQAFBERERERERERCWJKAIqIiIiIiIiIiAQxJQBFRERERERERESCmBKAIiIiIiIiIiIiQUwJQBERERERERERkSCmBKCIiIiIiIiIiEgQUwJQREREREREREQkiCkBKCIiIiIiIiIiEsSUABQREREREREREQli/w9ltl9j0rq/hgAAAABJRU5ErkJggg==" + }, + "metadata": { + "image/png": { + "height": 480, + "width": 640 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kernel_no_mean_match.plot_imputed_distributions()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see the effects that mean matching has, depending on the\n", + "distribution of the data. Simply returning the value from the model\n", + "prediction, while it may provide a better ‘fit’, will not provide\n", + "imputations with a similair distribution to the original. This may be\n", + "beneficial, depending on your goal." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [] } ], From 8b848f082efe1d699eb74fc14a06d2c8e1d822ee Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:36:29 -0400 Subject: [PATCH 17/44] Updated tests for recent changes. Tests are now much more thorough. --- tests/test_ImputationKernel.py | 205 +++++++++++++++++++++------------ tests/test_imputed_accuracy.py | 63 +++++----- tests/test_reproducibility.py | 113 ++++++++---------- tests/test_sklearn_pipeline.py | 38 +++--- tests/test_utils.py | 17 +-- 5 files changed, 240 insertions(+), 196 deletions(-) diff --git a/tests/test_ImputationKernel.py b/tests/test_ImputationKernel.py index 4d3d88d..c336c08 100644 --- a/tests/test_ImputationKernel.py +++ b/tests/test_ImputationKernel.py @@ -1,4 +1,3 @@ - from sklearn.datasets import load_iris import pandas as pd import numpy as np @@ -14,31 +13,39 @@ random_state = np.random.RandomState(1991) iris = pd.concat(load_iris(as_frame=True, return_X_y=True), axis=1) # iris = iris.sample(100000, replace=True) -iris['sp'] = iris['target'].map({0: 'Category1', 1: 'Category2', 2: 'Category3'}).astype('category') -del iris['target'] -iris.rename({ - 'sepal length (cm)': 'sl', - 'sepal width (cm)': 'ws', - 'petal length (cm)': 'pl', - 'petal width (cm)': 'pw', -}, axis=1, inplace=True) -iris['bi'] = pd.Series(np.random.binomial(n=1, p=0.5, size=iris.shape[0])).map({0: 'FOO', 1: 'BAR'}).astype('category') -iris['ui8'] = iris['sl'].round(0).astype('UInt8') -iris['ws'] = iris['ws'].astype('float32') +iris["sp"] = ( + iris["target"] + .map({0: "Category1", 1: "Category2", 2: "Category3"}) + .astype("category") +) +del iris["target"] +iris.rename( + { + "sepal length (cm)": "sl", + "sepal width (cm)": "ws", + "petal length (cm)": "pl", + "petal width (cm)": "pw", + }, + axis=1, + inplace=True, +) +iris["bi"] = ( + pd.Series(np.random.binomial(n=1, p=0.5, size=iris.shape[0])) + .map({0: "FOO", 1: "BAR"}) + .astype("category") +) +iris["ui8"] = iris["sl"].round(0).astype("UInt8") +iris["ws"] = iris["ws"].astype("float32") iris.reset_index(drop=True, inplace=True) -amputed_variables = ['sl', 'ws', 'pl', 'sp', 'bi', 'ui8'] +amputed_variables = ["sl", "ws", "pl", "sp", "bi", "ui8"] iris_amp = mf.ampute_data( - iris, - variables=amputed_variables, - perc=0.25, - random_state=random_state + iris, variables=amputed_variables, perc=0.25, random_state=random_state ) -na_where = { - var: np.where(iris_amp[var].isnull())[0] - for var in iris_amp.columns -} +na_where = {var: np.where(iris_amp[var].isnull())[0] for var in iris_amp.columns} notnan_where = { - var: np.setdiff1d(np.arange(iris_amp.shape[0]), na_where[var], assume_unique=True)[0] + var: np.setdiff1d(np.arange(iris_amp.shape[0]), na_where[var], assume_unique=True)[ + 0 + ] for var in iris_amp.columns } @@ -47,29 +54,26 @@ # Make special datasets that have weird edge cases # Multiple columns with all missing values -# sp is categorical, and pw had no missing +# sp is categorical, and pw had no missing # values in the original kernel data new_amputed_data_special_1 = iris_amp.loc[range(20), :].reset_index(drop=True).copy() -for col in ['sp', 'pw']: +for col in ["sp", "pw"]: new_amputed_data_special_1[col] = np.nan dtype = iris[col].dtype new_amputed_data_special_1[col] = new_amputed_data_special_1[col].astype(dtype) # Some columns with no missing values new_amputed_data_special_2 = iris_amp.loc[range(20), :].reset_index(drop=True).copy() -new_amputed_data_special_2[['sp', 'ui8']] = iris.loc[range(20), ['sp', 'ui8']] +new_amputed_data_special_2[["sp", "ui8"]] = iris.loc[range(20), ["sp", "ui8"]] def make_and_test_kernel(**kwargs): # kwargs = { - # 'data':iris_amp, - # 'num_datasets':2, - # 'variable_schema':vs, - # 'mean_match_candidates':mmc, - # 'data_subset':ds, - # 'mean_match_strategy':'normal', - # 'save_all_iterations_data':True, + # "data": iris_amp, + # "num_datasets": 2, + # "mean_match_strategy": "fast", + # "save_all_iterations_data": True, # } # Build a normal kernel, run mice, save, load, and run mice again @@ -78,10 +82,10 @@ def make_and_test_kernel(**kwargs): kernel.mice(iterations=2, verbose=True) assert kernel.iteration_count() == 2 new_file, filename = mkstemp() - with open(filename, 'wb') as file: + with open(filename, "wb") as file: dill.dump(kernel, file) del kernel - with open(filename, 'rb') as file: + with open(filename, "rb") as file: kernel = dill.load(file) kernel.mice(iterations=1, verbose=True) assert kernel.iteration_count() == 3 @@ -90,8 +94,8 @@ def make_and_test_kernel(**kwargs): imputed_variables = kernel.imputed_variables # pw has no missing values. - assert 'pw' not in imputed_variables - + assert "pw" not in imputed_variables + # Make a completed dataset completed_data = kernel.complete_data(dataset=0, inplace=False) @@ -123,21 +127,45 @@ def make_and_test_kernel(**kwargs): # Make sure the models were trained the way we expect for variable in modeled_variables: - if variable == 'sp': - objective = 'multiclass' - elif variable == 'bi': - objective = 'binary' + if variable == "sp": + objective = "multiclass" + elif variable == "bi": + objective = "binary" else: - objective = 'regression' - assert kernel.get_model(variable=variable, dataset=0, iteration=1).params['objective'] == objective - assert kernel.get_model(variable=variable, dataset=0, iteration=2).params['objective'] == objective - assert kernel.get_model(variable=variable, dataset=1, iteration=1).params['objective'] == objective - assert kernel.get_model(variable=variable, dataset=1, iteration=2).params['objective'] == objective + objective = "regression" + assert ( + kernel.get_model(variable=variable, dataset=0, iteration=1).params[ + "objective" + ] + == objective + ) + assert ( + kernel.get_model(variable=variable, dataset=0, iteration=2).params[ + "objective" + ] + == objective + ) + assert ( + kernel.get_model(variable=variable, dataset=1, iteration=1).params[ + "objective" + ] + == objective + ) + assert ( + kernel.get_model(variable=variable, dataset=1, iteration=2).params[ + "objective" + ] + == objective + ) # Impute a new dataset, and complete the data imputed_new_data = kernel.impute_new_data(new_amputed_data, verbose=True) - imputed_dataset_0 = imputed_new_data.complete_data(dataset=0, iteration=2, inplace=False) - imputed_dataset_1 = imputed_new_data.complete_data(dataset=1, iteration=2, inplace=False) + imputed_dataset_0 = imputed_new_data.complete_data( + dataset=0, iteration=2, inplace=False + ) + imputed_dataset_1 = imputed_new_data.complete_data( + dataset=1, iteration=2, inplace=False + ) # Assert we didn't just impute the same thing for all values assert not np.all(imputed_dataset_0 == imputed_dataset_1) @@ -150,9 +178,40 @@ def make_and_test_kernel(**kwargs): assert not np.any(imputed_dataset_special_1[modeled_variables].isnull()) assert not np.any(imputed_dataset_special_2[modeled_variables].isnull()) - return kernel - + # Reproducibility + random_seed_array = np.random.randint(9999, size=new_amputed_data_special_1.shape[0], dtype='uint32') + imputed_data_special_3 = kernel.impute_new_data( + new_data=new_amputed_data_special_1, + random_seed_array=random_seed_array, + random_state=1, + ) + imputed_data_special_4 = kernel.impute_new_data( + new_data=new_amputed_data_special_1, + random_seed_array=random_seed_array, + random_state=1, + ) + assert imputed_data_special_3.complete_data(0).equals(imputed_data_special_4.complete_data(0)) + + # Ensure kernel imputes new data on a subset of datasets deterministically + if kernel.num_datasets > 1: + datasets = list(range(kernel.num_datasets)) + datasets.remove(0) + imputed_data_special_5 = kernel.impute_new_data( + new_data=new_amputed_data_special_1, + datasets=datasets, + random_seed_array=random_seed_array, + random_state=1, + verbose=True + ) + imputed_data_special_6 = kernel.impute_new_data( + new_data=new_amputed_data_special_1, + datasets=datasets, + random_seed_array=random_seed_array, + random_state=1, + ) + assert imputed_data_special_5.complete_data(1).equals(imputed_data_special_6.complete_data(1)) + return kernel def test_defaults(): @@ -160,19 +219,19 @@ def test_defaults(): kernel_normal = make_and_test_kernel( data=iris_amp, num_datasets=2, - mean_match_strategy='normal', + mean_match_strategy="normal", save_all_iterations_data=True, ) kernel_fast = make_and_test_kernel( data=iris_amp, num_datasets=2, - mean_match_strategy='fast', + mean_match_strategy="fast", save_all_iterations_data=True, ) kernel_shap = make_and_test_kernel( data=iris_amp, num_datasets=2, - mean_match_strategy='shap', + mean_match_strategy="shap", save_all_iterations_data=True, ) kernel_iwp = make_and_test_kernel( @@ -184,18 +243,18 @@ def test_defaults(): def test_complex(): - + # Customize everything. vs = { - 'sl': ['ws', 'pl', 'pw', 'sp', 'bi'], - 'ws': ['sl'], - 'pl': ['sp', 'bi'], + "sl": ["ws", "pl", "pw", "sp", "bi"], + "ws": ["sl"], + "pl": ["sp", "bi"], # 'sp': ['sl', 'ws', 'pl', 'pw', 'bc'], # Purposely don't train a variable that does have missing values - 'pw': ['sl', 'ws', 'pl', 'sp', 'bi'], - 'bi': ['ws', 'pl', 'sp'], - 'ui8': ['sp', 'ws'], + "pw": ["sl", "ws", "pl", "sp", "bi"], + "bi": ["ws", "pl", "sp"], + "ui8": ["sp", "ws"], } - mmc = {"sl": 4, 'ws': 0, "bi": 5} + mmc = {"sl": 4, "ws": 0, "bi": 5} ds = {"sl": int(iris_amp.shape[0] / 2), "ws": 50} imputed_var_names = list(vs) @@ -208,43 +267,41 @@ def test_complex(): variable_schema=vs, mean_match_candidates=mmc, data_subset=ds, - mean_match_strategy='normal', + mean_match_strategy="normal", save_all_iterations_data=True, ) assert kernel.data_subset == { - 'sl': 75, - 'ws': 50, - 'pl': 0, - 'bi': 0, - 'ui8': 0, - 'pw': 0 + "sl": 75, + "ws": 50, + "pl": 0, + "bi": 0, + "ui8": 0, + "pw": 0, }, "mean_match_subset initialization failed" - + kernel_fast = make_and_test_kernel( data=iris_amp, num_datasets=2, variable_schema=vs, mean_match_candidates=mmc, data_subset=ds, - mean_match_strategy='fast', + mean_match_strategy="fast", save_all_iterations_data=True, ) mmc_shap = mmc.copy() - mmc_shap['ws'] = 1 + mmc_shap["ws"] = 1 kernel_shap = make_and_test_kernel( data=iris_amp, num_datasets=2, variable_schema=vs, mean_match_candidates=mmc_shap, data_subset=ds, - mean_match_strategy='shap', + mean_match_strategy="shap", save_all_iterations_data=True, ) - mixed_mms = { - 'sl': 'shap', 'ws': 'fast', 'ui8': 'fast', 'bi': 'normal' - } + mixed_mms = {"sl": "shap", "ws": "fast", "ui8": "fast", "bi": "normal"} kernel_mixed = make_and_test_kernel( data=iris_amp, num_datasets=2, diff --git a/tests/test_imputed_accuracy.py b/tests/test_imputed_accuracy.py index 39110f0..8586954 100644 --- a/tests/test_imputed_accuracy.py +++ b/tests/test_imputed_accuracy.py @@ -1,4 +1,3 @@ - from sklearn.datasets import load_iris import pandas as pd import numpy as np @@ -11,16 +10,22 @@ def make_dataset(seed): random_state = np.random.RandomState(seed) iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) - iris["bi"] = random_state.binomial(1,(iris["target"] == 0).map({True: 0.85, False: 0.15}), size=150) - iris["bi"] = iris["bi"].astype('category') - iris['sp'] = iris['target'].map({0: 'A', 1: 'B', 2: 'C'}).astype('category') - del iris['target'] - iris.rename({ - 'sepal length (cm)': 'sl', - 'sepal width (cm)': 'sw', - 'petal length (cm)': 'pl', - 'petal width (cm)': 'pw', - }, axis=1, inplace=True) + iris["bi"] = random_state.binomial( + 1, (iris["target"] == 0).map({True: 0.85, False: 0.15}), size=150 + ) + iris["bi"] = iris["bi"].astype("category") + iris["sp"] = iris["target"].map({0: "A", 1: "B", 2: "C"}).astype("category") + del iris["target"] + iris.rename( + { + "sepal length (cm)": "sl", + "sepal width (cm)": "sw", + "petal length (cm)": "pl", + "petal width (cm)": "pw", + }, + axis=1, + inplace=True, + ) iris_amp = mf.utils.ampute_data(iris, perc=0.20) return iris, iris_amp @@ -72,14 +77,16 @@ def get_categorical_performance(kernel: mf.ImputationKernel, variables, iris): for col in variables: ind = kernel.na_where[col] model = kernel.get_model(col, 0, -1) - cand = kernel._make_label(col, seed=model.params['seed']) + cand = kernel._make_label(col, seed=model.params["seed"]) orig = iris.loc[ind, col] imps = kernel[col, iterations, 0] bf = kernel.get_bachelor_features(col) preds = model.predict(bf) - rocs[col] = roc_auc_score(orig, preds, multi_class='ovr', average='macro') + rocs[col] = roc_auc_score(orig, preds, multi_class="ovr", average="macro") accs[col] = (imps == orig).mean() - rand_accs[col] = np.sum(cand.value_counts(normalize=True) * imps.value_counts(normalize=True)) + rand_accs[col] = np.sum( + cand.value_counts(normalize=True) * imps.value_counts(normalize=True) + ) rocs = pd.Series(rocs) accs = pd.Series(accs) rand_accs = pd.Series(rand_accs) @@ -102,14 +109,16 @@ def test_defaults(): kernel_1.mice(4, verbose=False) kernel_1.complete_data(0, inplace=True) - rocs, accs, rand_accs = get_categorical_performance(kernel_1, ['bi', 'sp'], iris) + rocs, accs, rand_accs = get_categorical_performance( + kernel_1, ["bi", "sp"], iris + ) assert np.all(accs > rand_accs) assert np.all(rocs > 0.6) # sw Just doesn't have the information density to pass this test reliably. # It's definitely the hardest variable to model. - mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) - mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + mses = get_imp_mse(kernel_1, ["sl", "pl", "pw"], iris) + mpses = get_mean_pred_mse(kernel_1, ["sl", "pl", "pw"], iris) assert np.all(mpses > mses) @@ -130,17 +139,15 @@ def test_no_mean_match(): kernel_1.complete_data(0, inplace=True) rocs, accs, rand_accs = get_categorical_performance( - kernel=kernel_1, - variables=['bi', 'sp'], - iris=iris + kernel=kernel_1, variables=["bi", "sp"], iris=iris ) assert np.all(accs > rand_accs) assert np.all(rocs > 0.5) # sw Just doesn't have the information density to pass this test reliably. # It's definitely the hardest variable to model. - mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) - mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + mses = get_imp_mse(kernel_1, ["sl", "pl", "pw"], iris) + mpses = get_mean_pred_mse(kernel_1, ["sl", "pl", "pw"], iris) assert np.all(mpses > mses) @@ -158,24 +165,22 @@ def test_custom_params(): random_state=i, ) kernel_1.mice( - iterations=4, + iterations=4, verbose=False, - boosting='random_forest', + boosting="random_forest", num_iterations=500, min_data_in_leaf=15, ) kernel_1.complete_data(0, inplace=True) rocs, accs, rand_accs = get_categorical_performance( - kernel=kernel_1, - variables=['bi', 'sp'], - iris=iris + kernel=kernel_1, variables=["bi", "sp"], iris=iris ) assert np.all(accs > rand_accs) assert np.all(rocs > 0.5) # sw Just doesn't have the information density to pass this test reliably. # It's definitely the hardest variable to model. - mses = get_imp_mse(kernel_1, ['sl', 'pl','pw'], iris) - mpses = get_mean_pred_mse(kernel_1, ['sl', 'pl','pw'], iris) + mses = get_imp_mse(kernel_1, ["sl", "pl", "pw"], iris) + mpses = get_mean_pred_mse(kernel_1, ["sl", "pl", "pw"], iris) assert np.all(mpses > mses) diff --git a/tests/test_reproducibility.py b/tests/test_reproducibility.py index 6abbc5a..0ce2167 100644 --- a/tests/test_reproducibility.py +++ b/tests/test_reproducibility.py @@ -1,4 +1,3 @@ - from sklearn.datasets import load_iris import pandas as pd import numpy as np @@ -9,63 +8,57 @@ # Define data random_state = np.random.RandomState(1991) iris = pd.concat(load_iris(as_frame=True, return_X_y=True), axis=1) -iris['sp'] = iris['target'].astype('category') -del iris['target'] -iris.rename({ - 'sepal length (cm)': 'sl', - 'sepal width (cm)': 'ws', - 'petal length (cm)': 'pl', - 'petal width (cm)': 'pw', -}, axis=1, inplace=True) -iris['bc'] = pd.Series(np.random.binomial(n=1, p=0.5, size=150)).astype('category') +iris["sp"] = iris["target"].astype("category") +del iris["target"] +iris.rename( + { + "sepal length (cm)": "sl", + "sepal width (cm)": "ws", + "petal length (cm)": "pl", + "petal width (cm)": "pw", + }, + axis=1, + inplace=True, +) +iris["bc"] = pd.Series(np.random.binomial(n=1, p=0.5, size=150)).astype("category") iris_amp = mf.ampute_data(iris, perc=0.25, random_state=random_state) rows = iris_amp.shape[0] -random_seed_array = np.random.choice( - range(1000), - size=rows, - replace=False -).astype("int32") +random_seed_array = np.random.choice(range(1000), size=rows, replace=False).astype( + "int32" +) def test_pandas_reproducibility(): datasets = 2 kernel = mf.ImputationKernel( - data=iris_amp, - num_datasets=datasets, - initialize_empty=False, - random_state=2 + data=iris_amp, num_datasets=datasets, initialize_empty=False, random_state=2 ) kernel2 = mf.ImputationKernel( - data=iris_amp, - num_datasets=datasets, - initialize_empty=False, - random_state=2 + data=iris_amp, num_datasets=datasets, initialize_empty=False, random_state=2 ) - assert kernel.complete_data(0).equals(kernel2.complete_data(0)), ( - "random_state initialization failed to be deterministic" - ) - assert kernel.complete_data(1).equals(kernel2.complete_data(1)), ( - "random_state initialization failed to be deterministic" - ) + assert kernel.complete_data(0).equals( + kernel2.complete_data(0) + ), "random_state initialization failed to be deterministic" + assert kernel.complete_data(1).equals( + kernel2.complete_data(1) + ), "random_state initialization failed to be deterministic" # Run mice for 2 iterations kernel.mice(2) kernel2.mice(2) - assert kernel.complete_data(0).equals(kernel2.complete_data(0)), ( - "random_state after mice() failed to be deterministic" - ) - assert kernel.complete_data(1).equals(kernel2.complete_data(1)), ( - "random_state after mice() failed to be deterministic" - ) + assert kernel.complete_data(0).equals( + kernel2.complete_data(0) + ), "random_state after mice() failed to be deterministic" + assert kernel.complete_data(1).equals( + kernel2.complete_data(1) + ), "random_state after mice() failed to be deterministic" kernel_imputed_as_new = kernel.impute_new_data( - iris_amp, - random_state=4, - random_seed_array=random_seed_array + iris_amp, random_state=4, random_seed_array=random_seed_array ) # Generate and impute new data as a reordering of original @@ -74,64 +67,60 @@ def test_pandas_reproducibility(): new_data = iris_amp.loc[new_order].reset_index(drop=True) new_seeds = random_seed_array[new_order] new_imputed = kernel.impute_new_data( - new_data, - random_state=4, - random_seed_array=new_seeds + new_data, random_state=4, random_seed_array=new_seeds ) # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): reordered_kernel_completed = ( - kernel_imputed_as_new - .complete_data(dataset=0) + kernel_imputed_as_new.complete_data(dataset=0) .loc[new_order] .reset_index(drop=True) ) new_data_completed = new_imputed.complete_data(dataset=0) - assert (reordered_kernel_completed == new_data_completed).all().all(), ( - "Seeds did not cause deterministic imputations when data was reordered." - ) + assert ( + (reordered_kernel_completed == new_data_completed).all().all() + ), "Seeds did not cause deterministic imputations when data was reordered." # Generate and impute new data as a subset of original - new_ind = [0,1,4,7,8,10] + new_ind = [0, 1, 4, 7, 8, 10] new_data = iris_amp.loc[new_ind].reset_index(drop=True) new_seeds = random_seed_array[new_ind] new_imputed = kernel.impute_new_data( - new_data, - random_state=4, - random_seed_array=new_seeds + new_data, random_state=4, random_seed_array=new_seeds ) # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): - reordered_kernel_completed = kernel_imputed_as_new.complete_data(dataset=0).loc[new_ind].reset_index(drop=True) + reordered_kernel_completed = ( + kernel_imputed_as_new.complete_data(dataset=0) + .loc[new_ind] + .reset_index(drop=True) + ) new_data_completed = new_imputed.complete_data(dataset=0) - assert (reordered_kernel_completed == new_data_completed).all().all(), ( - "Seeds did not cause deterministic imputations when data was reordered." - ) + assert ( + (reordered_kernel_completed == new_data_completed).all().all() + ), "Seeds did not cause deterministic imputations when data was reordered." # Generate and impute new data as a reordering of original new_order = np.arange(rows) random_state.shuffle(new_order) new_data = iris_amp.loc[new_order].reset_index(drop=True) new_imputed = kernel.impute_new_data( - new_data, - random_state=4, - random_seed_array=random_seed_array + new_data, random_state=4, random_seed_array=random_seed_array ) # Expect deterministic imputations at the record level, since seeds were passed. for i in range(datasets): reordered_kernel_completed = ( - kernel_imputed_as_new - .complete_data(dataset=0) + kernel_imputed_as_new.complete_data(dataset=0) .loc[new_order] .reset_index(drop=True) ) new_data_completed = new_imputed.complete_data(dataset=0) - assert not (reordered_kernel_completed == new_data_completed).all().all(), ( - "Different seeds caused deterministic imputations for all rows / columns." - ) + assert ( + not (reordered_kernel_completed == new_data_completed).all().all() + ), "Different seeds caused deterministic imputations for all rows / columns." diff --git a/tests/test_sklearn_pipeline.py b/tests/test_sklearn_pipeline.py index f47d5e8..2575b63 100644 --- a/tests/test_sklearn_pipeline.py +++ b/tests/test_sklearn_pipeline.py @@ -1,4 +1,3 @@ - import numpy as np from sklearn.preprocessing import StandardScaler from sklearn.datasets import load_iris @@ -9,15 +8,18 @@ def make_dataset(seed): - random_state = np.random.RandomState(seed) iris = pd.concat(load_iris(return_X_y=True, as_frame=True), axis=1) - del iris['target'] - iris.rename({ - 'sepal length (cm)': 'sl', - 'sepal width (cm)': 'sw', - 'petal length (cm)': 'pl', - 'petal width (cm)': 'pw', - }, axis=1, inplace=True) + del iris["target"] + iris.rename( + { + "sepal length (cm)": "sl", + "sepal width (cm)": "sw", + "petal length (cm)": "pl", + "petal width (cm)": "pw", + }, + axis=1, + inplace=True, + ) iris_amp = mf.utils.ampute_data(iris, perc=0.20) return iris_amp @@ -30,19 +32,17 @@ def test_pipeline(): kernel = mf.ImputationKernel(iris_amp_train, num_datasets=1) - pipe = Pipeline([ - ('impute', kernel), - ('scaler', StandardScaler()), - ]) + pipe = Pipeline( + [ + ("impute", kernel), + ("scaler", StandardScaler()), + ] + ) # The pipeline can be used as any other estimator # and avoids leaking the test set into the train set - X_train_t = pipe.fit_transform( - X=iris_amp_train, - y=None, - impute__iterations=2 - ) + X_train_t = pipe.fit_transform(X=iris_amp_train, y=None, impute__iterations=2) X_test_t = pipe.transform(iris_amp_test) assert not np.any(np.isnan(X_train_t)) - assert not np.any(np.isnan(X_test_t)) \ No newline at end of file + assert not np.any(np.isnan(X_test_t)) diff --git a/tests/test_utils.py b/tests/test_utils.py index f15e362..fecae0b 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,10 +1,8 @@ - -from miceforest.utils import ( - stratified_subset -) +from miceforest.utils import stratified_subset import numpy as np import pandas as pd + def test_subset(): strat_std_closer = [] @@ -12,12 +10,7 @@ def test_subset(): for i in range(1000): y = pd.Series(np.random.normal(size=1000)) size = 100 - ss_ind = stratified_subset( - y, - size, - groups=10, - random_state=i - ) + ss_ind = stratified_subset(y, size, groups=10, random_state=i) y_strat_sub = y[ss_ind] y_rand_sub = np.random.choice(y, size, replace=False) @@ -53,10 +46,10 @@ def test_subset_continuous_reproduce(): def test_subset_categorical_reproduce(): # Tests for reproducibility in categorical stratified subsetting for i in range(100): - y = pd.Series(np.random.randint(low=1, high=10, size=1000)).astype('category') + y = pd.Series(np.random.randint(low=1, high=10, size=1000)).astype("category") size = 100 ss1 = stratified_subset(y, size, groups=10, random_state=i) ss2 = stratified_subset(y, size, groups=10, random_state=i) - assert np.all(ss1 == ss2) \ No newline at end of file + assert np.all(ss1 == ss2) From 08c9f4c7be1a5bf763611a8633ebd7b2a8145e14 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:41:09 -0400 Subject: [PATCH 18/44] Updated readme to remove seaborn reference --- README.md | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 616f5c6..41b5320 100644 --- a/README.md +++ b/README.md @@ -372,7 +372,7 @@ new_data_imputed = cust_kernel.impute_new_data(new_data=new_data) print(f"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds") ``` - New Data imputed in 0.040128 seconds + New Data imputed in 0.040396 seconds ## Saving and Loading Kernels @@ -916,7 +916,7 @@ acclist 0 0.35 1 0.81 2 0.81 - 3 0.81 + 3 0.78 Name: Species Imputation Accuracy, dtype: float64 @@ -1041,13 +1041,6 @@ ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst) ``` - - - - - - - ```python import plotnine as p9 import itertools From 22962b07e0c87fde105b970b1279d97630816df4 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:41:30 -0400 Subject: [PATCH 19/44] Updated dependencies, added black formatting check --- .github/workflows/run_tests.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index e9ed80c..0742124 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -27,10 +27,8 @@ jobs: pip install mypy pip install codecov pip install pytest-cov - pip install blosc2 - pip install dill pip install pandas - pip install seaborn + pip install plotnine pip install matplotlib pip install scipy pip install scikit-learn @@ -39,5 +37,6 @@ jobs: - name: Test with pytest run: | mypy miceforest + black miceforest --check pytest --cov-config .coveragerc --cov-report html --cov=miceforest codecov From 8d64c24d933bae9115bd5cce99b0a30e11bdb4b9 Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 08:41:43 -0400 Subject: [PATCH 20/44] Updated dependencies --- setup.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 6d24b85..2ee522d 100644 --- a/setup.py +++ b/setup.py @@ -15,14 +15,13 @@ long_description=long_description, long_description_content_type="text/markdown", install_requires=[ - 'lightgbm >= 3.3.1', + 'lightgbm >= 4.1.0', 'numpy', - "blosc2", - "dill" + "pandas" ], extras_require={ "Plotting": [ - 'seaborn >= 0.11.0', + 'plotnine >=0.13.6' 'matplotlib >= 3.3.0' ], "Default_MM": [ From bc4d7f0b27a4783fd0fe08584ada2e67a2a8abda Mon Sep 17 00:00:00 2001 From: AnotherSamWilson Date: Fri, 26 Jul 2024 10:07:55 -0400 Subject: [PATCH 21/44] Committing image files, hopefully I don't regret this. --- README_files/README_48_0.png | Bin 0 -> 111130 bytes README_files/README_50_0.png | Bin 0 -> 120575 bytes README_files/README_60_0.png | Bin 0 -> 395943 bytes README_files/README_63_0.png | Bin 0 -> 194847 bytes README_files/README_64_0.png | Bin 0 -> 192691 bytes 5 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 README_files/README_48_0.png create mode 100644 README_files/README_50_0.png create mode 100644 README_files/README_60_0.png create mode 100644 README_files/README_63_0.png create mode 100644 README_files/README_64_0.png diff --git a/README_files/README_48_0.png b/README_files/README_48_0.png new file mode 100644 index 0000000000000000000000000000000000000000..7ad596dd83621416b4bb53ccdb428386199fe46d GIT binary patch literal 111130 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 literal 0 HcmV?d00001 diff --git a/README_files/README_60_0.png b/README_files/README_60_0.png new file mode 100644 index 0000000000000000000000000000000000000000..5a8e9b3ca8e4fc0f29a8a1ba1c2366e88f4dddd6 GIT binary patch literal 395943 zcmcfpc{tZ?7c~xlkxY?fh$xB-8AGHRqFd7gXkwbowyj68Da05c;GBZWd?*49!t zpipSN$iMWf@h3b?&lT{WT^<@H9)_+C9v5uf?I{OsJlvdJJ)BS3@}IYNKX=OYjI87? zNf~i|M-LCTb4pTDF8}ujBwgK4N`2t|C4diMaMLn9N1<%0A^%dHY4KE{P*Et_>idkm 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�tUAlUApBbw`1T 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

SAR0`P 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�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%0DJn5wd#p44jJo#22Y& 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