From 848fe5400cb505b8f357c325e0b33050f5b457b0 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Fri, 5 Jul 2024 11:01:18 +0100 Subject: [PATCH 01/97] Direct implementation of R `ssm_analysis()` --- src/circumplex/__init__.py | 2 +- src/circumplex/circumplex.py | 4 +- src/circumplex/core/__init__.py | 0 src/circumplex/core/ssm_analysis.py | 695 ++++++++++++++++++++++++++++ src/circumplex/datasets.py | 4 +- src/circumplex/instrument.py | 46 +- src/circumplex/utils.py | 17 +- 7 files changed, 742 insertions(+), 26 deletions(-) create mode 100644 src/circumplex/core/__init__.py create mode 100644 src/circumplex/core/ssm_analysis.py diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index b8cfd5d..46b356f 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -2,4 +2,4 @@ # from circumplex import datasets from circumplex import instrument -from circumplex import utils \ No newline at end of file +from circumplex import utils diff --git a/src/circumplex/circumplex.py b/src/circumplex/circumplex.py index 893b947..0d7783c 100644 --- a/src/circumplex/circumplex.py +++ b/src/circumplex/circumplex.py @@ -459,8 +459,8 @@ def profile_plot( incl_fit=True, incl_disp=True, incl_amp=True, - c_scores='red', - c_fit='black', + c_scores="red", + c_fit="black", ) -> plt.Axes: """ Plot the SSM profile. diff --git a/src/circumplex/core/__init__.py b/src/circumplex/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py new file mode 100644 index 0000000..9433a79 --- /dev/null +++ b/src/circumplex/core/ssm_analysis.py @@ -0,0 +1,695 @@ +# %% + +import pandas as pd +import numpy as np +from scipy import stats +from scipy.optimize import curve_fit +from typing import Optional, List, Union, Callable + + +BOUNDS = ([0, 0, -np.inf], [np.inf, 2*np.pi, np.inf]) +OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) + + +def ssm_analyze( + data: pd.DataFrame, + scales: List[str], + angles: Optional[List[float]] = OCTANTS, + measures: Optional[List[str]] = None, + grouping: Optional[str] = None, + contrast: Optional[str] = "none", + boots: int = 2000, + interval: float = 0.95, + listwise: bool = True, + measures_labels: Optional[List[str]] = None, +) -> dict: + """ + Perform analyses using the Structural Summary Method. + + This function calculates SSM parameters with bootstrapped confidence intervals for various + analysis types. Depending on the arguments supplied, it performs either mean-based or + correlation-based analyses, uses one or more groups to stratify the data, and calculates + contrasts between groups or measures. + + Args: + data (pd.DataFrame): A DataFrame containing at least circumplex scales. + scales (List[str]): The variable names for the circumplex scales to be analyzed. + angles (Optional[List[float]]): Angular displacement of each circumplex scale (in degrees). + measures (Optional[List[str]]): Variables to be correlated with the circumplex scales. + grouping (Optional[str]): Variable name that indicates group membership of each observation. + contrast (str): Type of contrast to run ("none", "model", or "test"). + boots (int): Number of bootstrap resamples for estimating confidence intervals. + interval (float): Confidence level for estimating the confidence intervals. + listwise (bool): Whether to use listwise deletion for missing values. + measures_labels (Optional[List[str]]): Labels for each measure provided in measures. + + Returns: + dict: A dictionary containing the results and description of the analysis. + """ + + assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" + assert all( + scale in data.columns for scale in scales + ), "All scales must be present in data" + assert isinstance(angles, list) and all( + isinstance(a, (int, float)) for a in angles + ), "angles must be a list of numbers" + assert isinstance(boots, int) and boots > 0, "boots must be a positive integer" + assert 0 < interval < 1, "interval must be between 0 and 1" + assert isinstance(listwise, bool), "listwise must be a boolean" + assert contrast in [ + "none", + "model", + "test", + ], "contrast must be 'none', 'model', or 'test'" + + if measures is not None: + assert all( + measure in data.columns for measure in measures + ), "All measures must be present in data" + + if grouping is not None: + assert grouping in data.columns, "grouping must be a column in data" + + if measures_labels is not None: + assert len(measures_labels) == len( + measures + ), "measures_labels must have the same length as measures" + + # Convert angles from degrees to radians + angles_rad = np.deg2rad(angles) + + # Determine analysis type and forward to appropriate subfunction + if measures is not None: + if grouping is not None: + # Multiple group correlations + results = ssm_analyze_corrs( + data, + scales, + angles_rad, + measures, + grouping, + contrast, + boots, + interval, + listwise, + measures_labels, + ) + else: + # Single group correlations + results = ssm_analyze_corrs( + data, + scales, + angles_rad, + measures, + None, + contrast, + boots, + interval, + listwise, + measures_labels, + ) + else: + if grouping is not None: + # Multiple group means + results = ssm_analyze_means( + data, scales, angles_rad, grouping, contrast, boots, interval, listwise + ) + else: + # Single group means + if contrast != "none": + raise ValueError( + "Without specifying measures or grouping, no contrasts are possible. " + "Set contrast = 'none' or add the measures or grouping arguments." + ) + results = ssm_analyze_means( + data, scales, angles_rad, None, "none", boots, interval, listwise + ) + + return results + + +def ssm_analyze_means( + data: pd.DataFrame, + scales: List[str], + angles: List[float], + grouping: Optional[str] = None, + contrast: str = "none", + boots: int = 2000, + interval: float = 0.95, + listwise: bool = True, +) -> dict: + """ + Perform analyses using the mean-based Structural Summary Method. + + Args: + data (pd.DataFrame): A DataFrame containing at least circumplex scales. + scales (List[str]): The variable names for the circumplex scales to be analyzed. + angles (List[float]): Angular displacement of each circumplex scale (in radians). + grouping (Optional[str]): Variable name that indicates group membership of each observation. + contrast (str): Type of contrast to run ("none", "model", or "test"). + boots (int): Number of bootstrap resamples for estimating confidence intervals. + interval (float): Confidence level for estimating the confidence intervals. + listwise (bool): Whether to use listwise deletion for missing values. + + Returns: + dict: A dictionary containing the results and description of the analysis. + """ + # Select circumplex scales and grouping variable (if applicable) + if grouping is not None: + bs_input = data[scales + [grouping]].copy() + bs_input["Group"] = bs_input[grouping].astype("category") + + # Check if more than one contrast is possible + if contrast != "none" and len(bs_input["Group"].cat.categories) != 2: + raise ValueError( + "Only two groups can be contrasted at a time. Set contrast = 'none' or use a dichotomous grouping variable." + ) + else: + bs_input = data[scales].copy() + bs_input["Group"] = "All" + + # Perform listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() + + # Calculate mean observed scores + scores = bs_input.groupby("Group")[scales].mean().reset_index() + scores = scores.rename_axis("label").reset_index() + + # Define bootstrap function + def bs_function(data, index, angles, contrast, listwise): + resample = data.iloc[index] + scores_r = resample.groupby("Group")[scales].mean() + return ssm_by_group(scores_r, angles, contrast) + + # Perform bootstrapping + bs_output = ssm_bootstrap( + bs_input=bs_input, + bs_function=bs_function, + angles=angles, + boots=boots, + interval=interval, + contrast=contrast, + listwise=listwise, + strata=bs_input["Group"], + ) + + # Select and label results + group_levels = bs_input["Group"].unique() + if contrast == "none": + row_data = bs_output + row_labels = group_levels + else: + row_data = bs_output.iloc[-1:] + row_labels = [f"{group_levels[1]} - {group_levels[0]}"] + + results = row_data.copy() + results["label"] = row_labels + + # Collect analysis details + details = { + "boots": boots, + "interval": interval, + "listwise": listwise, + "angles": np.rad2deg(angles), + "contrast": contrast, + "score_type": "Mean", + "results_type": "Profile" if contrast == "none" else "Contrast", + } + + # Create output dictionary + out = {"results": results, "scores": scores, "details": details} + + return out + + +def ssm_by_group( + scores: pd.DataFrame, angles: List[float], contrast: str +) -> np.ndarray: + """ + Calculate SSM parameters for each group, potentially with contrast. + + Args: + scores (pd.DataFrame): DataFrame containing scores for each group. + angles (List[float]): Angular displacement of each circumplex scale (in radians). + contrast (str): Type of contrast to run ("none", "model", or "test"). + + Returns: + np.ndarray: Array of SSM parameters for each group (and contrast if applicable). + """ + # Convert scores DataFrame to numpy array + scores_array = scores.to_numpy() + + # To model contrast, subtract scores then SSM + if contrast == "model": + contrast_scores = scores_array[1] - scores_array[0] + scores_array = np.vstack([scores_array, contrast_scores]) + + # Calculate parameters per group + results = group_parameters(scores_array, angles) + + # To test contrast, SSM then subtract parameters + if contrast == "test": + contrast_params = results[6:] - results[:6] + results = np.concatenate([results, contrast_params]) + + return results + + +def group_parameters(scores: np.ndarray, angles: List[float]) -> np.ndarray: + """ + Calculate the SSM parameters as a vector for each group where rows are groups. + + Args: + scores (np.ndarray): 2D array where each row represents a group's scores. + angles (List[float]): Angular displacement of each circumplex scale (in radians). + + Returns: + np.ndarray: 1D array of SSM parameters for all groups. + """ + n = scores.shape[0] # Number of groups + out = np.zeros(n * 6) # Initialize output array + + for i in range(n): + out[i * 6 : (i + 1) * 6] = ssm_parameters_cpp(scores[i], angles) + + return out + + +# def ssm_parameters_cpp(scores: np.ndarray, angles: List[float]) -> np.ndarray: +# """ +# Calculate SSM parameters for a single group. +# +# Args: +# scores (np.ndarray): 1D array of scores for a single group. +# angles (List[float]): Angular displacement of each circumplex scale (in radians). +# +# Returns: +# np.ndarray: Array of 6 SSM parameters [elevation, x-value, y-value, amplitude, angular displacement, model fit]. +# """ +# # Ensure scores and angles are numpy arrays +# scores = np.array(scores) +# angles = np.array(angles) +# +# # Calculate SSM parameters +# elevation = np.mean(scores) +# x_value = np.mean(scores * np.cos(angles)) +# y_value = np.mean(scores * np.sin(angles)) +# amplitude = np.sqrt(x_value**2 + y_value**2) +# displacement = np.arctan2(y_value, x_value) +# +# # Calculate model fit (R-squared) +# predicted_scores = elevation + amplitude * np.cos(angles - displacement) +# ss_total = np.sum((scores - np.mean(scores)) ** 2) +# ss_residual = np.sum((scores - predicted_scores) ** 2) +# model_fit = 1 - (ss_residual / ss_total) +# +# return np.array([elevation, x_value, y_value, amplitude, displacement, model_fit]) + + +def cosine_form(theta, ampl, disp, elev): + """Cosine function with amplitude, dispersion and elevation parameters.""" + return elev + ampl * np.cos(theta - disp) + + +def _r2_score(y_true: np.array, y_pred: np.array): + """Calculate the R2 score for a set of predictions.""" + ss_res = np.sum(np.square(y_true - y_pred)) + ss_tot = np.sum(np.square(y_true - np.mean(y_true))) + return 1 - (ss_res / ss_tot) + + + +def ssm_parameters_cpp(scores, angles, bounds=BOUNDS) -> tuple: + """Calculate SSM parameters (without confidence intervals) for a set of scores. + + Args: + scores (np.array): A numeric vector (or single row dataframe) containing one score for each of a + set of circumplex scales. + angles (tuple): A numeric vector containing the angular displacement of each circumplex scale + included in `scores`. + bounds (tuple, optional): The bounds for each of the parameters of the curve optimisation. + Defaults to ([0, 0, -1], [np.inf, 360, 1]). + + Returns: + tuple: A tuple containing the elevation, x-value, y-value, amplitude, displacement, and R2 fit of the SSM curve. + + Examples: + # >>> scores = np.array([-0.5, 0, 0.25, 0.51, 0.52, 0.05, -0.26, -0.7]) + # >>> angles = OCTANTS + # >>> results = ssm_parameters_cpp(scores, angles) + # >>> [round(i, 3) for i in results] + [-0.016, -0.478, 0.333, 0.582, 145.158, 0.967] + """ + + # noinspection PyTupleAssignmentBalance + # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off + # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution + param, covariance = curve_fit( + cosine_form, xdata=angles, ydata=scores, bounds=bounds + ) + r2 = _r2_score(scores, cosine_form(angles, *param)) + ampl, disp, elev = param + + def polar2cart(r, theta): + x = r * np.cos(theta) + y = r * np.sin(theta) + return x, y + + xval, yval = polar2cart(ampl, disp) + return np.array([elev, xval, yval, ampl, disp, r2]) + +def ssm_bootstrap( + bs_input: pd.DataFrame, + bs_function: Callable, + angles: List[float], + boots: int, + interval: float, + contrast: str, + listwise: bool, + strata: Optional[pd.Series] = None, +) -> pd.DataFrame: + """ + Perform bootstrap to get confidence intervals around SSM parameters. + + Args: + bs_input (pd.DataFrame): Input data for bootstrapping. + bs_function (Callable): Function to calculate SSM parameters. + angles (List[float]): Angular displacement of each circumplex scale (in radians). + boots (int): Number of bootstrap resamples. + interval (float): Confidence interval level. + contrast (str): Type of contrast to run ("none", "model", or "test"). + listwise (bool): Whether to use listwise deletion for missing values. + strata (Optional[pd.Series]): Series to use for stratified sampling. + + Returns: + pd.DataFrame: DataFrame containing bootstrap results. + """ + # Perform bootstrapping + bootstrap_results = [] + for _ in range(boots): + if strata is not None: + resample = ( + bs_input.groupby(strata, observed=False) + .apply(lambda x: x.sample(n=len(x), replace=True)) + .reset_index(drop=True) + ) + else: + resample = bs_input.sample(n=len(bs_input), replace=True) + bootstrap_results.append( + bs_function(resample, range(len(resample)), angles, contrast, listwise) + ) + + bs_t = np.array(bootstrap_results) + + # Calculate point estimates + bs_est = pd.DataFrame( + bs_function(bs_input, range(len(bs_input)), angles, contrast, listwise).reshape( + -1, 6 + ), + columns=[f"{p}_est" for p in ["e", "x", "y", "a", "d", "fit"]], + ) + + # Calculate confidence intervals + bs_lci = pd.DataFrame( + np.percentile(bs_t, (1 - interval) / 2 * 100, axis=0).reshape(-1, 6), + columns=[f"{p}_lci" for p in ["e", "x", "y", "a", "d", "fit"]], + ) + bs_uci = pd.DataFrame( + np.percentile(bs_t, (1 + interval) / 2 * 100, axis=0).reshape(-1, 6), + columns=[f"{p}_uci" for p in ["e", "x", "y", "a", "d", "fit"]], + ) + + # Combine results and convert radians to degrees for displacement + results = pd.concat([bs_est, bs_lci, bs_uci], axis=1) + for col in ["d_est", "d_lci", "d_uci"]: + results[col] = np.rad2deg(results[col]) + + return results + + +def angle_median(angles: np.ndarray) -> float: + """ + Calculate the median of circular data. + + Args: + angles (np.ndarray): Array of angles in radians. + + Returns: + float: Median angle in radians. + """ + return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) + + +def ssm_analyze_corrs(data: pd.DataFrame, + scales: List[str], + angles: List[float], + measures: List[str], + grouping: Optional[str] = None, + contrast: str = "none", + boots: int = 2000, + interval: float = 0.95, + listwise: bool = True, + measures_labels: Optional[List[str]] = None) -> dict: + """ + Perform analyses using the correlation-based Structural Summary Method. + + Args: + data (pd.DataFrame): A DataFrame containing at least circumplex scales and measures. + scales (List[str]): The variable names for the circumplex scales to be analyzed. + angles (List[float]): Angular displacement of each circumplex scale (in radians). + measures (List[str]): Variables to be correlated with the circumplex scales. + grouping (Optional[str]): Variable name that indicates group membership of each observation. + contrast (str): Type of contrast to run ("none", "model", or "test"). + boots (int): Number of bootstrap resamples for estimating confidence intervals. + interval (float): Confidence level for estimating the confidence intervals. + listwise (bool): Whether to use listwise deletion for missing values. + measures_labels (Optional[List[str]]): Labels for each measure provided in measures. + + Returns: + dict: A dictionary containing the results and description of the analysis. + """ + # Select circumplex scales, measure variables, and grouping variable + if grouping is not None: + bs_input = data[scales + measures + [grouping]].copy() + bs_input['Group'] = bs_input[grouping].astype('category') + else: + bs_input = data[scales + measures].copy() + bs_input['Group'] = 'All' + + # Check that this combination of arguments is executable + n_measures = len(measures) + n_groups = bs_input['Group'].nunique() + if contrast != "none": + contrast_measures = (n_measures == 2 and n_groups == 1) + contrast_groups = (n_measures == 1 and n_groups == 2) + if not (contrast_measures or contrast_groups): + raise ValueError("No valid contrasts were possible. To contrast measures, ensure " + "there are 2 measures and no grouping variable. To contrast groups, " + "ensure there is 1 measure and a dichotomous grouping variable.") + + # Perform listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() + + # Select and label results + if measures_labels is None: + measure_names = measures + else: + measure_names = measures_labels + + # Calculate observed scores (i.e., correlations) + cs = bs_input[scales].values + mv = bs_input[measures].values + grp = bs_input['Group'].astype('category').cat.codes.values + scores = corr_scores(cs, mv, grp, listwise) + scores_df = pd.DataFrame(scores, columns=scales) + scores_df['Group'] = np.repeat(bs_input['Group'].unique(), len(measures)) + scores_df['Measure'] = np.tile(measure_names, n_groups) + if grouping is not None: + scores_df['label'] = scores_df['Group'].astype(str) + "_" + scores_df['Measure'] + else: + scores_df['label'] = scores_df['Measure'] + + # Define bootstrap function + def bs_function(data, index, angles, contrast, listwise): + resample = data.iloc[index] + grp = resample['Group'].astype('category').cat.codes.values + cs = resample[scales].values + mv = resample[measures].values + scores_r = corr_scores(cs, mv, grp, listwise) + scores_r = scores_r.drop(columns=['Group', 'Measure']) + return ssm_by_group(scores_r, angles, contrast) + + # Perform bootstrapping + bs_output = ssm_bootstrap( + bs_input=bs_input, + bs_function=bs_function, + angles=angles, + boots=boots, + interval=interval, + contrast=contrast, + listwise=listwise, + strata=bs_input['Group'] + ) + + # Select and label results + group_names = bs_input['Group'].cat.categories + if contrast == "none": + row_data = bs_output + grp_labels = np.repeat(group_names, len(measures)) + msr_labels = np.tile(measure_names, n_groups) + if grouping is not None: + lbl_labels = grp_labels + "_" + msr_labels + else: + lbl_labels = msr_labels + results = row_data.assign( + label=lbl_labels, + Group=grp_labels, + Measure=msr_labels + ) + else: + row_data = bs_output.iloc[-1:].copy() + if n_measures == 2: + row_labels = [f"{measure_names[1]} - {measure_names[0]}"] + else: + row_labels = [f"{measure_names[0]}: {group_names[1]} - {group_names[0]}"] + results = row_data.assign(label=row_labels) + + # Collect analysis details + details = { + 'boots': boots, + 'interval': interval, + 'listwise': listwise, + 'angles': np.rad2deg(angles), + 'contrast': contrast, + 'score_type': "Correlation", + 'results_type': "Profile" if contrast == "none" else "Contrast" + } + + # Create output dictionary + out = { + 'results': results, + 'scores': scores_df, + 'details': details + } + + return out + + +def corr_scores(scores: Union[np.ndarray, pd.DataFrame], + measures: Union[np.ndarray, pd.DataFrame], + grouping: Union[np.ndarray, pd.Series], + listwise: bool, + scales: List[str] = None + ) -> pd.DataFrame: + """ + Calculate the correlation of each measure with each scale by group. + + Args: + scores (Union[np.ndarray, pd.DataFrame]): Circumplex scale scores. + measures (Union[np.ndarray, pd.DataFrame]): Measure variable scores. + grouping (Union[np.ndarray, pd.Series]): Group codes. + listwise (bool): Whether to use listwise deletion (True) or pairwise deletion (False). + scales (List[str], optional): Names of the circumplex scales. If None, will use column names if cs is a DataFrame, else will use default names. + + Returns: + pd.DataFrame: Correlation scores. + """ + # Convert inputs to numpy arrays if they're not already + cs_array = scores.values if isinstance(scores, pd.DataFrame) else scores + mv_array = measures.values if isinstance(measures, pd.DataFrame) else measures + grp_array = grouping.values if isinstance(grouping, (pd.Series, pd.DataFrame)) else grouping + + levels = np.unique(grp_array) + ng = len(levels) + pm, ps = mv_array.shape[1], cs_array.shape[1] + out = np.zeros((ng * pm, ps)) + + if ng == 1: + if listwise: + # Single group and LWD + out = np.corrcoef(mv_array.T, cs_array.T)[:pm, pm:] + else: + # Single group and PWD + for m in range(pm): + x = mv_array[:, m] + for s in range(ps): + y = cs_array[:, s] + out[m, s] = pairwise_r(x, y) + else: + if listwise: + # Multiple groups and LWD + for g, level in enumerate(levels): + mask = (grp_array == level) + gcs = cs_array[mask] + gmv = mv_array[mask] + out[g * pm:(g + 1) * pm, :] = np.corrcoef(gmv.T, gcs.T)[:pm, pm:] + else: + # Multiple groups and PWD + for g, level in enumerate(levels): + mask = (grp_array == level) + gcs = cs_array[mask] + gmv = mv_array[mask] + for m in range(pm): + x = gmv[:, m] + for s in range(ps): + y = gcs[:, s] + out[g * pm + m, s] = pairwise_r(x, y) + + # Create a DataFrame from the output + if scales is None: + if isinstance(scores, pd.DataFrame): + scales = scores.columns.tolist() + else: + scales = [f'Scale_{i + 1}' for i in range(ps)] + + df_out = pd.DataFrame(out, columns=scales) + + # Add group and measure information + if isinstance(measures, pd.DataFrame): + measure_names = measures.columns.tolist() + else: + measure_names = [f'Measure_{i + 1}' for i in range(pm)] + + df_out['Group'] = np.repeat(levels, pm) + df_out['Measure'] = np.tile(measure_names, ng) + + return df_out + + +def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: + """ + Calculate the Pearson correlation coefficient using pairwise deletion. + + Args: + x (np.ndarray): First array of values. + y (np.ndarray): Second array of values. + + Returns: + float: Pearson correlation coefficient. + """ + mask = ~(np.isnan(x) | np.isnan(y)) + x, y = x[mask], y[mask] + return np.corrcoef(x, y)[0, 1] if len(x) > 1 else np.nan + + +# %% + +if __name__ == "__main__": + ######## SCRATCH ######## + from importlib.resources import files + + _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) + data = pd.read_csv(_jz2017_path) + + results = ssm_analyze( + data=data, + scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + angles=[90, 135, 180, 225, 270, 315, 0, 45], + grouping = 'Gender', + measures = ['NARPD', 'ASPD'], + # measures_labels=['Narcissistic PD', 'Antisocial PD'], + ) + print(results['results']) diff --git a/src/circumplex/datasets.py b/src/circumplex/datasets.py index 54ef1aa..9f3bcd2 100644 --- a/src/circumplex/datasets.py +++ b/src/circumplex/datasets.py @@ -11,4 +11,6 @@ _satp_path = str(files("circumplex.data").joinpath("SATP Dataset v1.4.xlsx")) satp_data = pd.read_excel(_satp_path) -SATP_ENG = instrument.load_instrument("SATP-eng").attach_data(satp_data.query("Language == 'eng'")) +SATP_ENG = instrument.load_instrument("SATP-eng").attach_data( + satp_data.query("Language == 'eng'") +) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index dc1506d..7b85a6e 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -59,7 +59,8 @@ def from_dict(inst_dict: dict) -> Instrument: label=[scale["label"] for scale in inst_dict["scales"].values()], angle=[scale["angle"] for scale in inst_dict["scales"].values()], inst_items=[ - inst_dict["scales"][scale]["inst_items"] for scale in inst_dict["scales"].keys() + inst_dict["scales"][scale]["inst_items"] + for scale in inst_dict["scales"].keys() ] if items_exist else None, @@ -68,10 +69,14 @@ def from_dict(inst_dict: dict) -> Instrument: value=[int(key) for key in inst_dict["anchors"].keys()], label=list(inst_dict["anchors"].values()), ) - norms = Norms( - table=pd.DataFrame.from_dict(inst_dict["norms"]), - src=pd.DataFrame.from_dict(inst_dict["norms_src"]) - ) if "norms" in inst_dict else None + norms = ( + Norms( + table=pd.DataFrame.from_dict(inst_dict["norms"]), + src=pd.DataFrame.from_dict(inst_dict["norms_src"]), + ) + if "norms" in inst_dict + else None + ) details = InstrumentDetails(**inst_dict["details"]) return Instrument(scales, anchors, details, norms) @@ -140,7 +145,9 @@ def __str__(self): def show(self, n=10): n = len(self.data) if n is None or n > len(self.data) else n - p = "\n".join([f"{number}. {text}" for number, text in list(self.data.items())[:n]]) + p = "\n".join( + [f"{number}. {text}" for number, text in list(self.data.items())[:n]] + ) if n < len(self.data): p += f"\n\n...and {len(self.data) - n} more items." @@ -177,7 +184,9 @@ def show(self, inst_items: bool = True): for i, abbrev in enumerate(self.abbrev): p.append(f"{abbrev}: {self.label[i]} ({self.angle[i]}°)") p.append( - "\n".join([f"\t{key}: {val}" for key, val in self.inst_items[i].items()]) + "\n".join( + [f"\t{key}: {val}" for key, val in self.inst_items[i].items()] + ) ) return print("\n".join(p)) @@ -237,15 +246,19 @@ class Instrument: def __repr__(self): return ( - f"{self.details.abbrev}: {self.details.name}\n" - f"{self.details.inst_items} Items, {self.details.scales} Scales\n" - f"{self.details.reference}\n" - f"<{self.details.url}>" - ) if self.norms is None else ( - f"{self.details.abbrev}: {self.details.name}\n" - f"{self.details.inst_items} Items, {self.details.scales} Scales, {len(self.norms.src)} normative data sets\n" - f"{self.details.reference}\n" - f"<{self.details.url}>" + ( + f"{self.details.abbrev}: {self.details.name}\n" + f"{self.details.inst_items} Items, {self.details.scales} Scales\n" + f"{self.details.reference}\n" + f"<{self.details.url}>" + ) + if self.norms is None + else ( + f"{self.details.abbrev}: {self.details.name}\n" + f"{self.details.inst_items} Items, {self.details.scales} Scales, {len(self.norms.src)} normative data sets\n" + f"{self.details.reference}\n" + f"<{self.details.url}>" + ) ) @property @@ -294,7 +307,6 @@ def summary(self): "\nNo data has been loaded for this instrument. Use attach_data() to load data." ) - def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrument: # check scales assert set(self.scales.abbrev).issubset(data.columns), ( diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 9aaac52..1acc968 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -3,8 +3,15 @@ from circumplex.instrument import Scales, Instrument -def standardize(data: pd.DataFrame, scales: Scales, angles: np.array, instrument: Instrument, sample: int = 1, - prefix: str = "", suffix: str = "_z"): +def standardize( + data: pd.DataFrame, + scales: Scales, + angles: np.array, + instrument: Instrument, + sample: int = 1, + prefix: str = "", + suffix: str = "_z", +): scale_names = scales.abbrev assert len(scale_names) == len(angles) @@ -14,9 +21,9 @@ def standardize(data: pd.DataFrame, scales: Scales, angles: np.array, instrument for i in range(len(angles)): scale_i = scale_names[i] new_var = f"{prefix}{scale_i}{suffix}" - index_i = key['angle'][i] - m_i = key['m'][i] - s_i = key['sd'][i] + index_i = key["angle"][i] + m_i = key["m"][i] + s_i = key["sd"][i] data[new_var] = (data[scale_i] - m_i) / s_i return data From 1ce506df16498ea3a333e5e065ddd776b99136ed Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Fri, 5 Jul 2024 23:13:27 +0100 Subject: [PATCH 02/97] Implement circle plotting --- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 909 +-------------------- docs/tutorials/Random_exs.ipynb | 494 ++--------- src/circumplex/core/instrument.py | 97 +++ src/circumplex/core/plot.py | 248 ++++++ src/circumplex/core/ssm_analysis.py | 61 +- src/circumplex/core/ssm_plot.py | 218 +++++ src/circumplex/core/ssm_results.py | 44 + 7 files changed, 747 insertions(+), 1324 deletions(-) create mode 100644 src/circumplex/core/instrument.py create mode 100644 src/circumplex/core/plot.py create mode 100644 src/circumplex/core/ssm_plot.py create mode 100644 src/circumplex/core/ssm_results.py diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index ac8b0c0..8547510 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -31,8 +31,8 @@ "import matplotlib.pyplot as plt\n", "degree_sign = u'\\N{DEGREE SIGN}'" ], - "outputs": [], - "execution_count": 30 + "execution_count": 30, + "outputs": [] }, { "cell_type": "markdown", @@ -86,19 +86,8 @@ } }, "id": "b2b2c99827c47a27", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 31 + "execution_count": 31, + "outputs": [] }, { "cell_type": "markdown", @@ -137,19 +126,8 @@ } }, "id": "21f5a12726008489", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 32 + "execution_count": 32, + "outputs": [] }, { "cell_type": "markdown", @@ -180,19 +158,8 @@ } }, "id": "c90c1bcb4a07781b", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 33 + "execution_count": 33, + "outputs": [] }, { "cell_type": "markdown", @@ -222,19 +189,8 @@ } }, "id": "c826947d0b98109e", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 34 + "execution_count": 34, + "outputs": [] }, { "cell_type": "markdown", @@ -289,19 +245,8 @@ } }, "id": "3d4382669e2bbfa8", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 35 + "execution_count": 35, + "outputs": [] }, { "metadata": {}, @@ -358,22 +303,8 @@ } }, "id": "d06f5b82ed8a562c", - "outputs": [ - { - "data": { - "text/plain": [ - "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", - "32 Items, 8 Scales, 2 normative data sets\n", - "Soldz, Budman, Demby, & Merry (1995)\n", - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 36 + "execution_count": 36, + "outputs": [] }, { "cell_type": "markdown", @@ -396,186 +327,8 @@ } }, "id": "3828a5802369696e", - "outputs": [ - { - "data": { - "text/plain": [ - " Gender PA BC DE FG HI JK LM NO PARPD SCZPD \\\n", - "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 3 \n", - "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 0 \n", - "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 1 \n", - "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 0 \n", - "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 0 \n", - "\n", - " SZTPD ASPD BORPD HISPD NARPD AVPD DPNPD OCPD \n", - "0 7 7 8 4 6 3 4 6 \n", - "1 2 0 1 2 3 0 1 0 \n", - "2 0 4 1 5 4 0 0 1 \n", - "3 0 0 1 0 0 0 0 0 \n", - "4 0 0 1 0 0 1 0 0 " - ], - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GenderPABCDEFGHIJKLMNOPARPDSCZPDSZTPDASPDBORPDHISPDNARPDAVPDDPNPDOCPD
0Female1.501.501.251.002.002.502.252.504377846346
1Female0.000.250.000.251.251.752.252.251020123010
2Female0.000.000.000.000.000.000.000.000104154001
3Male2.001.751.752.502.001.752.002.501000100000
4Female0.250.500.250.000.000.000.000.000000100100
\n", - "
" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 37 + "execution_count": 37, + "outputs": [] }, { "cell_type": "markdown", @@ -598,19 +351,8 @@ } }, "id": "4fca74a7a59559a", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 38 + "execution_count": 38, + "outputs": [] }, { "cell_type": "markdown", @@ -650,370 +392,8 @@ } }, "id": "6f8df300b9442ef0", - "outputs": [ - { - "data": { - "text/plain": [ - " Gender PA BC DE FG HI JK LM NO PARPD ... \\\n", - "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 ... \n", - "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 ... \n", - "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 ... \n", - "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 ... \n", - "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 ... \n", - "... ... ... ... ... ... ... ... ... ... ... ... \n", - "1161 Male 0.00 1.00 1.00 2.50 2.50 2.50 1.75 1.00 3 ... \n", - "1162 Female 0.00 0.00 0.00 0.00 0.00 0.00 2.25 0.00 1 ... \n", - "1163 Male 0.00 0.50 0.25 0.25 0.00 0.25 0.75 0.50 2 ... \n", - "1164 Female 0.50 0.25 0.00 0.25 0.25 0.25 0.25 0.50 3 ... \n", - "1165 Female 1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.75 4 ... \n", - "\n", - " DPNPD OCPD PA_z BC_z DE_z FG_z HI_z JK_z \\\n", - "0 4 6 1.121212 1.025362 0.409357 -0.050132 0.633880 1.307918 \n", - "1 1 0 -1.151515 -0.786232 -1.052632 -0.841689 -0.185792 0.428152 \n", - "2 0 1 -1.151515 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", - "3 0 0 1.878788 1.387681 0.994152 1.532982 0.633880 0.428152 \n", - "4 0 0 -0.772727 -0.423913 -0.760234 -1.105541 -1.551913 -1.624633 \n", - "... ... ... ... ... ... ... ... ... \n", - "1161 3 4 -1.151515 0.300725 0.116959 1.532982 1.180328 1.307918 \n", - "1162 0 0 -1.151515 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", - "1163 0 1 -1.151515 -0.423913 -0.760234 -0.841689 -1.551913 -1.331378 \n", - "1164 0 2 -0.393939 -0.786232 -1.052632 -0.841689 -1.278689 -1.331378 \n", - "1165 1 5 0.363636 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", - "\n", - " LM_z NO_z \n", - "0 0.951515 1.84375 \n", - "1 0.951515 1.53125 \n", - "2 -1.775758 -1.28125 \n", - "3 0.648485 1.84375 \n", - "4 -1.775758 -1.28125 \n", - "... ... ... \n", - "1161 0.345455 -0.03125 \n", - "1162 0.951515 -1.28125 \n", - "1163 -0.866667 -0.65625 \n", - "1164 -1.472727 -0.65625 \n", - "1165 -0.563636 -0.34375 \n", - "\n", - "[1166 rows x 27 columns]" - ], - "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", - " \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", - " \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", - "
GenderPABCDEFGHIJKLMNOPARPD...DPNPDOCPDPA_zBC_zDE_zFG_zHI_zJK_zLM_zNO_z
0Female1.501.501.251.002.002.502.252.504...461.1212121.0253620.409357-0.0501320.6338801.3079180.9515151.84375
1Female0.000.250.000.251.251.752.252.251...10-1.151515-0.786232-1.052632-0.841689-0.1857920.4281520.9515151.53125
2Female0.000.000.000.000.000.000.000.000...01-1.151515-1.148551-1.052632-1.105541-1.551913-1.624633-1.775758-1.28125
3Male2.001.751.752.502.001.752.002.501...001.8787881.3876810.9941521.5329820.6338800.4281520.6484851.84375
4Female0.250.500.250.000.000.000.000.000...00-0.772727-0.423913-0.760234-1.105541-1.551913-1.624633-1.775758-1.28125
..................................................................
1161Male0.001.001.002.502.502.501.751.003...34-1.1515150.3007250.1169591.5329821.1803281.3079180.345455-0.03125
1162Female0.000.000.000.000.000.002.250.001...00-1.151515-1.148551-1.052632-1.105541-1.551913-1.6246330.951515-1.28125
1163Male0.000.500.250.250.000.250.750.502...01-1.151515-0.423913-0.760234-0.841689-1.551913-1.331378-0.866667-0.65625
1164Female0.500.250.000.250.250.250.250.503...02-0.393939-0.786232-1.052632-0.841689-1.278689-1.331378-1.472727-0.65625
1165Female1.000.000.000.000.000.001.000.754...150.363636-1.148551-1.052632-1.105541-1.551913-1.624633-0.563636-0.34375
\n", - "

1166 rows × 27 columns

\n", - "
" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 39 + "execution_count": 39, + "outputs": [] }, { "metadata": {}, @@ -1037,8 +417,8 @@ ")" ], "id": "876dadadc07e23a9", - "outputs": [], - "execution_count": 40 + "execution_count": 40, + "outputs": [] }, { "metadata": {}, @@ -1056,86 +436,8 @@ "cell_type": "code", "source": "results.table", "id": "7c587d1d7f7c35fd", - "outputs": [ - { - "data": { - "text/plain": [ - " label group measure elevation xval yval amplitude \\\n", - "SSM SSM None None -0.225058 0.130532 -0.014815 0.13137 \n", - "\n", - " displacement r2 PA_z BC_z DE_z FG_z HI_z JK_z LM_z NO_z \n", - "SSM 353.524846 0.709645 90 135 180 225 270 315 360 45 " - ], - "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", - "
labelgroupmeasureelevationxvalyvalamplitudedisplacementr2PA_zBC_zDE_zFG_zHI_zJK_zLM_zNO_z
SSMSSMNoneNone-0.2250580.130532-0.0148150.13137353.5248460.7096459013518022527031536045
\n", - "
" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 41 + "execution_count": 41, + "outputs": [] }, { "metadata": {}, @@ -1153,29 +455,8 @@ "cell_type": "code", "source": "results.plot()", "id": "17120bfc93c74a9d", - "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 42 + "execution_count": 42, + "outputs": [] }, { "metadata": { @@ -1187,30 +468,8 @@ "cell_type": "code", "source": "results.results[0].profile_plot()", "id": "c5ae6bacbc5bb83d", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 43 + "execution_count": 43, + "outputs": [] }, { "metadata": { @@ -1226,86 +485,8 @@ "cor_res.table" ], "id": "fb8c38caf15ab6fa", - "outputs": [ - { - "data": { - "text/plain": [ - " label group measure elevation xval yval amplitude \\\n", - "NARPD NARPD None NARPD 0.202476 0.178969 0.061508 0.189244 \n", - "\n", - " displacement r2 PA BC DE FG HI JK LM NO \n", - "NARPD 18.966744 0.957009 0 45 90 135 180 225 270 315 " - ], - "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", - "
labelgroupmeasureelevationxvalyvalamplitudedisplacementr2PABCDEFGHIJKLMNO
NARPDNARPDNoneNARPD0.2024760.1789690.0615080.18924418.9667440.95700904590135180225270315
\n", - "
" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 44 + "execution_count": 44, + "outputs": [] }, { "metadata": { @@ -1317,38 +498,16 @@ "cell_type": "code", "source": "cor_res.results[0].profile_plot()", "id": "11edf672affbfd8e", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 45 + "execution_count": 45, + "outputs": [] }, { "metadata": {}, "cell_type": "code", - "outputs": [], "execution_count": null, "source": "\n", - "id": "efcee9158a27aa8d" + "id": "efcee9158a27aa8d", + "outputs": [] } ], "metadata": { diff --git a/docs/tutorials/Random_exs.ipynb b/docs/tutorials/Random_exs.ipynb index a93a6fe..38f0a78 100644 --- a/docs/tutorials/Random_exs.ipynb +++ b/docs/tutorials/Random_exs.ipynb @@ -11,7 +11,6 @@ "start_time": "2024-02-15T14:42:01.945946Z" } }, - "outputs": [], "source": [ "%load_ext autoreload\n", "%matplotlib inline\n", @@ -24,46 +23,12 @@ "data = pd.read_excel(\n", " \"/Users/mitch/Library/CloudStorage/OneDrive-UniversityCollegeLondon/_Fellowship/Papers - Drafts/J2308_APA_SATP-Main/data/SATP Dataset v1.4.xlsx\"\n", " )" - ] + ], + "outputs": [] }, { "cell_type": "code", "execution_count": 2, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error: array must not contain infs or NaNs | in Language = arb\n", - "Error: array must not contain infs or NaNs | in Language = cmn\n", - "Error: array must not contain infs or NaNs | in Language = ell\n", - "Error: array must not contain infs or NaNs | in Language = fra\n", - "Error: array must not contain infs or NaNs | in Language = ind\n", - "Error: array must not contain infs or NaNs | in Language = jpn\n", - "Error: array must not contain infs or NaNs | in Language = kor\n", - "Error: array must not contain infs or NaNs | in Language = nld\n", - "Error: array must not contain infs or NaNs | in Language = spa\n", - "Error: array must not contain infs or NaNs | in Language = vie\n", - "Error: array must not contain infs or NaNs | in Language = zsm\n" - ] - }, - { - "data": { - "text/plain": "(
, )" - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "%autoreload\n", "plt.style.use(\"ggplot\")\n", @@ -79,21 +44,12 @@ "start_time": "2024-02-15T14:42:04.127613Z" } }, - "id": "7be48f6cc42a46b2" + "id": "7be48f6cc42a46b2", + "outputs": [] }, { "cell_type": "code", "execution_count": 3, - "outputs": [ - { - "data": { - "text/plain": "SSMParams(deu_loud, scores=PAQ1 -0.735505\nPAQ2 -0.094355\nPAQ3 0.344259\nPAQ4 0.656572\nPAQ5 0.753815\nPAQ6 0.021532\nPAQ7 -0.394931\nPAQ8 -0.795127\ndtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315))" - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ssm_res.results[0]" ], @@ -104,30 +60,12 @@ "start_time": "2024-02-15T14:42:04.419231Z" } }, - "id": "78230ac68ea161a9" + "id": "78230ac68ea161a9", + "outputs": [] }, { "cell_type": "code", "execution_count": 4, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error: array must not contain infs or NaNs | in Language = arb\n", - "Error: array must not contain infs or NaNs | in Language = cmn\n", - "Error: array must not contain infs or NaNs | in Language = ell\n", - "Error: array must not contain infs or NaNs | in Language = fra\n", - "Error: array must not contain infs or NaNs | in Language = ind\n", - "Error: array must not contain infs or NaNs | in Language = jpn\n", - "Error: array must not contain infs or NaNs | in Language = kor\n", - "Error: array must not contain infs or NaNs | in Language = nld\n", - "Error: array must not contain infs or NaNs | in Language = spa\n", - "Error: array must not contain infs or NaNs | in Language = vie\n", - "Error: array must not contain infs or NaNs | in Language = zsm\n" - ] - } - ], "source": [ "test = circumplex.ssm_analyse_grouped_corrs(data, scales, [\"loud\"], [\"Language\"])" ], @@ -138,21 +76,12 @@ "start_time": "2024-02-15T14:42:05.949054Z" } }, - "id": "83645267c6b51ea1" + "id": "83645267c6b51ea1", + "outputs": [] }, { "cell_type": "code", "execution_count": 5, - "outputs": [ - { - "data": { - "text/plain": "[SSMParams(deu_loud, scores=PAQ1 -0.735505\n PAQ2 -0.094355\n PAQ3 0.344259\n PAQ4 0.656572\n PAQ5 0.753815\n PAQ6 0.021532\n PAQ7 -0.394931\n PAQ8 -0.795127\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(eng_loud, scores=PAQ1 -0.606997\n PAQ2 -0.027397\n PAQ3 0.324510\n PAQ4 0.608231\n PAQ5 0.644103\n PAQ6 0.117573\n PAQ7 -0.314404\n PAQ8 -0.730986\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(hrv_loud, scores=PAQ1 -0.621366\n PAQ2 0.328738\n PAQ3 0.364106\n PAQ4 0.700794\n PAQ5 0.669574\n PAQ6 0.011157\n PAQ7 -0.321482\n PAQ8 -0.633544\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(ita_loud, scores=PAQ1 -0.516713\n PAQ2 0.126906\n PAQ3 0.249130\n PAQ4 0.617427\n PAQ5 0.690386\n PAQ6 -0.058512\n PAQ7 -0.191610\n PAQ8 -0.651333\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(por_loud, scores=PAQ1 -0.489250\n PAQ2 0.375296\n PAQ3 0.695722\n PAQ4 0.639984\n PAQ5 0.607933\n PAQ6 -0.223063\n PAQ7 -0.328263\n PAQ8 -0.621765\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(swe_loud, scores=PAQ1 -0.661008\n PAQ2 0.014031\n PAQ3 0.232966\n PAQ4 0.725853\n PAQ5 0.787736\n PAQ6 0.066319\n PAQ7 -0.298978\n PAQ8 -0.737212\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315)),\n SSMParams(tur_loud, scores=PAQ1 -0.502171\n PAQ2 0.087115\n PAQ3 0.580815\n PAQ4 0.562785\n PAQ5 0.758338\n PAQ6 -0.187736\n PAQ7 -0.584758\n PAQ8 -0.723721\n dtype: float64, angles=(0, 45, 90, 135, 180, 225, 270, 315))]" - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "test.results" ], @@ -163,21 +92,12 @@ "start_time": "2023-11-25T18:35:34.219547Z" } }, - "id": "f155ed134be053e2" + "id": "f155ed134be053e2", + "outputs": [] }, { "cell_type": "code", "execution_count": 6, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "fig, axes = plt.subplots(4, 2, figsize=(12, 16), sharey=True)\n", "ssm_res.profile_plots(axes=axes)\n", @@ -190,22 +110,12 @@ "start_time": "2023-11-25T18:35:34.222066Z" } }, - "id": "8632928f988b2c91" + "id": "8632928f988b2c91", + "outputs": [] }, { "cell_type": "code", "execution_count": 7, - "outputs": [ - { - "data": { - "text/plain": " label group measure elevation xval yval amplitude \\\ndeu_loud deu_loud deu loud -0.030467 -0.649443 0.420938 0.773928 \neng_loud eng_loud eng loud 0.001829 -0.575145 0.370843 0.684336 \nhrv_loud hrv_loud hrv loud 0.062247 -0.502474 0.463418 0.683547 \nita_loud ita_loud ita loud 0.033210 -0.493285 0.367250 0.614981 \npor_loud por_loud por loud 0.082074 -0.391568 0.584820 0.703804 \nswe_loud swe_loud swe loud 0.016213 -0.630065 0.382379 0.737018 \ntur_loud tur_loud tur loud -0.001167 -0.493964 0.567405 0.752296 \n\n displacement r2 PAQ1 PAQ2 PAQ3 PAQ4 PAQ5 PAQ6 PAQ7 \\\ndeu_loud 147.050614 0.978323 0 45 90 135 180 225 270 \neng_loud 147.186772 0.982669 0 45 90 135 180 225 270 \nhrv_loud 137.315498 0.916134 0 45 90 135 180 225 270 \nita_loud 143.332361 0.912120 0 45 90 135 180 225 270 \npor_loud 123.804373 0.928637 0 45 90 135 180 225 270 \nswe_loud 148.746958 0.955507 0 45 90 135 180 225 270 \ntur_loud 131.041796 0.947249 0 45 90 135 180 225 270 \n\n PAQ8 \ndeu_loud 315 \neng_loud 315 \nhrv_loud 315 \nita_loud 315 \npor_loud 315 \nswe_loud 315 \ntur_loud 315 ", - "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 \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
labelgroupmeasureelevationxvalyvalamplitudedisplacementr2PAQ1PAQ2PAQ3PAQ4PAQ5PAQ6PAQ7PAQ8
deu_louddeu_louddeuloud-0.030467-0.6494430.4209380.773928147.0506140.97832304590135180225270315
eng_loudeng_loudengloud0.001829-0.5751450.3708430.684336147.1867720.98266904590135180225270315
hrv_loudhrv_loudhrvloud0.062247-0.5024740.4634180.683547137.3154980.91613404590135180225270315
ita_loudita_louditaloud0.033210-0.4932850.3672500.614981143.3323610.91212004590135180225270315
por_loudpor_loudporloud0.082074-0.3915680.5848200.703804123.8043730.92863704590135180225270315
swe_loudswe_loudsweloud0.016213-0.6300650.3823790.737018148.7469580.95550704590135180225270315
tur_loudtur_loudturloud-0.001167-0.4939640.5674050.752296131.0417960.94724904590135180225270315
\n
" - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ssm_res.table" ], @@ -216,46 +126,12 @@ "start_time": "2023-11-25T18:35:34.888084Z" } }, - "id": "99ab18f9960d34a2" + "id": "99ab18f9960d34a2", + "outputs": [] }, { "cell_type": "code", "execution_count": 8, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error: array must not contain infs or NaNs | in Language = arb\n", - "Error: array must not contain infs or NaNs | in Language = cmn\n", - "Error: array must not contain infs or NaNs | in Language = ell\n", - "Error: array must not contain infs or NaNs | in Language = fra\n", - "Error: array must not contain infs or NaNs | in Language = ind\n", - "Error: array must not contain infs or NaNs | in Language = jpn\n", - "Error: array must not contain infs or NaNs | in Language = kor\n", - "Error: array must not contain infs or NaNs | in Language = nld\n", - "Error: array must not contain infs or NaNs | in Language = spa\n", - "Error: array must not contain infs or NaNs | in Language = vie\n", - "Error: array must not contain infs or NaNs | in Language = zsm\n" - ] - }, - { - "data": { - "text/plain": "(
, )" - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "lang_angles = {\n", " 'arb': (0, 65, 97, 131, 182, 255, 281, 335),\n", @@ -288,21 +164,12 @@ "start_time": "2023-11-25T18:35:34.900761Z" } }, - "id": "a33ca93dde25b889" + "id": "a33ca93dde25b889", + "outputs": [] }, { "cell_type": "code", "execution_count": 9, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "corr_res.profile_plots();" ], @@ -313,22 +180,12 @@ "start_time": "2023-11-25T18:35:35.101478Z" } }, - "id": "e5d424d89e2d808c" + "id": "e5d424d89e2d808c", + "outputs": [] }, { "cell_type": "code", "execution_count": 10, - "outputs": [ - { - "data": { - "text/plain": " label group measure elevation xval yval amplitude \\\ndeu_loud deu_loud deu loud 0.008102 -0.757320 0.232137 0.792100 \neng_loud eng_loud eng loud 0.005455 -0.585892 0.340915 0.677859 \nhrv_loud hrv_loud hrv loud 0.089558 -0.613045 0.313814 0.688697 \nita_loud ita_loud ita loud 0.062258 -0.595895 0.224498 0.636781 \npor_loud por_loud por loud 0.099232 -0.514793 0.449479 0.683405 \nswe_loud swe_loud swe loud 0.054330 -0.735613 0.204448 0.763495 \ntur_loud tur_loud tur loud 0.023584 -0.615972 0.401942 0.735513 \n\n displacement r2 PAQ1 PAQ2 PAQ3 PAQ4 PAQ5 PAQ6 PAQ7 \\\ndeu_loud 162.958416 0.998362 0 65 97 131 182 255 281 \neng_loud 149.805988 0.981556 0 46 93 138 182 228 272 \nhrv_loud 152.892397 0.963337 0 65 97 131 182 255 281 \nita_loud 159.356518 0.974369 0 65 97 131 182 255 281 \npor_loud 138.874937 0.973591 0 65 97 131 182 255 281 \nswe_loud 164.467842 0.989495 0 65 97 131 182 255 281 \ntur_loud 146.874258 0.969585 0 65 97 131 182 255 281 \n\n PAQ8 \ndeu_loud 335 \neng_loud 340 \nhrv_loud 335 \nita_loud 335 \npor_loud 335 \nswe_loud 335 \ntur_loud 335 ", - "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 \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
labelgroupmeasureelevationxvalyvalamplitudedisplacementr2PAQ1PAQ2PAQ3PAQ4PAQ5PAQ6PAQ7PAQ8
deu_louddeu_louddeuloud0.008102-0.7573200.2321370.792100162.9584160.99836206597131182255281335
eng_loudeng_loudengloud0.005455-0.5858920.3409150.677859149.8059880.98155604693138182228272340
hrv_loudhrv_loudhrvloud0.089558-0.6130450.3138140.688697152.8923970.96333706597131182255281335
ita_loudita_louditaloud0.062258-0.5958950.2244980.636781159.3565180.97436906597131182255281335
por_loudpor_loudporloud0.099232-0.5147930.4494790.683405138.8749370.97359106597131182255281335
swe_loudswe_loudsweloud0.054330-0.7356130.2044480.763495164.4678420.98949506597131182255281335
tur_loudtur_loudturloud0.023584-0.6159720.4019420.735513146.8742580.96958506597131182255281335
\n
" - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "corr_res.table" ], @@ -339,12 +196,12 @@ "start_time": "2023-11-25T18:35:35.899807Z" } }, - "id": "c7583551aed48dd2" + "id": "c7583551aed48dd2", + "outputs": [] }, { "cell_type": "code", "execution_count": 11, - "outputs": [], "source": [ "lang_data = data[data[\"Language\"] == \"deu\"]\n", "rec_data = data[data[\"Recording\"] == \"CG01\"]\n", @@ -360,21 +217,12 @@ "start_time": "2023-11-25T18:35:35.906154Z" } }, - "id": "bf9f01e61ec25305" + "id": "bf9f01e61ec25305", + "outputs": [] }, { "cell_type": "code", "execution_count": 12, - "outputs": [ - { - "data": { - "text/plain": "[0, 65, 97, 131, 182, 255, 281, 335]" - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "new_ang_results.angles" ], @@ -385,29 +233,12 @@ "start_time": "2023-11-25T18:35:35.913372Z" } }, - "id": "6c83db8be730d642" + "id": "6c83db8be730d642", + "outputs": [] }, { "cell_type": "code", "execution_count": 13, - "outputs": [ - { - "data": { - "text/plain": "(
,\n )" - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "new_ang_results.profile_plot()" ], @@ -418,21 +249,12 @@ "start_time": "2023-11-25T18:35:35.916368Z" } }, - "id": "c2b3a77b1350c969" + "id": "c2b3a77b1350c969", + "outputs": [] }, { "cell_type": "code", "execution_count": 14, - "outputs": [ - { - "data": { - "text/plain": "34.87191446710762" - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "new_ang_results.displacement" ], @@ -443,21 +265,12 @@ "start_time": "2023-11-25T18:35:36.026395Z" } }, - "id": "64f3cd8bb92fe5b9" + "id": "64f3cd8bb92fe5b9", + "outputs": [] }, { "cell_type": "code", "execution_count": 15, - "outputs": [ - { - "data": { - "text/plain": "42.91989829477362" - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "new_ang_results.elevation" ], @@ -468,12 +281,12 @@ "start_time": "2023-11-25T18:35:36.032692Z" } }, - "id": "a00685d5a11367bb" + "id": "a00685d5a11367bb", + "outputs": [] }, { "cell_type": "code", "execution_count": 16, - "outputs": [], "source": [ "import soundscapy as sspy\n", "\n", @@ -486,22 +299,12 @@ "start_time": "2023-11-25T18:35:36.036804Z" } }, - "id": "1a75672166b1fd02" + "id": "1a75672166b1fd02", + "outputs": [] }, { "cell_type": "code", "execution_count": 17, - "outputs": [ - { - "data": { - "text/plain": " LocationID SessionID GroupID RecordID Language \\\n441 MonumentoGaribaldi MonumentoGaribaldi1 MG101 2.0 Italian \n442 MonumentoGaribaldi MonumentoGaribaldi1 MG101 1.0 Italian \n443 MonumentoGaribaldi MonumentoGaribaldi1 MG102 206.0 English \n444 MonumentoGaribaldi MonumentoGaribaldi1 MG103 3.0 English \n445 MonumentoGaribaldi MonumentoGaribaldi1 MG104 4.0 English \n.. ... ... ... ... ... \n521 MonumentoGaribaldi MonumentoGaribaldi3 MG330 NaN NaN \n522 MonumentoGaribaldi MonumentoGaribaldi3 MG331 NaN NaN \n523 MonumentoGaribaldi MonumentoGaribaldi3 MG332 NaN NaN \n524 MonumentoGaribaldi MonumentoGaribaldi3 MG333 NaN NaN \n525 MonumentoGaribaldi MonumentoGaribaldi3 MG334 NaN NaN \n\n Lockdown start_time end_time latitude longitude ... \\\n441 0 03/03/2019 11:18 03/03/2019 11:22 45.431837 12.354908 ... \n442 0 03/03/2019 11:18 03/03/2019 11:22 45.431837 12.354908 ... \n443 0 03/03/2019 11:18 03/03/2019 11:28 45.431837 12.354908 ... \n444 0 03/03/2019 11:23 03/03/2019 11:29 45.431837 12.354908 ... \n445 0 03/03/2019 11:22 03/03/2019 11:33 45.431837 12.354908 ... \n.. ... ... ... ... ... ... \n521 1 NaN NaN NaN NaN ... \n522 1 NaN NaN NaN NaN ... \n523 1 NaN NaN NaN NaN ... \n524 1 NaN NaN NaN NaN ... \n525 1 NaN NaN NaN NaN ... \n\n FS_Avg,arith(vacil) I_HM_Avg,arith(iu) Ton_HM_Avg,arith(tuHMS) \\\n441 0.0283 0.410 0.2390 \n442 0.0283 0.410 0.2390 \n443 0.0312 0.529 0.2490 \n444 0.0111 0.480 0.1140 \n445 0.0156 0.771 0.0851 \n.. ... ... ... \n521 0.0594 0.383 0.4750 \n522 0.0435 0.381 0.3810 \n523 0.0576 0.407 0.4150 \n524 0.0303 0.453 0.2990 \n525 0.0496 0.422 0.3530 \n\n LZeq_L(dB(SPL)) LAeq_L(A)(dB(SPL)) LA10_LA90(dB(SPL)) \\\n441 60.95 53.66 8.08 \n442 60.95 53.66 8.08 \n443 62.36 54.93 9.13 \n444 59.74 50.01 4.61 \n445 56.51 50.68 5.14 \n.. ... ... ... \n521 62.07 57.41 12.76 \n522 58.19 52.56 10.78 \n523 57.02 53.97 13.76 \n524 57.23 53.72 16.18 \n525 60.17 57.01 16.93 \n\n LCeq_LAeq(dB(SPL)) LC10_LC90(dB(SPL)) RA_2D_cp(cPa) PA(Zwicker) \n441 6.73 4.82 9.86 10.758803 \n442 6.73 4.82 9.86 10.758803 \n443 7.01 4.89 10.40 11.670954 \n444 9.15 3.65 9.10 9.744015 \n445 4.99 3.37 9.81 8.246837 \n.. ... ... ... ... \n521 1.18 8.60 9.53 12.503792 \n522 1.56 6.77 8.60 7.972545 \n523 0.41 8.33 9.03 8.887960 \n524 1.40 8.44 8.41 8.912749 \n525 1.32 8.87 9.65 12.126460 \n\n[85 rows x 78 columns]", - "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 \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 \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
LocationIDSessionIDGroupIDRecordIDLanguageLockdownstart_timeend_timelatitudelongitude...FS_Avg,arith(vacil)I_HM_Avg,arith(iu)Ton_HM_Avg,arith(tuHMS)LZeq_L(dB(SPL))LAeq_L(A)(dB(SPL))LA10_LA90(dB(SPL))LCeq_LAeq(dB(SPL))LC10_LC90(dB(SPL))RA_2D_cp(cPa)PA(Zwicker)
441MonumentoGaribaldiMonumentoGaribaldi1MG1012.0Italian003/03/2019 11:1803/03/2019 11:2245.43183712.354908...0.02830.4100.239060.9553.668.086.734.829.8610.758803
442MonumentoGaribaldiMonumentoGaribaldi1MG1011.0Italian003/03/2019 11:1803/03/2019 11:2245.43183712.354908...0.02830.4100.239060.9553.668.086.734.829.8610.758803
443MonumentoGaribaldiMonumentoGaribaldi1MG102206.0English003/03/2019 11:1803/03/2019 11:2845.43183712.354908...0.03120.5290.249062.3654.939.137.014.8910.4011.670954
444MonumentoGaribaldiMonumentoGaribaldi1MG1033.0English003/03/2019 11:2303/03/2019 11:2945.43183712.354908...0.01110.4800.114059.7450.014.619.153.659.109.744015
445MonumentoGaribaldiMonumentoGaribaldi1MG1044.0English003/03/2019 11:2203/03/2019 11:3345.43183712.354908...0.01560.7710.085156.5150.685.144.993.379.818.246837
..................................................................
521MonumentoGaribaldiMonumentoGaribaldi3MG330NaNNaN1NaNNaNNaNNaN...0.05940.3830.475062.0757.4112.761.188.609.5312.503792
522MonumentoGaribaldiMonumentoGaribaldi3MG331NaNNaN1NaNNaNNaNNaN...0.04350.3810.381058.1952.5610.781.566.778.607.972545
523MonumentoGaribaldiMonumentoGaribaldi3MG332NaNNaN1NaNNaNNaNNaN...0.05760.4070.415057.0253.9713.760.418.339.038.887960
524MonumentoGaribaldiMonumentoGaribaldi3MG333NaNNaN1NaNNaNNaNNaN...0.03030.4530.299057.2353.7216.181.408.448.418.912749
525MonumentoGaribaldiMonumentoGaribaldi3MG334NaNNaN1NaNNaNNaNNaN...0.04960.4220.353060.1757.0116.931.328.879.6512.126460
\n

85 rows × 78 columns

\n
" - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ss_data.query(\"LocationID == 'MonumentoGaribaldi'\")" ], @@ -512,23 +315,12 @@ "start_time": "2023-11-25T18:35:37.134917Z" } }, - "id": "9f0b5e4a63535199" + "id": "9f0b5e4a63535199", + "outputs": [] }, { "cell_type": "code", "execution_count": 18, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Renaming PAQ columns.\n", - "Checking PAQ data quality.\n", - "Identified 627 samples to remove.\n", - "[95, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 152, 168, 171, 190, 198, 204, 222, 230, 247, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 302, 308, 337, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 557, 580, 583, 607, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 818, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 870, 876, 885, 889, 905, 930, 958, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 1000, 1009, 1023, 1028, 1041, 1063, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1213, 1220, 1251, 1271, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1433, 1448, 1468, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1553, 1586, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1744, 1747, 1752, 1753, 1755, 1759, 1765, 1785, 1798, 1799, 1830, 1846, 1851, 1865, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908]\n" - ] - } - ], "source": [ "ss_data, excl_data = sspy.isd.validate(ss_data)" ], @@ -539,22 +331,12 @@ "start_time": "2023-11-25T18:35:37.151777Z" } }, - "id": "ce971cc7b2f46236" + "id": "ce971cc7b2f46236", + "outputs": [] }, { "cell_type": "code", "execution_count": 19, - "outputs": [ - { - "data": { - "text/plain": " LocationID SessionID GroupID RecordID Language Lockdown \\\n95 CamdenTown CamdenTown4 CT411 NaN NaN 0 \n106 CamdenTown CamdenTown5 CT501 NaN NaN 1 \n107 CamdenTown CamdenTown5 CT502 NaN NaN 1 \n108 CamdenTown CamdenTown5 CT503 NaN NaN 1 \n109 CamdenTown CamdenTown5 CT504 NaN NaN 1 \n... ... ... ... ... ... ... \n1904 TorringtonSq TorringtonSq5 TS537 NaN NaN 1 \n1905 TorringtonSq TorringtonSq5 TS538 NaN NaN 1 \n1906 TorringtonSq TorringtonSq5 TS539 NaN NaN 1 \n1907 TorringtonSq TorringtonSq5 TS540 NaN NaN 1 \n1908 TorringtonSq TorringtonSq5 TS541 NaN NaN 1 \n\n start_time end_time latitude longitude ... FS_Avg,arith(vacil) \\\n95 NaN NaN NaN NaN ... 0.04410 \n106 NaN NaN NaN NaN ... 0.00700 \n107 NaN NaN NaN NaN ... 0.00656 \n108 NaN NaN NaN NaN ... 0.01390 \n109 NaN NaN NaN NaN ... 0.01820 \n... ... ... ... ... ... ... \n1904 NaN NaN NaN NaN ... 0.00550 \n1905 NaN NaN NaN NaN ... 0.00916 \n1906 NaN NaN NaN NaN ... 0.00967 \n1907 NaN NaN NaN NaN ... 0.00902 \n1908 NaN NaN NaN NaN ... 0.00930 \n\n I_HM_Avg,arith(iu) Ton_HM_Avg,arith(tuHMS) LZeq_L(dB(SPL)) \\\n95 0.369 0.608 85.82 \n106 0.361 0.175 74.52 \n107 0.339 0.287 78.27 \n108 0.370 0.181 84.71 \n109 0.462 0.177 73.67 \n... ... ... ... \n1904 0.399 0.203 71.77 \n1905 0.359 0.230 68.85 \n1906 0.363 0.481 79.33 \n1907 0.445 0.257 67.57 \n1908 0.404 0.246 78.01 \n\n LAeq_L(A)(dB(SPL)) LA10_LA90(dB(SPL)) LCeq_LAeq(dB(SPL)) \\\n95 75.37 4.79 10.00 \n106 59.44 12.32 9.35 \n107 69.67 15.15 7.19 \n108 72.93 21.23 6.32 \n109 62.28 8.99 7.76 \n... ... ... ... \n1904 52.90 5.61 12.97 \n1905 56.30 10.09 9.27 \n1906 64.32 14.80 13.95 \n1907 49.33 2.64 12.12 \n1908 59.17 16.54 14.17 \n\n LC10_LC90(dB(SPL)) RA_2D_cp(cPa) PA(Zwicker) \n95 6.34 18.80 54.379887 \n106 8.93 11.70 18.410488 \n107 11.39 12.90 37.721660 \n108 9.70 15.50 40.301608 \n109 5.27 12.80 20.047791 \n... ... ... ... \n1904 8.31 10.80 9.987229 \n1905 8.16 9.99 14.359218 \n1906 20.39 10.90 30.033977 \n1907 5.04 9.62 7.882057 \n1908 17.02 11.10 20.284137 \n\n[627 rows x 78 columns]", - "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 \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 \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
LocationIDSessionIDGroupIDRecordIDLanguageLockdownstart_timeend_timelatitudelongitude...FS_Avg,arith(vacil)I_HM_Avg,arith(iu)Ton_HM_Avg,arith(tuHMS)LZeq_L(dB(SPL))LAeq_L(A)(dB(SPL))LA10_LA90(dB(SPL))LCeq_LAeq(dB(SPL))LC10_LC90(dB(SPL))RA_2D_cp(cPa)PA(Zwicker)
95CamdenTownCamdenTown4CT411NaNNaN0NaNNaNNaNNaN...0.044100.3690.60885.8275.374.7910.006.3418.8054.379887
106CamdenTownCamdenTown5CT501NaNNaN1NaNNaNNaNNaN...0.007000.3610.17574.5259.4412.329.358.9311.7018.410488
107CamdenTownCamdenTown5CT502NaNNaN1NaNNaNNaNNaN...0.006560.3390.28778.2769.6715.157.1911.3912.9037.721660
108CamdenTownCamdenTown5CT503NaNNaN1NaNNaNNaNNaN...0.013900.3700.18184.7172.9321.236.329.7015.5040.301608
109CamdenTownCamdenTown5CT504NaNNaN1NaNNaNNaNNaN...0.018200.4620.17773.6762.288.997.765.2712.8020.047791
..................................................................
1904TorringtonSqTorringtonSq5TS537NaNNaN1NaNNaNNaNNaN...0.005500.3990.20371.7752.905.6112.978.3110.809.987229
1905TorringtonSqTorringtonSq5TS538NaNNaN1NaNNaNNaNNaN...0.009160.3590.23068.8556.3010.099.278.169.9914.359218
1906TorringtonSqTorringtonSq5TS539NaNNaN1NaNNaNNaNNaN...0.009670.3630.48179.3364.3214.8013.9520.3910.9030.033977
1907TorringtonSqTorringtonSq5TS540NaNNaN1NaNNaNNaNNaN...0.009020.4450.25767.5749.332.6412.125.049.627.882057
1908TorringtonSqTorringtonSq5TS541NaNNaN1NaNNaNNaNNaN...0.009300.4040.24678.0159.1716.5414.1717.0211.1020.284137
\n

627 rows × 78 columns

\n
" - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "excl_data" ], @@ -565,12 +347,12 @@ "start_time": "2023-11-25T18:35:37.273277Z" } }, - "id": "74e7aa3c27c484e8" + "id": "74e7aa3c27c484e8", + "outputs": [] }, { "cell_type": "code", "execution_count": 20, - "outputs": [], "source": [ "ss_data.dropna(subset=[\"Appropriate\"], inplace=True)\n", "ss_data.dropna(subset=[\"LocationID\"], inplace=True)" @@ -582,29 +364,12 @@ "start_time": "2023-11-25T18:35:37.286480Z" } }, - "id": "e165d5b1f2aa841e" + "id": "e165d5b1f2aa841e", + "outputs": [] }, { "cell_type": "code", "execution_count": 21, - "outputs": [ - { - "data": { - "text/plain": "(
, )" - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "%autoreload\n", "ss_res = circumplex.ssm_analyse(ss_data, scales, measures=[\"Appropriate\"], grouping=[\"LocationID\"])\n", @@ -617,22 +382,12 @@ "start_time": "2023-11-25T18:35:37.290756Z" } }, - "id": "575b5a5e7851ae08" + "id": "575b5a5e7851ae08", + "outputs": [] }, { "cell_type": "code", "execution_count": 22, - "outputs": [ - { - "data": { - "text/plain": " label \\\nCamdenTown_Appropriate CamdenTown_Appropriate \nEustonTap_Appropriate EustonTap_Appropriate \nMarchmontGarden_Appropriate MarchmontGarden_Appropriate \nMonumentoGaribaldi_Appropriate MonumentoGaribaldi_Appropriate \nPancrasLock_Appropriate PancrasLock_Appropriate \nRegentsParkFields_Appropriate RegentsParkFields_Appropriate \nRegentsParkJapan_Appropriate RegentsParkJapan_Appropriate \nRussellSq_Appropriate RussellSq_Appropriate \nSanMarco_Appropriate SanMarco_Appropriate \nStPaulsCross_Appropriate StPaulsCross_Appropriate \nStPaulsRow_Appropriate StPaulsRow_Appropriate \nTateModern_Appropriate TateModern_Appropriate \nTorringtonSq_Appropriate TorringtonSq_Appropriate \n\n group measure elevation \\\nCamdenTown_Appropriate CamdenTown Appropriate -0.012624 \nEustonTap_Appropriate EustonTap Appropriate -0.053329 \nMarchmontGarden_Appropriate MarchmontGarden Appropriate 0.035732 \nMonumentoGaribaldi_Appropriate MonumentoGaribaldi Appropriate 0.033375 \nPancrasLock_Appropriate PancrasLock Appropriate -0.015507 \nRegentsParkFields_Appropriate RegentsParkFields Appropriate 0.008437 \nRegentsParkJapan_Appropriate RegentsParkJapan Appropriate -0.017871 \nRussellSq_Appropriate RussellSq Appropriate -0.037783 \nSanMarco_Appropriate SanMarco Appropriate 0.043938 \nStPaulsCross_Appropriate StPaulsCross Appropriate 0.064805 \nStPaulsRow_Appropriate StPaulsRow Appropriate -0.077965 \nTateModern_Appropriate TateModern Appropriate -0.023393 \nTorringtonSq_Appropriate TorringtonSq Appropriate -0.024703 \n\n xval yval amplitude displacement \\\nCamdenTown_Appropriate 0.009983 0.198888 0.199139 87.126609 \nEustonTap_Appropriate 0.088189 0.076755 0.116913 41.034683 \nMarchmontGarden_Appropriate 0.247035 -0.167318 0.298364 325.890005 \nMonumentoGaribaldi_Appropriate 0.165411 0.157678 0.228524 43.628852 \nPancrasLock_Appropriate 0.350502 -0.049884 0.354034 351.899919 \nRegentsParkFields_Appropriate 0.412197 -0.098031 0.423694 346.622152 \nRegentsParkJapan_Appropriate 0.222595 -0.099201 0.243699 335.979462 \nRussellSq_Appropriate 0.416207 0.070529 0.422140 9.617804 \nSanMarco_Appropriate 0.155632 0.227018 0.275243 55.567422 \nStPaulsCross_Appropriate 0.312216 -0.055789 0.317161 349.868872 \nStPaulsRow_Appropriate 0.382289 -0.014567 0.382566 357.817845 \nTateModern_Appropriate 0.326791 0.097733 0.341092 16.650245 \nTorringtonSq_Appropriate 0.219167 0.135520 0.257681 31.730213 \n\n r2 PAQ1 PAQ2 PAQ3 PAQ4 PAQ5 PAQ6 \\\nCamdenTown_Appropriate 0.748778 0 45 90 135 180 225 \nEustonTap_Appropriate 0.318162 0 45 90 135 180 225 \nMarchmontGarden_Appropriate 0.965836 0 45 90 135 180 225 \nMonumentoGaribaldi_Appropriate 0.474805 0 45 90 135 180 225 \nPancrasLock_Appropriate 0.909881 0 45 90 135 180 225 \nRegentsParkFields_Appropriate 0.920718 0 45 90 135 180 225 \nRegentsParkJapan_Appropriate 0.822661 0 45 90 135 180 225 \nRussellSq_Appropriate 0.943055 0 45 90 135 180 225 \nSanMarco_Appropriate 0.940069 0 45 90 135 180 225 \nStPaulsCross_Appropriate 0.891766 0 45 90 135 180 225 \nStPaulsRow_Appropriate 0.954414 0 45 90 135 180 225 \nTateModern_Appropriate 0.956939 0 45 90 135 180 225 \nTorringtonSq_Appropriate 0.945766 0 45 90 135 180 225 \n\n PAQ7 PAQ8 \nCamdenTown_Appropriate 270 315 \nEustonTap_Appropriate 270 315 \nMarchmontGarden_Appropriate 270 315 \nMonumentoGaribaldi_Appropriate 270 315 \nPancrasLock_Appropriate 270 315 \nRegentsParkFields_Appropriate 270 315 \nRegentsParkJapan_Appropriate 270 315 \nRussellSq_Appropriate 270 315 \nSanMarco_Appropriate 270 315 \nStPaulsCross_Appropriate 270 315 \nStPaulsRow_Appropriate 270 315 \nTateModern_Appropriate 270 315 \nTorringtonSq_Appropriate 270 315 ", - "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 \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 \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
labelgroupmeasureelevationxvalyvalamplitudedisplacementr2PAQ1PAQ2PAQ3PAQ4PAQ5PAQ6PAQ7PAQ8
CamdenTown_AppropriateCamdenTown_AppropriateCamdenTownAppropriate-0.0126240.0099830.1988880.19913987.1266090.74877804590135180225270315
EustonTap_AppropriateEustonTap_AppropriateEustonTapAppropriate-0.0533290.0881890.0767550.11691341.0346830.31816204590135180225270315
MarchmontGarden_AppropriateMarchmontGarden_AppropriateMarchmontGardenAppropriate0.0357320.247035-0.1673180.298364325.8900050.96583604590135180225270315
MonumentoGaribaldi_AppropriateMonumentoGaribaldi_AppropriateMonumentoGaribaldiAppropriate0.0333750.1654110.1576780.22852443.6288520.47480504590135180225270315
PancrasLock_AppropriatePancrasLock_AppropriatePancrasLockAppropriate-0.0155070.350502-0.0498840.354034351.8999190.90988104590135180225270315
RegentsParkFields_AppropriateRegentsParkFields_AppropriateRegentsParkFieldsAppropriate0.0084370.412197-0.0980310.423694346.6221520.92071804590135180225270315
RegentsParkJapan_AppropriateRegentsParkJapan_AppropriateRegentsParkJapanAppropriate-0.0178710.222595-0.0992010.243699335.9794620.82266104590135180225270315
RussellSq_AppropriateRussellSq_AppropriateRussellSqAppropriate-0.0377830.4162070.0705290.4221409.6178040.94305504590135180225270315
SanMarco_AppropriateSanMarco_AppropriateSanMarcoAppropriate0.0439380.1556320.2270180.27524355.5674220.94006904590135180225270315
StPaulsCross_AppropriateStPaulsCross_AppropriateStPaulsCrossAppropriate0.0648050.312216-0.0557890.317161349.8688720.89176604590135180225270315
StPaulsRow_AppropriateStPaulsRow_AppropriateStPaulsRowAppropriate-0.0779650.382289-0.0145670.382566357.8178450.95441404590135180225270315
TateModern_AppropriateTateModern_AppropriateTateModernAppropriate-0.0233930.3267910.0977330.34109216.6502450.95693904590135180225270315
TorringtonSq_AppropriateTorringtonSq_AppropriateTorringtonSqAppropriate-0.0247030.2191670.1355200.25768131.7302130.94576604590135180225270315
\n
" - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ss_res.table" ], @@ -643,21 +398,12 @@ "start_time": "2023-11-25T18:35:37.562415Z" } }, - "id": "a08facba2975a1f0" + "id": "a08facba2975a1f0", + "outputs": [] }, { "cell_type": "code", "execution_count": 23, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "ss_res.profile_plots();" ], @@ -668,21 +414,12 @@ "start_time": "2023-11-25T18:35:37.579464Z" } }, - "id": "a35ed5883bae593d" + "id": "a35ed5883bae593d", + "outputs": [] }, { "cell_type": "code", "execution_count": 24, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "circumplex.profile_plot(\n", " 0.22,\n", @@ -702,29 +439,12 @@ "start_time": "2023-11-25T18:35:38.956960Z" } }, - "id": "9a081d5c6031399b" + "id": "9a081d5c6031399b", + "outputs": [] }, { "cell_type": "code", "execution_count": 25, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "sspy.plotting.scatter(ss_res.table, x='xval', y='yval')\n" ], @@ -735,7 +455,8 @@ "start_time": "2023-11-25T18:35:39.110359Z" } }, - "id": "e614fdebb98c3cad" + "id": "e614fdebb98c3cad", + "outputs": [] }, { "cell_type": "markdown", @@ -750,38 +471,6 @@ { "cell_type": "code", "execution_count": 26, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SATP-eng: Soundscape Attributes Translation Project - English Translation\n", - "8 Items, 8 Scales\n", - "Aletta, Mitchell, et.al. (2024)\n", - "<>\n", - "\n", - "The SATP-eng contains 8 circumplex scales.\n", - "PAQ1: pleasant (0°)\n", - "PAQ2: vibrant (46°)\n", - "PAQ3: eventful (93°)\n", - "PAQ4: chaotic (138°)\n", - "PAQ5: annoying (178°)\n", - "PAQ6: monotonous (228°)\n", - "PAQ7: uneventful (272°)\n", - "PAQ8: calm (340°)\n", - "\n", - "The SATP-eng is rated using the following 5-point scale.\n", - "0. Strongly disagree\n", - "25. Somewhat disagree\n", - "50. Neither agree nor disagree\n", - "75. Somewhat agree\n", - "100. Strongly agree\n", - "\n", - "The SATP-eng contains 8 items (open-access).\n", - "None\n" - ] - } - ], "source": [ "from circumplex.datasets import SATP_ENG\n", "\n", @@ -795,21 +484,12 @@ "start_time": "2023-11-25T18:35:41.803575Z" } }, - "id": "bbcca11c33dfca66" + "id": "bbcca11c33dfca66", + "outputs": [] }, { "cell_type": "code", "execution_count": 27, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAGICAYAAAA57FtMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACJ30lEQVR4nO3dd3hTd54v/rd6l9XcjW1sMNgYMJgSek9II8mQkAzJ9N2dkuyUO7O/ndnJPpPMncnsZKflJnCn7E42dyeNJEwICQRCQjemGLAxzci4gHGTZElWb+f3h/ecsZBsy8Yqtj6v58kTLB0dnWNL532+nccwDANCCCEkDfGTfQCEEEJIslAIEkIISVsUgoQQQtIWhSAhhJC0RSFICCEkbVEIEkIISVsUgoQQQtIWhSAhhJC0RSFICCEkbQmTfQCEkOg8Hg/+67/+C3V1dbDZbLjvvvvw5S9/OebXb9u2DZcuXcK2bdvid5CETHAUgoQk0dmzZ2E0GrFly5aI53bu3IlDhw5h8+bNyM7ORkFBQRKOkJDJjUKQkCQ6d+4c9u3bFzUEL168iOnTp+Oxxx5LwpERkh6oTZCQFGWz2aBQKJJ9GIRMalQSJJOexWLBW2+9hXPnzsHpdCInJwcPPPAA1q5dC6vVim984xvYvHlzRInr1q1b+O53v4uvfvWr2LhxIwDA6XTinXfewcmTJ2Gz2aDX67Fu3Tps2rQJfP7APWVPTw+eeeYZPPXUU5DL5di1axfMZjOKiorwta99DdOmTQMw0GZ3+PBhAAgrCf7kJz/B888/z+2Lfe6VV17BpUuXsH37drzyyivIysriXnPx4kU8//zz+MlPfoJZs2bF6TdJyORDIUgmNavVih//+McAgHvuuQdqtRrnz5/H73//e7jdbtx///2oqKjAiRMnIkKwpqYGfD4fd911FwDA6/Xiueeeg8Viwfr162EwGHD16lW8+eabsFqtEZ1Wjh8/DrfbjfXr14PH42HXrl349a9/jZdffhlCoRAbNmxAX18fGhoa8Mwzz3Cvy8/PxzPPPIPXXnsNer0eDzzwAABArVbH8TdFSHqiECST2ltvvYVQKIRf/epXUKlUAIC7774bv/vd7/DOO+9gw4YNWLp0Kf74xz+ivb0dhYWF3GtrampQUVEBjUYDAPjwww/R1dWFF198Ebm5uQCADRs2QKfT4YMPPsADDzwAg8HAvd5kMuGll16CUqkEAOTl5eHFF19EfX09qqurUVZWhtzcXDQ0NGDlypVhx71y5Uq8/fbb0Ol0Ec8RQsYPtQmSSYthGJw8eRLV1dVgGAZ2u537r6qqCi6XC9evX8eiRYsgEAhQU1PDvba9vR03b97E0qVLucdqa2tRXl4OhUIRtq/Zs2cjFArh8uXLYe+/ZMkSLgABYObMmQCA7u7uOJ85ISRWVBIkk5bdbofT6cSBAwdw4MCBIbeZOXMmKisrceLECTzxxBMABkqBAoEAixYt4rbt7OxEW1sb/u7v/i7qvmw2W9jPg0uFALhAdDqdYz4nQsj4ohAkkxbDMACAFStWYNWqVVG3KSoqAgAsW7YM27dvR2trK4qLi3HixAlUVlaGtcMxDIM5c+Zg06ZNUfeVl5cX9jPbUWao4xpPoVBo3PdJSDqgECSTllqthkwmQygUwpw5c4bdduHChRAKhVyVaGdnJx555JGwbbKzs+HxeEbc12jweLxRbc+WJl0uV9jjvb2943ZMhKQTahMkkxafz8fixYtx8uRJtLe3Rzxvt9u5fysUCsydOxcnTpzA8ePHIRQKsXDhwrDtlyxZgqamJpw/fz5iX06nE8FgcNTHKJFIuNfHIjs7GwBw6dIl7rFQKIRPP/101O9NCKGSIJnktm7diosXL+LHP/4x1q1bh4KCAjgcDly/fh0XLlzAq6++ym27dOlSvPzyy9i/fz/mzp0bMVB906ZNOHPmDH75y19i1apVKCkpgdfrRXt7O2pra7Ft27ZRD2MoKSkBALz66quYO3cu+Hw+li1bNuT2U6ZMwfTp0/Hmm2/C4XBAqVSipqZmTAFMCKEQJJOcRqPBCy+8gHfffRcnT57Evn37oFKpMGXKFDz55JNh2y5YsABisRhutzusVyhLIpHg+eefx86dO1FbW4sjR45AJpMhLy8PW7ZsgVwuH/XxLV68GBs3bkRNTQ2OHj0KhmGGDUEA+Pa3v40//vGP2LVrF+RyOdauXYtZs2bhZz/72ajfn5B0x2Pi0UpPCCGETADUJkgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFK8sTEge3r1XN4/FSan+EkAEUgoSMwuAwuj2IGIZBKBRCKBRCMBjk/pPJZPD5fPB4PBH7GC7c2H/zeDzw+XwIBAIIBIKIfw91fNGOkRASjkKQkCjYMGFDhGEY+P1+BIPBsJBj/82GXzRCoRDBYBBerzcuxxotIAc/JhQKwePxIs6JEEIhSEhEOIRCIfj9/rD/AoHAHe0/nsHDBrDf7x9yG5FIxP0nFospGAn5HxSCJK3EO/CGes9khwx7boNRMBJCIUjSABtCbJWmz+fj/h8MBuP+/qFQCEJh6n3VRgpGiUQCoVBIoUgmtdT7ZhIyDtjgC4VC8Hq98Hg88Hq9Q7bbJeJYJoLbg1EgEEAqlUIqlUIsFnM3ExPlfAgZCYUgmRQGl1aCwSA8Hg8XfMnGMExEL86JIhgMwul0wul0gsfjQSqVQiKRQCqVgs/nUyCSCY9CkExYg4MvEAjA7XbD4/GMe5venQqFQpMiKBiGgdvthtvtBgCIxWKulEjVpmSiohAkE8rg9j22mtPj8SSlmjNWk7W05PP54PP5YLfbIRQKuUAUiUTcNpPxvMnkQiFIJgQ2SPx+P5xOJzweT8TA8FQVCoUmbHVorAKBABwOBxwOB/h8PuRyOeRyOVdCpDAkqYpCkKSswZ1bXC4XXC5XylV1xiLdQiAUCnGBKBaLoVAoIJVKuefT6XdBUh+FIEk5bGj4fD64XC6uDWqiSrcQHIytMuXz+ZDJZFAoFFQ6JCmFQpCkhMFVmy6XC06nc0KW+qJhO8YMHoiebkKhENfLVCKRcKVDCkOSbBSCJKkGV3myF8nJFhSDe01OtnMbC6/XC6/XC4FAAIVCAYVCwT1HgUgSjUKQJMXgji4Oh4NbYWGyohJPpGAwCLvdjv7+fsjlciiVSq4DEf2uSKJQCJKEYsMgEAjAbrenxGD2RGB7iCZimraJhmEYrhZALpdDpVKBz+dTEJKEoBAkCcFWAwaDQfT390/4zi6jRSXB2LAdoRQKBZRKJdeWSki8UAiSuGMYBgzDwG63w+VyJftwkoJCMHYMw8DhcMDlckGpVHJthvT7I/EwuUfwkqRiV1rv7+9Hd3d32gYgkB4D5sdbKBSC3W5HT08P3G43dzOVDDt27MCWLVvCHtuyZQv+8z//MynHQ8YPfSvJuGMvVk6nEz09PXA4HGnfK5JKgmMXDAZhtVrR29vLdaBK98/TcHbu3IlTp04l+zAmDApBMm7Y8HO73ejp6YHdbk/pOT0TiUqCdy4QCKCvrw8mk4lb7ilRYbh582b85S9/Sch73am//vWvOH36dLIPY8KgNkFyx9hSjtfrhd1unzSD3McTlQTHj8/ng8lkgkQigVqthlAojPvvViAQQCAQjNv+PB5P2FRyJHkoBMkdYdv9rFZr2gx3GAsKwfHn9XrR29sLpVIJlUoFYPSdZ2pra/Gb3/wGzz33HCoqKsKe++STT/CnP/0Jv/rVr1BbW4t3330XO3bsiNjH0aNH8e6778JkMqGgoABf+tKXwva1Y8cOvPvuu/jNb36D9957D+fPn0dmZiZefPFFtLW14cMPP8Tly5fR19cHuVyOefPm4Qtf+AJ3ToP38X/+z//Be++9h9OnT4NhGCxevBhf+9rXIJFIAIBrtzx8+DAOHz4MAFi1ahWefvrpUf1e0gmFIBkT9qLudrths9mojWYEoVAIQiF93eKBnWxBo9FAJBKNKgjnz58PqVSKmpqaiBCsqanBlClTUFhYiNra2qivv3TpEmpqanDvvfdCJBJh//79eOGFF/DCCy+gsLAwbNvf/OY3yMnJwec//3nu+9LQ0ICenh6sXr0aGo0GN2/exIEDB3Dz5k38/Oc/jziX3/72t8jMzMTWrVtx/fp1fPbZZ1Cr1XjqqacAAM888wz+8Ic/YNq0aVi3bh0AICcnJ+bfRzqibyUZNbb0Z7PZJv1ML+OFSoLxFQgEYDKZRl0qFIvFqK6uxsmTJ/HVr36Va7e1Wq24dOkSHnvssWFff+PGDfzbv/0bSkpKAADLli3Dd77zHezYsQM/+MEPwrYtKirCd77znbDH7rnnHjz44INhj02fPh0vvfQSrly5gvLy8rDniouL8c1vfpP72eFw4ODBg1wIrly5En/605+QlZWFlStXjnj+hDrGkFFg717Zji8UgLGjEEwMh8OB3t5e+P3+mGsnli5dCpvNhosXL3KP1dbWgmEYLF26dNjXlpWVcQEIAAaDAQsXLkR9fX1Ep7ANGzZEvF4sFnP/Zhconj59OgCgpaUlYvvb9zFz5kz09/en9fCjO0UlQRITtudnX18fhd8YUO/QxBltqbCqqgpyuRw1NTWYPXs2gIGq0OLiYuTl5Q37XtGqGnNzc7lOYhqNhns8KysrYluHw4F33nkHNTU1sNlsYc9FCzaDwRD2s1KpBABuyjkyevStjNGhQ4ewZcsWNDc3J/tQwmzZsiVqY/14GVz66+7upgAcIyoJJl6spUKRSISFCxfi1KlTCAaDsFgsuHr16oilwNEaXOpj/fa3v8Wnn36KDRs24Ac/+AGeffZZ/Mu//AsARB1eNNSNFLXJjx2VBCeAs2fPwmg0RsxYEW9U+hs/FILJEWupcOnSpTh8+DAuXLiAjo6OmKpCAaCrqyvisc7OTm74xnAcDgcuXLiALVu24NFHHw17/Z2gz9noUAhOAOfOncO+ffuihuBf/vKXcR2/BIT3/KQB7+ODqkOTi+1BqtVqo44rnD17NpRKJWpqatDR0YFp06ZFrb68XVNTE65fv861C5pMJpw+fRpVVVUj/r3Z528vxX300UejObUIEokETqfzjvaRTigEJ7hoVSx3gv1CWiwWKv2NIyoJJl8gEEBvby9UKhVUKlXY30QoFGLRokWoqamB1+vFF77whZj2OWXKFPz85z8PGyIBIKZaG7lcjvLycnzwwQcIBoPQ6XSor69HT0/P2E8SQElJCS5cuIAPP/wQWq0WWVlZXGcbEolCcBCLxYK3334b58+fR39/P7RaLaqqqvCVr3yF28bv9+O1117DkSNH4PP5MGfOHHz9618Pq/o4ffo0Dhw4gNbWVvT390Ov12PVqlX43Oc+F3F3eOLECbz//vu4efMmpFIp5s6di6eeego6nQ4AsG3bNm7Q6+AvFtsOyFalDH5uuPMYbqwaO/TBbDbTrC/jLBQKccsCUftNcvX39yMQCECj0YQF4dKlS/HZZ5+Bx+NhyZIlMe2roqICZWVlYYPlv/Wtb6GoqCim13/nO9/Bn//8Z+zbtw8Mw2DOnDn4l3/5F3z9618f8/l96Utfwh/+8Ae89dZb8Pl8WLVqFYXgMHgMfSMBDATHj370I7hcLqxbtw75+fmwWCyora3Fz372M5w+fRrbt2/H1KlToVAosGjRIvT09GDPnj1YvHgxvve973H7+vd//3cIhUKUlpZCKpWisbERtbW1ePDBB8PuMA8dOoTt27ejtLQUy5cvh81mw549e5CRkYEXX3wRCoUCTU1N2LFjBxoaGvDMM89wr2XHAN0egiOdB7ssze0YhoHf74fFYqHqzzjJy8tDV1cX/X5ThEgkgk6nowV80xyVBP/HG2+8AavVihdeeAGlpaXc448//njYnbtSqcSzzz7LfWkYhsHevXvhcrm4Lsrf+c53wqop7777bvzxj3/E/v378cQTT0AkEiEQCOD111/HlClT8Pzzz3Pbz5w5E//2b/+Gjz76CFu2bEFZWRlyc3PR0NAQ0+DXWM/jdi6XK6KLNhlfVCWaWvx+P3p7e6HT6UY90wyZPKilHgNVVadPn0Z1dXVYcLAGfznWr18f9nN5eTlCoRB6e3u5xwYHINu5pLy8HF6vFx0dHQCA69evw2az4Z577gnbfv78+cjPz8fZs2fjeh7A33p/2mw2CsAEoM4xqScUCsFkMsHtdif7UEiSUEkQgN1uh9vtjpjrL5rbB6uy1YuDe2PduHEDb731FhobGyO+XOwAWDY0ow3GzcvLw5UrV0Z3EhjdebABaLFY4PP5Rv1eZPSoJJi6rFYr/H4/17ZPf6f0QSE4SiMNVnU6nXjuuecgk8nw+OOPIzs7GyKRCC0tLXj99ddTolMEwzAIBoMwm80IBoPJPpy0QSGY2pxOJwKBALRaLQAKwnRBIQhArVZDJpOhvb39jvd18eJF9Pf34/vf/37YrPS3d3vOzMwEANy6dQuVlZVhz926dYt7Hoj9yxjLeTAMA6/Xi76+vpQI5FTX1NTE9c4FBtaVUygUKCgowLx588Kmqmpvb8e+ffsgl8uxdevWiL8bWx3q8XhQX1+PtrY2OBwOCIVCGAwGVFZWRpTiA4EAjh8/jt7eXjgcDjAMA7VajRkzZqCiooKqV8eZ1+uFyWSCTqeDQCCgIEwD9A3CQOlu4cKFqKurizot2mjCItpFKRAIcOOHWCUlJcjIyMAnn3zCrZINDAyM7+jowPz587nH2LXCRhoAO9x5sOfgcDhgsVgoAEepuroaq1evxtKlS5GdnY3Lly/jgw8+CBtKYjQaoVQq4XK5cOvWrYh9MAwDq9WKnTt3orGxEbm5uVi6dCmqqqrg8Xiwb98+nDp1Kuw1gUAAVqsVU6ZMwaJFi7B48WLodDqcOHEChw4divdppyV2PKHP56PvSRqgkuD/2Lp1KxoaGvDcc89h3bp1KCgoQF9fH2pra/HTn/405v3MmDEDCoUC27Ztw7333gtgYNHN279MQqEQTz75JLZv347nnnsOy5Ytg9Vqxd69e5GZmYn777+f25adjeLVV1/F3LlzwefzsWzZspjOo7CwEOXl5TAYDDCbzdQ9f4ymTJnClc5nzpwJqVSKCxcuoLW1FdOmTYPf70dbWxsWLlyIpqYmGI1G5Ofnh+0jEAjgo48+gtfrxYMPPhg2I0llZSUOHjyI+vp6GAwG7m8ulUrx0EMPhe2noqICYrEYly5dwl133UUTJ8cBwzAwm81Qq9XcJNVkcqKS4P/Q6XR44YUXsHjxYhw7dgyvvvoqjhw5goqKCq4kFguVSoUf/vCH0Gg0eOutt7B7927Mnj2bW+9rsNWrV+O73/0uN1ziwIEDWLhwIf73//7fYeP5Fi9ejI0bN+L8+fN45ZVX8NJLL8V0HqdOnUJWVhb0ej12795NHWDGEduhqb+/HwDQ2tqKYDCIkpISlJaWoqWlJWLCgatXr8JsNmPu3LkRU3Lx+XysWLECYrEYdXV1I74/Ow8m/U3jy263w263J/swSBzRYPlJjHqA3jm2TfDhhx8Oa6dtbGzEiRMnsHz5cpSXl2Pv3r0IhUK4//774XA48Oabb2LdunVha80dPXoUV65cwRNPPMGF2O0OHTqEa9eu4fHHHw+bhSgYDMLv93NVdcePH4dAIMDjjz9O7YIJoFAokJGRkezDIHFA1aGTFBuAZrM5rM2RjI3P54PH40EgEEB3dzfOnj0LgUCAwsJCuN1udHR0YPny5QAGJlTIzs6G0WgMC0Gz2QyJRDJkAAKAXq/HtWvX0NfXFxaCra2t+Oyzz7ifDQYDVq1aRQGYIE6nEwzDREy1RiY+CsFJiAJw/O3ZsyfsZ6VSiTVr1kChUKCxsRE8Hg9Tp07lni8tLUVtbS28Xi9Xne7z+Uac8FwkEgFAxN8tNzcX9913H7xeL27dukV/2ySQSCQIBAIQCAQUhJMIheAkwwagyWSiSbDH0bJly5CRkQEejweZTAaNRsNdBI1GIzIzM+HxeLiVN/R6PUKhEK5fv47y8nIAAzMJjdS+xAabTCYLe1wul3MdYEpKSnDu3Dns3bsXW7ZsoY4xCaDRaCAUCmEymSCRSKhEOIlQCE4iFIDxk5mZGdYmyLLZbNzsP+zKHoMZjUYuBLVaLTfeb6gehxaLBQCGrTIFgKlTp+LMmTNoa2vj9k/iIyMjA2KxGCaTCaFQCG63GwzDQKvVUhBOAhSCkwQFYHIYjUbw+XysXr064mLY3d2NxsZGLvSKi4vR1NSEpqamsHGgLJ/Ph7a2NhgMhhFXJWdn+qEOT/GlVqshkUi4AGR5PB5YrVYqEU4CFIKTwOA2QArAxDIajcjJyYk6YXl2djYaGxthNBpRVVWFkpISZGZmor6+PmzcITDwNzx27Bi8Xi9WrFjBPe7xeCCRSCIusuzcsrfPZUvGj1qthlQqHXJ8rdvtBo/Hg0ajSfzBkXFDITjBsSNcqKNE4vX09MBut2PWrFlRn1coFDAYDGhubkZVVRV4PB4effRRvPbaa9i9ezfKyspgMBjg8/nQ3NwMk8mEqqqqsA42165dw+XLl1FcXAyVSgW/34+bN2+io6MDhYWFEQPyyfhQqVSQyWQwmUzDzq/rcrnA4/Fo+MQERiE4gVEAJpfRaASAYVftKCwsxNmzZ2E2m5GVlYWsrCxs3rwZ58+fR1tbG65evcqVMlauXIkZM2aEvT4nJwfd3d1obm4OK3ncddddQ4YvuTNKpRJyuTzmCebZ6QwpCCcmGiw/gTEMA4fDwc1aQlIbn89HTk5OxLyiFosFu3fvhkKhwKZNm0YcRkHiR6FQQKVSjaltXaVSjdihiaQeGmk7gTmdTigUirAp1kjqYkt8tw9w1+l0uPvuu2G327F//35a3ipJ5HI5VCrVmNvW+/v7uZ6jZOKgkuAExDAMXC4XbDYbRCIRdDodXC4XlQgngNzcXPT09FDQpRiZTIaMjIw7blrg8XgwGAwQCoXUY3SCoJLgBMMwDHw+H2w2G4CBwdUmk4kbwE1SWygUootjipFKpcjIyIDFYrnjtnV2rl62xzZJfRSCEwjDMAiFQujr6wt7PBgMwmQycaVCusimLoZhaL7PFCKVSqHRaNDX1zduYy6DwSA36QEFYeqjb+MEMbgnaLQxS6FQCCaTCTweD3q9ni60KYoGVqcOdvqzvr4+eL3ecd03W1tDf+vUR1fKCYLH46Gvr2/YBnt2wHwwGITBYIBAIEjgEZJYhEIhukFJAWKxGFqtFlarddwDkOVyueBwOKg0mOLo2zhB2O12bnLmkfT19cHj8XAN9CR1UEkw+cRiMXQ6HWw2W8zfqbGy2+3w+XwUhCmMQjDFMQwDt9sNh8MxqtfZ7XY4nU4YDAYad5ZCKASTi203t9vtcLvdCXlPi8WCYDBIQZiiKARTGMMwCAQCsFqtY3q9w+GAzWaDTqeDVCod34MjY0LVockjEomg1+tht9vhcrkS9r7UYzS10bcxRbFfGPbLM1Zutxt9fX3QaDQ0qD4FUEkwOYRCIXQ6Hfr7+xMagKxAIBDRq5ukBgrBFMZWo9wpr9cLs9kMpVJJ0zolGYVg4gkEAuj1ejidTm6ez2Twer00oUUKohBMQQzDcA3q44UG1acGqg5NLIFAAIPBwPXUTDaHwwGPx0PVoimEvo0phmEY+P3+uNyx0qD65KOSYOKwJUC3251SJTCr1UrtgymEQjAFxbPtgAbVJxfNGJMYfD4fer0eXq8Xdrs92YcTJhQK0UD6FELfxhTCVoPGe3JlGlSfPDR3aPyxATh4jt1U43a7acWJFEEhmCLiWQ06FBpUn3hUHRpfbA2H3+8f89CiRLHZbFQtmgLoypdCktGF2m63IxQKwWAwwGKxjGtnHBIpXTvGNDU14fDhw9zPAoEACoUCBQUFmDdvHuRyOfdce3s79u3bB7lcjq1btw550+DxeFBfX4+2tjY4HA4IhULk5eVh/vz50Ol0Yds6HA5cvXoVN27c4KoidTod5s2bh/z8/Pic9AjYalGtVpuU9ycDKARTRCKqQYficDgQDAah0+lgtVrjPpVUOkv3kmB1dTVUKhWCwSC6urpw+fJl3LhxA48++ihXG2E0GqFUKuFwOHDr1q2oIWW1WrFnzx643W6UlZUhKysLQqEQjY2NeO+99zB37lwsWrSI276trQ319fUoLi7G9OnTwTAMrl27hj179mDlypWYMWNGwn4Hg7ndbkilUkil0rT+XCQThWCSJaMaNBq3241QKAStVov+/v6kH89kle4hOGXKFGRmZgIAZs6cCalUigsXLqC1tRXTpk2D3+9HW1sbFi5ciKamJhiNxogQDIVCOHDgALxeLx588EFkZ2dzJb+pU6fi4MGDqK+vh8FgQElJCYCBxYy3bt0aNnNSeXk5du7cibq6uqSFIDBQLSqRSAAgrT8byZJ+9TIpKFVmkqBB9fHHLoOVjlWi0eTl5QEAN4ShtbUVwWAQJSUlKC0tRUtLS8TKKS0tLejr68PcuXORlZXFVSdaLBbw+XysWLECYrEYdXV13GuiTR0oEAgwZcoUOJ3OpDYDUG/R5KJvYpIlsxo0GhpUH3/pXhocjB2+wAaU0WhEbm4u5HI5SktL4ff70d7eHvaatrY2AMD06dOh0+nA5/PDphcUi8UoKiqC1WodcXiEy+WCUChMescw6i2aPBSCScIwDLxeb0pWO9Kg+vhK5xD0+XzweDxwOBxobm7G2bNnIRAIUFhYCLfbjY6ODpSWlgIAlEolsrOzYTQaw/ZhtVohFotRWFgIPp8Ps9kcER56vR7A8LUsNpsNra2tKC4uTomSOfUWTQ5qE0yiZHThjrWXXigUwtmzZ/Hxxx9DqVRi69atQ345o/XSMxgMqKysRGFh4bDH09XVhd27dwMAvvCFL6TFahfp2kMUAPbs2RP2s1KpxJo1a6BQKNDY2Agej4epU6dyz5eWlqK2thZer5drN/P7/ZBIJBAKhVEDEBhYMYLdNppAIIBPP/0UQqEwrANNMlFv0eSgEEyCRA2KH04svfSuXbvG9dJzOBxQq9URx3x7L73MzEz4fD4YjUbs27cvopfeYAzDoKamBkKhMKLdZzJL55LgsmXLkJGRAR6Px1W5s78Lo9GIzMxMeDweroeyXq9HKBTC9evXUV5eDmCg6tRms8FsNnNtrLdjw08mk0U8FwqF8Omnn6Kvrw8bN25MqdVVqLdo4lEIJhjDMAgGg0mvBh1tL736+no88sgjMJvNXGDd3ksvKyuL239lZWXUXnqDXb58GQ6HAzNnzkRjY2NiTjwFpHMIZmZmcp+7wWw2G3p7ewEAO3bsiHjeaDSivLwcGRkZyMzMRE9PD+x2O5RKZdT3sVgsABC1g9fRo0fR3t6ONWvWJG2M4HDsdnta1IikCgrBBOPxeCk3lyEw0EvvwoULUXvpBYNBnDt3DjabLWxQPdtLr7q6OiwAAXC99G7evIm6urqIEPR4PDhz5gwWLFiQsBW+U0U6V4cOxWg0gs/nY/Xq1RE3CN3d3dxNkkQiQW5uLi5evIimpibMnz8/Yl8+nw9tbW0wGAxQq9Vhz508eRJNTU1YsmQJpk2bFr8TugPBYBAulwtyuTxtb5YSib6JCcSOCUzFweix9NK7dOlS2Er1g3vpRTNcL726ujrI5XLMnDkzjmeVmtK5JDgUo9GInJwclJaWoqSkJOy/OXPmAACam5thNptRVFQErVaL+vp6rvTIYhgGx44dg9frRVVVVdhz9fX1aGhoQFVVFSorKxN1amOSSqteTHZUEkygVCoFsr30AoEAuru7o/bSW758OYDwXnolJSXcoHq73Q6xWDzsmEK9Xo9r166hr6+Puys3m824fPkyNm7cmJYlIioJhmOrNmfNmhX1+ezsbOTm5uL8+fMoLS0Fn8/H+vXr8dFHH2H37t0oKyuDwWCAz+dDc3MzTCYTqqqqwjrYtLS04NSpU1Cr1dBoNLh27VrYe+Tn54dN3ZZsoVAIDocDSqWSbpjijEIwQRiGgc/ng9frTfahALizXnoAuLZBsVg87PtE66V34sQJTJkyBQUFBeN1OhMKlQTDsUMgovUkVigUUCqVyM/Px5kzZ2A2m6HX66HRaLB582acP38ebW1tuHr1KtdJJto0aGwbod1ux6FDhyLe5/7770+pEAQGpjNkO+3Q5yV+KAQTJJVKgcCd99Lz+/3g8/nw+/3QaDRDDve4vZdec3Mzuru7sXnz5vifZIpKxzUFy8rKUFZWFvW5pUuXYunSpRGPy+VyqFQqmM1mzJs3D/PmzQt7XiqV4q677sJdd90FYCDodu/ejQsXLmDq1KlhN2jV1dWorq4exzOKP4Zh0N/fH9GuScYXhWACMAwDj8cz5JilZLjTXnoAoNFoYDab4XK5oNPp0NfXFzFm6/ZeeidPnsTUqVMhEAi4dg92yip2Iu9U6rIeD6FQKOkzlKQ6mUwGtVoNs9kc8/dGp9Ph7rvvxt69e7F//37ce++9E36tTKfTCaVSCT6fT6XBOKFvYoKkUilwOLH00mPbKoqKitDc3IyTJ09i/fr10Ov1sFgsXLVUtF56TqcTzc3NaG5ujnjvv/71r9DpdJO+lEjVocOTyWTIyMiAxWIZ9Y1jbm4uvvrVr8bpyJLDbrfTAPo4ohCMM4Zh4HK5Ump+0OEM7qV3u+zsbDQ2NsJoNHIdD7RaLc6fP4+CggKUlZVxQRgIBLheeitWrOD2sWHDhoj9Njc34/r161i9evWkLwUCFILDkUqlyMjIQF9fH61t+T/cbjdUKhUEAgF9buKAQjABJkp355F66SkUChgMBjQ3N6OqqipqL73CwkIEg0GcP38+ai+94uLiiP2azWYAAwP402GQMPUOjU4ikUCj0aCvry9lOpClCrvdHrFQMBkfFIJxxDAMHA7HkFM7pZrheumxCgsLcfbs2Zh66a1ZsyZlByQnE5UEI4nFYmi1WlitVgrAKDweD3w+H0QiEX12xhmPoSnL4yYUCqG7uzvtZoVne+llZGTgkUceSbvzH4lQKIRer0d3d3eyDyUliMVi6HQ62Gy2tJs9aDTEYjEMBkOyD2PSoTqZOGFLgekYAGwvPYvFgn379nGz/5MBox0iMVHak8eCXa7LbrdTAI6AneAiHa8p8UQlwThJ11Lg7diLnMvlmjBto2PR29uLM2fOcKW7rKwsLF68mFvXjnXu3Dm0t7fD4XDA6/VCoVCgsLAQVVVVESse3Lx5E0eOHIHL5cKUKVOwevXqSXVDIRKJoNfrYbfb4XK5kn04EwKVBscflQTjgO0Rmu4BCAwMljebzZN6pXqTyYTdu3fDbrdj/vz5mDdvHmw2G3bv3h0xiYDJZIJOp8OKFSuwfPlyFBUV4erVq/jggw/ChgP4/X589tlnKCsrw/r16+Hz+XD69OkEn1n8sFXC/f39FICj4PP54Pf76doyjqhjTJwke6mkVBIIBGAymaDX64ccVD+RnTlzBkKhEA899BDXu3X69OnYsWMHTp8+HTYshP13bm4uenp6EAwGkZ2djQMHDqC9vZ0bmmK1WqFUKrFgwQIAA5MNHDx4MMFnFh9sADocDvqejIHD4aBxg+OISoLjjJ0dZjK344xFKBSCyWQCj8eDXq+fVEMEurq6kJeXFza8Qy6XIycnB+3t7VEHfA/uIcquiTe4V6RSqYTNZsP169dht9vR2NiIjIyMOJ9J/AkEAuj1erhcLjgcjmQfzoTkdrvp+jKOqCQ4zng8Ht3dDoFhGJjNZmi1Wm5Q/WT4MgeDwajToAmFQoRCIVgsFmRnZ3OPs52m3G43TCYTTp8+DR6Ph7y8PG4bmUyG6upqfPbZZ2AYBkqlEvfee29Czide2AB0u92Tun04EVwuF60wMU4oBMcRwzAIBAI008UI+vr6kJGRAYPBELZS/USl0WjQ09MTNgg+GAxyc7De3ubldrvxH//xH9zPCoUCa9asiWgznTNnDkpLS+FyuaDVaif0fKN8Ph96vR5er3fCTCGYytg5Rcmdm7jfqhRFpcDY2Gw2BIPBsJXqJ6ry8nIcP34cR44cwdy5c8EwDM6dO8eF3+0hL5FI8MQTT8DhcKCzsxOtra1D3ggoFIoJP5Xc4AC02WzJPpxJIRQKwe12QyaTUWnwDlEIjiOGYWis0yiwq0bodDpYrVZu2aaJpqKiAk6nEw0NDdxirQaDAXPmzMH58+e5NRVZAoEARUVF8Hg8yM3NRX5+Pj744ANIpVIUFRUl4xTihm0D9vv9FIDjzOl0ptwaiBMRheA4YQNwMvV6TAS32x22Uv1E7S6/cOFCzJkzB319fdwMKOyQhmgdWgZ3jMnOzoZcLkdzc/OkCkE2AAOBwJDrTZKx8/v98Pv9EAqFVBq8A5Oni16SUYeYsfN6vTCbzVCr1dy6gxORRCJBTk4ON9FxR0cHFApF1PGRt88aEwwGJ3SV8O3YAAyFQujr60v24UxaE/WmMZVQCI4DhmHg9/snfAePZPL7/TCZTNxachNdc3Mzent7UVlZyd2lD/6MhEIh7vGWlhZ4vd5JMxMIj8eDTqfjesaS+KEQvHNUHTpOqBR45ybqoPrOzk6cPXsWBQUFkEgk6OnpQVNTEwoKClBZWcltZ7fb8dFHH6G0tBTZ2dng8/m4ceMGrl27BqVSGbbtRMYO5KYSYPyxzTDUQWbsaO7QccAwDLq6uibEBXsiYEsSPB4PZrM55X+vdrsdx44dg9lsht/vh0qlwvTp0zF79mwIBAJuO4/Hg9OnT6OrqwtOpxOhUIibO3TevHmTYi1FnU4HPp8/If5ukwXNJ3pnKATvEDtPKPV8G3/s2LjJMqh+MLlcDqlUOqmqC7VaLQQCAQVgEmRlZdHK82NEbYJ3iMfjTdiu/amur68PPp8PBoNhQg8Uj2ayLayr0WggFAopAJOEhmaNHYXgHQqFQrQSdhzZbDY4nU4YDAaIxeJkH864GTy7zESXkZEBkUgEs9mMUCg06UrtE4HH45lUN1WJNLlurxOMYRgKwARwOBwIhUITflD9YKlWEjx37hzOnDkDrVaLRx99NOy5YDDITQTgcDi4Nqjly5cjPz8fEokEJpMJV69exYkTJ+D3+zFt2jQsX748rE2UxI/f70cwGKTf9xhQCN4BqgpNHJfLhWAwOOEH1bNSKQQdDgfOnz8ftco5FAph37596O7uxsyZM6HT6eD1etHT0wOxWAyJRAKz2QybzYbjx49j/vz5UCqVOHv2LBobGzF37twknFF68ng8kMvlKfO5migoBO8Au2wSSQx2UL1er4dAIIjbSgTsGL54XkxSqTr05MmTyMrKivp5vnDhAjo7O/Hggw8iKyuLe1ylUkEul8NkMnGThefl5WHOnDkABuYLvXr1KoVgAnk8ngk/z2wyUAiOEcMw8Pl81AlgnPn9fjQ0NKCnpwe9vb3wer1YtWoVysrKuOdNJhPa2trQ0NAAs9kMr9cLuVyOvLw8zJ8/P2LWGZ/Ph3PnzqG1tRVOpxMymQx5eXmorq4Om4mfYRjU1tbi8uXL4PP5WLBgQdzG7qVKSbCzsxMtLS343Oc+h5qamrDnGIZBY2MjiouLkZWVhVAohFAoBI1GA7lcDrPZzLX/qdVqdHV14ebNm1Aqlbhy5cqkmPRgImGvR6nwuZpIKATvAJUCx5/H48HZs2ehVCqh0+nQ2dkZsU0gEEBrayu0Wi2mT5+OYDCI/v5+XLlyBe3t7fjc5z7H3REzDIM9e/agr68PFRUVyMjIgN1ux6VLl9DR0YFHH32U63DT3NyMlpYWrFixAoFAAKdPn0ZWVlZYCWi8sDdPPB4vaTdSoVAINTU1mDFjBjfV22B9fX1wuVzQ6XQ4evQompqaEAqFkJWVhbvuuitsjUSDwYBp06Zh7969AAbGC65atSph50L+1kdBIpFQEI4CheAYUXtgfMjlcjz55JOQy+Xo7e3F+++/H3W7ZcuWRQyqLyoqwvvvv49r166hqqoKALgS5dKlSzFr1izu9RkZGThy5Ag6OjowdepUAEB3dzfmzJmD6dOnAwCsViu6urriFoLs/KHJ6k15+fJlOBwO3HfffVGfZ8e+XrhwARKJBOvWrYNMJsPhw4fx4Ycf4uGHH4Zer+e2X7p0KSorK+Hz+bhB8ySxPB4PJBJJsg9jQqFP6RgFAgHqCh4HAoEg5uVh2JXq2XUJ2YmqB09Ezf5bJpOFvZZ9j8GdQVQqFYxGI8xmM7q7u9HW1hbXKr1kVl15PB7U1dVh3rx5Eb8bFjvPqd/vx+bNm3HXXXehoKCAC82GhoaI16jVahgMBgrAJKGhEqNHJcExoA4xqcPj8eDWrVsABjp4AEBeXh73fGZmJoRCIerq6iCRSKDRaGC323Hq1ClkZmYiPz+f27aiogItLS3YuXMnAKC0tBSFhYVxO/Zkdo45c+YMJBJJWOn4dmx3+7y8PBQUFMBiscDv90OpVCI7Oxvd3d2JOlwSo1AoBJ/PB5FIRGEYIwrBMaCq0NTxxhtvcCVyqVSKe+65ByUlJVwJUCqVYt26dTh69Cj27NnDva6goADr168PCyGhUIhNmzbBYrFAIBBEXQJpPCWrJGiz2XDlyhXcddddYUNNgsEgQqEQ+vv7IRKJuHbVjIwMbvYelkwmg9lsTvixk5F5PJ6IhZzJ0CgEx4C92yLJt3HjRgSDQfT19cFoNKK/vz9iUL1UKoVer0dFRQW0Wi3MZjMaGhpw+PBhrF+/Pmx/7Dp4iZCsEHQ6nWAYBidOnMCJEycinn/rrbdQWVmJpUuXgs/no6+vL2JSCJfLNSkm/J6MPB4P1Gp1sg9jwqAQHCWqCk0tbNXnlClTUFxcjHfffRdCoRCrVq2C3W5HV1cXPvroI6xevZrrAFNcXAyVSoXDhw/jxo0bmDJlSlKOPVnVoTqdDhs2bIh4/MyZM/D7/ViyZAn0ej2ys7NRVFSE1tZWWK1WrmTc19eH7u5ulJeXJ/jISSzY/go0e0xsKARHiapCU5darYZer8eVK1cwe/Zs6HQ61NbWIhgMRrTtFRUVAQC6urqSFoLJKglKpVIUFxdHPN7Y2AgAKCsrg06ng81mQ3V1NW7evImPPvqIaz+8ePEiJBIJ1wOXpB632w2FQkHtgjGgEBwDmi80dQWDQQSDQfh8PphMJm4A8e1j8UKhEAAkdbKDVBzYzA47sdlscLvd0Gq1eOCBB3Dq1CmcO3cOPB4PeXl5WLx4Mc1OksK8Xm/YRBBkaBSCoxQIBGiWmCQLhULw+/0R46F6enpgsVhQWloKYOBvxW7DlvjYv11zczMAJKz9L5pUmjoNAB555BHo9XrY7fawpXkMBsOQYwlJavL7/ck+hAmDQnAUGIahD1cCXLx4EV6vl+u52NbWBofDAQCorKwEwzB44403UFJSAq1WC5FIBIvFgqamJojFYsyfP5/b1/Tp01FfX4/9+/dzY+J6e3tx9epVaLXaqNWCicIOlk8FQqEQer0e/f39E35ycgJuSStqFxwZrSw/CgzDwG63w+l0JvtQJrU333yTC73bPfHEE5DL5Th16hRu3bqF/v5+BINByOVy5OfnY968eRFzhzqdTpw5cwbd3d1wOByQSCQoLCzEwoULk9rDUalUQigUwmq1Ju0YgL8FoNPpHPL3TiYenU5HU6jFgEJwlNh2JjIxZWRkQCqVwmw2czOiJItcLodUKoXFYknaMQgEAhgMBrhcrritykGSQ6VSQalUUgiOIDXqYiYQqg6d2FJppfpkd4wRCATQ6/Vwu90UgJOQz+ejAIwBheAoUKeYycHhcMBut0On0yW1OjSZHWP4fD70ej28Xi/sdntSjoHEF92wx4ZCMEbUKWZycblc3ADwWCfsHm/JKgkODkB2pQgy+bDrP5LhUQiOAoXg5OLxeGCxWKBWqyM60yRCMkKQnRbO7/dTAKYBWvh7ZBSCMeLxeNQhZhJiB9XL5fKEr4Se6OpQNgADgUDSe6SSxKAb95FRCI4CfaAmp0AggN7eXojFYmi12oS9byJLgmwAhkIh9PX1JeQ9SfL5/X7qHDMCCsEYBYNBqlaYxEKhEEwmE/h8PgwGQ0IuHOznKd7vxU6FFgqFkjocgyQe1V6NjEIwBgzD0IcpDdy+Un28qyrZOU3j/T46nQ4AqASYhqhzzMgoBGNEVaHpg11All2VPp7iXSWq0+nA4/FgsVioJiNNUeeY4VEIxoDH41EIpplEDaqPZwhqtVrw+XyYzWa6CKYxunYNj0IwRsmeYoskXiIG1cerh6hGo4FQKKQAJAgEAtQ5ZhgUgjEKBoPJPgSSBPEeVB+PkqBGo4FIJKIAJABAbYIjoBCMAX2I0ls8B9WPdwhmZGRALBbDbDbT55YAoBv4kVAIxoA+RCReg+rHszpUrVZDIpFQAJIwdP0aHoVgDOhDRID4DKofr5KgSqWCTCbjhngQwmKH4pDoKARHwDAM3VUTzuBB9Xq9/o4DbDxKgkqlEnK5nAKQDImuYUOjEIwBXVjIYOyg+lAodMeD6u+0JKhQKKBQKFJikWCSuugaNjQKwRjQXRSJZjwG1d9JCMrlcqhUKlgsFgpAMiya9nFoaRuCFy9exJYtW3Dx4sVht+PxeHQXRYZks9ngcrnGPKh+rNWhcrkcarUaZrOZBkOTEdGN/NDSNgRHgz5AZDj9/f1jHlQ/lpKgTCaDWq2GxWKhACQxoRv5ofGYNC0jh0IhBAIBCIXCEe/Eu7u76UNERiSVSqHRaGC32+FyuWJ+jVKphMlkGtV7WCwWmtSdxEwmkyV0mbCJJG1Lgnw+H2KxOKaqKApAEovBg+qVSmVMrxlNdahEIoFGo+HaIgmJFdVmDW1Urfm9vb3YtWsXLly4AJPJBIlEgsrKSjz11FPIysritjt06BC2b9+On/70pzh58iSOHDkCn8+HOXPm4Otf/zrUajW37dNPP40pU6bg4YcfxmuvvYb29nZotVo89thjWLVqVdj7d3d34/XXX8eFCxfg9/tRVFSEzZs3Y/78+QAGLkJ///d/j7Vr1+IrX/lK2GvNZjO+9a1v4YknnsAjjzyCixcv4vnnn8dPfvITzJo1CwDw3HPPob+/H9/73vfwn//5nygrK8NDDz2ETz/9FOvWrQvbn8ViwXvvvYdr165BLBajuroaM2fOxB/+8Ac8/fTTmD59eky/06amJhw+fJj7WSAQQKFQoKCgAPPmzQubqqu9vR379u2DXC7H1q1bh6xG83g8qK+vR1tbGxwOB4RCIQwGAyorK1FYWBix/Z/+9Keo+1m4cCGqqqpiOo9UEwwGIRAIEv6+7KB6vV4PgUAAm8027PaxVodKJBJotVpYrVZ4vd7xOlySJuhGfmijCsHm5mZcvXoVy5Ytg06nQ29vL/bv34/nn38ev/nNbyCRSMK2f/XVV6FQKPDYY4+hp6cHe/bswX/+53/ie9/7Xth2XV1d+PWvf421a9di1apVOHjwILZv346SkhJMmTIFAGC1WvHss8/C5/Ph3nvvhVKpxOHDh/HLX/4S3//+97Fo0SJIpVIsXLgQNTU1+NKXvhR2h338+HEAwIoVK4Y9R4fDgZ///OdYvHgxli5dCofDgd27dyM3NxcVFRUAAK/Xi23btsFut2PlypVQq9Woq6vDtWvXRvPrDFNdXQ2VSoVgMIiuri5cvnwZN27cwKOPPsr1PDQajVAqlXA4HLh16xby8/Mj9mO1WrFnzx643W6UlZUhMzMTPp8PRqMR+/btw9y5c7Fo0aKI1+Xn50cEt16vH9O5+P1+NDQ0oKenB729vfB6vVi1ahXKysrCthsqfNnjue+++7ifXS4X6urqcPPmTbjdbsjlchQVFWHevHlh7XCBQABHjhzB9evXIZVKsWTJEpSWlo7pPMaKHVSv1+uh1WqHXccvFAqNGILs4HybzQaPxzPeh0vSAJUEhzaqEJw/fz7uuuuusMeqq6vx7LPP4uTJk1i5cmXYc0qlEs8++yz3JWcYBnv37oXL5Qor4dy6dQvPP/88ysvLAQBLly7FN7/5TRw8eBBf/OIXAQDvv/8+bDYbfvrTn2LmzJkAgPXr1+MHP/gBXnvtNSxYsAB8Ph+rVq3CsWPH0NDQEFaKOXr0KMrLy2EwGIY9x76+PjzzzDPcuXg8HqjVapw8eZILwZqaGpjNZnzta1/D7NmzuWP+93//99H8OsNMmTIFmZmZAICZM2dCKpXiwoULaG1txbRp0+D3+9HW1oaFCxeiqakJRqMxIgRDoRAOHDgAr9eLBx98MKx0XllZiYMHD6K+vh4GgwElJSVhr83IyIi59DoSj8eDs2fPQqlUQqfTobOzM+p2q1evjnjMZDKhsbEx7Nz8fj927dqFQCCAiooKblzcpUuX0NnZiUceeYT7jF24cAEWiwVr166Fw+HA0aNHkZ2dHXP15HhhB9Xr9Xro9foh1/MbaVFdkUgEnU4Hm80Gt9sdz0NOimSV2NNNKBRCMBjE0aNHo37v0tmoQnBwF/BAIAC3242cnBwoFApcv349IgTXr18fdpdbXl6Ojz76CL29vSgqKuIeLygo4AIQGJgDMS8vDz09Pdxj586dw7Rp07gABAY6Caxfvx5vvPEGbt68icLCQsyePRtarRZHjx7lQrC9vR1tbW34+te/PuI5SqVSrrTITjdUWFgIs9nMbXPlyhVkZGSgsrKSe0wkEmHJkiXYtWvXiO8Ri7y8PFy4cAH9/f0AgNbWVgSDQZSUlCAYDOLcuXNYtmxZ2Pi0lpYW9PX1obq6OiwAgYE20BUrVuDmzZuoq6uLCEHgb8tF3elCsnK5HE8++STkcjl6e3vx/vvvR90uWuiygTm49MZW695zzz1h1blSqRRnz56F2Wzmbm66u7uxYMECFBcXAxioZejt7U14CAIDnx+TyQStVguDwRB1Tk82GHk8XkRIikQi6PV62O32CRWAwWAQZ86cgdFohNfrhU6nw4IFC1BQUMBt4/F48Nlnn+HWrVtQKBRYtWoV8vLy4n5sqdD8cOnSJdy6dQs9PT1wOp2YPn16QoLJ4/HEdW3MZDl79iyMRiO2bNkypteP6mrn8/nw17/+FYcOHYq4s43WG+72UpdCoQAAOJ3OYbdjtx28nclkinrRZEsMJpMJhYWF3MV+//798Hq9kEgkOHbsGBdSI7l9KiyBQACVSoXOzk5IpVIwDIO+vj5kZmZCJBJxQckwDFeSGw92ux0AuKo+o9GI3NxcyOVylJaW4tSpU2hvbw8Ls7a2NgDRwwUYuIkpKirCtWvXYLfbw9pmm5qacOnSJQADS/HMmzcP06ZNG9OxCwSCMS07FAwG0dLSgtzc3LDQYjuByGSysO3ZnweHtlqtxpUrV6DRaOBwONDV1YXq6uqxnMa46evrQ0ZGBjIzMyNmdmE/O3w+P6zdRigUQq/Xo7+/P+aepqni8OHDuH79OmbPng21Wo2mpiZ8/PHHeOCBB5CTkwMAOHXqFILBINavX4/e3l58+umneOKJJyASiRJyjMlsfqivr4ff70dmZmZC/7axVL1PROfOncO+ffsSE4J//vOfcfDgQdx///0oKyvjLnQvvfRS1Kqeoap5bt821u1itXLlSnzwwQc4ffo0li1bhmPHjqG6ujqmC/PtxyIQCCAQCMDj8aBUKsHj8SAQCLi7PR6Px32wOjo6AAwEaU5OTlhARvsPCL+QCwQC+P1+3Lp1C+fOnYNQKMS0adMQCARw69YtrFy5EkKhEBkZGcjOzobRaAwLQavVCrFYPOxyP3q9HteuXUNfXx8XgtnZ2SgpKYFKpYLT6cSlS5dw8OBB+Hw+rgo4Edrb2+Hz+SLCNzc3FzweDydOnMDixYuhUChgsVhw/vx5FBUVQaPRcNtWVVXhww8/xDvvvAMAmDt37pjbNseTzWbjplm7fXjD7Z1j2AB0OBwRN4yprqenB83NzVi8eDHmzJkDYOCm7L333sPJkyfx0EMPcdutWbMGer0excXFuHHjBqxW67jeSA4nmc0PDzzwAHctefXVVxNyvuzxxmMB54luVCFYW1uLVatWce10wMBdeiK+qAaDAbdu3Yp4nA2ewaXJwsJCTJ06FUePHoVOp4PJZMJXv/rVMb2v1+uF1+tFMBjkxnKp1Wp0dnais7OTu3jxeDw0NTUBGAgjk8nEBeRw/7Fh+O6774a9r1qtxkMPPYS8vDycOXMGPB6PC3Iej4f58+dj//790Gq1XAk1FApBIpEgKytryOBlg48t4TIMg89//vNh28yZMwdvv/02zpw5g4qKCggEAu444zkjfXNzMwQCAaZOnRr2uFarxfLly3Hy5El88MEH3OPTp0+PqIKXy+XYvHkzLBYLpFLpuK//dyf6+/sRDAah0+lgtVq5Ti6DQ1AgEECv18PlcsHhcCTzcMekpaUFPB4vrNlCKBRixowZOH36NBwOB5RKJVQqFRobGzFv3jyYTCbY7fak/q0S2fww3ue5d+9e7Nu3Dz/60Y+wd+9eXL58GQKBAAsWLMCDDz7Ila6DwWBECDqdTrzzzjs4efIkbDYb9Ho91q1bh02bNoVt+8EHH+DUqVO4desWvF4vCgoK8Mgjj0T0EWloaMA777yDGzducJ/1xYsXY+vWrQAGmlzee+89nD17Fl1dXQiFQpg6dSq2bNkS1rzU09ODZ555Bk899RTkcjl27doFs9mMoqIifO1rX+NulLdt28ZVbw8uCe7YsSPm39+oQjDaXcTHH3+ckJ5H8+bNw549e9DU1MT1MvR4PPj000+RmZkZ1t4ADPQCff311yESiaBSqca1q//MmTNx9epVNDY2ch1jfD4fampqAAx82GKdy5G9EC5btgwZGRng8XiQyWTQaDTg8Xjo7e3FuXPnYDAYcOPGDe51QqEQwWAQJ06cwKxZs7gSqtPp5LrlRwtdtnu9UqnkOiRE227x4sXYu3cvfD4fioqKIqpRRirhsv9mz48NpKG29Xq9aG9vR2FhIRQKRcR2CoUCmZmZKCwshFKpRFdXFxobGyGVSiO+iAKBIGElitFyuVwIhUJhg+rZO3Q2AN1uN3cxnmjMZjO3sO9g7N/DbDZDqVRi4cKF2Lt3L5qamsDj8bBkyZJRz7YznhLd/BAP//Vf/wWdTocHHngAbW1tOHLkCFwuF5566ikAA9elwd9jr9eL5557DhaLBevXr4fBYMDVq1fx5ptvwmq14stf/jK37d69e1FdXY3ly5cjEAigpqYGv/nNb/DDH/6QG6J248YN/Nu//RuKioqwZcsWiEQidHV14erVq9x+XC4XPvvsMyxbtgzr1q3j2oZ//vOf4xe/+AXXls86fvw43G43179k165d+PWvf42XX34ZQqEQGzZsQF9fHxoaGvDMM8+M6fc26t6hR44cgVwuR0FBAZqamnDhwoWE3ME9/PDDOH78OF544YWwIRI9PT34/ve/HxHQy5cvx+uvv45Tp07h7rvvvqMJjm+3dOlSHD16FP/v//2/sCES7B3XWOrdMzMzo164bTYbent7AUS/u7l27Rp3152RkQGTycRdaKJhO57w+XxYrdYhj4e9sens7Ay7oMVSuh1cOh58M8Dn84fc9vr16wgGg5g/f35ENTPbQeGrX/0q8vLyuGDUaDQ4evQoFi9eDL1eP2QQxxrY0Z6LB3ZQvU6nA5/P59oE9Xo9PB4Pd0GeiG7v+c1iH2PbwHQ6HR5//HFYLBZuKahE8vl88Hg8CAQC6O7uxtmzZyEQCFBYWAi3242Ojg4sX74cwMAN43g2P8SLXq/H3/3d3wEYKARIpVIcO3YMa9euRV5eXkR16Icffoiuri68+OKLyM3NBQBs2LABOp0OH3zwAR544AGuhu2ll14Kuw5s3LgR//zP/4wPP/yQC8GGhgYEAgH86Ec/GvJclUoltm3bFnY9XrduHb773e9i7969+OY3vxm2vclkwksvvcRdz/Ly8vDiiy+ivr4e1dXVKCsrQ25uLhoaGiJqhWI1qmT4yle+Aj6fj6NHj8Lv92PGjBn413/9V/z85z8f05uPhkajwc9+9jO8/vrr+Pjjj7kSyj//8z9zf4Tbt58zZw7OnTs35l/OUCQSCZ5++mm89957OHLkCCQSCRYuXIji4mK8+uqrd9y7cjCj0Qg+n4/Vq1dHhGt3dzcaGxu5KqaioiI0Nzejqakp6u/E5/Ohra0NBoNhxC8kWxK5/e58tAHB9mr0eDzDDhw/d+4cxGIxMjIy0NXVxT3O4/Fw7NgxyGQyiESisGpmtjfh9evXoVAooobrUMEbLbAH/zz4XMc7XNmq676+Pq49U61Ww+v1or+/f0J3XggEAlwb+mDsd2JwaUQkEiE7OzvhxwgAe/bsCftZqVRi7dq1UCqVaGxsBI/HQ0lJCXespaWlqK2thc/n48ZD+/1+iESiYf9ebHAEAoEht7v9czda7GtXrFgRtp+VK1fi2LFjuHTpEvLz85GdnR1Ww1BbW4vy8nIoFIqwG6/Zs2fj/fffx+XLl7me8oMD0OFwIBQKoby8nBt/Dfyt4+OZM2ewevXqqDWHfD6fezwUCnE1IaWlpWhpaYnYfsmSJWE39OwNf3d39yh+Q8Mb1dVaoVDgW9/6VsTj27ZtC/t59erVUbv8zpo1K6I0c/trWc8991zEY9nZ2fhf/+t/xXy8QqEQ2dnZEYO0hzqWaO8JAE8++WTEY3q9Hv/wD/8Q9tihQ4cAIKyjxp0yGo3IycmJOuA7OzsbjY2NMBqNqKqqwtSpU6HValFfXx/W8A8MXJCPHTsGr9cbNmGA2+2O6HXp8/m4qsaRxlWOB5fLhc7OTkyfPj1izBjDMHC5XGAYJmLWC7aq1ev1jmsvu9EE5u3/DQ7dkba9/eInl8sTXiIab1KpFEKhkCtZsNgQ1Ol0Ec8lEnvxvO+++6DX68Hn86FQKLjaB2CghFRQUBB2ozhjxgxufDDb21gul6Ovr2/Y82ltbQUw0Is92nZs88ed/E7YkJg1a1ZY22RmZiZ4PB48Hg+3/8Gdzjo7O9HW1saVHm83+Ka1rq4OO3fuRGtra9ik7YM/v0uXLsWnn36K3//+93j99dcxe/ZsLFq0CHfddVdYIB46dAgffvghOjo6wr7Tt7erApEjB9hzHc9+KONXZEkxfX19OHv2LD73uc/FZf8+ny/s7sjv96OmpgaZmZnjFoI9PT2w2+3ctG63Y7+8zc3NqKqqAp/Px/r16/HRRx9h9+7dKCsrg8FggM/nQ3NzM0wmExeWrEuXLqG1tRVFRUVQKpVwuVy4evUqHA4H1qxZk5CBzM3NzWAYZsghGRkZGejo6MCtW7fCxpI1NzcDiD7E5k7Euzp0ML1eD6FQCK/XCz6fD4lEAr/fD7fbDbfbPeHWgBOLxejr64uYIIHtwBYIBIacPCER2CYAiUTC3fwFAgGu9sFms3Ed8F5++eWI19fV1XGfQbZt+tq1a0M2P7Ah6Pf7o543wzBwu9139DthO1D19PSEhQr7b/YmMzc3F0ajkfuesZ3gNm3aFHW/7HlevnwZL774IsrLy/G1r30NWq0WAoEAhw4dwrFjx7jtxWIxnn/+eVy8eBFnz57F+fPnUVNTg8rKSjz77LPg8/k4cuQItm/fjoULF2LTpk1Qq9Xg8/l4//33o5buxnvkQDSTLgR7enpw5coVfPbZZ1zDaTz8+c9/hlarRX5+PjweD86cOYOenh584QtfGLf3MBqNABB1wC2rsLCQGzCu1+uh0WiwefNmnD9/Hm1tbbh69SrXvrdy5UrMmDEj7PXZ2dno7u7GlStX4PV6IRQKkZmZiZUrV0YdFxWrixcvhpXQ2IHEwED38cE3EEajEXK5fMjB0rNmzUJTUxP279+PWbNmQalUorOzE83NzcjPz496BzkRaLVarrNSMBiE1WrlSgbseoEejwdut3vCTJem1+u5HoSD/8bsBU6n06VEsA91o3Pt2rURmx/6+/uhVCpRWFgIo9GIq1evjtj8wHYKG82xjOZcgIFrn06n4x7v7e0FwzDc77y7uzus2jM7Oxsej4cbyjKUkydPQiQS4cc//nHYOE625mswPp+P2bNnY/bs2fjSl76EnTt34q233kJjYyPmzJmD2tpaZGdn4wc/+EHY75cd0jQWd9p8MOlC8NKlS9i+fTsMBgOefvrpOy6VDfULnjlzJmpra1FXVweGYZCdnY0vfvGLUb8MwykrK4taXQsMVC8sXbp02NdXV1dHDAZne0yyvSYtFgt2796NCxcuYOrUqWEXp4KCgoieteOhoaEhrIt/a2srd1c8ffp07hjY4SSzZ88e8net0WjwyCOP4MyZM7h27Ro3d+icOXOSPhB+rDIyMrg2TnbMGPC36l+Xy8VNOqBWq6HRaLjSYSqvIDF16lQ0NDTgypUr3MU1GAyiqakJWVlZSZm5ZzTi3fwQT8eOHQsbmnL06FEA4Gbj4vP5YT35lyxZgnfeeQfnz5+P6D3vdDohlUohEAi4Kv7Br+3p6cHp06fDXsP2TRiM7e3JdpBjS3aDhwVdu3YNTU1NY67RYdtonU4n1y45GpMuBIdqj5yo7zMedDod7r77buzduxf79+/HvffeG/dqzs9//vMxbafRaPD3f//3MW23fv36Oz2slKBUKiGVSmEymYYdXhQMBtHf34/+/n6IRCLI5XLodDqEQiG43W64XK6UWx0gKysLU6dOxalTp+B2u6FWq3Ht2jX09/ePewe18ZaI5gdgoFaEnYYxFArBYrHg7NmzAICioqIxT+5gNpvxpz/9CeXl5WhtbcWZM2dQXV3N1egMHu8LAJs2bcKZM2fwy1/+EqtWrUJJSQk3VKm2thbbtm2DWq3G/Pnz8eGHH+KFF17AsmXLYLfbsW/fPuTk5HDDRICBsc6XL1/GvHnzkJmZCZvNhv3790Ov13PhXF1djVOnTuFXv/oV5s+fj56eHnzyyScoKCgYc20H22P31Vdfxdy5c8Hn87Fs2bKYXz/pQpBEl5ubO+YJA8j4kclk3CK6bICNNIk2MNCmZLPZYLPZIJVKIZPJkJWVBb/fD5fLlVLth6tXr+ZWVfH5fNDpdLjnnnuS2iEmFolofgAGBtkPXnHGbDZzoahUKsccgl/60pewd+9e7N69GwKBACtWrAhr7xMIBGE3XRKJBM8//zx27tyJ2tpaHDlyBDKZDHl5ediyZQvXSauyshLf+MY3sGvXLrz22mvIysrCk08+iZ6enrAQXLBgAXp6enDw4EH09/dDpVKhoqIibF+rV6+G1WrFgQMHUF9fj4KCAvzjP/4jTpw4wU3bOFqLFy/Gxo0bUVNTg6NHj4JhmFGFYNquLB8LdrD3cEvhEBIrdk3A26dNUyqVEAqFw47bjGZw+6FIJJpw7YeTFdv8oFAosGnTprhPWs3OGPOzn/1s2OrmnJwcmjYtCvqNEJIAIpGIWxT39ja92+cOjRXbfmgymdDT04NAIAC1Wo2cnByuzZEkHtv8YLfbsX///pSrsibhqDp0GOy4L0LuBDshtt1uj1pKG2sIDja4/VAsFkMmk0Gv16d0++FklorNDxN5EoZ4ohAcAS34Se4En8+HTqeD0+kcckD/eITgYD6fDz6fb0K0H5LEYHt4kkjUJjiCUCgUNo0XIbHi8XgwGAzw+/3DtvdJpVKus0w8j4XaD9OXUCicsONp441KgiNg76DoXoGMlk6n4wbBD2e8S4JDvcdw4w9dLlfYdFhkcqEaraFRCMbg9lW/CRkJOxuMxWIZcdtEhOBgw7UfstWlqfB5DwaDdPEeJ/R7HBqFYAwEAkFKXBTIxJCRkQGhUAiz2RxTDUKiQ3CwaO2HKpUKHR0dOHz4MLq7u+FyuSAUCqHVajFnzhwUFRVF3VcoFMJ7770Hq9UatrI8i2EYNDQ04NKlS3C73cjIyMDcuXMj5owNBAI4cuQIrl+/DqlUiiVLlkSdwYXEjl2yi9oFI1EIxoB6iJJYxTobzGCpUtXu8Xjg8XjA5/PR29vLre8olUrhcrlw7do17N+/H8uXL+em4hqMXdZrKKdPn0Z9fT1mzpyJzMxMtLa24uDBg+DxeGEhd+HCBVgsFqxduxYOhwNHjx5FdnZ2yk+5lsqoJDg0CsERMAxDHyASE7lcHjEbTKxS6Q49FAohOzsb2dnZXPuhTCbDypUr8cc//hGNjY0RIeh2u3Hu3DnMnTsXdXV1Eft0Op24cOECKioquNk8ZsyYgQ8//BAnT57E1KlTuZvN7u5uLFiwgJt3squrC729vRSCd4Bu5IdGv5kY0AeIjEQikUCtVsNisXCTBccqlaup2PbDnp4eWK1WqFQq+P1+bjJs9gbx1KlTyMjIGHI5rLa2NoRCIVRUVHCP8Xg8lJeXw+l0oqenh3tcrVbjypUrsFqtuHnzJrq6uuK+KvtkF22hYzKAru4xoJIgGc5ws8HEIpVD0O/3w+PxwG63o66uDi0tLcjJyYHdbodIJEJWVha8Xi+uXbuGpUuXDnkeJpMJQqEwYlUXttv+4OEhVVVVsNvteOedd7B3717MnDlzzPNpkgF0DRsaVYeOgGaNIcMZaTaYWLBtgqk4FKe2thZXrlwBMHB8xcXFWLZsGdd+yOPxsG/fPpSXl2Pu3LlRF0YFBhZ2lclkESHJTqw8eCIBuVyOzZs3w2KxQCqVQqVSxens0gddw4ZGIRgDuosi0cQyG0wsUjkEZ8+ejZKSEjidTly/fh0Mw4S1d165cgUmkwlr167l5i8FBjoIZWRkcOMPhxruwD52exuqQCAIW5+PjB2Px0vZmoZUQLcHMaAQJLfj8XjQ6/Xwer3o7++/4/2lapWoRqNBfn4+ysrKsHHjRvj9fuzfvx8Mw8Dn8+H06dOYO3culEolgsEgnE4ngIGOMsDASvNZWVmQSCRRe8uy4Uffsfih3+3wKARjQFUJ5HbsbDA2m21c9peqIXi7qVOnore3FzabDQ0NDQiFQigpKeEG37Mh6HK5cPPmTXR0dMBut0OlUsHtdkOn00Eul3Pnypag2WpRMv4oBIdH1aExogHzhDWa2WBiNVFCkP0O+Hw+OBwOeL1evPvuuxHbnT9/HufPn8fnPvc5CAQCKJVK+P1+3Lp1CwUFBcjIyIDH40FraysAUMeXOKKb+OFRCMZIKBRSCBJuNhiTyTSu7XepFoJutxsymSzssVAohGvXrkEgEECr1aKyspIbyzf4dceOHUNZWRmKioq4Ti1FRUWora1FXV0dpFIphEIhpFIprly5ApVKhbKyMng8Hpq/NA6EQmHKfb5SCYVgDBiGgUgkgtfrTfahkCQaPBvMeHdgSbWL1NGjR+H3+5GTkwOFQgGXy4Xm5mZuSjSRSASDwQCDwRD2OrZ9VKvVhgWkUqlEZWUlV4XKzhhz48YNbNiwAXw+PyXnL50MaHHl4VEIxog+SOntTmaDiVUqhWBpaSmuXr2Ky5cvw+PxQCwWw2AwYNGiRUPOHTqSRYsWQSKR4PLly2hqakJGRgbWrFmD4uJi2Gw2bv5SuVwOlUoFn88Ht9tN6x/eIbFYnFKfrVRD6wnGKBgMDjkGikxuEokEWq0WFotlTIPhY2EwGOBwOGh9v//B5/Mhk8kgk8m49Q9dLhfVxowSn89HTk5Osg8jpVFJMEbstEN0z5Be7nQ2mFilWnVosoVCITidTjidTgiFQshkMmRkZIDH43GlQ2o/HJlYLE72IaQ8CsFREIlEcb0QktQyHrPBxIpCcGiBQCDq+ofBYJALRGo/jE4kEtFnawQUgjFiGAZisZhCME2M12wwsaILVWxuX/+Q2g+HR30ZRkYhOAr0gUoP4z0bTCwoBEdv8PqHMpkMcrmcG39I7YcDqFPMyCgEY8Tj8SgE08R4zwYTCwrBsbu9/fD69evYt28f97xAIIBCoUBBQQHmzZsXNjtNe3s79u3bB7lcjq1btw75N/B4PKivr0dbWxscDgeEQiEMBgMqKytRWFgYsb3P58O5c+fQ2toKp9MJmUyGvLw8VFdXJ2xdRD6fTwPlY0AhOApCoZA6x0xy8ZgNJhYUguMjEAhw7beLFi2CwWAAn89HW1sbGhsbcePGDTz66KMQCgcufUajEUqlEg6HA7du3UJ+fn7EPq1WK/bs2QO3242ysjJkZmbC5/PBaDRi3759mDt3LhYtWsRtzzAM9uzZg76+PlRUVCAjIwN2ux2XLl1CR0cHHn300YR0WKFOMbGhEBwl6hwzecVrNphYMAxDd+3jLC8vD5mZmeDxeJg6dSqkUilOnz4Ns9mM4uJi9Pf3o62tDQsXLkRTUxOMRmNECIZCIRw4cABerxcPPvggt/4hAFRWVuLgwYOor6+HwWBASUkJAKCnpwe9vb1YunQpZs2axW2fkZGBI0eOoKOjA1OnTo37+VOnmNjQt24U2JljyOTDzgZjsViSUtKni1X8MAwDj8cDnU4HYGABX4VCgb6+PgSDQcycOROlpaVoaWnhloJitbS0oK+vD3Pnzg0LQGCgunHFihUQi8Woq6vjHmdvkm+fdo6thmVLofFG16rYUAiOElUxTD7sbDBmszlpXe0pBOPPbrcDGAgvk8mEuro6TJkyBfn5+Vi8eDH8fj86OjrCXtPW1gYAmD59etR9isViFBUVwWq1cvvPzMyEUChEXV0dOjo64HQ60dnZiVOnTiEzMzNqlWs8iEQi+kzFgKpDR4E6x0w+EokEarUaFoslohTACoVCtDDpBOTz+eDxeBAIBNDd3Y2zZ89CIBCgsLAQbrcbN2/exPLly9Hd3Q2xWIy8vDy0trZiwYIF3HALq9UKsVg87Or2er0e165dQ19fH9RqNaRSKdatW4ejR49iz5493HYFBQVYv359Qqq9+Xw+LaEUIwrBUaLOMYnV29uLpqYm3Lp1Cw6HAxKJBFlZWViwYAE0Gg2AgVLUtWvX0NLSArPZDK/XC5VKhZKSEsyZMyei+ontudfW1sb13MvNzY3ouccwDGpra3H58mXw+XwsWLAAlZWVcTlPKgmOv8EBBAxUea9ZswYKhQKNjY1cWyEw8JkoLi5GbW0tTCYTtFotVCoVgsEgN8xgqO88e2M8eAYbqVQKvV6PiooKaLVamM1mNDQ04PDhw1i/fn2czjjymMjIKATHQCKR0ByPCVJfX4+uri6UlJRAp9PB5XLh0qVL+Otf/4qHHnoIOp0OgUAAhw8fRlZWFsrLyyGTybg7/1u3buH+++/nAmZwz72FCxdCLpfDZDJF7bnX3NyMlpYWrFixAoFAAKdPn0ZWVlZE29B4oBAcf8uWLeOmWpPJZNBoNNzv2Gg0IjMzkxtrCIBbxeLSpUsoLy8Hn8+HSCSC2+1GTk4OVzq8ffwhG35sG6DdbsdHH32E1atXcyFbXFwMlUqFw4cP48aNG5gyZUpcz10qldJnKkYUgqPEMAykUimFYILMnj0ba9asCavaKS0txXvvvYf6+nqsWbMGfD4fmzZtQnZ2NrfNzJkzoVKpUFdXF9b1ne25t3HjRlRUVKC/vx8lJSVRe+51d3djzpw5XHuQ1WpFV1cXheAEkZmZiczMzIjHbTYbent7AQA7duyIeN5oNKK8vByhUAhqtRq9vb24fv06srKyuNqHwfOXssNp2CrTpqYmBIPBiPGD7OobXV1dCQlB+jzFhkJwlHg8HqRSabIPI20MDjZWRkYGN6k1MDAYOtp2xcXFqKurQ19fHxeC7F27SCQKmw0mWs89lUoFo9GI3NxcBAIBtLW1YcmSJeN2boNRCCaO0WgEn8/H6tWrI37n3d3daGxshMPhgFKpRFFREZqbm3H58mXIZDJu/lK5XA69Xg+Xy4W2tjYYDAao1WoA4KZuu736NBQKAUDcm1KEQiG1B44C9Q4dAz6fT71Ek4hhGLjdbkgkkmG3Y+f8HHzTMn36dIhEIhw9enTEnnsVFRXg8XjYuXMnPvjgA2RlZUWdHWS8zolCMDGMRiNycnJQWlqKkpKSsP/mzJnDbQMAU6dOhVarRX19PVd69Pl8XK3Ahx9+CK/XizVr1kCv13PVrgBw/fr1sPdtbm4GMFDtGk9sVSiJDZUEx4CtEqVB88lhNBrhdDpRXV097HYNDQ0QiURc1ZNWq4VAIMC6detw5MiREXvuCYVCbNq0CRaLBQKBgLu4xQOFYGL09PTAbreHDWIfTKFQwGAwoLm5GVVVVeDz+Vi/fj0++ugj7N69G2VlZTAYDPD5fGhubobJZEJVVRV0Oh08Hg+USiWWLVuGCxcu4OjRo1wnG5PJhKtXr0Kr1aK4uDiu50g1VaNDITgGbJUoOy6IJI7VasXx48eRlZU15NgtADh37hw6OjqwbNkySCSSsNlgJBJJzD332Mm0441CMDHYEt5wJfrCwkKcPXsWZrMZer0eGo0Gmzdvxvnz59HW1oarV69yVZsrV67EjBkzIuYv3bp1K06dOoW2tjZcuXIFEokEM2bMwMKFC+NaVUm1VKNHK8vfge7ublrHLIFcLhc++OADhEIhPPTQQ1AoFFG3a25uxmeffYYZM2Zg5cqVUCqVUCgUMJlM6Ovrw3vvvRfWcw8Y6Mxw+PBhbNy4Me6dFqIRCATIyspCZ2dnwt+bjJ7FYsHu3buhUCiwadOmIYOHbT+USqXc+ocul4sL0fHGrqRBN1SxozbBMWKrREli+Hw+fPzxx/D5fLj33nuHDMCbN2/i0KFDKCwsxPLlyyNmg4ml514yUElwYtHpdLj77rtht9uxf//+IW+G2fbD7u5uOBwOiMViZGdnc+2H4/03p2vS6FF16B2QSqVwOp3JPoxJLxAIYN++fbDZbLjvvvug1WqjbtfT04NPPvkEmZmZWLduHeRyecRsMMnuuTcU9n1pIoaJIzc3F1/96ldj2pbtzOV2u7n1D5VKJbf+YbTxh6PF4/EgkUjoZmqUqCQ4RjwejxasTIBQKITPPvsM3d3dWLduXdShEADQ19eHjz/+GCqVCvfccw/kcjk0Gg2sVmtYB6aMjAwAyeu5Rwjbftjb2wuTyYRQKASNRoPs7Gyo1eoxT7BNATg2VBK8A2wHGbfbnexDmbROnjyJtrY2FBYWwuv14tq1a2HPT58+HT6fD3v37oXP58OcOXPQ0dEBpVIJo9EIr9cLtVrNhWdZWRkaGhqS1nNvKFQSTE+BQAB2ux12u51rPzQYDGNqP5RIJFStPgYUgneAbRekEIwfs9kMYGAF8Pb29ojnp0+fDq/Xy1VLnz59Ouo2bAhKpVI88sgjOHPmDNrb23H58mVIpdKE9NwbCV3A0pvP54PP5+NurmUyGVQqFXw+H1wuFzwez7A3SDRLzNhQ79A7FAqFktaZgoTj8XjcGC6bzZbswxm1nJwcmEymIVezIOmHbT+Uy+UQCARDth+KRKKoU8SRkVFJ8A7x+XxIJJI7btQmd46dTHsiBiBwZyVBWu5pcrp9/CHb1g2Aqy4NBAI0YfYdoJLgHWIYBi6Xa8JeeCcLdjYYk8mU8PeOZbknAPjTn/405D7y8/Px5S9/GVarFT09Pbh69Spu3ryJ/v5+CIVCGAwGVFdXR9ztJ3K5J5I6JBIJZDIZN/6Qz+eDz+dTCI4BlQTvEI/Hg1wuh91upw4NSTJ4NphkiGW5JwBYvXp1xGtNJhMaGxuRn5/P3clfuXIFV69exdSpU1FRUQGfz4crV65g165duPfee8PmN03kck8kdXi9Xni9XvB4PCiVymEX/b1TPT09eOaZZ/Ctb30r6md4oqMQHCcymYybsJkkjlKphFQqRW9vb9JuQmJZ7glA1Gne2BliSktLuRAsLS1FdXV12MKoM2bMwDvvvIO6urqwEEzkck8k9TAMA4FAQFWhd4DGCY6ToWYwIfEzeDaYeE1DFYvs7OyIXqW3L/cUTTAYREtLC3Jzc6FUKrkLWWZmZsTK4FKpFDk5ORH7Y5d7MpvN6O7uRltbGzcWkkx+7ILBFIBjRyXBccDj8SASiSAUCqlnX4JIpdKI2WBSCTtDyHArT7S3t8Pn82HatGnca4a7mLnd7ohpsSoqKtDS0oKdO3cCGChRxmu5J5J62HUwydhRCI4ThmGgUCiog0wCiMXiqLPBpJJYlntqbm6GQCDgJvIeLgQ7OzvR3d2NefPmhT2eyOWeSOoZKQQtFgvefvttnD9/Hv39/dBqtaiqqsJXvvIVeDwe7Ny5E/X19ejp6QGfz8eMGTOwdevWESeN2LZtG2pra/Hb3/4W//Ef/4GLFy9CLpfjkUcewcaNG9He3o5XX30VRqMRKpUKW7duxfLly8fxzMcPheA4YaslqINMfAmFQuh0Otjtdng8nmQfTlSxLPfk8/nQ3t6OKVOmhC0OHC0E3W43Dh48CJVKhblz50Y8n6jlnkhqEYlEEdXmg1ksFvzoRz+Cy+XCunXrkJ+fD4vFgtraWni9XnR3d+P06dNYsmQJsrKyYLVaceDAATz33HP4zW9+w3XoGkooFMILL7yA8vJyPPXUUzh27Bj+/Oc/QyqV4s0338SKFSuwePFifPLJJ3jllVdQVlaWkm3VFILjiA1C6iATH3w+H3q9Hk6nM2V/xy6XCx9//DHEYnHEIr2DtbS0IBgMclWhQPTJu/1+P/bt2we/348HH3xw2IseSS8KhWLY2oM33ngDVqsVL7zwAkpLS7nHH3/8cTAMg8LCQrz00kthn9GVK1fie9/7Hj777DM8+uijw76/3+/HihUr8MgjjwAAli9fjq9//ev4v//3/+I73/kOli5dCgCYM2cOvvvd7+LQoUPYsmXLnZ72uKOOMeOMOsjEB1va8Xg86O/vT/bhRBXrck/AQHWpWCwOa7+7/YIWDAbxySefwGKx4O677x7xzpykD3YmmaECMBQK4fTp06iurg4LQBbbj4ENwFAohP7+fkilUuTl5aGlpSWm41i3bh33b4VCgby8PEgkEixZsoR7PC8vDwqFAj09PaM5xYShkuA4Yj9YYrE4ZduqJqpUnw0m1uWegIHSYmdnJ6ZPnx7Wq3RwCDIMg0OHDuHWrVtYt24dcnNz434OZOIY6WbbbrfD7XYP20kqFAphz5492L9/P3p6esJ6WCuVyhGPQSQSQa1Whz0ml8uh1+sjwlkul8PhcIy4z2SgEBxnbAcZCsHxwwZKX19fko8kusHLPd19991DLvfEam5uBsMwYVWhwMBnh70zr6mpwfXr17F8+XKu4wwhLIVCccfDIv7617/i7bffxpo1a/D4449DqVSCx+Phtddei6lfw1BV/UM9nqooBMcZOwO8QCAYcrVpErtkzwYTi1iWexrMaDRCLpcjLy8v7HG2JHjhwgVcunQJWVlZEAqFEfsrLi6mtsE0JpPJRgwatVoNmUwWdeUVVm1tLWbNmoVvfvObYY87nc64zkCTaigE40ShUMButyf7MCY0lUqV9NlgYhHLck8sq9UKk8mE2bNnR9zJsyHI7q+npydqO8oTTzxBIZjGBk+sMBQ+n4+FCxfi6NGjaG5ujmgXHFzrMNiJEydgsViQk5Mz7sedqigE44CdT7S/vz+lL96pTC6XQ6FQcCtvp7IHHngg5m01Gg3+/u//Pupz7IVt9erVk3KORnLnxGJxzDdAW7duRUNDA5577jmsW7cOBQUF6OvrQ21tLX7605+iuroa7777LrZv346ysjK0t7fj2LFjI1bnTzYUgnHC4/GgUChStjE4laX6bDDxQvM/kpHEUgpk6XQ6vPDCC3jrrbdw7NgxuN1u6HQ6VFVVQSKR4JFHHoHH48Hx48dRU1ODqVOn4oc//CHeeOONBJxJ6qCllOIoFAqhu7ubSoOjIBaLodPpYLVaU3YwfLxIpVIolcqUbv8kySMWi2EwGJJ9GJPOxOrGM8Gwy5yQ2EyE2WDijUqCZChqtZpuqOOAQjCO2BCcaF2Gk0EgEECv18PhcKTsbDDxRhc4MhSpVAqxWEw3SXFAV+cESKfuxmPB4/Gg0+ng8XjSug2V2gTJUKgUGD8UgnHG9hQVCqkPUjTsdGipPBtMolAIkmjY6wd9NuKDQjBBqDQYnUajAcMwKTsbTCJRCJJoVCoVlQLjiEIwAdjVJWiAczh2NhiLxZLsQ0kJFILkdgqFAnw+nz4XcUQhmCAMw0RMNpvOVCoVJBIJzGYz3eX+DwpBMhiPx6MapASghqoE4fF4kEgkkEgk8Hq9yT6cITU1NeHw4cPczwKBAAqFAgUFBZg3b17YStbt7e3Yt28f5HI5tm7dOuQF3OPxoL6+Hm1tbXA4HBAKhcjPz8fMmTORn58f9TUulwt1dXVob2+H1+uFTCZDXl4eVq1aNb4nnELYmwEej0c3BoSb0JpujOKLQjCB2NJgb29vsg9lRNXV1VCpVAgGg+jq6sLly5dx48YNPProo1wnH6PRCKVSCYfDgVu3bkUNNKvVij179sDtdqOsrAx5eXng8/k4f/489uzZg7lz52LRokVhr3E4HPjggw8AAOXl5VAoFHA6nRPi93YnKAQJi8/ncyFI4otCMIHY9QZlMhncbneyD2dYU6ZMQWZmJgBg5syZkEqluHDhAlpbWzFt2jT4/X60tbVh4cKFaGpqgtFojAjBUCiEAwcOwOv14sEHH0RBQQF0Oh36+vpQVFSEgwcPor6+HgaDASUlJdzrjh07Bj6fj4cffhhSqTSh551sVCVKAOpIl0jUJphgDMNMyA84u+wPu6p7a2srgsEgSkpKUFpaipaWloh5PltaWtDX14e5c+ciLy+Pmw3G6/WCz+djxYoVEIvFqKur415jtVpx48YNzJkzB1KpFIFAIOUn0B5PFIJEIBBALpfT5yBBqCSYYDwej2tnczqdyT6cmLHLQrElM6PRiNzcXMjlcpSWluLUqVNob28PK9G1tbUBGChJRpsNRiwWo6ioCNeuXYPdbodarUZHRweAgTXTPvroI9y6dQs8Hg/5+flYvnz5hLyBGA2qBiXUgS6xqCSYBDweD2q1GgKBINmHMiSfz8fN4NLc3IyzZ89CIBCgsLAQbrcbHR0d3BplSqUS2dnZMBqNYfuwWq1c0A01G4xerwfwt1Xj2QHzR48eBZ/Px9q1a7Fo0SJ0d3djz549abGqBJUA0pdMJoNMJqPPQAJRSTCJtFptyq4YsGfPnrCflUol1qxZA4VCgcbGRvB4PEydOpV7vrS0FLW1tfB6vZBIJAAAv98PiUQy7Gww7NhJv98f9n+5XI6NGzdyFwOFQoHPPvsMRqMRM2fOHN+TTSFUHZq++Hw+MjIy6DOQYBSCScLj8SAWi1O2WnTZsmXIyMjgBvprNBrui2k0GpGZmQmPx8Ot9qDX6xEKhXD9+nWUl5cDGKg6tdlsw84Gw4aeTCYDAK7naUlJSdiFYOrUqeDxeOju7qYQJJMS+32jv39iUQgmmVqthsfjQTAYTPahhMnMzOR6hw5ms9m4oQo7duyIeN5oNKK8vBwZGRnIzMxET08PHA7HkEtKsbPFsG197DhENhRZfD4fUqk0pcdYjgcKwfTEVoOSxKMQTAGpXC16O6PRCD6fj9WrV0dcrLu7u9HY2AiGYSCRSJCTk4OLFy+iqakJ8+fPj9iXz+dDW1sbDAYD1xmAXTT09tJxMBiEx+OZ9BcKCsH0Q9WgyUUhmGTs2MFUrRa9ndFoRE5ODtcpZrDs7Gw0Njbi+vXrEIlEKC4uhlarRX19fdi4Q2DgYn/s2DF4vV6sWLGCezwvLw8ymQxGoxFVVVVc9WhTUxMYhhlyhpnJgi6E6YeqQZOLQjAFsL1FU7FadLCenh7Y7XbMmjUr6vN6vR65ubk4f/48SktLwefzsX79enz00UfYvXs3ysrKYDAY4PP50NzcDJPJhKqqqrAONgKBAIsWLcLhw4fx4YcfYtq0aXA6nWhsbEROTg6Ki4sTdLbJQSGYXqgaNPkoBFNIqleLskMgCgsLI54Ti8XQaDSYMmUKTp06BbPZDL1eD41Gg82bN+P8+fNoa2vD1atXucHvK1euxIwZMyL2VVZWBoFAgPPnz+PUqVMQi8WYOXMmFi5cCD5/co/qoRBMH1QNmhp4DI3OTRkMw8But0+IatHBhEIhDAYD7HZ72GD4oVgsFuzevRsKhQKbNm2CWCxOwFFODBkZGQiFQtzMPGTy0ul0kEgkFIBJNrlvqyeYiTCI/nYCgSDqbDDD0el0uPvuu2G327F///6UrgJONCoVpAeZTAapVEp/6xRAJcEUwzAM/H5/SleLsng8HtfGN9RgeDI6arUaPB6Pfp+TGJ/PR1ZWFnWGSRFUEkwxg3uLpjIejwe9Xj/sbDBk9OiedPJjJ56gAEwNFIIpiK0WTeW2Mq1WC4Zhhp0NhoweVYdObkqlkqpBUwyFYArT6XQp2T6YkZEBgUDAzfZCxg+F4OQlkUgm/SooExGFYIpiq0t0Ol1KXRRVKhUkEgnMZjNV3cUBheDkJBQKodVqk30YJAoKwRTG4/EgFAqh0WiSfSgABub1VCgUsFgsabXQbSJRCE4+g29m6W+beigEUxyPx4NUKk16NYpUKoVarYbZbE6LNf2ShUJw8mGbNejvmpooBCcAHo8HlUrFreqeaOxsMH19fdzSRyQ+KAQnF7aDG/1NUxeF4ATBMAy0Wi03oXSiCIVC6HQ62O32Sb+MUSqgEJw85HI5lEol/T1THIXgBMF+kfR6fcLmzxzLbDDkzlAITg5isZibF5SkNgrBCYTH44HP50On0yXkvXQ6HTweDxwOR9zfjwygEJz4BAIB9x2lv2XqoxCcYNgZZTIyMuL6HjQbDCGjRz1BJx4KwQmIx+NBoVBALpfHZf80G0zyMAwz6ZeLmsw0Gg2EQiEF4ARC6wlOYBkZGQgGg+PaYYWdDWYiTOCdKpqamnD48GHuZ4FAAIVCgYKCAsybNy/sZqW9vR379u2DXC7H1q1bIy6WbBuSx+NBfX092tra4HA4uOWqKisrI9ZzvP39b7dmzRpMmzZtPE6VDEOlUtECuRMQheAEp9PpYDab4fP57nhf7GwwJpOJGvTHoLq6GiqVCsFgEF1dXbh8+TJu3LiBRx99lOvVazQaoVQq4XA4cOvWLeTn54ftg2EYmEwm7Ny5E263G2VlZcjMzITP54PRaMS+ffswd+5cLFq0iHtNTk4OVq9eHXE8jY2NMJvNyMvLi+t5k4E5QZM9lpeMDYXgBMbj8cAwDPR6/R0HITsbjMlkotlgxmjKlCnIzMwEAMycORNSqRQXLlxAa2srpk2bBr/fj7a2NixcuBBNTU0wGo0RIRgMBvH+++/D6/XiwQcfRFZWFvdcZWUlDh48iPr6ehgMBpSUlAAYGIumVqvD9hMIBHD8+HHk5eXFrdqcDFAoFBG/fzJxUOPDBMdWp+l0OohEojHtg2aDiQ+2BMauEt/a2opgMIiSkhKUlpaipaUl4vfd0tKCnp4ezJs3LywAgYF16FasWAGxWIy6urph37utrQ1+v5+qQeNMLpfHtZMaiT8KwUmA7Ymm1+tHPZieZoOJH7vdDgDcTD9GoxG5ubmQy+UoLS2F3+9He3t72Gva2toAADNmzIi6T7FYjKKiIlitVm7/0TQ3N0MgEKC4uHgczoREI5PJUmZeXzJ2FIKTBBuEBoMh5iBkZ4Ox2Ww0G8w48Pl83LjK5uZmnD17FgKBAIWFhXC73ejo6EBpaSmAgTak7OxsGI3GsH1YrVZIJJJhq9f0ej0ADNl71+Px4MaNGygqKkrpNSknMqlUCo1GQ23nkwC1CU4ibNWowWCAyWQatmpz8Gwwbrc7UYc4qe3ZsyfsZ6VSiTVr1kChUKCxsRE8Hg9Tp07lni8tLUVtbS28Xi8kEgkAwO/3jzjXJFvtPVTJvaWlBaFQiKpC42RwCZCGQkx8FIKTzOAgNJvNUS+U7KwzNBvM+Fq2bBkyMjLA4/G4CyX79zAajcjMzITH44HH4wEwUKILhUK4fv06ysvLAQwEnMPhGPbiyv5Nh+qObzQaIZFIMGXKlPE8PYLwNkAKwMmBQnASGjzP6O1ByM5oQbPBjL/MzEyud+hgNpsNvb29AIAdO3ZEPG80GrkQ1Gg0MJvNcDgcQ3Z0slgsABC1S77D4UBXVxdmzpxJg+7HmVwu56pAKQAnDwrBSWpwEFosFm74BM0Gk3hGoxF8Ph+rV6+OuHh2d3ejsbERDocDSqUSRUVFaG5uxpUrVzB79uyIffl8PrS1tcFgMERtN2TbGKkqdHwpFAoqAU5SFIKT2O0lQrlcTrPBJIHRaEROTg7XKWaw7OxsNDY2wmg0oqqqClOnToXBYEBdXR1ycnLCSpYMw+DYsWPwer1YsWJF1Pdqbm6GUqlETk5O3M4n3SiVShoHOIlRfckkNzgIJRIJzGYz9WhLoJ6eHtjtdhQVFUV9XqFQwGAwoLm5GcBAe+3DDz8MsViM3bt349ixY7hy5QoaGhrw/vvvo7m5mQvL21ksFlgsFpSWllJpZZxEm4iATC5UEkwD7MwyAoEASqVy2PFlZHyx1ZO3z/c5WGFhIc6ePQuz2Qy9Xg+dToennnoKNTU1aGtrw9WrV7lZfFauXDnkGEKqCh0/bNs5DTGZ/HgMFQvSCsMw8Hq96OvroxJhitJoNAgEAmE9dy0WC3bv3g2FQoFNmzbRxTmO2PGzAoGAStRpgKpD0wyPx4NEIkFmZiYEAkGyD4dEEa33oU6nw9133w273Y79+/cjGAwm6egmN4lEAoPBQAGYRqgkmKYYhuF6idJsMamFbYOiauvEGrwSBAVg+qCSYJpip1nT6XRQKBTJPhwyCI1DSzyNRgO1Wk0rwqch6hiTxtgve0ZGBkQiEaxWa3IPiACgEEwkdvaksa7AQiY+CkECYGAKLqFQCIvFQusJJhmFYGKIRCLodDrw+Xz6facxqg4lAAZKhSKRCJmZmXRXnGQUgvEnk8lgMBgoAAmFIPkbHo8HPp8Pg8Ew5OTMJDHowhw/arUaWq0WAP2eCVWHktuwA+u1Wi2kUilsNhtVjyYYddiOD6FQCK1Wy623SQFIACoJprSrV69ix44dcDqdCX1f9uIglUqRlZXFrYxOEoOqQ8efUqlEZmYmhEIh/W5JGArBFHb16lW8++67CQ9B1uBhFFqtlpbmSRAKwfEjFAqRmZkJlUpFwx9IVFQdSoY1uFQokUhgtVq5RWFJfFAIjg8a/E5ikRYzxuzYsQPvvvsufve73+Hdd99FXV0dhEIhNmzYgMcffxxmsxl//vOfcfHiRYjFYmzatAkPPvgg93qbzYY33ngDZ8+ehcvlQl5eHu6//36sXr2a26anpwfPPPMMnnrqKcjlcuzatQtmsxlFRUX42te+FjGpcWNjI3bs2IGWlhYIBAJUVFRg69atKCgoCDvm273yyivIyspCMBjEX//6Vxw+fBhmsxlarRbLli3DY489Fta78+mnn8aUKVPw8MMP47XXXkN7ezu0Wi0ee+wxrFq1Kmzf3d3deP3113HhwgX4/X4UFRVh8+bNmD9/PoC/XZyPHz8OrVYLjUbDvfbatWvYtm0bnn76aUyfPh0A0Nvbi927d6OlpQVutxsKhQIlJSXYsmULdbwZBtt1v7u7O9mHMiENbvuj8CMjSauS4O9+9zvk5+fjySefxNmzZ7Fz504olUocOHAAlZWVePLJJ3H06FH893//N0pLS1FRUQGfz4fnnnsOXV1d2LhxI7KyslBbW4vt27fD5XLhvvvuC3uP48ePw+12Y/369eDxeNi1axd+/etf4+WXX+Ya5BsaGvCLX/wCWVlZeOyxx+Dz+bB3717867/+K375y18iKysLixcvRmdnJ44fP44vfelL3B0tO6XW73//exw+fBh33XUXHnjgAVy7dg3vv/8+Ojo68E//9E9hx9TV1YVf//rXWLt2LVatWoWDBw9i+/btKCkpwZQpUwAAVqsVzz77LHw+H+69914olUocPnwYv/zlL/H9738fixYtAo/Hw6VLlzBnzhzIZDLY7fYhS4WBQAC///3vEQgEsGLFCqjValitVly6dAlut5tCcBhUEhw7Kv2R0UqrEJw2bRr+4R/+AQCwfv16PP300/jv//5vfP7zn8fDDz8MAFi2bBm+/vWv4+DBg6ioqMCBAwfQ0dGBf/zHf+QWMt2wYQOee+45vPXWW1izZk3YBd1kMuGll16CUqkEAOTl5eHFF19EfX09qqurAQB/+ctfoFQq8fOf/5zbbuHChfj//r//Dzt27MAzzzyDoqIiTJ06FcePH8fChQuRlZXFvUdraysOHz6MtWvX4hvf+AYA4J577kFGRgZ2796NxsZGVFZWctvfunULzz//PMrLywEAS5cuxTe/+U0cPHgQX/ziFwEA77//Pmw2G376059i5syZ3O/oBz/4AV577TUsWLAAfD4fPT09+O1vf4uXX34ZOp0OLpcLNpst4nfd1dUFs9mML3/5y6iqquIe37hx4xj/eumDQnD0hEIhNBoNRCIR/e7IqKRVT4e1a9dy/+bz+SgpKQHDMGGPKxQK5OXloaenBwBw7tw5aDQaLFu2jNtGKBTi3nvvhcfjwaVLl8LeY8mSJVywAeACha3a6uvrQ2trK1atWhW2XVFREebMmYNz586NeB7sNg888EDY42wV7tmzZ8MeLygo4AIQGChNDj5Hdp/Tpk3jjhcYaAdcv349ent7cfPmTe5xm83GTe4sk8mQlZUFvV4f9p7sjcGVK1fg8/lGPCfyNxSCo8P2/KQAJGORViVBg8EQ9rNcLodIJIpYOVoul6O/vx/AQLtWbm5uRM/I/Px87vnh3oMNOraHJ7t9Xl5exPHl5+ejvr4eHo9n2GEJvb294PF4yMnJCXtco9FAoVDAZDINe0zAQNgP7nVqMpm4trzbj4l9PtrCsOwA+8rKSvzwhz/kxhTq9XqsXr0ahw4dQl1dHUpKSlBZWYkFCxZQVegI2GZ6dswmiU4ikUCtVlPbH7kjaRWC0br4j3e3/6H2F4+LWaxf/HgfE4/HQ1tbG3JycpCbmwu3243+/n48/PDDWLRoERobG3HlyhXs3LkTBw4cwPe+972wTjUkOgrB6MRiMdRqNcRiMZWayR1Lq+rQscjMzERnZ2fErCm3bt3inh/t/ga//vZ9qlQqrhQ41Jc7MzMTDMOgs7Mz7HGr1Qqn0xm15DcSg8EQ9Zg6Ojq454G/lWxdLlfYds3Nzfj+97+Pzs5OropUrVajoKAAd999N7797W/j29/+Nmw2G44fPz7q40snFHzRsSu+GwwGrgc0BSC5UxSCI5g3bx6sVitqamq4x4LBIPbu3QupVIqKiopR7U+r1aK4uBiHDx8Oq45sb29HfX095s2bxz0mkUgARAYOu82ePXvCHv/www8BgBvSMBrz5s2D0WhEU1MT95jH48Gnn36KzMxMbuhGdnY2AIS1hYZCIXz66acIBoPo6+sDj8eD3++HQqFAVlYWN1A5NzcXPB4PgUBg1MeXbqiE8zcCgQAajQaZmZncd4J+N2S8pFV16FisX78en3zyCbZv347r169zQySuXr2KL3/5y2Nq33rqqafwi1/8As8++yzWrFkDn8+Hjz/+GHK5HFu2bOG2KykpAQC8+eabWLZsGQQCAaqrq1FcXIxVq1bhwIEDcDqdqKiogNFoxOHDh7Fw4cKwnqGxevjhh3H8+HG88MILYUMkenp68P3vf5+rUp0yZQqmT5+ON998Ew6HA0qlEjU1NQgGg2H7O3/+PN5++2185StfQXl5OUQiEU6ePAmxWIy5c+eO+vjSDYXgQDW+UqnkFn1O998HiQ8KwRGIxWI899xzeP3113H48GG43W7k5eXhW9/6Vthg+dGYM2cO/uVf/gU7duzAjh07uMHyTz75ZNhQiGnTpuHxxx/HJ598gvPnz4NhGLzyyiuQSqX4xje+gezsbBw6dAinTp2CRqPBww8/jMcee2xMx6TRaPCzn/0Mr7/+Oj7++GP4fD4UFRXhn//5nyNKlt/+9rfxxz/+Ebt27YJcLsfatWsxa9Ys/OxnP+O2KS4uxrRp0/CHP/wBALBlyxZs2rQJGzduhNvthtvtHtNxpot0DkEejweFQgGlUklTnZG4S4sZY0jqYC/ufr8fdrsdXq832YeUkrKysmC1WtNueIlCoaB5PklCUUmQJBR7YRMKhdDr9fD5fHA6nVQyvE06lQR5PB7kcjmUSiVX7Z4u506Sj0KQJAV7kROJRNBqtVCr1XA6nXC5XLR+IdIjBIVCIRQKBeRyOffYZD9nknooBElSsRc9Pp8PlUoFlUoFl8sFp9OZ1r1IJ3MISiQSKBQKSKXSSX2eZGKgECQpYfCFUC6XQ6FQwOv1wuVypWVV6WQLBz6fD5lMBoVCAaFQGDYrDiHJRCFIUg57YRSLxZBIJMjIyIDL5YLL5Uqb0uFkCUGJRAK5XB4xDeBkODcyOVAIkpQ1uKqU7TLv8/m40uFk79g8UYOCz+dzpXmBQDBpAp1MTjREgkwogz+uXq8XHo8HHo9n0nWm0Wg0CAaD3ETuqU4oFEIqlUIqlXJzegITN8hJ+qCSIJlQBl9UJRIJJBIJNBoN/H4/F4h+vz+JRzg+JsK9Kfv7l8lkXImPReFHJgoqCZJJYXDJIxgMcoE4UQfjs8t7ses2pgIej8eV9iQSCfh8PlV1kgmPSoJkUhh8IRYIBFybFMMwYYE4UapNGYYZ92W+xkIgEIRVc7LLO7G/bwpAMtFRCJJJafBFmr2IA4Df74fP54Pf74ff70/Z3qbJKmGJRCLuP4lEEnU4AwUfmUwoBMmkN/iizV7g2ccYhknJYExECA4OPLFYzK3QTqFH0gmFIEkrt1/QeTxeSgbjeIfg4LATiURDBt7t/yZksqMQJGkv1mAMBAIIBAIIhUIIBoNR/z9eRhOCAoEAfD4/6v+FQiEEAgEFHiFDoBAkJIqhglEoFA65HcMwCIVCXCjeHpCDO2Kz/769c/bgVTb4fD7Xlhkt4Nh/DzbU/qKdEyGEhkgQEhfDhdGd7o/CjJDxQyFICCEkbSV/IBIhhBCSJBSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0hYtqktImvN4PPiv//ov1NXVwWaz4b777sOXv/zlmF+/bds2XLp0Cdu2bYvfQRISJxSChKSBs2fPwmg0YsuWLRHP7dy5E4cOHcLmzZuRnZ2NgoKCJBwhIclBIUhIGjh37hz27dsXNQQvXryI6dOn47HHHkvCkRGSXNQmSEias9lsUCgUyT4MQpKCSoIk7QzVhrVjxw68++672LFjBwBgy5YtuOeeezB79my8/fbb6OzsRE5ODr74xS+iqqoq7LUWiwVvvfUWzp07B6fTiZycHDzwwANYu3YtAMBqteIb3/gGNm/eHFHiunXrFr773e/iq1/9KjZu3AgAcDqdeOedd3Dy5EnYbDbo9XqsW7cOmzZtAp8/cO/a09ODZ555Bk899RTkcjl27doFs9mMoqIifO1rX8O0adO48z18+DB3Tqyf/OQneP7557l9sc+98soruHTpErZv345XXnkFWVlZ3GsuXryI559/Hj/5yU8wa9assf8RCEkRFIKEDOPKlSs4deoU7r77bshkMuzduxe//vWvsX37dqhUKgADAffjH/8YAHDPPfdArVbj/Pnz+P3vfw+32437778fGo0GFRUVOHHiREQI1tTUgM/n46677gIAeL1ePPfcc7BYLFi/fj0MBgOuXr2KN998E1arNaLTyvHjx+F2u7F+/XrweDzs2rULv/71r/Hyyy9DKBRiw4YN6OvrQ0NDA5555hnudfn5+XjmmWfw2muvQa/X44EHHgAAqNXqeP06CUk5FIKEDKOjowO/+c1vkJOTAwCYNWsW/umf/gnHjx/nSm1vvfUWQqEQfvWrX3HBePfdd+N3v/sd3nnnHWzYsAFisRhLly7FH//4R7S3t6OwsJB7j5qaGlRUVECj0QAAPvzwQ3R1deHFF19Ebm4uAGDDhg3Q6XT44IMP8MADD8BgMHCvN5lMeOmll6BUKgEAeXl5ePHFF1FfX4/q6mqUlZUhNzcXDQ0NWLlyZdj5rVy5Em+//TZ0Ol3Ec4SkA2oTJGQYs2fP5gIQAIqKiiCTydDd3Q0AYBgGJ0+eRHV1NRiGgd1u5/6rqqqCy+XC9evXAQCLFi2CQCBATU0Nt7/29nbcvHkTS5cu5R6rra1FeXk5FApF2P5mz56NUCiEy5cvhx3jkiVLuAAEgJkzZwIAd4yEkKFRSZCQYQwucbGUSiWcTicAwG63w+l04sCBAzhw4EDUfdjtdgAD1YyVlZU4ceIEnnjiCQADpUCBQIBFixZx23d2dqKtrQ1/93d/F3V/Nptt2GNkA5E9RkLI0CgESdrh8XhRHw+FQhGPsZ1QbscwTNj/V6xYgVWrVkXdtqioiPv3smXLsH37drS2tqK4uBgnTpxAZWVlWDscwzCYM2cONm3aFHV/eXl5ozrG8RTtd0TIREYhSNKOQqGIWkoymUyj3pdarYZMJkMoFMKcOXNG3H7hwoUQCoVclWhnZyceeeSRsG2ys7Ph8Xhi2l+shgr+obClSZfLFfZ4b2/vuB0TIamA2gRJ2snOzobL5UJbWxv3WF9fH06dOjXqffH5fCxevBgnT55Ee3t7xPNsVShLoVBg7ty5OHHiBI4fPw6hUIiFCxeGbbNkyRI0NTXh/PnzEftzOp0IBoOjPk6JRMK9PhbZ2dkAgEuXLnGPhUIhfPrpp6N+b0JSGZUESdpZtmwZXn/9dfzqV7/CvffeC6/Xi/379yM3NxctLS2j3t/WrVtx8eJF/PjHP8a6detQUFAAh8OB69ev48KFC3j11VfDtl+6dClefvll7N+/H3Pnzo0YqL5p0yacOXMGv/zlL7Fq1SqUlJTA6/Wivb0dtbW12LZt26iHMZSUlAAAXn31VcydOxd8Ph/Lli0bcvspU6Zg+vTpePPNN+FwOKBUKlFTUzOmACYklVEIkrSjUqnwT//0T3jttdfwl7/8BVlZWdi6dSs6OzvHFIIajQYvvPAC3n33XZw8eRL79u2DSqXClClT8OSTT0Zsv2DBAojFYrjd7rBeoSyJRILnn38eO3fuRG1tLY4cOQKZTIa8vDxs2bIFcrl81Me4ePFibNy4ETU1NTh69CgYhhk2BAHg29/+Nv74xz9i165dkMvlWLt2LWbNmoWf/exno35/QlIVj4lH6zkhhBAyAVCbICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0haFICGEkLRFIUgIISRtUQgSQghJWxSChBBC0tb/D9nZGr1Ineh8AAAAAElFTkSuQmCC" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "satp_eng.demo_plot()" ], @@ -820,33 +500,12 @@ "start_time": "2023-11-25T18:35:47.955539Z" } }, - "id": "da11116471121fef" + "id": "da11116471121fef", + "outputs": [] }, { "cell_type": "code", "execution_count": 28, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "====================================\n", - "Measure: loud\n", - "Group: None\n", - "Scales: ['PAQ1', 'PAQ2', 'PAQ3', 'PAQ4', 'PAQ5', 'PAQ6', 'PAQ7', 'PAQ8']\n", - "Scale Angles: (0, 46, 93, 138, 178, 228, 272, 340)\n", - "\n", - "Profile [All]:\n", - " Estimate\n", - "Elevation: 0.002\n", - "X-Value: -0.58\n", - "Y-Value: 0.342\n", - "Amplitude: 0.674\n", - "Displacement: 149.477\n", - "R2: 0.983\n" - ] - } - ], "source": [ "satp_eng_res = satp_eng.ssm_analyse(measures=['loud'])\n", "print(satp_eng_res)" @@ -858,29 +517,12 @@ "start_time": "2023-11-25T18:35:58.891366Z" } }, - "id": "4c7f315bfc5df6d4" + "id": "4c7f315bfc5df6d4", + "outputs": [] }, { "cell_type": "code", "execution_count": 6, - "outputs": [ - { - "data": { - "text/plain": "(
, )" - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "satp_eng_res.plot()" ], @@ -891,21 +533,12 @@ "start_time": "2023-11-16T15:56:02.124062Z" } }, - "id": "6431fbd8bb17bac" + "id": "6431fbd8bb17bac", + "outputs": [] }, { "cell_type": "code", "execution_count": 10, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "satp_eng_res.results[0].profile_plot();" ], @@ -916,12 +549,12 @@ "start_time": "2023-11-16T15:56:26.539583Z" } }, - "id": "bb2fc8e49a953a75" + "id": "bb2fc8e49a953a75", + "outputs": [] }, { "cell_type": "code", "execution_count": 10, - "outputs": [], "source": [], "metadata": { "collapsed": false, @@ -930,17 +563,18 @@ "start_time": "2023-11-16T15:56:27.020638Z" } }, - "id": "8a4a01ca2ed0058c" + "id": "8a4a01ca2ed0058c", + "outputs": [] }, { "cell_type": "code", "execution_count": null, - "outputs": [], "source": [], "metadata": { "collapsed": false }, - "id": "2a99ea4bcc555038" + "id": "2a99ea4bcc555038", + "outputs": [] } ], "metadata": { diff --git a/src/circumplex/core/instrument.py b/src/circumplex/core/instrument.py new file mode 100644 index 0000000..014a982 --- /dev/null +++ b/src/circumplex/core/instrument.py @@ -0,0 +1,97 @@ +import pandas as pd +from typing import List, Dict, Any + + +class Instrument: + def __init__(self, scales: pd.DataFrame, anchors: pd.DataFrame, items: pd.DataFrame, + norms: Dict[str, Any], details: Dict[str, Any] + ): + self.scales = scales + self.anchors = anchors + self.items = items + self.norms = norms + self.details = details + + def __str__(self): + return (f"{self.details['Abbrev']}: {self.details['Name']}\n" + f"{self.details['Items']} items, {self.details['Scales']} scales, " + f"{len(self.norms[1])} normative data sets\n" + f"{self.details['Reference']}\n" + f"<{self.details['URL']}>") + + def summary(self, scales=True, anchors=True, items=True, norms=True): + output = [str(self)] + if scales: + output.append("\n" + self.get_scales()) + if anchors: + output.append("\n" + self.get_anchors()) + if items: + output.append("\n" + self.get_items()) + if norms: + output.append("\n" + self.get_norms()) + return "\n".join(output) + + def get_scales(self, items=False): + output = [f"The {self.details['Abbrev']} contains {self.details['Scales']} circumplex scales."] + for _, scale in self.scales.iterrows(): + output.append(f"{scale['Abbrev']}: {scale['Label']} ({scale['Angle']} degrees)") + if items: + item_nums = [int(i) for i in scale['Items'].split(',')] + for num in item_nums: + item = self.items.loc[self.items['Number'] == num, 'Text'].iloc[0] + output.append(f" {num}. {item}") + return "\n".join(output) + + def get_items(self): + output = [f"The {self.details['Abbrev']} contains {self.details['Items']} items ({self.details['Status']}):"] + for _, item in self.items.iterrows(): + if not pd.isna(item['Number']): + output.append(f"{item['Number']}. {item['Text']}") + else: + output.append(item['Text']) + return "\n".join(output) + + def get_anchors(self): + output = [f"The {self.details['Abbrev']} is rated using the following {len(self.anchors)}-point scale."] + for _, anchor in self.anchors.iterrows(): + output.append(f"{anchor['Value']}. {anchor['Label']}") + return "\n".join(output) + + def get_norms(self): + samples = self.norms[1] + n_norms = len(samples) + if n_norms == 0: + return f"The {self.details['Abbrev']} currently has no normative data sets." + + output = [f"The {self.details['Abbrev']} currently has {n_norms} normative data set(s):"] + for i, sample in samples.iterrows(): + output.extend([ + f"{sample['Sample']}. {sample['Size']} {sample['Population']}", + sample['Reference'], + f"<{sample['URL']}>" + ] + ) + return "\n".join(output) + + +def instruments(): + return """The circumplex package currently includes 13 instruments: +1. CSIE: Circumplex Scales of Interpersonal Efficacy (csie) +2. CSIG: Circumplex Scales of Intergroup Goals (csig) +3. CSIP: Circumplex Scales of Interpersonal Problems (csip) +4. CSIV: Circumplex Scales of Interpersonal Values (csiv) +5. IGI-CR: Interpersonal Goals Inventory for Children, Revised Version (igicr) +6. IIP-32: Inventory of Interpersonal Problems, Brief Version (iip32) +7. IIP-64: Inventory of Interpersonal Problems (iip64) +8. IIP-SC: Inventory of Interpersonal Problems, Short Circumplex (iipsc) +9. IIS-32: Inventory of Interpersonal Strengths, Brief Version (iis32) +10. IIS-64: Inventory of Interpersonal Strengths (iis64) +11. IIT-C: Inventory of Influence Tactics Circumplex (iitc) +12. IPIP-IPC: IPIP Interpersonal Circumplex (ipipipc) +13. ISC: Interpersonal Sensitivities Circumplex (isc)""" + + +def instrument(code: str): + # This function would load the instrument data from a file or database + # For now, we'll just return a placeholder + return f"Instrument data for {code}" \ No newline at end of file diff --git a/src/circumplex/core/plot.py b/src/circumplex/core/plot.py new file mode 100644 index 0000000..d94fde4 --- /dev/null +++ b/src/circumplex/core/plot.py @@ -0,0 +1,248 @@ +import matplotlib.pyplot as plt +import seaborn as sns +import numpy as np +import pandas as pd +from typing import Optional, List +from circumplex.core.ssm_results import SSMResults +import matplotlib.patches as patches + + +def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): + """ + Create a figure from SSM results. + + Args: + ssm_object (SSMResults): The results output of ssm_analyze. + fontsize (int): Font size of text in the figure, in points (default = 12). + **kwargs: Additional arguments to pass on to the plotting function. + + Returns: + matplotlib.figure.Figure: A figure object representing the plot. + """ + assert isinstance(ssm_object, SSMResults), "ssm_object must be an SSMResults instance" + assert fontsize > 0, "fontsize must be a positive number" + + sns.set(style="whitegrid", font_scale=fontsize / 12) + + if ssm_object.details['contrast'] == "test": + return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) + else: + return ssm_plot_circle(ssm_object, fontsize=fontsize, **kwargs) + + +def ssm_plot_circle(ssm_object: SSMResults, + amax: Optional[float] = None, + legend_font_size: int = 12, + scale_font_size: int = 12, + lowfit: bool = True, + repel: bool = False, + angle_labels: Optional[List[str]] = None, + palette: Optional[str] = "husl", + **kwargs + ): + """ + Create a Circular Plot of SSM Results using Seaborn. + + Args: + ssm_object (SSMResults): The output of ssm_analyze. + amax (Optional[float]): A positive number corresponding to the radius of the circle. + legend_font_size (int): Size of the text labels in the legend. + scale_font_size (int): Size of the text labels for the amplitude and displacement scales. + lowfit (bool): Whether profiles with low model fit (<.70) should be plotted with dashed borders. + repel (bool): Experimental argument for plotting text labels instead of colors. + angle_labels (Optional[List[str]]): Text labels to plot around the circle for each scale. + palette (Optional[str]): Color palette to use for the plot. + **kwargs: Additional arguments for seaborn. + + Returns: + matplotlib.figure.Figure: A figure object containing the circular plot. + """ + df = ssm_object.results + angles = np.round(ssm_object.details['angles']).astype(int) + + if amax is None: + amax = np.ceil(df['a_uci'].max() * 10) / 10 + + # Convert results to numbers usable by seaborn + df_plot = df.copy() + df_plot['d_uci'] = np.where(df_plot['d_uci'] < df_plot['d_lci'], + df_plot['d_uci'] + 360, + df_plot['d_uci'] + ) + df_plot['a_lci'] = df_plot['a_lci'] * 5 / amax + df_plot['a_uci'] = df_plot['a_uci'] * 5 / amax + df_plot['x_est'] = df_plot['x_est'] * 5 / amax + df_plot['y_est'] = df_plot['y_est'] * 5 / amax + + # Remove profiles with low model fit (unless overridden) + if not lowfit: + df_plot = df_plot[df_plot['fit_est'] >= 0.70] + if len(df_plot) < 1: + raise ValueError("After removing profiles, there were none left to plot.") + + df_plot['linestyle'] = np.where(df_plot['fit_est'] >= 0.70, 'solid', 'dashed') + + fig, ax = plt.subplots(figsize=(10, 10)) + circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) + + # Use seaborn color palette + colors = sns.color_palette(palette, n_colors=len(df_plot)) + + # Plot confidence regions + for i, (_, row) in enumerate(df_plot.iterrows()): + wedge = patches.Wedge((0, 0), row['a_uci'], row['d_lci'], row['d_uci'], + width=row['a_uci'] - row['a_lci'], + fc=colors[i], + alpha=0.3, + linestyle=row['linestyle'] + ) + ax.add_patch(wedge) + + # Plot points + sns.scatterplot(data=df_plot, x='x_est', y='y_est', hue='label', + palette=palette, s=100, ax=ax, legend='brief' + ) + + if repel: + for _, row in df_plot.iterrows(): + ax.annotate(row['label'], (row['x_est'], row['y_est']), + xytext=(-25 - row['x_est'], 0), + textcoords='offset points', + ha='right', va='center', + fontsize=legend_font_size, + bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.8), + arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0') + ) + ax.legend().remove() + else: + ax.legend(title=ssm_object.details['results_type'], + fontsize=legend_font_size, + title_fontsize=legend_font_size + ) + + return fig + +def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): + """ + Create an Empty Circular Plot. + + Args: + ax (matplotlib.axes.Axes): The axes to draw on. + angles (List[float]): Angular displacement of each circumplex scale. + amax (float): Maximum amplitude. + amin (float): Minimum amplitude. + fontsize (int): Font size for labels. + labels (Optional[List[str]]): Labels for the angles. + + Returns: + None + """ + if labels is None: + labels = [f"{angle}°" for angle in angles] + + # Draw circles + for r in range(1, 6): + ax.add_artist(plt.Circle((0, 0), r, fill=False, color='gray')) + + # Draw lines + for angle in np.deg2rad(angles): + ax.plot([0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color='gray', linewidth=0.5) + + # Add labels + for angle, label in zip(np.deg2rad(angles), labels): + ax.text(5.1 * np.cos(angle), 5.1 * np.sin(angle), label, + ha='center', va='center', fontsize=fontsize + ) + + # Add amplitude labels + ax.text(2, 0, f"{amin + (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) + ax.text(4, 0, f"{amin + 2 * (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) + + ax.set_xlim(-5.5, 5.5) + ax.set_ylim(-5.5, 5.5) + ax.set_aspect('equal') + ax.axis('off') + + +def ssm_plot_contrast(ssm_object: SSMResults, + axislabel: str = "Difference", + xy: bool = True, + color: str = "red", + linesize: float = 1.25, + fontsize: int = 12 + ): + """ + Create a Difference Plot of SSM Contrast Results using Seaborn. + + Args: + ssm_object (SSMResults): The results output of ssm_analyze. + axislabel (str): Label for the y-axis. + xy (bool): Whether to include X-Value and Y-Value parameters in the plot. + color (str): Color of the point range. + linesize (float): Size of the point range elements in points. + fontsize (int): Size of the axis labels, numbers, and facet headings in points. + + Returns: + matplotlib.figure.Figure: A figure object containing the difference plot. + """ + plabs = { + 'e': r'$\Delta$ Elevation', + 'x': r'$\Delta$ X-Value', + 'y': r'$\Delta$ Y-Value', + 'a': r'$\Delta$ Amplitude', + 'd': r'$\Delta$ Displacement' + } + + pvals = ['e', 'x', 'y', 'a', 'd'] + + res = ssm_object.results + + if not xy: + res = res.drop(columns=['x_est', 'x_lci', 'x_uci', 'y_est', 'y_lci', 'y_uci']) + plabs = {k: v for k, v in plabs.items() if k not in ['x', 'y']} + pvals = [p for p in pvals if p not in ['x', 'y']] + + res['d_est'] = res['d_est'].astype(float) + res['d_uci'] = np.where((res['d_uci'] < res['d_lci']) & (res['d_uci'] < 180), + (res['d_uci'] + 360) % 360, res['d_uci'] + ) + res['d_lci'] = np.where((res['d_lci'] > res['d_uci']) & (res['d_lci'] > 180), + (res['d_lci'] - 360) % 360, res['d_lci'] + ) + + # Reshape data for seaborn + plot_data = [] + for param in pvals: + for _, row in res.iterrows(): + plot_data.append({ + 'Parameter': plabs[param], + 'Estimate' : row[f'{param}_est'], + 'Lower CI' : row[f'{param}_lci'], + 'Upper CI' : row[f'{param}_uci'], + 'Label' : row['label'] + } + ) + plot_df = pd.DataFrame(plot_data) + + # Create plot + fig, ax = plt.subplots(figsize=(12, 6)) + sns.pointplot(data=plot_df, x='Parameter', y='Estimate', hue='Label', + join=False, ci=None, palette=color, scale=0.75, ax=ax + ) + + # Add error bars + ax.errorbar(x=plot_df['Parameter'], y=plot_df['Estimate'], + yerr=[plot_df['Estimate'] - plot_df['Lower CI'], + plot_df['Upper CI'] - plot_df['Estimate']], + fmt='none', ecolor=color, elinewidth=linesize, capsize=5 + ) + + # Customize plot + ax.axhline(y=0, color='gray', linestyle='--', linewidth=linesize) + ax.set_ylabel(axislabel, fontsize=fontsize) + ax.set_xlabel('') + ax.tick_params(axis='both', which='major', labelsize=fontsize - 2) + ax.legend(title=ssm_object.details['results_type'], fontsize=fontsize - 2, title_fontsize=fontsize) + + plt.tight_layout() + return fig diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index 9433a79..05bc7f7 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -5,6 +5,7 @@ from scipy import stats from scipy.optimize import curve_fit from typing import Optional, List, Union, Callable +from circumplex.core.ssm_results import SSMResults BOUNDS = ([0, 0, -np.inf], [np.inf, 2*np.pi, np.inf]) @@ -22,7 +23,7 @@ def ssm_analyze( interval: float = 0.95, listwise: bool = True, measures_labels: Optional[List[str]] = None, -) -> dict: +) -> SSMResults: """ Perform analyses using the Structural Summary Method. @@ -44,7 +45,7 @@ def ssm_analyze( measures_labels (Optional[List[str]]): Labels for each measure provided in measures. Returns: - dict: A dictionary containing the results and description of the analysis. + SSMResults: An object containing the results and description of the analysis. """ assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" @@ -126,7 +127,19 @@ def ssm_analyze( data, scales, angles_rad, None, "none", boots, interval, listwise ) - return results + # Calculate scores + if measures is not None: + scores = corr_scores(data[scales], data[measures], data[grouping] if grouping else None, listwise) + else: + scores = data[scales].groupby(data[grouping] if grouping else pd.Series(['All'] * len(data))).mean() + + # Create the call string + call_str = f"ssm_analyze(data, scales={scales}, angles={angles}, measures={measures}, " \ + f"grouping={grouping}, contrast={contrast}, boots={boots}, " \ + f"interval={interval}, listwise={listwise}, measures_labels={measures_labels})" + + # Create and return the SSMResults object + return SSMResults(results=results['results'], scores=scores, details=results['details'], call=call_str) def ssm_analyze_means( @@ -174,13 +187,13 @@ def ssm_analyze_means( bs_input = bs_input.dropna() # Calculate mean observed scores - scores = bs_input.groupby("Group")[scales].mean().reset_index() + scores = bs_input.groupby("Group", observed=False)[scales].mean().reset_index() scores = scores.rename_axis("label").reset_index() # Define bootstrap function def bs_function(data, index, angles, contrast, listwise): resample = data.iloc[index] - scores_r = resample.groupby("Group")[scales].mean() + scores_r = resample.groupby("Group", observed=False)[scales].mean() return ssm_by_group(scores_r, angles, contrast) # Perform bootstrapping @@ -218,11 +231,11 @@ def bs_function(data, index, angles, contrast, listwise): "results_type": "Profile" if contrast == "none" else "Contrast", } - # Create output dictionary - out = {"results": results, "scores": scores, "details": details} - - return out + call_str = f"ssm_analyze_means(data, scales={scales}, angles={angles}, " \ + f"grouping={grouping}, contrast={contrast}, boots={boots}, " \ + f"interval={interval}, listwise={listwise})" + return {"results": results, "details": details, "call": call_str} def ssm_by_group( scores: pd.DataFrame, angles: List[float], contrast: str @@ -568,15 +581,12 @@ def bs_function(data, index, angles, contrast, listwise): 'results_type': "Profile" if contrast == "none" else "Contrast" } - # Create output dictionary - out = { - 'results': results, - 'scores': scores_df, - 'details': details - } - - return out + call_str = f"ssm_analyze_corrs(data, scales={scales}, angles={angles}, " \ + f"measures={measures}, grouping={grouping}, contrast={contrast}, " \ + f"boots={boots}, interval={interval}, listwise={listwise}, " \ + f"measures_labels={measures_labels})" + return {"results": results, "details": details, "call": call_str} def corr_scores(scores: Union[np.ndarray, pd.DataFrame], measures: Union[np.ndarray, pd.DataFrame], @@ -680,6 +690,9 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: if __name__ == "__main__": ######## SCRATCH ######## from importlib.resources import files + from ssm_plot import ssm_plot + import matplotlib.pyplot as plt + from plot import ssm_plot as sm_plot _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) data = pd.read_csv(_jz2017_path) @@ -689,7 +702,17 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], grouping = 'Gender', - measures = ['NARPD', 'ASPD'], + # contrast='model' + # measures = ['NARPD', 'ASPD'], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) - print(results['results']) + print(results) + print(results.summary()) + fig = ssm_plot(results) + plt.show() + + fig = sm_plot(results) + plt.show() + + + diff --git a/src/circumplex/core/ssm_plot.py b/src/circumplex/core/ssm_plot.py new file mode 100644 index 0000000..e608191 --- /dev/null +++ b/src/circumplex/core/ssm_plot.py @@ -0,0 +1,218 @@ +import matplotlib.pyplot as plt +import matplotlib.patches as patches +import numpy as np +from typing import Optional, List +from circumplex.core.ssm_results import SSMResults + +def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): + """ + Create a figure from SSM results. + + Args: + ssm_object (SSMResults): The results output of ssm_analyze. + fontsize (int): Font size of text in the figure, in points (default = 12). + **kwargs: Additional arguments to pass on to the plotting function. + + Returns: + matplotlib.figure.Figure: A figure object representing the plot. + """ + assert isinstance(ssm_object, SSMResults), "ssm_object must be an SSMResults instance" + assert fontsize > 0, "fontsize must be a positive number" + + if ssm_object.details['contrast'] == "test": + return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) + else: + return ssm_plot_circle(ssm_object, fontsize=fontsize, **kwargs) + + +def ssm_plot_circle(ssm_object: SSMResults, + amax: Optional[float] = None, + legend_font_size: int = 12, + scale_font_size: int = 12, + lowfit: bool = True, + repel: bool = False, + angle_labels: Optional[List[str]] = None, + palette: Optional[str] = "Set2", + **kwargs + ): + """ + Create a Circular Plot of SSM Results. + + Args: + ssm_object (SSMResults): The output of ssm_analyze. + amax (Optional[float]): A positive number corresponding to the radius of the circle. + legend_font_size (int): Size of the text labels in the legend. + scale_font_size (int): Size of the text labels for the amplitude and displacement scales. + lowfit (bool): Whether profiles with low model fit (<.70) should be plotted with dashed borders. + repel (bool): Experimental argument for plotting text labels instead of colors. + angle_labels (Optional[List[str]]): Text labels to plot around the circle for each scale. + palette (Optional[str]): Color palette to use for the plot. + **kwargs: Additional arguments for matplotlib. + + Returns: + matplotlib.figure.Figure: A figure object containing the circular plot. + """ + df = ssm_object.results + angles = np.round(ssm_object.details['angles']).astype(int) + + if amax is None: + amax = np.ceil(df['a_uci'].max() * 10) / 10 + + # Convert results to numbers usable by matplotlib + df_plot = df.copy() + df_plot['d_uci'] = np.where(df_plot['d_uci'] < df_plot['d_lci'], + np.deg2rad(df_plot['d_uci'] + 360), + np.deg2rad(df_plot['d_uci']) + ) + df_plot['d_lci'] = np.deg2rad(df_plot['d_lci']) + df_plot['a_lci'] = df_plot['a_lci'] * 10 / (2 * amax) + df_plot['a_uci'] = df_plot['a_uci'] * 10 / (2 * amax) + df_plot['x_est'] = df_plot['x_est'] * 10 / (2 * amax) + df_plot['y_est'] = df_plot['y_est'] * 10 / (2 * amax) + + # Remove profiles with low model fit (unless overridden) + if not lowfit: + df_plot = df_plot[df_plot['fit_est'] >= 0.70] + if len(df_plot) < 1: + raise ValueError("After removing profiles, there were none left to plot.") + + df_plot['linestyle'] = np.where(df_plot['fit_est'] >= 0.70, 'solid', 'dashed') + + fig, ax = plt.subplots(figsize=(10, 10)) + circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) + + colors = plt.cm.get_cmap(palette)(np.linspace(0, 1, len(df_plot))) + + for i, (_, row) in enumerate(df_plot.iterrows()): + wedge = patches.Wedge((0, 0), row['a_uci'], np.rad2deg(row['d_lci']), np.rad2deg(row['d_uci']), + width=row['a_uci'] - row['a_lci'], + fc=colors[i], + alpha=0.4, + linestyle=row['linestyle'] + ) + ax.add_patch(wedge) + ax.plot(row['x_est'], row['y_est'], 'o', color=colors[i]) + + if repel: + for _, row in df_plot.iterrows(): + ax.annotate(row['label'], (row['x_est'], row['y_est']), + xytext=(-25 - row['x_est'], 0), + textcoords='offset points', + ha='right', va='center', + fontsize=legend_font_size, + bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.8), + arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0') + ) + else: + ax.legend(df_plot['label'], loc='center left', bbox_to_anchor=(1, 0.5), + fontsize=legend_font_size + ) + + return fig + +def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): + """ + Create an Empty Circular Plot. + + Args: + ax (matplotlib.axes.Axes): The axes to draw on. + angles (List[float]): Angular displacement of each circumplex scale. + amax (float): Maximum amplitude. + amin (float): Minimum amplitude. + fontsize (int): Font size for labels. + labels (Optional[List[str]]): Labels for the angles. + + Returns: + None + """ + if labels is None: + labels = [f"{angle}°" for angle in angles] + + # Draw circles + for r in range(1, 6): + circle = plt.Circle((0, 0), r, fill=False, color='gray') + ax.add_artist(circle) + + # Draw lines + for angle in np.deg2rad(angles): + ax.plot([0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color='gray', linewidth=0.5) + + # Add labels + for angle, label in zip(np.deg2rad(angles), labels): + ax.text(5.1 * np.cos(angle), 5.1 * np.sin(angle), label, + ha='center', va='center', fontsize=fontsize + ) + + # Add amplitude labels + ax.text(2, 0, f"{amin + (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) + ax.text(4, 0, f"{amin + 2 * (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) + + ax.set_xlim(-5.5, 5.5) + ax.set_ylim(-5.5, 5.5) + ax.set_aspect('equal') + ax.axis('off') + + +def ssm_plot_contrast(ssm_object: SSMResults, + axislabel: str = "Difference", + xy: bool = True, + color: str = "red", + linesize: float = 1.25, + fontsize: int = 12 + ): + """ + Create a Difference Plot of SSM Contrast Results. + + Args: + ssm_object (SSMResults): The results output of ssm_analyze. + axislabel (str): Label for the y-axis. + xy (bool): Whether to include X-Value and Y-Value parameters in the plot. + color (str): Color of the point range. + linesize (float): Size of the point range elements in points. + fontsize (int): Size of the axis labels, numbers, and facet headings in points. + + Returns: + matplotlib.figure.Figure: A figure object containing the difference plot. + """ + plabs = { + 'e': r'$\Delta$ Elevation', + 'x': r'$\Delta$ X-Value', + 'y': r'$\Delta$ Y-Value', + 'a': r'$\Delta$ Amplitude', + 'd': r'$\Delta$ Displacement' + } + + pvals = ['e', 'x', 'y', 'a', 'd'] + + res = ssm_object.results + + if not xy: + res = res.drop(columns=['x_est', 'x_lci', 'x_uci', 'y_est', 'y_lci', 'y_uci']) + plabs = {k: v for k, v in plabs.items() if k not in ['x', 'y']} + pvals = [p for p in pvals if p not in ['x', 'y']] + + res['d_est'] = res['d_est'].astype(float) + res['d_uci'] = np.where((res['d_uci'] < res['d_lci']) & (res['d_uci'] < 180), + (res['d_uci'] + 360) % 360, res['d_uci'] + ) + res['d_lci'] = np.where((res['d_lci'] > res['d_uci']) & (res['d_lci'] > 180), + (res['d_lci'] - 360) % 360, res['d_lci'] + ) + + fig, axes = plt.subplots(1, len(pvals), figsize=(4 * len(pvals), 4), sharey=True) + fig.suptitle(axislabel, fontsize=fontsize + 2) + + for ax, param in zip(axes, pvals): + ax.axhline(y=0, color='darkgray', linewidth=linesize) + ax.errorbar(res['label'], res[f'{param}_est'], + yerr=[res[f'{param}_est'] - res[f'{param}_lci'], + res[f'{param}_uci'] - res[f'{param}_est']], + fmt='o', color=color, capsize=5, capthick=linesize, + elinewidth=linesize, markersize=linesize * 3 + ) + ax.set_title(plabs[param], fontsize=fontsize) + ax.tick_params(axis='x', rotation=45) + ax.tick_params(axis='both', labelsize=fontsize - 2) + + fig.tight_layout() + return fig \ No newline at end of file diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/core/ssm_results.py new file mode 100644 index 0000000..be11af1 --- /dev/null +++ b/src/circumplex/core/ssm_results.py @@ -0,0 +1,44 @@ +import pandas as pd +import numpy as np +from typing import List, Dict, Any + + +class SSMResults: + def __init__(self, results: pd.DataFrame, scores: pd.DataFrame, details: Dict[str, Any], call: str): + self.results = results + self.scores = scores + self.details = details + self.call = call + + def __str__(self): + output = [f"Call:\n{self.call}\n"] + for _, row in self.results.iterrows(): + output.append(f"\n{self.details['results_type']} [{row['label']}]:") + params = ['Elevation', 'X-Value', 'Y-Value', 'Amplitude', 'Displacement', 'Model Fit'] + output.append(f"{'Parameter ':<10} {'Estimate ':>8} [LCI, UCI]") + param_abbrev = [f'{p.lower()[0]}' for p in params] + param_abbrev.pop(-1) + param_abbrev.append('fit') + estimates = [row[f'{p}_est'] for p in param_abbrev] + lower_ci = [row[f'{p}_lci'] for p in param_abbrev] + upper_ci = [row[f'{p}_uci'] for p in param_abbrev] + + max_len = max(len(p) for p in params) + for param, est, lci, uci in zip(params, estimates, lower_ci, upper_ci): + output.append(f"{param:<{max_len}} {est:>8.3f} [{lci:>8.3f}, {uci:>8.3f}]") + + return "\n".join(output) + + def summary(self): + output = [f"Call:\n{self.call}\n"] + output.extend([ + f"Statistical Basis: {self.details['score_type']} Scores", + f"Bootstrap Resamples: {self.details['boots']}", + f"Confidence Level: {self.details['interval']}", + f"Listwise Deletion: {self.details['listwise']}", + f"Scale Displacements: {self.details['angles'].tolist()}\n" + ] + ) + + output.extend(str(self).split('\n')[2:]) # Add the formatted results + return "\n".join(output) \ No newline at end of file From bf18bb60d73bf65f94d4292b11944ad302015134 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Fri, 5 Jul 2024 23:17:51 +0100 Subject: [PATCH 03/97] changed plotting to seaborn --- src/circumplex/core/plot.py | 248 ---------------------------- src/circumplex/core/ssm_analysis.py | 14 +- src/circumplex/core/ssm_plot.py | 102 ++++++++---- 3 files changed, 71 insertions(+), 293 deletions(-) delete mode 100644 src/circumplex/core/plot.py diff --git a/src/circumplex/core/plot.py b/src/circumplex/core/plot.py deleted file mode 100644 index d94fde4..0000000 --- a/src/circumplex/core/plot.py +++ /dev/null @@ -1,248 +0,0 @@ -import matplotlib.pyplot as plt -import seaborn as sns -import numpy as np -import pandas as pd -from typing import Optional, List -from circumplex.core.ssm_results import SSMResults -import matplotlib.patches as patches - - -def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): - """ - Create a figure from SSM results. - - Args: - ssm_object (SSMResults): The results output of ssm_analyze. - fontsize (int): Font size of text in the figure, in points (default = 12). - **kwargs: Additional arguments to pass on to the plotting function. - - Returns: - matplotlib.figure.Figure: A figure object representing the plot. - """ - assert isinstance(ssm_object, SSMResults), "ssm_object must be an SSMResults instance" - assert fontsize > 0, "fontsize must be a positive number" - - sns.set(style="whitegrid", font_scale=fontsize / 12) - - if ssm_object.details['contrast'] == "test": - return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) - else: - return ssm_plot_circle(ssm_object, fontsize=fontsize, **kwargs) - - -def ssm_plot_circle(ssm_object: SSMResults, - amax: Optional[float] = None, - legend_font_size: int = 12, - scale_font_size: int = 12, - lowfit: bool = True, - repel: bool = False, - angle_labels: Optional[List[str]] = None, - palette: Optional[str] = "husl", - **kwargs - ): - """ - Create a Circular Plot of SSM Results using Seaborn. - - Args: - ssm_object (SSMResults): The output of ssm_analyze. - amax (Optional[float]): A positive number corresponding to the radius of the circle. - legend_font_size (int): Size of the text labels in the legend. - scale_font_size (int): Size of the text labels for the amplitude and displacement scales. - lowfit (bool): Whether profiles with low model fit (<.70) should be plotted with dashed borders. - repel (bool): Experimental argument for plotting text labels instead of colors. - angle_labels (Optional[List[str]]): Text labels to plot around the circle for each scale. - palette (Optional[str]): Color palette to use for the plot. - **kwargs: Additional arguments for seaborn. - - Returns: - matplotlib.figure.Figure: A figure object containing the circular plot. - """ - df = ssm_object.results - angles = np.round(ssm_object.details['angles']).astype(int) - - if amax is None: - amax = np.ceil(df['a_uci'].max() * 10) / 10 - - # Convert results to numbers usable by seaborn - df_plot = df.copy() - df_plot['d_uci'] = np.where(df_plot['d_uci'] < df_plot['d_lci'], - df_plot['d_uci'] + 360, - df_plot['d_uci'] - ) - df_plot['a_lci'] = df_plot['a_lci'] * 5 / amax - df_plot['a_uci'] = df_plot['a_uci'] * 5 / amax - df_plot['x_est'] = df_plot['x_est'] * 5 / amax - df_plot['y_est'] = df_plot['y_est'] * 5 / amax - - # Remove profiles with low model fit (unless overridden) - if not lowfit: - df_plot = df_plot[df_plot['fit_est'] >= 0.70] - if len(df_plot) < 1: - raise ValueError("After removing profiles, there were none left to plot.") - - df_plot['linestyle'] = np.where(df_plot['fit_est'] >= 0.70, 'solid', 'dashed') - - fig, ax = plt.subplots(figsize=(10, 10)) - circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) - - # Use seaborn color palette - colors = sns.color_palette(palette, n_colors=len(df_plot)) - - # Plot confidence regions - for i, (_, row) in enumerate(df_plot.iterrows()): - wedge = patches.Wedge((0, 0), row['a_uci'], row['d_lci'], row['d_uci'], - width=row['a_uci'] - row['a_lci'], - fc=colors[i], - alpha=0.3, - linestyle=row['linestyle'] - ) - ax.add_patch(wedge) - - # Plot points - sns.scatterplot(data=df_plot, x='x_est', y='y_est', hue='label', - palette=palette, s=100, ax=ax, legend='brief' - ) - - if repel: - for _, row in df_plot.iterrows(): - ax.annotate(row['label'], (row['x_est'], row['y_est']), - xytext=(-25 - row['x_est'], 0), - textcoords='offset points', - ha='right', va='center', - fontsize=legend_font_size, - bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.8), - arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0') - ) - ax.legend().remove() - else: - ax.legend(title=ssm_object.details['results_type'], - fontsize=legend_font_size, - title_fontsize=legend_font_size - ) - - return fig - -def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): - """ - Create an Empty Circular Plot. - - Args: - ax (matplotlib.axes.Axes): The axes to draw on. - angles (List[float]): Angular displacement of each circumplex scale. - amax (float): Maximum amplitude. - amin (float): Minimum amplitude. - fontsize (int): Font size for labels. - labels (Optional[List[str]]): Labels for the angles. - - Returns: - None - """ - if labels is None: - labels = [f"{angle}°" for angle in angles] - - # Draw circles - for r in range(1, 6): - ax.add_artist(plt.Circle((0, 0), r, fill=False, color='gray')) - - # Draw lines - for angle in np.deg2rad(angles): - ax.plot([0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color='gray', linewidth=0.5) - - # Add labels - for angle, label in zip(np.deg2rad(angles), labels): - ax.text(5.1 * np.cos(angle), 5.1 * np.sin(angle), label, - ha='center', va='center', fontsize=fontsize - ) - - # Add amplitude labels - ax.text(2, 0, f"{amin + (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) - ax.text(4, 0, f"{amin + 2 * (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) - - ax.set_xlim(-5.5, 5.5) - ax.set_ylim(-5.5, 5.5) - ax.set_aspect('equal') - ax.axis('off') - - -def ssm_plot_contrast(ssm_object: SSMResults, - axislabel: str = "Difference", - xy: bool = True, - color: str = "red", - linesize: float = 1.25, - fontsize: int = 12 - ): - """ - Create a Difference Plot of SSM Contrast Results using Seaborn. - - Args: - ssm_object (SSMResults): The results output of ssm_analyze. - axislabel (str): Label for the y-axis. - xy (bool): Whether to include X-Value and Y-Value parameters in the plot. - color (str): Color of the point range. - linesize (float): Size of the point range elements in points. - fontsize (int): Size of the axis labels, numbers, and facet headings in points. - - Returns: - matplotlib.figure.Figure: A figure object containing the difference plot. - """ - plabs = { - 'e': r'$\Delta$ Elevation', - 'x': r'$\Delta$ X-Value', - 'y': r'$\Delta$ Y-Value', - 'a': r'$\Delta$ Amplitude', - 'd': r'$\Delta$ Displacement' - } - - pvals = ['e', 'x', 'y', 'a', 'd'] - - res = ssm_object.results - - if not xy: - res = res.drop(columns=['x_est', 'x_lci', 'x_uci', 'y_est', 'y_lci', 'y_uci']) - plabs = {k: v for k, v in plabs.items() if k not in ['x', 'y']} - pvals = [p for p in pvals if p not in ['x', 'y']] - - res['d_est'] = res['d_est'].astype(float) - res['d_uci'] = np.where((res['d_uci'] < res['d_lci']) & (res['d_uci'] < 180), - (res['d_uci'] + 360) % 360, res['d_uci'] - ) - res['d_lci'] = np.where((res['d_lci'] > res['d_uci']) & (res['d_lci'] > 180), - (res['d_lci'] - 360) % 360, res['d_lci'] - ) - - # Reshape data for seaborn - plot_data = [] - for param in pvals: - for _, row in res.iterrows(): - plot_data.append({ - 'Parameter': plabs[param], - 'Estimate' : row[f'{param}_est'], - 'Lower CI' : row[f'{param}_lci'], - 'Upper CI' : row[f'{param}_uci'], - 'Label' : row['label'] - } - ) - plot_df = pd.DataFrame(plot_data) - - # Create plot - fig, ax = plt.subplots(figsize=(12, 6)) - sns.pointplot(data=plot_df, x='Parameter', y='Estimate', hue='Label', - join=False, ci=None, palette=color, scale=0.75, ax=ax - ) - - # Add error bars - ax.errorbar(x=plot_df['Parameter'], y=plot_df['Estimate'], - yerr=[plot_df['Estimate'] - plot_df['Lower CI'], - plot_df['Upper CI'] - plot_df['Estimate']], - fmt='none', ecolor=color, elinewidth=linesize, capsize=5 - ) - - # Customize plot - ax.axhline(y=0, color='gray', linestyle='--', linewidth=linesize) - ax.set_ylabel(axislabel, fontsize=fontsize) - ax.set_xlabel('') - ax.tick_params(axis='both', which='major', labelsize=fontsize - 2) - ax.legend(title=ssm_object.details['results_type'], fontsize=fontsize - 2, title_fontsize=fontsize) - - plt.tight_layout() - return fig diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index 05bc7f7..b26eb10 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -690,9 +690,8 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: if __name__ == "__main__": ######## SCRATCH ######## from importlib.resources import files - from ssm_plot import ssm_plot import matplotlib.pyplot as plt - from plot import ssm_plot as sm_plot + from ssm_plot import ssm_plot _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) data = pd.read_csv(_jz2017_path) @@ -701,18 +700,15 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - grouping = 'Gender', + # grouping = 'Gender', # contrast='model' - # measures = ['NARPD', 'ASPD'], + measures = ['NARPD', 'ASPD'], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) print(results) print(results.summary()) - fig = ssm_plot(results) - plt.show() - - fig = sm_plot(results) - plt.show() + fig = ssm_plot(results) + plt.show() diff --git a/src/circumplex/core/ssm_plot.py b/src/circumplex/core/ssm_plot.py index e608191..d94fde4 100644 --- a/src/circumplex/core/ssm_plot.py +++ b/src/circumplex/core/ssm_plot.py @@ -1,8 +1,11 @@ import matplotlib.pyplot as plt -import matplotlib.patches as patches +import seaborn as sns import numpy as np +import pandas as pd from typing import Optional, List from circumplex.core.ssm_results import SSMResults +import matplotlib.patches as patches + def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): """ @@ -19,6 +22,8 @@ def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): assert isinstance(ssm_object, SSMResults), "ssm_object must be an SSMResults instance" assert fontsize > 0, "fontsize must be a positive number" + sns.set(style="whitegrid", font_scale=fontsize / 12) + if ssm_object.details['contrast'] == "test": return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) else: @@ -32,11 +37,11 @@ def ssm_plot_circle(ssm_object: SSMResults, lowfit: bool = True, repel: bool = False, angle_labels: Optional[List[str]] = None, - palette: Optional[str] = "Set2", + palette: Optional[str] = "husl", **kwargs ): """ - Create a Circular Plot of SSM Results. + Create a Circular Plot of SSM Results using Seaborn. Args: ssm_object (SSMResults): The output of ssm_analyze. @@ -47,7 +52,7 @@ def ssm_plot_circle(ssm_object: SSMResults, repel (bool): Experimental argument for plotting text labels instead of colors. angle_labels (Optional[List[str]]): Text labels to plot around the circle for each scale. palette (Optional[str]): Color palette to use for the plot. - **kwargs: Additional arguments for matplotlib. + **kwargs: Additional arguments for seaborn. Returns: matplotlib.figure.Figure: A figure object containing the circular plot. @@ -58,17 +63,16 @@ def ssm_plot_circle(ssm_object: SSMResults, if amax is None: amax = np.ceil(df['a_uci'].max() * 10) / 10 - # Convert results to numbers usable by matplotlib + # Convert results to numbers usable by seaborn df_plot = df.copy() df_plot['d_uci'] = np.where(df_plot['d_uci'] < df_plot['d_lci'], - np.deg2rad(df_plot['d_uci'] + 360), - np.deg2rad(df_plot['d_uci']) + df_plot['d_uci'] + 360, + df_plot['d_uci'] ) - df_plot['d_lci'] = np.deg2rad(df_plot['d_lci']) - df_plot['a_lci'] = df_plot['a_lci'] * 10 / (2 * amax) - df_plot['a_uci'] = df_plot['a_uci'] * 10 / (2 * amax) - df_plot['x_est'] = df_plot['x_est'] * 10 / (2 * amax) - df_plot['y_est'] = df_plot['y_est'] * 10 / (2 * amax) + df_plot['a_lci'] = df_plot['a_lci'] * 5 / amax + df_plot['a_uci'] = df_plot['a_uci'] * 5 / amax + df_plot['x_est'] = df_plot['x_est'] * 5 / amax + df_plot['y_est'] = df_plot['y_est'] * 5 / amax # Remove profiles with low model fit (unless overridden) if not lowfit: @@ -81,17 +85,23 @@ def ssm_plot_circle(ssm_object: SSMResults, fig, ax = plt.subplots(figsize=(10, 10)) circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) - colors = plt.cm.get_cmap(palette)(np.linspace(0, 1, len(df_plot))) + # Use seaborn color palette + colors = sns.color_palette(palette, n_colors=len(df_plot)) + # Plot confidence regions for i, (_, row) in enumerate(df_plot.iterrows()): - wedge = patches.Wedge((0, 0), row['a_uci'], np.rad2deg(row['d_lci']), np.rad2deg(row['d_uci']), + wedge = patches.Wedge((0, 0), row['a_uci'], row['d_lci'], row['d_uci'], width=row['a_uci'] - row['a_lci'], fc=colors[i], - alpha=0.4, + alpha=0.3, linestyle=row['linestyle'] ) ax.add_patch(wedge) - ax.plot(row['x_est'], row['y_est'], 'o', color=colors[i]) + + # Plot points + sns.scatterplot(data=df_plot, x='x_est', y='y_est', hue='label', + palette=palette, s=100, ax=ax, legend='brief' + ) if repel: for _, row in df_plot.iterrows(): @@ -103,9 +113,11 @@ def ssm_plot_circle(ssm_object: SSMResults, bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.8), arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0') ) + ax.legend().remove() else: - ax.legend(df_plot['label'], loc='center left', bbox_to_anchor=(1, 0.5), - fontsize=legend_font_size + ax.legend(title=ssm_object.details['results_type'], + fontsize=legend_font_size, + title_fontsize=legend_font_size ) return fig @@ -130,8 +142,7 @@ def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): # Draw circles for r in range(1, 6): - circle = plt.Circle((0, 0), r, fill=False, color='gray') - ax.add_artist(circle) + ax.add_artist(plt.Circle((0, 0), r, fill=False, color='gray')) # Draw lines for angle in np.deg2rad(angles): @@ -161,7 +172,7 @@ def ssm_plot_contrast(ssm_object: SSMResults, fontsize: int = 12 ): """ - Create a Difference Plot of SSM Contrast Results. + Create a Difference Plot of SSM Contrast Results using Seaborn. Args: ssm_object (SSMResults): The results output of ssm_analyze. @@ -199,20 +210,39 @@ def ssm_plot_contrast(ssm_object: SSMResults, (res['d_lci'] - 360) % 360, res['d_lci'] ) - fig, axes = plt.subplots(1, len(pvals), figsize=(4 * len(pvals), 4), sharey=True) - fig.suptitle(axislabel, fontsize=fontsize + 2) - - for ax, param in zip(axes, pvals): - ax.axhline(y=0, color='darkgray', linewidth=linesize) - ax.errorbar(res['label'], res[f'{param}_est'], - yerr=[res[f'{param}_est'] - res[f'{param}_lci'], - res[f'{param}_uci'] - res[f'{param}_est']], - fmt='o', color=color, capsize=5, capthick=linesize, - elinewidth=linesize, markersize=linesize * 3 + # Reshape data for seaborn + plot_data = [] + for param in pvals: + for _, row in res.iterrows(): + plot_data.append({ + 'Parameter': plabs[param], + 'Estimate' : row[f'{param}_est'], + 'Lower CI' : row[f'{param}_lci'], + 'Upper CI' : row[f'{param}_uci'], + 'Label' : row['label'] + } ) - ax.set_title(plabs[param], fontsize=fontsize) - ax.tick_params(axis='x', rotation=45) - ax.tick_params(axis='both', labelsize=fontsize - 2) + plot_df = pd.DataFrame(plot_data) - fig.tight_layout() - return fig \ No newline at end of file + # Create plot + fig, ax = plt.subplots(figsize=(12, 6)) + sns.pointplot(data=plot_df, x='Parameter', y='Estimate', hue='Label', + join=False, ci=None, palette=color, scale=0.75, ax=ax + ) + + # Add error bars + ax.errorbar(x=plot_df['Parameter'], y=plot_df['Estimate'], + yerr=[plot_df['Estimate'] - plot_df['Lower CI'], + plot_df['Upper CI'] - plot_df['Estimate']], + fmt='none', ecolor=color, elinewidth=linesize, capsize=5 + ) + + # Customize plot + ax.axhline(y=0, color='gray', linestyle='--', linewidth=linesize) + ax.set_ylabel(axislabel, fontsize=fontsize) + ax.set_xlabel('') + ax.tick_params(axis='both', which='major', labelsize=fontsize - 2) + ax.legend(title=ssm_object.details['results_type'], fontsize=fontsize - 2, title_fontsize=fontsize) + + plt.tight_layout() + return fig From 733c5f1165839af9733b05ebd4ddf1769d7bbb06 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Fri, 5 Jul 2024 23:42:24 +0100 Subject: [PATCH 04/97] fix bug with test palette --- src/circumplex/core/ssm_analysis.py | 5 +++-- src/circumplex/core/ssm_plot.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index b26eb10..d0a675b 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -490,6 +490,7 @@ def ssm_analyze_corrs(data: pd.DataFrame, else: bs_input = data[scales + measures].copy() bs_input['Group'] = 'All' + bs_input['Group'] = bs_input['Group'].astype('category') # Check that this combination of arguments is executable n_measures = len(measures) @@ -700,8 +701,8 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - # grouping = 'Gender', - # contrast='model' + grouping = 'Gender', + # contrast='model', measures = ['NARPD', 'ASPD'], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) diff --git a/src/circumplex/core/ssm_plot.py b/src/circumplex/core/ssm_plot.py index d94fde4..9b436d2 100644 --- a/src/circumplex/core/ssm_plot.py +++ b/src/circumplex/core/ssm_plot.py @@ -227,7 +227,7 @@ def ssm_plot_contrast(ssm_object: SSMResults, # Create plot fig, ax = plt.subplots(figsize=(12, 6)) sns.pointplot(data=plot_df, x='Parameter', y='Estimate', hue='Label', - join=False, ci=None, palette=color, scale=0.75, ax=ax + join=False, ci=None, color=color, scale=0.75, ax=ax ) # Add error bars From a06b70dc88c76730661f3091311d6d40e9f2113c Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 6 Jul 2024 00:10:39 +0100 Subject: [PATCH 05/97] formatting --- src/circumplex/circumplex.py | 2 - src/circumplex/core/instrument.py | 66 ++++--- src/circumplex/core/ssm_analysis.py | 165 +++++++++-------- src/circumplex/core/ssm_plot.py | 264 +++++++++++++++++----------- src/circumplex/core/ssm_results.py | 53 ++++-- 5 files changed, 333 insertions(+), 217 deletions(-) diff --git a/src/circumplex/circumplex.py b/src/circumplex/circumplex.py index 0d7783c..57de61c 100644 --- a/src/circumplex/circumplex.py +++ b/src/circumplex/circumplex.py @@ -2,10 +2,8 @@ import matplotlib.pyplot as plt from matplotlib import colormaps -from cycler import cycler import numpy as np import pandas as pd -import math from scipy.optimize import curve_fit OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) diff --git a/src/circumplex/core/instrument.py b/src/circumplex/core/instrument.py index 014a982..af6bd0d 100644 --- a/src/circumplex/core/instrument.py +++ b/src/circumplex/core/instrument.py @@ -1,11 +1,16 @@ import pandas as pd -from typing import List, Dict, Any +from typing import Dict, Any class Instrument: - def __init__(self, scales: pd.DataFrame, anchors: pd.DataFrame, items: pd.DataFrame, - norms: Dict[str, Any], details: Dict[str, Any] - ): + def __init__( + self, + scales: pd.DataFrame, + anchors: pd.DataFrame, + items: pd.DataFrame, + norms: Dict[str, Any], + details: Dict[str, Any], + ): self.scales = scales self.anchors = anchors self.items = items @@ -13,11 +18,13 @@ def __init__(self, scales: pd.DataFrame, anchors: pd.DataFrame, items: pd.DataFr self.details = details def __str__(self): - return (f"{self.details['Abbrev']}: {self.details['Name']}\n" - f"{self.details['Items']} items, {self.details['Scales']} scales, " - f"{len(self.norms[1])} normative data sets\n" - f"{self.details['Reference']}\n" - f"<{self.details['URL']}>") + return ( + f"{self.details['Abbrev']}: {self.details['Name']}\n" + f"{self.details['Items']} items, {self.details['Scales']} scales, " + f"{len(self.norms[1])} normative data sets\n" + f"{self.details['Reference']}\n" + f"<{self.details['URL']}>" + ) def summary(self, scales=True, anchors=True, items=True, norms=True): output = [str(self)] @@ -32,27 +39,35 @@ def summary(self, scales=True, anchors=True, items=True, norms=True): return "\n".join(output) def get_scales(self, items=False): - output = [f"The {self.details['Abbrev']} contains {self.details['Scales']} circumplex scales."] + output = [ + f"The {self.details['Abbrev']} contains {self.details['Scales']} circumplex scales." + ] for _, scale in self.scales.iterrows(): - output.append(f"{scale['Abbrev']}: {scale['Label']} ({scale['Angle']} degrees)") + output.append( + f"{scale['Abbrev']}: {scale['Label']} ({scale['Angle']} degrees)" + ) if items: - item_nums = [int(i) for i in scale['Items'].split(',')] + item_nums = [int(i) for i in scale["Items"].split(",")] for num in item_nums: - item = self.items.loc[self.items['Number'] == num, 'Text'].iloc[0] + item = self.items.loc[self.items["Number"] == num, "Text"].iloc[0] output.append(f" {num}. {item}") return "\n".join(output) def get_items(self): - output = [f"The {self.details['Abbrev']} contains {self.details['Items']} items ({self.details['Status']}):"] + output = [ + f"The {self.details['Abbrev']} contains {self.details['Items']} items ({self.details['Status']}):" + ] for _, item in self.items.iterrows(): - if not pd.isna(item['Number']): + if not pd.isna(item["Number"]): output.append(f"{item['Number']}. {item['Text']}") else: - output.append(item['Text']) + output.append(item["Text"]) return "\n".join(output) def get_anchors(self): - output = [f"The {self.details['Abbrev']} is rated using the following {len(self.anchors)}-point scale."] + output = [ + f"The {self.details['Abbrev']} is rated using the following {len(self.anchors)}-point scale." + ] for _, anchor in self.anchors.iterrows(): output.append(f"{anchor['Value']}. {anchor['Label']}") return "\n".join(output) @@ -63,14 +78,17 @@ def get_norms(self): if n_norms == 0: return f"The {self.details['Abbrev']} currently has no normative data sets." - output = [f"The {self.details['Abbrev']} currently has {n_norms} normative data set(s):"] + output = [ + f"The {self.details['Abbrev']} currently has {n_norms} normative data set(s):" + ] for i, sample in samples.iterrows(): - output.extend([ - f"{sample['Sample']}. {sample['Size']} {sample['Population']}", - sample['Reference'], - f"<{sample['URL']}>" + output.extend( + [ + f"{sample['Sample']}. {sample['Size']} {sample['Population']}", + sample["Reference"], + f"<{sample['URL']}>", ] - ) + ) return "\n".join(output) @@ -94,4 +112,4 @@ def instruments(): def instrument(code: str): # This function would load the instrument data from a file or database # For now, we'll just return a placeholder - return f"Instrument data for {code}" \ No newline at end of file + return f"Instrument data for {code}" diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index d0a675b..026b972 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -2,13 +2,12 @@ import pandas as pd import numpy as np -from scipy import stats from scipy.optimize import curve_fit from typing import Optional, List, Union, Callable from circumplex.core.ssm_results import SSMResults -BOUNDS = ([0, 0, -np.inf], [np.inf, 2*np.pi, np.inf]) +BOUNDS = ([0, 0, -np.inf], [np.inf, 2 * np.pi, np.inf]) OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) @@ -129,17 +128,30 @@ def ssm_analyze( # Calculate scores if measures is not None: - scores = corr_scores(data[scales], data[measures], data[grouping] if grouping else None, listwise) + scores = corr_scores( + data[scales], data[measures], data[grouping] if grouping else None, listwise + ) else: - scores = data[scales].groupby(data[grouping] if grouping else pd.Series(['All'] * len(data))).mean() + scores = ( + data[scales] + .groupby(data[grouping] if grouping else pd.Series(["All"] * len(data))) + .mean() + ) # Create the call string - call_str = f"ssm_analyze(data, scales={scales}, angles={angles}, measures={measures}, " \ - f"grouping={grouping}, contrast={contrast}, boots={boots}, " \ - f"interval={interval}, listwise={listwise}, measures_labels={measures_labels})" + call_str = ( + f"ssm_analyze(data, scales={scales}, angles={angles}, measures={measures}, " + f"grouping={grouping}, contrast={contrast}, boots={boots}, " + f"interval={interval}, listwise={listwise}, measures_labels={measures_labels})" + ) # Create and return the SSMResults object - return SSMResults(results=results['results'], scores=scores, details=results['details'], call=call_str) + return SSMResults( + results=results["results"], + scores=scores, + details=results["details"], + call=call_str, + ) def ssm_analyze_means( @@ -231,12 +243,15 @@ def bs_function(data, index, angles, contrast, listwise): "results_type": "Profile" if contrast == "none" else "Contrast", } - call_str = f"ssm_analyze_means(data, scales={scales}, angles={angles}, " \ - f"grouping={grouping}, contrast={contrast}, boots={boots}, " \ - f"interval={interval}, listwise={listwise})" + call_str = ( + f"ssm_analyze_means(data, scales={scales}, angles={angles}, " + f"grouping={grouping}, contrast={contrast}, boots={boots}, " + f"interval={interval}, listwise={listwise})" + ) return {"results": results, "details": details, "call": call_str} + def ssm_by_group( scores: pd.DataFrame, angles: List[float], contrast: str ) -> np.ndarray: @@ -333,7 +348,6 @@ def _r2_score(y_true: np.array, y_pred: np.array): return 1 - (ss_res / ss_tot) - def ssm_parameters_cpp(scores, angles, bounds=BOUNDS) -> tuple: """Calculate SSM parameters (without confidence intervals) for a set of scores. @@ -373,6 +387,7 @@ def polar2cart(r, theta): xval, yval = polar2cart(ampl, disp) return np.array([elev, xval, yval, ampl, disp, r2]) + def ssm_bootstrap( bs_input: pd.DataFrame, bs_function: Callable, @@ -455,16 +470,18 @@ def angle_median(angles: np.ndarray) -> float: return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) -def ssm_analyze_corrs(data: pd.DataFrame, - scales: List[str], - angles: List[float], - measures: List[str], - grouping: Optional[str] = None, - contrast: str = "none", - boots: int = 2000, - interval: float = 0.95, - listwise: bool = True, - measures_labels: Optional[List[str]] = None) -> dict: +def ssm_analyze_corrs( + data: pd.DataFrame, + scales: List[str], + angles: List[float], + measures: List[str], + grouping: Optional[str] = None, + contrast: str = "none", + boots: int = 2000, + interval: float = 0.95, + listwise: bool = True, + measures_labels: Optional[List[str]] = None, +) -> dict: """ Perform analyses using the correlation-based Structural Summary Method. @@ -486,22 +503,24 @@ def ssm_analyze_corrs(data: pd.DataFrame, # Select circumplex scales, measure variables, and grouping variable if grouping is not None: bs_input = data[scales + measures + [grouping]].copy() - bs_input['Group'] = bs_input[grouping].astype('category') + bs_input["Group"] = bs_input[grouping].astype("category") else: bs_input = data[scales + measures].copy() - bs_input['Group'] = 'All' - bs_input['Group'] = bs_input['Group'].astype('category') + bs_input["Group"] = "All" + bs_input["Group"] = bs_input["Group"].astype("category") # Check that this combination of arguments is executable n_measures = len(measures) - n_groups = bs_input['Group'].nunique() + n_groups = bs_input["Group"].nunique() if contrast != "none": - contrast_measures = (n_measures == 2 and n_groups == 1) - contrast_groups = (n_measures == 1 and n_groups == 2) + contrast_measures = n_measures == 2 and n_groups == 1 + contrast_groups = n_measures == 1 and n_groups == 2 if not (contrast_measures or contrast_groups): - raise ValueError("No valid contrasts were possible. To contrast measures, ensure " - "there are 2 measures and no grouping variable. To contrast groups, " - "ensure there is 1 measure and a dichotomous grouping variable.") + raise ValueError( + "No valid contrasts were possible. To contrast measures, ensure " + "there are 2 measures and no grouping variable. To contrast groups, " + "ensure there is 1 measure and a dichotomous grouping variable." + ) # Perform listwise deletion if requested if listwise: @@ -516,24 +535,24 @@ def ssm_analyze_corrs(data: pd.DataFrame, # Calculate observed scores (i.e., correlations) cs = bs_input[scales].values mv = bs_input[measures].values - grp = bs_input['Group'].astype('category').cat.codes.values + grp = bs_input["Group"].astype("category").cat.codes.values scores = corr_scores(cs, mv, grp, listwise) scores_df = pd.DataFrame(scores, columns=scales) - scores_df['Group'] = np.repeat(bs_input['Group'].unique(), len(measures)) - scores_df['Measure'] = np.tile(measure_names, n_groups) + scores_df["Group"] = np.repeat(bs_input["Group"].unique(), len(measures)) + scores_df["Measure"] = np.tile(measure_names, n_groups) if grouping is not None: - scores_df['label'] = scores_df['Group'].astype(str) + "_" + scores_df['Measure'] + scores_df["label"] = scores_df["Group"].astype(str) + "_" + scores_df["Measure"] else: - scores_df['label'] = scores_df['Measure'] + scores_df["label"] = scores_df["Measure"] # Define bootstrap function def bs_function(data, index, angles, contrast, listwise): resample = data.iloc[index] - grp = resample['Group'].astype('category').cat.codes.values + grp = resample["Group"].astype("category").cat.codes.values cs = resample[scales].values mv = resample[measures].values scores_r = corr_scores(cs, mv, grp, listwise) - scores_r = scores_r.drop(columns=['Group', 'Measure']) + scores_r = scores_r.drop(columns=["Group", "Measure"]) return ssm_by_group(scores_r, angles, contrast) # Perform bootstrapping @@ -545,11 +564,11 @@ def bs_function(data, index, angles, contrast, listwise): interval=interval, contrast=contrast, listwise=listwise, - strata=bs_input['Group'] + strata=bs_input["Group"], ) # Select and label results - group_names = bs_input['Group'].cat.categories + group_names = bs_input["Group"].cat.categories if contrast == "none": row_data = bs_output grp_labels = np.repeat(group_names, len(measures)) @@ -559,9 +578,7 @@ def bs_function(data, index, angles, contrast, listwise): else: lbl_labels = msr_labels results = row_data.assign( - label=lbl_labels, - Group=grp_labels, - Measure=msr_labels + label=lbl_labels, Group=grp_labels, Measure=msr_labels ) else: row_data = bs_output.iloc[-1:].copy() @@ -573,28 +590,32 @@ def bs_function(data, index, angles, contrast, listwise): # Collect analysis details details = { - 'boots': boots, - 'interval': interval, - 'listwise': listwise, - 'angles': np.rad2deg(angles), - 'contrast': contrast, - 'score_type': "Correlation", - 'results_type': "Profile" if contrast == "none" else "Contrast" + "boots": boots, + "interval": interval, + "listwise": listwise, + "angles": np.rad2deg(angles), + "contrast": contrast, + "score_type": "Correlation", + "results_type": "Profile" if contrast == "none" else "Contrast", } - call_str = f"ssm_analyze_corrs(data, scales={scales}, angles={angles}, " \ - f"measures={measures}, grouping={grouping}, contrast={contrast}, " \ - f"boots={boots}, interval={interval}, listwise={listwise}, " \ - f"measures_labels={measures_labels})" + call_str = ( + f"ssm_analyze_corrs(data, scales={scales}, angles={angles}, " + f"measures={measures}, grouping={grouping}, contrast={contrast}, " + f"boots={boots}, interval={interval}, listwise={listwise}, " + f"measures_labels={measures_labels})" + ) return {"results": results, "details": details, "call": call_str} -def corr_scores(scores: Union[np.ndarray, pd.DataFrame], - measures: Union[np.ndarray, pd.DataFrame], - grouping: Union[np.ndarray, pd.Series], - listwise: bool, - scales: List[str] = None - ) -> pd.DataFrame: + +def corr_scores( + scores: Union[np.ndarray, pd.DataFrame], + measures: Union[np.ndarray, pd.DataFrame], + grouping: Union[np.ndarray, pd.Series], + listwise: bool, + scales: List[str] = None, +) -> pd.DataFrame: """ Calculate the correlation of each measure with each scale by group. @@ -611,7 +632,9 @@ def corr_scores(scores: Union[np.ndarray, pd.DataFrame], # Convert inputs to numpy arrays if they're not already cs_array = scores.values if isinstance(scores, pd.DataFrame) else scores mv_array = measures.values if isinstance(measures, pd.DataFrame) else measures - grp_array = grouping.values if isinstance(grouping, (pd.Series, pd.DataFrame)) else grouping + grp_array = ( + grouping.values if isinstance(grouping, (pd.Series, pd.DataFrame)) else grouping + ) levels = np.unique(grp_array) ng = len(levels) @@ -633,14 +656,14 @@ def corr_scores(scores: Union[np.ndarray, pd.DataFrame], if listwise: # Multiple groups and LWD for g, level in enumerate(levels): - mask = (grp_array == level) + mask = grp_array == level gcs = cs_array[mask] gmv = mv_array[mask] - out[g * pm:(g + 1) * pm, :] = np.corrcoef(gmv.T, gcs.T)[:pm, pm:] + out[g * pm : (g + 1) * pm, :] = np.corrcoef(gmv.T, gcs.T)[:pm, pm:] else: # Multiple groups and PWD for g, level in enumerate(levels): - mask = (grp_array == level) + mask = grp_array == level gcs = cs_array[mask] gmv = mv_array[mask] for m in range(pm): @@ -654,7 +677,7 @@ def corr_scores(scores: Union[np.ndarray, pd.DataFrame], if isinstance(scores, pd.DataFrame): scales = scores.columns.tolist() else: - scales = [f'Scale_{i + 1}' for i in range(ps)] + scales = [f"Scale_{i + 1}" for i in range(ps)] df_out = pd.DataFrame(out, columns=scales) @@ -662,10 +685,10 @@ def corr_scores(scores: Union[np.ndarray, pd.DataFrame], if isinstance(measures, pd.DataFrame): measure_names = measures.columns.tolist() else: - measure_names = [f'Measure_{i + 1}' for i in range(pm)] + measure_names = [f"Measure_{i + 1}" for i in range(pm)] - df_out['Group'] = np.repeat(levels, pm) - df_out['Measure'] = np.tile(measure_names, ng) + df_out["Group"] = np.repeat(levels, pm) + df_out["Measure"] = np.tile(measure_names, ng) return df_out @@ -701,15 +724,13 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - grouping = 'Gender', + grouping="Gender", # contrast='model', - measures = ['NARPD', 'ASPD'], + measures=["NARPD", "ASPD"], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) print(results) print(results.summary()) - fig = ssm_plot(results) plt.show() - diff --git a/src/circumplex/core/ssm_plot.py b/src/circumplex/core/ssm_plot.py index 9b436d2..babfa5d 100644 --- a/src/circumplex/core/ssm_plot.py +++ b/src/circumplex/core/ssm_plot.py @@ -19,27 +19,30 @@ def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): Returns: matplotlib.figure.Figure: A figure object representing the plot. """ - assert isinstance(ssm_object, SSMResults), "ssm_object must be an SSMResults instance" + assert isinstance( + ssm_object, SSMResults + ), "ssm_object must be an SSMResults instance" assert fontsize > 0, "fontsize must be a positive number" sns.set(style="whitegrid", font_scale=fontsize / 12) - if ssm_object.details['contrast'] == "test": + if ssm_object.details["contrast"] == "test": return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) else: return ssm_plot_circle(ssm_object, fontsize=fontsize, **kwargs) -def ssm_plot_circle(ssm_object: SSMResults, - amax: Optional[float] = None, - legend_font_size: int = 12, - scale_font_size: int = 12, - lowfit: bool = True, - repel: bool = False, - angle_labels: Optional[List[str]] = None, - palette: Optional[str] = "husl", - **kwargs - ): +def ssm_plot_circle( + ssm_object: SSMResults, + amax: Optional[float] = None, + legend_font_size: int = 12, + scale_font_size: int = 12, + lowfit: bool = True, + repel: bool = False, + angle_labels: Optional[List[str]] = None, + palette: Optional[str] = "husl", + **kwargs, +): """ Create a Circular Plot of SSM Results using Seaborn. @@ -58,29 +61,28 @@ def ssm_plot_circle(ssm_object: SSMResults, matplotlib.figure.Figure: A figure object containing the circular plot. """ df = ssm_object.results - angles = np.round(ssm_object.details['angles']).astype(int) + angles = np.round(ssm_object.details["angles"]).astype(int) if amax is None: - amax = np.ceil(df['a_uci'].max() * 10) / 10 + amax = np.ceil(df["a_uci"].max() * 10) / 10 # Convert results to numbers usable by seaborn df_plot = df.copy() - df_plot['d_uci'] = np.where(df_plot['d_uci'] < df_plot['d_lci'], - df_plot['d_uci'] + 360, - df_plot['d_uci'] - ) - df_plot['a_lci'] = df_plot['a_lci'] * 5 / amax - df_plot['a_uci'] = df_plot['a_uci'] * 5 / amax - df_plot['x_est'] = df_plot['x_est'] * 5 / amax - df_plot['y_est'] = df_plot['y_est'] * 5 / amax + df_plot["d_uci"] = np.where( + df_plot["d_uci"] < df_plot["d_lci"], df_plot["d_uci"] + 360, df_plot["d_uci"] + ) + df_plot["a_lci"] = df_plot["a_lci"] * 5 / amax + df_plot["a_uci"] = df_plot["a_uci"] * 5 / amax + df_plot["x_est"] = df_plot["x_est"] * 5 / amax + df_plot["y_est"] = df_plot["y_est"] * 5 / amax # Remove profiles with low model fit (unless overridden) if not lowfit: - df_plot = df_plot[df_plot['fit_est'] >= 0.70] + df_plot = df_plot[df_plot["fit_est"] >= 0.70] if len(df_plot) < 1: raise ValueError("After removing profiles, there were none left to plot.") - df_plot['linestyle'] = np.where(df_plot['fit_est'] >= 0.70, 'solid', 'dashed') + df_plot["linestyle"] = np.where(df_plot["fit_est"] >= 0.70, "solid", "dashed") fig, ax = plt.subplots(figsize=(10, 10)) circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) @@ -90,38 +92,54 @@ def ssm_plot_circle(ssm_object: SSMResults, # Plot confidence regions for i, (_, row) in enumerate(df_plot.iterrows()): - wedge = patches.Wedge((0, 0), row['a_uci'], row['d_lci'], row['d_uci'], - width=row['a_uci'] - row['a_lci'], - fc=colors[i], - alpha=0.3, - linestyle=row['linestyle'] - ) + wedge = patches.Wedge( + (0, 0), + row["a_uci"], + row["d_lci"], + row["d_uci"], + width=row["a_uci"] - row["a_lci"], + fc=colors[i], + alpha=0.3, + linestyle=row["linestyle"], + ) ax.add_patch(wedge) # Plot points - sns.scatterplot(data=df_plot, x='x_est', y='y_est', hue='label', - palette=palette, s=100, ax=ax, legend='brief' - ) + sns.scatterplot( + data=df_plot, + x="x_est", + y="y_est", + hue="label", + palette=palette, + s=100, + ax=ax, + legend="brief", + ) if repel: for _, row in df_plot.iterrows(): - ax.annotate(row['label'], (row['x_est'], row['y_est']), - xytext=(-25 - row['x_est'], 0), - textcoords='offset points', - ha='right', va='center', - fontsize=legend_font_size, - bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.8), - arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0') - ) + ax.annotate( + row["label"], + (row["x_est"], row["y_est"]), + xytext=(-25 - row["x_est"], 0), + textcoords="offset points", + ha="right", + va="center", + fontsize=legend_font_size, + bbox=dict(boxstyle="round,pad=0.5", fc="white", alpha=0.8), + arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=0"), + ) ax.legend().remove() else: - ax.legend(title=ssm_object.details['results_type'], - fontsize=legend_font_size, - title_fontsize=legend_font_size - ) + ax.legend( + title=ssm_object.details["results_type"], + fontsize=legend_font_size, + title_fontsize=legend_font_size, + ) return fig + def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): """ Create an Empty Circular Plot. @@ -142,35 +160,57 @@ def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): # Draw circles for r in range(1, 6): - ax.add_artist(plt.Circle((0, 0), r, fill=False, color='gray')) + ax.add_artist(plt.Circle((0, 0), r, fill=False, color="gray")) # Draw lines for angle in np.deg2rad(angles): - ax.plot([0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color='gray', linewidth=0.5) + ax.plot( + [0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color="gray", linewidth=0.5 + ) # Add labels for angle, label in zip(np.deg2rad(angles), labels): - ax.text(5.1 * np.cos(angle), 5.1 * np.sin(angle), label, - ha='center', va='center', fontsize=fontsize - ) + ax.text( + 5.1 * np.cos(angle), + 5.1 * np.sin(angle), + label, + ha="center", + va="center", + fontsize=fontsize, + ) # Add amplitude labels - ax.text(2, 0, f"{amin + (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) - ax.text(4, 0, f"{amin + 2 * (amax - amin) / 3:.2f}", ha='left', va='bottom', fontsize=fontsize) + ax.text( + 2, + 0, + f"{amin + (amax - amin) / 3:.2f}", + ha="left", + va="bottom", + fontsize=fontsize, + ) + ax.text( + 4, + 0, + f"{amin + 2 * (amax - amin) / 3:.2f}", + ha="left", + va="bottom", + fontsize=fontsize, + ) ax.set_xlim(-5.5, 5.5) ax.set_ylim(-5.5, 5.5) - ax.set_aspect('equal') - ax.axis('off') - - -def ssm_plot_contrast(ssm_object: SSMResults, - axislabel: str = "Difference", - xy: bool = True, - color: str = "red", - linesize: float = 1.25, - fontsize: int = 12 - ): + ax.set_aspect("equal") + ax.axis("off") + + +def ssm_plot_contrast( + ssm_object: SSMResults, + axislabel: str = "Difference", + xy: bool = True, + color: str = "red", + linesize: float = 1.25, + fontsize: int = 12, +): """ Create a Difference Plot of SSM Contrast Results using Seaborn. @@ -186,63 +226,87 @@ def ssm_plot_contrast(ssm_object: SSMResults, matplotlib.figure.Figure: A figure object containing the difference plot. """ plabs = { - 'e': r'$\Delta$ Elevation', - 'x': r'$\Delta$ X-Value', - 'y': r'$\Delta$ Y-Value', - 'a': r'$\Delta$ Amplitude', - 'd': r'$\Delta$ Displacement' - } + "e": r"$\Delta$ Elevation", + "x": r"$\Delta$ X-Value", + "y": r"$\Delta$ Y-Value", + "a": r"$\Delta$ Amplitude", + "d": r"$\Delta$ Displacement", + } - pvals = ['e', 'x', 'y', 'a', 'd'] + pvals = ["e", "x", "y", "a", "d"] res = ssm_object.results if not xy: - res = res.drop(columns=['x_est', 'x_lci', 'x_uci', 'y_est', 'y_lci', 'y_uci']) - plabs = {k: v for k, v in plabs.items() if k not in ['x', 'y']} - pvals = [p for p in pvals if p not in ['x', 'y']] - - res['d_est'] = res['d_est'].astype(float) - res['d_uci'] = np.where((res['d_uci'] < res['d_lci']) & (res['d_uci'] < 180), - (res['d_uci'] + 360) % 360, res['d_uci'] - ) - res['d_lci'] = np.where((res['d_lci'] > res['d_uci']) & (res['d_lci'] > 180), - (res['d_lci'] - 360) % 360, res['d_lci'] - ) + res = res.drop(columns=["x_est", "x_lci", "x_uci", "y_est", "y_lci", "y_uci"]) + plabs = {k: v for k, v in plabs.items() if k not in ["x", "y"]} + pvals = [p for p in pvals if p not in ["x", "y"]] + + res["d_est"] = res["d_est"].astype(float) + res["d_uci"] = np.where( + (res["d_uci"] < res["d_lci"]) & (res["d_uci"] < 180), + (res["d_uci"] + 360) % 360, + res["d_uci"], + ) + res["d_lci"] = np.where( + (res["d_lci"] > res["d_uci"]) & (res["d_lci"] > 180), + (res["d_lci"] - 360) % 360, + res["d_lci"], + ) # Reshape data for seaborn plot_data = [] for param in pvals: for _, row in res.iterrows(): - plot_data.append({ - 'Parameter': plabs[param], - 'Estimate' : row[f'{param}_est'], - 'Lower CI' : row[f'{param}_lci'], - 'Upper CI' : row[f'{param}_uci'], - 'Label' : row['label'] + plot_data.append( + { + "Parameter": plabs[param], + "Estimate": row[f"{param}_est"], + "Lower CI": row[f"{param}_lci"], + "Upper CI": row[f"{param}_uci"], + "Label": row["label"], } - ) + ) plot_df = pd.DataFrame(plot_data) # Create plot fig, ax = plt.subplots(figsize=(12, 6)) - sns.pointplot(data=plot_df, x='Parameter', y='Estimate', hue='Label', - join=False, ci=None, color=color, scale=0.75, ax=ax - ) + sns.pointplot( + data=plot_df, + x="Parameter", + y="Estimate", + hue="Label", + join=False, + ci=None, + color=color, + scale=0.75, + ax=ax, + ) # Add error bars - ax.errorbar(x=plot_df['Parameter'], y=plot_df['Estimate'], - yerr=[plot_df['Estimate'] - plot_df['Lower CI'], - plot_df['Upper CI'] - plot_df['Estimate']], - fmt='none', ecolor=color, elinewidth=linesize, capsize=5 - ) + ax.errorbar( + x=plot_df["Parameter"], + y=plot_df["Estimate"], + yerr=[ + plot_df["Estimate"] - plot_df["Lower CI"], + plot_df["Upper CI"] - plot_df["Estimate"], + ], + fmt="none", + ecolor=color, + elinewidth=linesize, + capsize=5, + ) # Customize plot - ax.axhline(y=0, color='gray', linestyle='--', linewidth=linesize) + ax.axhline(y=0, color="gray", linestyle="--", linewidth=linesize) ax.set_ylabel(axislabel, fontsize=fontsize) - ax.set_xlabel('') - ax.tick_params(axis='both', which='major', labelsize=fontsize - 2) - ax.legend(title=ssm_object.details['results_type'], fontsize=fontsize - 2, title_fontsize=fontsize) + ax.set_xlabel("") + ax.tick_params(axis="both", which="major", labelsize=fontsize - 2) + ax.legend( + title=ssm_object.details["results_type"], + fontsize=fontsize - 2, + title_fontsize=fontsize, + ) plt.tight_layout() return fig diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/core/ssm_results.py index be11af1..9cd82ca 100644 --- a/src/circumplex/core/ssm_results.py +++ b/src/circumplex/core/ssm_results.py @@ -1,10 +1,15 @@ import pandas as pd -import numpy as np -from typing import List, Dict, Any +from typing import Dict, Any class SSMResults: - def __init__(self, results: pd.DataFrame, scores: pd.DataFrame, details: Dict[str, Any], call: str): + def __init__( + self, + results: pd.DataFrame, + scores: pd.DataFrame, + details: Dict[str, Any], + call: str, + ): self.results = results self.scores = scores self.details = details @@ -14,31 +19,41 @@ def __str__(self): output = [f"Call:\n{self.call}\n"] for _, row in self.results.iterrows(): output.append(f"\n{self.details['results_type']} [{row['label']}]:") - params = ['Elevation', 'X-Value', 'Y-Value', 'Amplitude', 'Displacement', 'Model Fit'] + params = [ + "Elevation", + "X-Value", + "Y-Value", + "Amplitude", + "Displacement", + "Model Fit", + ] output.append(f"{'Parameter ':<10} {'Estimate ':>8} [LCI, UCI]") - param_abbrev = [f'{p.lower()[0]}' for p in params] + param_abbrev = [f"{p.lower()[0]}" for p in params] param_abbrev.pop(-1) - param_abbrev.append('fit') - estimates = [row[f'{p}_est'] for p in param_abbrev] - lower_ci = [row[f'{p}_lci'] for p in param_abbrev] - upper_ci = [row[f'{p}_uci'] for p in param_abbrev] + param_abbrev.append("fit") + estimates = [row[f"{p}_est"] for p in param_abbrev] + lower_ci = [row[f"{p}_lci"] for p in param_abbrev] + upper_ci = [row[f"{p}_uci"] for p in param_abbrev] max_len = max(len(p) for p in params) for param, est, lci, uci in zip(params, estimates, lower_ci, upper_ci): - output.append(f"{param:<{max_len}} {est:>8.3f} [{lci:>8.3f}, {uci:>8.3f}]") + output.append( + f"{param:<{max_len}} {est:>8.3f} [{lci:>8.3f}, {uci:>8.3f}]" + ) return "\n".join(output) def summary(self): output = [f"Call:\n{self.call}\n"] - output.extend([ - f"Statistical Basis: {self.details['score_type']} Scores", - f"Bootstrap Resamples: {self.details['boots']}", - f"Confidence Level: {self.details['interval']}", - f"Listwise Deletion: {self.details['listwise']}", - f"Scale Displacements: {self.details['angles'].tolist()}\n" + output.extend( + [ + f"Statistical Basis: {self.details['score_type']} Scores", + f"Bootstrap Resamples: {self.details['boots']}", + f"Confidence Level: {self.details['interval']}", + f"Listwise Deletion: {self.details['listwise']}", + f"Scale Displacements: {self.details['angles'].tolist()}\n", ] - ) + ) - output.extend(str(self).split('\n')[2:]) # Add the formatted results - return "\n".join(output) \ No newline at end of file + output.extend(str(self).split("\n")[2:]) # Add the formatted results + return "\n".join(output) From 2913794b6a5fe6a67d1d808f0d540168ef23fb8e Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Mon, 8 Jul 2024 17:04:12 +0100 Subject: [PATCH 06/97] refactored into four main files --- src/circumplex/core/__init__.py | 12 +++ src/circumplex/core/ssm_analysis.py | 75 ++----------------- src/circumplex/core/utils.py | 29 +++++++ .../core/{ssm_plot.py => visualization.py} | 0 4 files changed, 48 insertions(+), 68 deletions(-) create mode 100644 src/circumplex/core/utils.py rename src/circumplex/core/{ssm_plot.py => visualization.py} (100%) diff --git a/src/circumplex/core/__init__.py b/src/circumplex/core/__init__.py index e69de29..c51b736 100644 --- a/src/circumplex/core/__init__.py +++ b/src/circumplex/core/__init__.py @@ -0,0 +1,12 @@ +from ssm_analysis import ssm_analyze +from ssm_results import SSMResults +from visualization import ssm_plot +from instrument import Instrument, instruments + +__all__ = [ + "ssm_analyze", + "SSMResults", + "ssm_plot", + "Instrument", + "instruments", +] diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index 026b972..cab197b 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -1,14 +1,11 @@ -# %% - import pandas as pd import numpy as np from scipy.optimize import curve_fit from typing import Optional, List, Union, Callable from circumplex.core.ssm_results import SSMResults - +from circumplex.core.utils import OCTANTS, cosine_form, r2_score BOUNDS = ([0, 0, -np.inf], [np.inf, 2 * np.pi, np.inf]) -OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) def ssm_analyze( @@ -300,55 +297,12 @@ def group_parameters(scores: np.ndarray, angles: List[float]) -> np.ndarray: out = np.zeros(n * 6) # Initialize output array for i in range(n): - out[i * 6 : (i + 1) * 6] = ssm_parameters_cpp(scores[i], angles) + out[i * 6 : (i + 1) * 6] = ssm_parameters(scores[i], angles) return out -# def ssm_parameters_cpp(scores: np.ndarray, angles: List[float]) -> np.ndarray: -# """ -# Calculate SSM parameters for a single group. -# -# Args: -# scores (np.ndarray): 1D array of scores for a single group. -# angles (List[float]): Angular displacement of each circumplex scale (in radians). -# -# Returns: -# np.ndarray: Array of 6 SSM parameters [elevation, x-value, y-value, amplitude, angular displacement, model fit]. -# """ -# # Ensure scores and angles are numpy arrays -# scores = np.array(scores) -# angles = np.array(angles) -# -# # Calculate SSM parameters -# elevation = np.mean(scores) -# x_value = np.mean(scores * np.cos(angles)) -# y_value = np.mean(scores * np.sin(angles)) -# amplitude = np.sqrt(x_value**2 + y_value**2) -# displacement = np.arctan2(y_value, x_value) -# -# # Calculate model fit (R-squared) -# predicted_scores = elevation + amplitude * np.cos(angles - displacement) -# ss_total = np.sum((scores - np.mean(scores)) ** 2) -# ss_residual = np.sum((scores - predicted_scores) ** 2) -# model_fit = 1 - (ss_residual / ss_total) -# -# return np.array([elevation, x_value, y_value, amplitude, displacement, model_fit]) - - -def cosine_form(theta, ampl, disp, elev): - """Cosine function with amplitude, dispersion and elevation parameters.""" - return elev + ampl * np.cos(theta - disp) - - -def _r2_score(y_true: np.array, y_pred: np.array): - """Calculate the R2 score for a set of predictions.""" - ss_res = np.sum(np.square(y_true - y_pred)) - ss_tot = np.sum(np.square(y_true - np.mean(y_true))) - return 1 - (ss_res / ss_tot) - - -def ssm_parameters_cpp(scores, angles, bounds=BOUNDS) -> tuple: +def ssm_parameters(scores: np.ndarray, angles: List[float], bounds=BOUNDS) -> np.array: """Calculate SSM parameters (without confidence intervals) for a set of scores. Args: @@ -376,7 +330,7 @@ def ssm_parameters_cpp(scores, angles, bounds=BOUNDS) -> tuple: param, covariance = curve_fit( cosine_form, xdata=angles, ydata=scores, bounds=bounds ) - r2 = _r2_score(scores, cosine_form(angles, *param)) + r2 = r2_score(scores, cosine_form(angles, *param)) ampl, disp, elev = param def polar2cart(r, theta): @@ -457,19 +411,6 @@ def ssm_bootstrap( return results -def angle_median(angles: np.ndarray) -> float: - """ - Calculate the median of circular data. - - Args: - angles (np.ndarray): Array of angles in radians. - - Returns: - float: Median angle in radians. - """ - return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) - - def ssm_analyze_corrs( data: pd.DataFrame, scales: List[str], @@ -709,13 +650,11 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: return np.corrcoef(x, y)[0, 1] if len(x) > 1 else np.nan -# %% - if __name__ == "__main__": ######## SCRATCH ######## from importlib.resources import files import matplotlib.pyplot as plt - from ssm_plot import ssm_plot + from visualization import ssm_plot _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) data = pd.read_csv(_jz2017_path) @@ -724,9 +663,9 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - grouping="Gender", + # grouping="Gender", # contrast='model', - measures=["NARPD", "ASPD"], + # measures=["NARPD", "ASPD"], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) print(results) diff --git a/src/circumplex/core/utils.py b/src/circumplex/core/utils.py new file mode 100644 index 0000000..aaa82d5 --- /dev/null +++ b/src/circumplex/core/utils.py @@ -0,0 +1,29 @@ +import numpy as np + + +def cosine_form(theta, ampl, disp, elev): + """Cosine function with amplitude, dispersion and elevation parameters.""" + return elev + ampl * np.cos(theta - disp) + + +def angle_median(angles: np.ndarray) -> float: + """ + Calculate the median of circular data. + + Args: + angles (np.ndarray): Array of angles in radians. + + Returns: + float: Median angle in radians. + """ + return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) + + +def r2_score(y_true: np.array, y_pred: np.array): + """Calculate the R2 score for a set of predictions.""" + ss_res = np.sum(np.square(y_true - y_pred)) + ss_tot = np.sum(np.square(y_true - np.mean(y_true))) + return 1 - (ss_res / ss_tot) + + +OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) diff --git a/src/circumplex/core/ssm_plot.py b/src/circumplex/core/visualization.py similarity index 100% rename from src/circumplex/core/ssm_plot.py rename to src/circumplex/core/visualization.py From 6de9f698bda025b1cedd5ca9330231573cb7f651 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Tue, 9 Jul 2024 11:56:28 +0100 Subject: [PATCH 07/97] implement profile plots --- src/circumplex/core/ssm_analysis.py | 25 ++++--- src/circumplex/core/ssm_results.py | 27 ++++++++ src/circumplex/core/utils.py | 9 +++ src/circumplex/core/visualization.py | 98 +++++++++++++++++++++++++++- 4 files changed, 148 insertions(+), 11 deletions(-) diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index cab197b..f0335c1 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -145,7 +145,7 @@ def ssm_analyze( # Create and return the SSMResults object return SSMResults( results=results["results"], - scores=scores, + scores=results["scores"], details=results["details"], call=call_str, ) @@ -246,7 +246,7 @@ def bs_function(data, index, angles, contrast, listwise): f"interval={interval}, listwise={listwise})" ) - return {"results": results, "details": details, "call": call_str} + return {"results": results, "details": details, "call": call_str, "scores": scores} def ssm_by_group( @@ -477,7 +477,7 @@ def ssm_analyze_corrs( cs = bs_input[scales].values mv = bs_input[measures].values grp = bs_input["Group"].astype("category").cat.codes.values - scores = corr_scores(cs, mv, grp, listwise) + scores = corr_scores(cs, mv, grp, listwise, scales) scores_df = pd.DataFrame(scores, columns=scales) scores_df["Group"] = np.repeat(bs_input["Group"].unique(), len(measures)) scores_df["Measure"] = np.tile(measure_names, n_groups) @@ -547,7 +547,12 @@ def bs_function(data, index, angles, contrast, listwise): f"measures_labels={measures_labels})" ) - return {"results": results, "details": details, "call": call_str} + return { + "results": results, + "details": details, + "call": call_str, + "scores": scores_df, + } def corr_scores( @@ -654,7 +659,7 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: ######## SCRATCH ######## from importlib.resources import files import matplotlib.pyplot as plt - from visualization import ssm_plot + from visualization import ssm_plot, ssm_plot_profile _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) data = pd.read_csv(_jz2017_path) @@ -663,13 +668,15 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - # grouping="Gender", + grouping="Gender", # contrast='model', - # measures=["NARPD", "ASPD"], + measures=["NARPD", "ASPD"], # measures_labels=['Narcissistic PD', 'Antisocial PD'], ) - print(results) + print(results.scores) + # print(results) print(results.summary()) - fig = ssm_plot(results) + # fig = ssm_plot(results) + fig, ax = results.profile_plot() plt.show() diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/core/ssm_results.py index 9cd82ca..f23e8bf 100644 --- a/src/circumplex/core/ssm_results.py +++ b/src/circumplex/core/ssm_results.py @@ -1,6 +1,9 @@ import pandas as pd from typing import Dict, Any +from matplotlib import pyplot as plt +from circumplex.core.visualization import ssm_plot_profile + class SSMResults: def __init__( @@ -57,3 +60,27 @@ def summary(self): output.extend(str(self).split("\n")[2:]) # Add the formatted results return "\n".join(output) + + def profile_plot(self, **kwargs): + results = self.results + scores = self.scores + details = self.details + + n_components = results.shape[0] + fig, axes = plt.subplots(n_components, 1, figsize=(6, 4 * n_components)) + if n_components == 1: + axes = [axes] + + for i, (ax, (_, row)) in enumerate(zip(axes, results.iterrows())): + fig, ax = ssm_plot_profile( + scores=scores.iloc[i].values[:-3], + angles=details["angles"], + amplitude=row["a_est"], + displacement=row["d_est"], + elevation=row["e_est"], + r2=row["fit_est"], + ax=ax, + title=f"{scores.iloc[i].values[-1]} Profile", + **kwargs, + ) + return fig, axes diff --git a/src/circumplex/core/utils.py b/src/circumplex/core/utils.py index aaa82d5..6adcd0f 100644 --- a/src/circumplex/core/utils.py +++ b/src/circumplex/core/utils.py @@ -1,4 +1,5 @@ import numpy as np +from typing import Tuple def cosine_form(theta, ampl, disp, elev): @@ -27,3 +28,11 @@ def r2_score(y_true: np.array, y_pred: np.array): OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) + + +def sort_angles( + angles: np.ndarray, scores: np.ndarray +) -> Tuple[np.ndarray, np.ndarray]: + """Sort angles and corresponding scores in ascending order.""" + sorted_indices = np.argsort(angles) + return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] diff --git a/src/circumplex/core/visualization.py b/src/circumplex/core/visualization.py index babfa5d..0e4b39f 100644 --- a/src/circumplex/core/visualization.py +++ b/src/circumplex/core/visualization.py @@ -2,9 +2,10 @@ import seaborn as sns import numpy as np import pandas as pd -from typing import Optional, List -from circumplex.core.ssm_results import SSMResults +from typing import Optional, List, Tuple +from circumplex import SSMResults import matplotlib.patches as patches +from circumplex.core.utils import cosine_form, OCTANTS, sort_angles def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): @@ -310,3 +311,96 @@ def ssm_plot_contrast( plt.tight_layout() return fig + + +def ssm_plot_profile( + scores: np.ndarray, + angles: np.ndarray, + amplitude: float, + displacement: float, + elevation: float, + r2: float = None, + title: str = "SSM Profile", + reorder_scales: bool = True, + incl_pred: bool = True, + incl_fit: bool = True, + incl_disp: bool = True, + incl_amp: bool = True, + c_scores: str = "red", + c_fit: str = "black", + fontsize: int = 12, + ax: Optional[plt.Axes] = None, +) -> Tuple[plt.Figure, plt.Axes]: + """ + Plot the SSM profile. + + Args: + scores (np.ndarray): Array of scores for each scale. + angles (np.ndarray): Array of angles for each scale. + amplitude (float): Amplitude of the cosine function. + displacement (float): Displacement of the cosine function. + elevation (float): Elevation of the cosine function. + r2 (float): R-squared value for the fit. + title (str): Title of the plot. + reorder_scales (bool): Whether to reorder scales based on angles. + incl_pred (bool): Whether to include the predicted fit line. + incl_fit (bool): Whether to include the R-squared value. + incl_disp (bool): Whether to include the displacement line. + incl_amp (bool): Whether to include the amplitude line. + c_scores (str): Color for the score points. + c_fit (str): Color for the fit line. + fontsize (int): Base font size for the plot. + ax (Optional[plt.Axes]): Existing axes to plot on. If None, creates new figure and axes. + + Returns: + Tuple[plt.Figure, plt.Axes]: A tuple containing the figure and axis objects. + """ + if ax is None: + fig, ax = plt.subplots(figsize=(10, 5)) + else: + fig = ax.get_figure() + + assert len(scores) == len(angles), "Scores and angles must be the same length." + assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." + assert 0 <= r2 <= 1, "R2 must be between 0 and 1." + assert 0 <= amplitude, "Amplitude must be a positive number." + assert 0 <= displacement <= 360, "Displacement must be between 0 and 360." + + if reorder_scales: + angles, scores = sort_angles(angles, scores) + if angles[-1] == 360: + angles = (0,) + angles + scores = (scores[-1],) + scores + + if incl_pred: + thetas = np.linspace(0, 360, 1000) + fit = cosine_form(np.deg2rad(thetas), amplitude, displacement, elevation) + ax.plot(thetas, fit, color=c_fit) + + ax.plot(angles, scores, color=c_scores, marker="o") + + if incl_disp: + ax.axvline(displacement, color="black", linestyle="--") + ax.text( + displacement + 5, elevation, f"d = {int(displacement)}", fontsize=fontsize + ) + + if incl_amp: + ax.axhline(amplitude + elevation, color="black", linestyle="--") + ax.text( + 0, amplitude + elevation * 0.9, f"a = {amplitude:.2f}", fontsize=fontsize + ) + + if incl_fit: + ax.text(0, elevation * 0.5, f"R2 = {r2:.2f}", fontsize=fontsize) + + ax.set_xticks(OCTANTS) + ax.set_xticklabels( + ["0", "45", "90", "135", "180", "225", "270", "315"], fontsize=fontsize + ) + ax.set_xlabel("Angle [deg]", fontsize=fontsize + 2) + ax.set_ylabel("Score", fontsize=fontsize + 2) + ax.set_title(title, fontsize=fontsize + 4) + + plt.tight_layout() + return fig, ax From 77ba1653e94aa6d1e735ca84758c10c78f302b9e Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Tue, 9 Jul 2024 12:19:33 +0100 Subject: [PATCH 08/97] fix bug in profile plot --- src/circumplex/core/visualization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/circumplex/core/visualization.py b/src/circumplex/core/visualization.py index 0e4b39f..76aa0ae 100644 --- a/src/circumplex/core/visualization.py +++ b/src/circumplex/core/visualization.py @@ -374,7 +374,7 @@ def ssm_plot_profile( if incl_pred: thetas = np.linspace(0, 360, 1000) - fit = cosine_form(np.deg2rad(thetas), amplitude, displacement, elevation) + fit = cosine_form(np.deg2rad(thetas), amplitude, np.deg2rad(displacement), elevation) ax.plot(thetas, fit, color=c_fit) ax.plot(angles, scores, color=c_scores, marker="o") From 88d852d36281018526fbf716a7395b2bb11681f9 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Tue, 9 Jul 2024 12:22:46 +0100 Subject: [PATCH 09/97] add option for elevation hline --- src/circumplex/core/ssm_results.py | 2 +- src/circumplex/core/visualization.py | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/core/ssm_results.py index f23e8bf..66a5441 100644 --- a/src/circumplex/core/ssm_results.py +++ b/src/circumplex/core/ssm_results.py @@ -79,8 +79,8 @@ def profile_plot(self, **kwargs): displacement=row["d_est"], elevation=row["e_est"], r2=row["fit_est"], - ax=ax, title=f"{scores.iloc[i].values[-1]} Profile", + ax=ax, **kwargs, ) return fig, axes diff --git a/src/circumplex/core/visualization.py b/src/circumplex/core/visualization.py index 76aa0ae..fc2f23d 100644 --- a/src/circumplex/core/visualization.py +++ b/src/circumplex/core/visualization.py @@ -326,6 +326,7 @@ def ssm_plot_profile( incl_fit: bool = True, incl_disp: bool = True, incl_amp: bool = True, + incl_elev: bool = False, c_scores: str = "red", c_fit: str = "black", fontsize: int = 12, @@ -335,6 +336,7 @@ def ssm_plot_profile( Plot the SSM profile. Args: + incl_elev: scores (np.ndarray): Array of scores for each scale. angles (np.ndarray): Array of angles for each scale. amplitude (float): Amplitude of the cosine function. @@ -374,7 +376,9 @@ def ssm_plot_profile( if incl_pred: thetas = np.linspace(0, 360, 1000) - fit = cosine_form(np.deg2rad(thetas), amplitude, np.deg2rad(displacement), elevation) + fit = cosine_form( + np.deg2rad(thetas), amplitude, np.deg2rad(displacement), elevation + ) ax.plot(thetas, fit, color=c_fit) ax.plot(angles, scores, color=c_scores, marker="o") @@ -394,6 +398,10 @@ def ssm_plot_profile( if incl_fit: ax.text(0, elevation * 0.5, f"R2 = {r2:.2f}", fontsize=fontsize) + if incl_elev: + ax.axhline(elevation, color="black", linestyle="--") + ax.text(0, elevation, f"e = {elevation:.2f}", fontsize=fontsize) + ax.set_xticks(OCTANTS) ax.set_xticklabels( ["0", "45", "90", "135", "180", "225", "270", "315"], fontsize=fontsize From 35d69cbb418ed9a353f54fd9006ff597c284a342 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Tue, 9 Jul 2024 12:25:32 +0100 Subject: [PATCH 10/97] rename profile plot function --- src/circumplex/core/ssm_analysis.py | 5 ++--- src/circumplex/core/ssm_results.py | 4 ++-- src/circumplex/core/visualization.py | 2 +- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/core/ssm_analysis.py index f0335c1..1bbb71d 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/core/ssm_analysis.py @@ -659,7 +659,6 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: ######## SCRATCH ######## from importlib.resources import files import matplotlib.pyplot as plt - from visualization import ssm_plot, ssm_plot_profile _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) data = pd.read_csv(_jz2017_path) @@ -668,7 +667,7 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], angles=[90, 135, 180, 225, 270, 315, 0, 45], - grouping="Gender", + # grouping="Gender", # contrast='model', measures=["NARPD", "ASPD"], # measures_labels=['Narcissistic PD', 'Antisocial PD'], @@ -678,5 +677,5 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: print(results.summary()) # fig = ssm_plot(results) - fig, ax = results.profile_plot() + fig, ax = results.profile_plot(incl_elev=True) plt.show() diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/core/ssm_results.py index 66a5441..98ce4d1 100644 --- a/src/circumplex/core/ssm_results.py +++ b/src/circumplex/core/ssm_results.py @@ -2,7 +2,7 @@ from typing import Dict, Any from matplotlib import pyplot as plt -from circumplex.core.visualization import ssm_plot_profile +from circumplex.core.visualization import ssm_profile_plot class SSMResults: @@ -72,7 +72,7 @@ def profile_plot(self, **kwargs): axes = [axes] for i, (ax, (_, row)) in enumerate(zip(axes, results.iterrows())): - fig, ax = ssm_plot_profile( + fig, ax = ssm_profile_plot( scores=scores.iloc[i].values[:-3], angles=details["angles"], amplitude=row["a_est"], diff --git a/src/circumplex/core/visualization.py b/src/circumplex/core/visualization.py index fc2f23d..d63f649 100644 --- a/src/circumplex/core/visualization.py +++ b/src/circumplex/core/visualization.py @@ -313,7 +313,7 @@ def ssm_plot_contrast( return fig -def ssm_plot_profile( +def ssm_profile_plot( scores: np.ndarray, angles: np.ndarray, amplitude: float, From eafb9678d897541b195b352093c23c0593f6e5e7 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Thu, 11 Jul 2024 11:24:54 +0100 Subject: [PATCH 11/97] restructure whole module --- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 356 ++++++++++++-- docs/tutorials/Random_exs.ipynb | 44 +- src/circumplex/__init__.py | 18 +- src/circumplex/circumplex.py | 527 --------------------- src/circumplex/core/__init__.py | 3 - src/circumplex/core/instrument.py | 3 +- src/circumplex/core/utils.py | 38 -- src/circumplex/datasets.py | 4 +- src/circumplex/instrument.py | 7 +- src/circumplex/{core => }/ssm_analysis.py | 70 +-- src/circumplex/{core => }/ssm_results.py | 20 +- src/circumplex/utils.py | 65 +-- src/circumplex/{core => }/visualization.py | 38 +- 13 files changed, 471 insertions(+), 722 deletions(-) delete mode 100644 src/circumplex/circumplex.py delete mode 100644 src/circumplex/core/utils.py rename src/circumplex/{core => }/ssm_analysis.py (94%) rename src/circumplex/{core => }/ssm_results.py (88%) rename src/circumplex/{core => }/visualization.py (93%) diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index 8547510..866fb47 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -20,8 +20,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-06-08T12:09:56.081220Z", - "start_time": "2024-06-08T12:09:56.076995Z" + "end_time": "2024-07-11T10:13:24.397218Z", + "start_time": "2024-07-11T10:13:23.642241Z" } }, "source": [ @@ -29,10 +29,11 @@ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", "degree_sign = u'\\N{DEGREE SIGN}'" ], - "execution_count": 30, - "outputs": [] + "outputs": [], + "execution_count": 1 }, { "cell_type": "markdown", @@ -81,13 +82,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:09:57.004186Z", - "start_time": "2024-06-08T12:09:56.747142Z" + "end_time": "2024-07-11T10:13:24.510307Z", + "start_time": "2024-07-11T10:13:24.398223Z" } }, "id": "b2b2c99827c47a27", - "execution_count": 31, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 }, { "cell_type": "markdown", @@ -108,9 +120,9 @@ "import matplotlib.pyplot as plt\n", "\n", "jz_data = JZ2017\n", - "r = jz_data.ssm_analyse(measures = [\"NARPD\"])\n", + "r = circumplex.ssm_analyze(jz_data.data, jz_data.scales.abbrev, measures = [\"NARPD\"])\n", "plt.figure(figsize=(8, 5))\n", - "plt.bar(r.results[0].scores.index, r.results[0].scores.values, color='red')\n", + "plt.bar(r.scales, r.scores[r.scales].values[0], color='red')\n", "plt.ylim(0, 0.5)\n", "plt.ylabel(\"Score\")\n", "plt.xlabel(\"Scale\")\n", @@ -121,13 +133,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:09:57.823770Z", - "start_time": "2024-06-08T12:09:57.670974Z" + "end_time": "2024-07-11T10:13:27.097333Z", + "start_time": "2024-07-11T10:13:24.512490Z" } }, "id": "21f5a12726008489", - "execution_count": 32, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 }, { "cell_type": "markdown", @@ -142,9 +165,9 @@ { "cell_type": "code", "source": [ - "fig, ax = circumplex.profile_plot(r.results[0].amplitude, r.results[0].displacement, r.results[0].elevation, r.results[0].r2, r.results[0].angles, r.results[0].scores, r.results[0].label, incl_amp=False, incl_disp=False, incl_pred=False, incl_fit=False, reorder_scales=True);\n", + "fig, ax = r.profile_plot(incl_amp=False, incl_disp=False, incl_pred=False, incl_fit=False, reorder_scales=True)\n", "\n", - "ax.grid(True)\n", + "ax[0].grid(True)\n", "plt.ylim(0, 0.5)\n", "plt.xlabel(\"Angle\")\n", "plt.title(\"Scores by Angle\")\n", @@ -153,13 +176,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:09:59.239947Z", - "start_time": "2024-06-08T12:09:59.105765Z" + "end_time": "2024-07-11T10:13:27.163979Z", + "start_time": "2024-07-11T10:13:27.098006Z" } }, "id": "c90c1bcb4a07781b", - "execution_count": 33, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGECAYAAAA4IlRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABbd0lEQVR4nO3deZyN5f/H8deZ3ZB1GIxlLGXfskU0ZGzZt6REEt+U8B2lJMZStAgVUiK+TEUSbSZMtphsodVW9l0yMwaz3r8/7t8Mx5xhjJm5z5l5Px+P83DmPte5z+dc3aa3+77u67IZhmEgIiIikse5WV2AiIiIiDNQKBIRERFBoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhHJA2w2G0OHDrW6jGwXGBjIE088YXUZIi5LoUgkD/r111/p2bMn5cuXx8fHh4CAAFq3bs17771ndWm5wnfffYfNZqN06dIkJydbXY6IZJBCkUges2XLFho0aMCePXsYNGgQM2fO5KmnnsLNzY133nnH6vJyhbCwMAIDAzl16hQ//PCD1eWISAZ5WF2AiOSs1157jUKFCrF9+3YKFy5s99rZs2dztJbLly/j6+ubo5+Z3WJjY1m5ciVTpkzh448/JiwsjODgYKvLEpEM0JkikTzmr7/+okaNGmkCEUCJEiXSbFu8eDGNGjXC19eXIkWK8MADD7B69Wq7NrNnz6ZGjRp4e3tTunRpnn32WS5evGjXpkWLFtSsWZOdO3fywAMP4Ovry8svvwxAXFwcoaGhVK5cGW9vb8qWLcuoUaOIi4uz28eaNWto1qwZhQsXpkCBAlSpUiV1HxkRFhZGlSpV8PHxoX79+mzcuDH1tXXr1mGz2fjyyy/TvO+TTz7BZrMRGRl5y8/48ssvuXLlCr169eKRRx5h+fLlXL16NU27lHFOK1asoGbNmnh7e1OjRg3Cw8PTtF2/fj0NGjTAx8eHSpUq8cEHHzB+/HhsNtst67l48SIjRoygbNmyeHt7U7lyZd544w1d1hNxwGYYhmF1ESKSc9q2bUtkZCRbtmyhZs2aN207YcIExo8fT9OmTenWrRteXl5s3bqVsmXL8vrrrwMwfvx4JkyYQHBwMF26dGHfvn28//773HvvvWzevBlPT0/ADEX79u0jKSmJRx55hJo1a+Lv70+nTp1o3749P/74I4MHD6ZatWr8+uuvzJkzhw4dOrBixQoAfv/9d+69915q167N448/jre3NwcPHmTbtm1s2LDhpt/DZrNRs2ZNTp8+zbBhw/D29mb27NmcPXuWbdu2UbNmTQzDoHz58jRq1Ihly5bZvb9Dhw7s27ePgwcP3rJ/27dvT0JCAmvXruXo0aMEBgayZMkSevXqlaamOnXqcPbsWZ555hnuuusu3n33XU6fPs3Ro0cpVqwYALt27aJJkyaUKlWKp59+mqSkJGbNmkXx4sXZs2cP1/8KDwwMpEWLFixYsAAwz8Q1adKEEydO8J///Idy5cqxZcsWFi1axLBhw5gxY8Ytv49InmKISJ6yevVqw93d3XB3dzeaNGlijBo1yvj++++N+Ph4u3YHDhww3NzcjG7duhlJSUl2ryUnJxuGYRhnz541vLy8jDZt2ti1mTlzpgEY8+fPT90WFBRkAMacOXPs9rVo0SLDzc3N2LRpk932OXPmGICxefNmwzAMY/r06QZgnDt37ra/M2AAxo4dO1K3HTlyxPDx8TG6deuWum306NGGt7e3cfHixdRtZ8+eNTw8PIzQ0NBbfs6ZM2cMDw8PY+7cuanbmjZtanTp0sVhTV5eXsbBgwdTt+3Zs8cAjPfeey91W6dOnQxfX1/jxIkTqdsOHDhgeHh4GDf+Ci9fvrzRv3//1J8nTZpk5M+f39i/f79du5deeslwd3c3jh49esvvJJKX6PKZSB7TunVrIiMj6dy5M3v27OHNN9+kbdu2BAQE8NVXX6W2W7FiBcnJyYwbNw43N/tfFSmXbdauXUt8fDwjRoywazNo0CAKFizIt99+a/c+b29vBgwYYLft888/p1q1alStWpXz58+nPh588EHAvKwFpF7uW7lyZaYu/TRp0oT69eun/lyuXDm6dOnC999/T1JSEgD9+vUjLi7O7kzRkiVLSExMpG/fvrf8jM8++ww3Nzd69OiRuq1Pnz6sWrWKf//9N0374OBgKlWqlPpz7dq1KViwIH///TcASUlJrF27lq5du1K6dOnUdpUrV6Z9+/a3rOfzzz+nefPmFClSxK5vg4ODSUpKsrt8KCIaUySSJzVs2JDly5fz77//sm3bNkaPHk1MTAw9e/bkjz/+AMyxR25ublSvXj3d/Rw5cgSAKlWq2G338vKiYsWKqa+nCAgIwMvLy27bgQMH+P333ylevLjd45577gGuDf7u3bs3999/P0899RT+/v488sgjLF26NMMB6e67706z7Z577uHy5cucO3cOgKpVq9KwYUPCwsJS24SFhXHfffdRuXLlW35Gyvirf/75h4MHD3Lw4EHq1atHfHw8n3/+eZr25cqVS7OtSJEiqQHq7NmzXLlyxeFnZ6SeAwcOEB4enqZvUwZ+5/TAehFnp7vPRPIwLy8vGjZsSMOGDbnnnnsYMGAAn3/+OaGhodnyefny5UuzLTk5mVq1ajFt2jSH7ylbtmzqezdu3Mi6dev49ttvCQ8PZ8mSJTz44IOsXr0ad3f3LKmxX79+DB8+nOPHjxMXF8dPP/3EzJkzb/m+AwcOsH37dsBxAAsLC2Pw4MF229Kr2ciioZ7Jycm0bt2aUaNGOXw9JXiKiEmhSEQAaNCgAQCnTp0CoFKlSiQnJ/PHH39Qt25dh+8pX748APv27aNixYqp2+Pj4zl06FCGbkWvVKkSe/bsoVWrVre8m8rNzY1WrVrRqlUrpk2bxuTJkxkzZgzr1q275WcdOHAgzbb9+/fj6+tL8eLFU7c98sgjhISE8Omnn3LlyhU8PT3p3bv3Lb9HWFgYnp6eLFq0KE3Y+fHHH3n33Xc5evSow7ND6SlRogQ+Pj4OB3hnZNB3pUqVuHTpkqYEEMkgXT4TyWPWrVvn8EzEd999B1y7FNa1a1fc3NyYOHFimktUKe8PDg7Gy8uLd999126f8+bNIyoqig4dOtyynocffpgTJ04wd+7cNK9duXKF2NhYAC5cuJDm9ZSwduOt+45ERkby888/p/587NgxVq5cSZs2bexCjJ+fH+3bt2fx4sWEhYXRrl07/Pz8brn/sLAwmjdvTu/evenZs6fd44UXXgDg008/veV+rufu7k5wcDArVqzg5MmTqdsPHjzIqlWrbvn+hx9+mMjISL7//vs0r128eJHExMTbqkckt9OZIpE85rnnnuPy5ct069aNqlWrEh8fz5YtW1iyZAmBgYGpA6ErV67MmDFjmDRpEs2bN6d79+54e3uzfft2SpcuzZQpUyhevDijR49mwoQJtGvXjs6dO7Nv3z5mz55Nw4YNMzQ4+fHHH2fp0qU8/fTTrFu3jvvvv5+kpCT27t3L0qVL+f7772nQoAETJ05k48aNdOjQgfLly3P27Flmz55NmTJlaNas2S0/p2bNmrRt29bulnwwpx24Ub9+/ejZsycAkyZNuuW+t27dysGDB9NdXy0gIIB7772XsLAwXnzxxVvu73rjx49n9erV3H///QwZMoSkpCRmzpxJzZo12b17903f+8ILL/DVV1/RsWNHnnjiCerXr09sbCy//vory5Yt4/DhwxkKfCJ5hrU3v4lITlu1apXx5JNPGlWrVjUKFChgeHl5GZUrVzaee+4548yZM2naz58/36hXr57h7e1tFClSxAgKCjLWrFlj12bmzJlG1apVDU9PT8Pf398YMmSI8e+//9q1CQoKMmrUqOGwpvj4eOONN94watSokfo59evXNyZMmGBERUUZhmEYERERRpcuXYzSpUsbXl5eRunSpY0+ffqkud3cEcB49tlnjcWLFxt333234e3tbdSrV89Yt26dw/ZxcXFGkSJFjEKFChlXrly55f6fe+45AzD++uuvdNuMHz/eAIw9e/bY1XSjG2+rNwzzu9erV8/w8vIyKlWqZHz00UfGyJEjDR8fn1u+NyYmxhg9erRRuXJlw8vLy/Dz8zOaNm1qTJ06Nc00DCJ5nSZvFBG5QWJiIqVLl6ZTp07MmzfP6nIc6tq1K7///rvDsVIikjkaUyQicoMVK1Zw7tw5+vXrZ3UpgDm26noHDhzgu+++o0WLFtYUJJJL6UyRiMj/27p1K7/88guTJk3Cz8/PbmC2lUqVKsUTTzyROvfT+++/T1xcHLt27XJ4+7+IZI4GWouI/L/333+fxYsXU7du3dT1w5xBu3bt+PTTTzl9+jTe3t40adKEyZMnKxCJZDGnPVM0a9Ys3nrrLU6fPk2dOnV47733aNSokcO2CxYsSLN0gLe3t8OVqUVEREQcccoxRUuWLCEkJITQ0FB+/vln6tSpQ9u2bW86JX3BggU5depU6uPG5QVEREREbsYpQ9G0adMYNGgQAwYMoHr16syZMwdfX1/mz5+f7ntsNhslS5ZMffj7++dgxSIiIuLqnG5MUXx8PDt37mT06NGp29zc3AgODiYyMjLd9126dIny5cuTnJzMvffey+TJk6lRo4bDtnFxcXYz4CYnJ3PhwgWKFSt2y2UGRERExHUYhkFMTAylS5fGze3m54KcLhSdP3+epKSkNGd6/P392bt3r8P3VKlShfnz51O7dm2ioqKYOnUqTZs25ffff6dMmTJp2k+ZMsXhLLYiIiKSOx07dsxhJrie04WizGjSpAlNmjRJ/blp06ZUq1aNDz74wOEU/aNHjyYkJCT156ioKMqVK8ehQ4e46667srS2hIQE1q1bR8uWLfH09MzSfbsS9YP6IIX6waR+UB+kUD9kbx/ExMRQoUKFDP3/3elCkZ+fH+7u7pw5c8Zu+5kzZyhZsmSG9uHp6Um9evXSXUXa29sbb2/vNNuLFi1KwYIFb7/om0hISMDX15dixYrl2YMd1A+gPkihfjCpH9QHKdQP2dsHKfvLyPAYpxto7eXlRf369YmIiEjdlpycTEREhN3ZoJtJSkri119/pVSpUtlVpoiIiOQyTnemCCAkJIT+/fvToEEDGjVqxIwZM4iNjU2di6hfv34EBAQwZcoUACZOnMh9991H5cqVuXjxIm+99RZHjhzhqaeesvJriIiIiAtxylDUu3dvzp07x7hx4zh9+jR169YlPDw8dfD10aNH7UaQ//vvvwwaNIjTp09TpEgR6tevz5YtW6hevbpVX0FERERcjFOGIoChQ4cydOhQh6+tX7/e7ufp06czffr0HKhKREREciunG1MkIiIiYgWFIhEREREUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhaLslZSEbcMGAjZuxLZhAyQlWV2RiIiIpMNpQ9GsWbMIDAzEx8eHxo0bs23btgy977PPPsNms9G1a9fsLfBWli+HwEA8WremwbRpeLRuDYGB5nYRERFxOk4ZipYsWUJISAihoaH8/PPP1KlTh7Zt23L27Nmbvu/w4cM8//zzNG/ePIcqTcfy5dCzJxw/br/9xAlzu4KRiIiI03HKUDRt2jQGDRrEgAEDqF69OnPmzMHX15f58+en+56kpCQee+wxJkyYQMWKFXOw2jSFwPDhYBhpX0vZNmKELqWJiIg4GQ+rC7hRfHw8O3fuZPTo0anb3NzcCA4OJjIyMt33TZw4kRIlSjBw4EA2bdp008+Ii4sjLi4u9efo6GgAEhISSEhIuKP6bRs24HHjGaLrGQYcO0biZ59h9OgB7u539HmuIqVf77R/XZn6wKR+MKkf1Acp1A/Z2we3s0+nC0Xnz58nKSkJf39/u+3+/v7s3bvX4Xt+/PFH5s2bx+7duzP0GVOmTGHChAlptq9evRpfX9/brvl6ARs30iAD7Tz69iW5f3+u+PlxuUQJ8+Hvf+15iRJcLVoU3JzyZF6mrVmzxuoSLKc+MKkfTOoH9UEK9UP29MHly5cz3NbpQtHtiomJ4fHHH2fu3Ln4+fll6D2jR48mJCQk9efo6GjKli1LmzZtKFiw4B3VY8ufH6ZNu2U7w80Nt6Qk8p85Q/4zZxy38fKCcuUwypeHwECM8uXN5xUqmH/6+7tMaEpISGDNmjW0bt0aT09Pq8uxhPrApH4wqR/UBynUD9nbBylXgzLC6UKRn58f7u7unLkhKJw5c4aSJUumaf/XX39x+PBhOnXqlLotOTkZAA8PD/bt20elSpXs3uPt7Y23t3eafXl6et75f4yWLaFMGXNQtaNxRTYblCmD7eBBOHMGDh+GQ4fMP1Mehw7BsWPY4uPh4EGzrSPe3uYdbSmPChXsnxcvbn6eE8mSPnZx6gOT+sGkflAfpFA/ZE8f3M7+nC4UeXl5Ub9+fSIiIlJvq09OTiYiIoKhQ4emaV+1alV+/fVXu22vvPIKMTExvPPOO5QtWzYnyr7G3R3eece8y8xmsw9GKQFlxgzw8oKyZc2Ho7vlEhPNYHV9YLr++fHjEBcH+/aZD0fy5XMcllKeFyvmdKFJRETEKk4XigBCQkLo378/DRo0oFGjRsyYMYPY2FgGDBgAQL9+/QgICGDKlCn4+PhQs2ZNu/cXLlwYIM32HNO9OyxbZt6Fdv2g6zJlzEDUvfut9+HhAeXLmw9H4uPNfTsKTIcOwcmTcOUK/Pmn+XCkQIGbn2kqXDhrQtP1k1jmz2+eTcsjA8xFRMR1OGUo6t27N+fOnWPcuHGcPn2aunXrEh4enjr4+ujRo7g5+1ia7t2hSxcS161j96pV1G3fHo+sDANeXlCxovlwJC4Ojh1L/0zTqVNw6RL89pv5cKRgwZufaSpU6NZ1Ll8Ow4fjcfy4OQB92jQzHL7zTsbCoYiISA5xylAEMHToUIeXywDWr19/0/cuWLAg6wvKDHd3jKAgTsTGUicoKGfPjnh7Q+XK5sORq1fhyJH0zzSdPQvR0fDLL+bDkSJF0j/LFBgIq1eblxFvHFuVMonlsmUKRiIi4jScNhRJNvPxgSpVzIcjly+boSm9M03nz8O//5qPXbsc78PNLf1JLG02cxLLLl10KU1ERJyCQpE45usL1aqZD0diYm5+punff+H/7wJ06P8nsWTTJmjRIsvLFxERuV0KRZI5d90FNWuaD0fmzYOnnrr1fk6dytq6REREMsnJRyuLy7phbqh0lSqVvXWIiIhkkEKRZI/mzc27zG52S396czSJiIhYQKFIskfKJJaQfjAaO1aDrEVExGkoFEn2SZnEMiDAfnvKlOthYZCUlPN1iYiIOKBQJNmre3c4fJjENWvYERJC4po15rxHBQrAhg0waZLVFYqIiAAKRZITUiaxfOABjKAgqFoVPvjAfG3SJLjFZJwiIiI5QaFIrPHoo/Dkk+ZcRo8+CufOWV2RiIjkcQpFYp133zUnhzx1Cvr3v/lkjyIiItlMoUiskz8/LF1qLjmyahW8/bbVFYmISB6mUCTWqlnz2q37L78MP/1kbT0iIpJnKRSJ9QYNgocfhsRE6NMHLl60uiIREcmDFIrEejYbfPghVKxoLij71FPmgrEiIiI5SKFInEOhQrBkiTmx4xdfwJw5VlckIiJ5jEKROI8GDeCNN8zn//0v7NljbT0iIpKnKBSJcxkxAjp2hLg46N0bLl2yuiIREckjFIrEudhs8PHH5npp+/bBs89aXZGIiOQRCkXifPz84NNPwc0N/vc/8yEiIpLNFIrEOTVvDuPHm8+fecY8ayQiIpKNFIrEeb38Mjz4IMTGmvMYXb1qdUUiIpKLKRSJ83J3h8WLoXhx+OUXGDnS6opERCQXUygS51aqFCxaZD6fPducw0hERCQbKBSJ82vbFl580Xw+cCAcOmRtPSIikispFIlrmDQJmjSBqChzfbSEBKsrEhGRXEahSFyDp6d5m37hwrB1K4wZY3VFIiKSyygUiesoXx7mzTOfv/UWrFplbT0iIpKrKBSJa+neHYYONZ/36wcnT1pbj4iI5BoKReJ63noL6taF8+ehb19ISrK6IhERyQUUisT1+PjAkiWQPz+sWwevvWZ1RSIikgsoFIlruucemDPHfD5hAmzYYG09IiLi8hSKxHX17QtPPAHJyfDoo3DunNUViYiIC1MoEtc2cyZUrWoOuE4JSCIiIpmgUCSuLX9+c3yRtzd89x1Mn251RSIi4qIUisT11a4N77xjPn/pJdi2zdp6RETEJSkUSe4weDD06gWJifDII3DxotUViYiIi1EoktzBZoO5c6FCBXPB2EGDwDCsrkpERFyIQpHkHoUKwWefgYcHLFsGH3xgdUUiIuJCFIokd2nUCF5/3Xw+YgT88oul5YiIiOtQKJLc57//hYcegrg46N0bYmOtrkhERFyAQpHkPm5usHAhlC4Ne/deW0BWRETkJhSKJHfy84NPPjED0oIFsHix1RWJiIiTUyiS3CsoCEJDzedPPw3791tbj4iIODWFIsndxoyBli3NcUUPPwxXr1pdkYiIOCmFIsnd3N3NS2fFi8OePfD881ZXJCIiTkqhSHK/0qXhf/8zn8+aBcuXW1uPiIg4JacNRbNmzSIwMBAfHx8aN27MtpusZ7V8+XIaNGhA4cKFyZ8/P3Xr1mXRokU5WK04vXbt4IUXzOcDB8Lhw5aWIyIi/y8pCduGDQRs3IhtwwZISrKsFKcMRUuWLCEkJITQ0FB+/vln6tSpQ9u2bTl79qzD9kWLFmXMmDFERkbyyy+/MGDAAAYMGMD333+fw5WLU3vtNWjc2FwXrU8fSEiwuiIRkbxt+XIIDMSjdWsaTJuGR+vWEBho2Rl9pwxF06ZNY9CgQQwYMIDq1aszZ84cfH19mT9/vsP2LVq0oFu3blSrVo1KlSoxfPhwateuzY8//pjDlYtT8/Q0lwEpVAh++gnGjrW6IhGRvGv5cujZE44ft99+4oS53YJg5HShKD4+np07dxIcHJy6zc3NjeDgYCIjI2/5fsMwiIiIYN++fTzwwAPZWaq4osBASAnXb7wBOpsoIpLzkpJg+HDHC3enbBsxIscvpXnk6KdlwPnz50lKSsLf399uu7+/P3v37k33fVFRUQQEBBAXF4e7uzuzZ8+mdevWDtvGxcURFxeX+nN0dDQACQkJJGTxJZWU/WX1fl2NU/VDp064Pf007nPmYDz+OInbt5uDsbOZU/WBhdQPJvWD+iBFXuwH24YNeNx4huh6hgHHjpG4bh1GUNAdfdbt9KvThaLMuuuuu9i9ezeXLl0iIiKCkJAQKlasSIsWLdK0nTJlChMmTEizffXq1fj6+mZLfWvWrMmW/boaZ+kHtwcf5IHwcAodPszFTp3YMn68eft+DnCWPrCa+sGkflAfpMhL/RCwcSMNMtBu96pVnLjD9SsvX76c4bY2w3B07so68fHx+Pr6smzZMrp27Zq6vX///ly8eJGVK1dmaD9PPfUUx44dczjY2tGZorJly3L+/HkKFix4x9/hegkJCaxZs4bWrVvj6emZpft2JU7ZD/v24XHffdhiY0kKDSV5zJhs/Tin7AMLqB9M6gf1QYq82A+2DRvMQdW3kLhmzR2fKYqOjsbPz4+oqKhb/j/e6c4UeXl5Ub9+fSIiIlJDUXJyMhEREQy9jYU9k5OT7YLP9by9vfH29k6z3dPTM9sOyOzctytxqn6oWRNmz4b+/XGfNAn3Bx+EHBiH5lR9YCH1g0n9oD5Ikaf6oWVLKFMm7SDrFDYblCmDR8uWd3wW/3b61OkGWgOEhIQwd+5cFi5cyJ9//smQIUOIjY1lwIABAPTr14/Ro0entp8yZQpr1qzh77//5s8//+Ttt99m0aJF9O3b16qvIK6iXz/zkZwMjz4K589bXZGISO7n7g7Tpjl+zWYz/5wxI8eGNaRwujNFAL179+bcuXOMGzeO06dPU7duXcLDw1MHXx89ehQ3t2t5LjY2lmeeeYbjx4+TL18+qlatyuLFi+ndu7dVX0FcyaxZsHUr7NsHTzwBX3997S+liIhkj5SxPjab/V1oZcqYgah79xwv6Y5D0Zdffsmnn37K3r17uXz5MgcPHgRg7969fPXVVzz22GMEBATc9n6HDh2a7uWy9evX2/386quv8uqrr972Z4gAUKAALF0KjRrBt9/C9OkQEmJ1VSIiuVd8PKTc8DR5MokNGrB71Srqtm+fJZfMMivToSg5OZk+ffqwbNkyAPLly8eVK1dSXy9SpAhjxowhKSnJ7lKXiFOqXdsMQ888Ay+9BM2bQ8OGVlclIpI7ffwxHDoE/v4wbBiGpycnYmOpExRkWSCCOxhTNH36dD7//HP+85//8O+///L8DauP+/v707x5c7799ts7LlIkRzz9NPToYS7/0bs3REVZXZGISO5z9SpMmmQ+HzMGsmkqnMzIdChasGABDRs2ZPbs2RQsWBCbgzEYlStX5tChQ3dUoEiOsdngo4/MWa8PHYLBgx3PtioiIpk3Z465lEfZsubvWSeS6VB08OBBmjdvftM2xYoV459//snsR4jkvMKFzfXRPDzMcUZz51pdkYhI7nHpEkyZYj4fOxYcTI9jpUyHonz58hF1i8sLR44coXDhwpn9CBFrNG4Mkyebz4cPh19/tbYeEZHcYuZMOHsWKlUy7/Z1MpkORfXq1eP777/n6tWrDl+/cOEC4eHh3HfffZkuTsQyI0dC+/bmte/eveEOp5kXEcnzLl6EN980n48fD044UWWmQ9GwYcM4fvw4PXr04PgNM1L+9ddfdOvWjaioKIYNG3bHRYrkODc3WLjQXCj2zz/hueesrkhExLVNnw7//gvVqkGfPlZX41Cmb8nv0qULL774Im+88Qbly5cnf/78AJQoUYJ//vkHwzAYO3YsDz74YJYVK5KjiheHsDBo1cq8fbRVK3jsMaurEhFxPefPm6EIYOJES2+7v5k7WuZjypQpfP/993Ts2BFfX1/c3d1JTk6mXbt2rFq1yuFK9CIupUULczAgmLfsHzhgaTkiIi7prbcgJgbq1bNkpuqMyvSZoqNHj+Ll5UXr1q1pnYGVbkVc1tixsH49bNhgji+KjHS6OyZERJzWqVPw3nvm80mTzOEJTirTlVWoUIGXX345K2sRcU7u7uZlND8/2LULXnjB6opERFzHlClw5Qrcdx889JDV1dxUpkNRkSJFKFasWFbWIuK8AgLMgddg/otnxQpLyxERcQlHj8IHH5jPX33V6RfbznQoat68OVu3bs3KWkSc20MPQcpyNgMGwJEj1tYjIuLsXn3VXPy1ZUvzZhUnl+lQNGXKFH755RcmTpxIYmJiVtYk4rxeew0aNTLn2+jTx1wnTURE0jp4EObPN5+nrHXm5DI90PrNN9+kVq1aTJgwgQ8++IA6derg7++fZg00m83GvHnz7rhQEafg5WUuA1Kvnjngety4a1PWi4jINRMmQFKSORHu/fdbXU2GZDoULViwIPX5qVOnOHXqlMN2CkWS61SoYC4c26sXvP66eVq4TRurqxIRcR5//GHeoAIuc5YI7iAUHTp0KCvrEHEtPXua8xbNmQOPPw579kDJklZXJSLiHEJDwTDMOYnq17e6mgzLdCgqX758VtYh4nqmTYMtW+CXX6BvX/j+e6edpVVEJMfs2gXLlpl3mrnYJM7OO4OSiLPLlw+WLAFfX4iIMC+liYjkdSmrAPTpAzVrWlvLbbrjUBQWFkbr1q0pXrw43t7eFC9enDZt2vDJJ59kRX0izq1qVZg923w+bhxs2mRtPSIiVoqMhG+/Nc+ajx9vdTW3LdOhKCkpiR49etCvXz8iIiKIjY2ldOnSxMbGsnbtWh5//HF69OhBcnJyVtYr4nz69zfHFSUnw6OPwj//WF2RiIg1Us4SPfEE3H23paVkRqZD0bvvvsuXX37J/fffz+bNm7l8+TKHDh3i8uXLbNmyhWbNmrFixQreS1nvRCQ3mz0b7rkHjh83fxkYhtUViYjkrHXrzKEEnp7XwpGLyXQoWrhwIffccw8RERE0adLE7rX77ruPtWvXcs899/Dxxx/fcZEiTq9AAXN8kbc3fPMNvPOO1RWJiOQcw4BXXjGfDx4MLnozVqZD0f79++ncuTOenp4OX/f09KRTp07s378/08WJuJS6deHtt83no0bBjh2WliMikmPCw827cX18wIUXi890KPLy8iI2NvambWJjY/Hy8srsR4i4nmeegW7dzOU/HnkEoqOtrkhEJHtdf5Zo6FAoXdraeu5ApkNRvXr1WLp0KSdPnnT4+qlTp1i6dCn33ntvposTcTk2G8ybZ546/usv8zSyxheJSG62YgX8/LM5jGDUKKuruSOZDkUhISH8888/NGjQgLfffpsdO3Zw7NgxduzYwdSpU6lfvz4XLlwgJCQkK+sVcX5Fipjro3l4mOOMPvrI6opERLJHUtK1QdUjRkDx4paWc6cyPaN1p06dmDp1Ki+99BKjbkiGhmHg4eHB1KlT6dix4x0XKeJy7rsPXnsNXnwRhg2DRo2wnTtHwMaN2PLnN9dL0+zXIuLqliyB33+HwoVh5Eirq7ljmQ5FYJ4t6tq1K2FhYezevZvo6GgKFixIvXr1ePTRR6lYsWJW1Sniep5/Hn74wVz+o0EDPBITaQDm8iBlyph3qHXvbnWVIiKZk5hornEG8MILZjBycXcUigAqVqzIWBedj0AkW7m5Qe/eZihKTLR/7cQJc1HZZcsUjETENf3vf3DwIPj5mWfEcwGtfSaSXZKSzKU/HEkZfD1ihNlORMSVxMVdW+x19GhzkHUukOlQ9Pbbb+Pn55fu3WcnT56kePHivPvuu5kuTsSlbdpkznCdHsOAY8e0XpqIuJ6PPoKjR6FUKRgyxOpqskymQ9Hnn39OnTp1KJ3OfASlS5embt26fPbZZ5kuTsSlnTqVte1ERJzB5cvw6qvm81degXz5rK0nC2U6FB04cIAaNWrctE2NGjU4cOBAZj9CxLWVKpW17UREnMH778Pp0+Z8bE89ZXU1WSrToejKlSvkz5//pm18fHy4dOlSZj9CxLU1b27eZWazpd+mTBmznYiIK4iJgddfN5+HhkIuW7Ui06GoXLlybNmy5aZtIiMjKVOmTGY/QsS1ubtfWxg2vWBUtap5l5qIiCt45x04fx7uvhsef9zqarJcpn8bd+jQgR9//JH58+c7fP2jjz7ixx9/pFOnTpkuTsTlde9u3nYfEGC/3c/PDEpr15qTPIqIOLt//4WpU83nEyaYs/bnMpn+Ri+99BKffvopgwYNYvHixbRu3ZqAgABOnDjB6tWr2bhxI6VLl2b06NFZWa+I6+neHbp0IXHdOnavWkXd9u3xaNkS5swxF08cO9a8jPbEE1ZXKiKSvrffhqgoqFnTnIMtF8p0KCpevDjr1q2jb9++rF+/nvXr12Oz2TD+f/6Vhg0bEhYWRnEXXwdFJEu4u2MEBXEiNpY6QUHmpbVnnzVvyX/jDRg0yFxZuk0bqysVEUnr3DmYMcN8PmlSrr3sf0fnvqpUqcL27dvZvn0727ZtIyoqisKFC9OoUSMaNGiQVTWK5F6TJ5vB6JNPoEcPc86iunWtrkpExN7rr0NsLNSvD126WF1NtsmSC4INGzakYcOGJCYm8uuvvwKQkJCAp6dnVuxeJPdyc4P58825itatg/bt4aefzFtdRUScwYkTMHu2+fzVV29+R62Lu63zX4cOHWL+/Pns378/zWvffPMNAQEBNGjQgAYNGlCqVCmWLl2aZYWK5Fre3vDll1Crljn3R/v2cOGC1VWJiJgmT4arV6FZM2jb1upqstVthaK5c+cyaNAgvL297bYfPHiQhx9+mHPnzlGuXDmqVavGv//+y2OPPcauXbuytGCRXKlQIfjuO/MutT//hK5dzV9CIiJWOnwY5s41n+fys0Rwm6Hoxx9/pG7dupS/4dT+O++8w9WrV3n22Wc5dOgQv/32G1988QVJSUnMnDkzSwsWybXKlIFVq6BgQXNsUb9+kJxsdVUikpdNnAgJCRAcDEFBVleT7W778lmjRo3SbA8PD8fLy4vJkyenbuvatSvNmzdnkxa7FMm4WrVgxQrw9ITPP4fnn7e6IhHJq/bvh4ULzecpa53lcrcVis6dO4efn5/dtgsXLvDXX3/RuHFj7rrrLrvX6tWrx4kTJ+68SpG8pGVLWLDAfD59uvkQEclp48ebZ6s7dYLGja2uJkfcVijy9PTkn3/+sdu2c+dOAIe34N9qbTQRScejj5rzFwGMHGmeNRIRySm//gqffWY+nzjR2lpy0G2FonvuuYeIiAi7batXr8Zms9G0adM07U+ePEkprQAukjkvvGBO8GgY5hpDuhQtIjll3Djzd0+vXnlq7rTbCkU9evTgwIEDPP300/zyyy8sW7aMDz/8kAIFCtCuXbs07Tdv3kzlypUzVdisWbMIDAzEx8eHxo0bs23btnTbzp07l+bNm1OkSBGKFClCcHDwTduLuASbzVx8sWtXiIuDzp3hjz+srkpEcrsdO8yxjW5u5hpnechthaIRI0ZQq1YtPvzwQ+rVq0fv3r2JiYlhwoQJaS6V7dixg4MHD9K6devbLmrJkiWEhIQQGhrKzz//TJ06dWjbti1nz5512H79+vX06dOHdevWERkZSdmyZWnTpo3GM4nrc3c3Z7tu0gQuXjTnMDp50uqqRCQ3GzvW/LNvX6hWzdpacththSJfX182b97MhAkTaNeuHY899hgrV65kxIgRadr+/PPPdOnShc6dO992UdOmTWPQoEEMGDCA6tWrM2fOHHx9fZk/f77D9mFhYTzzzDPUrVuXqlWr8tFHH5GcnJzmUp+IS8qXD776Cu6+G44ehQ4dIDra6qpEJDf68UcIDwcPD/MSWh5z28t8FChQgLEpKfImBg8ezODBg2+7oPj4eHbu3Mno0aNTt7m5uREcHExkZGSG9nH58mUSEhIoWrSow9fj4uKIi4tL/Tn6//8Hk5CQQEJCwm3XfDMp+8vq/boa9cMd9kGhQvD113g88AC23btJ7tGDpJUrzVv3XYyOBZP6QX2Qwmn6wTBwHzMGNyDpiSdILlfOnKMoB2RnH9zOPm1GyrL2TuLkyZMEBASwZcsWmjRpkrp91KhRbNiwga1bt95yH8888wzff/89v//+Oz4+PmleHz9+PBMcXCf95JNP8PX1vbMvIJKNCh88yP1jxuARF8fRli3ZNWxYrp9hVkRyRvE9e2gaGkqShwdr33+fq8WLW11Slrh8+TKPPvooUVFRFCxY8KZts2RBWGfy+uuv89lnn7F+/XqHgQhg9OjRhISEpP4cHR2dOg7pVh12uxISElizZg2tW7fO0wvkqh+ysA/uvhuje3fKrVtHQJMmJI8fn2U15gQdCyb1g/oghVP0g2HgnjIB85AhPNi/f45+fHb2QfRtDDdwulDk5+eHu7s7Z86csdt+5swZSpYsedP3Tp06lddff521a9dSu3btdNt5e3unWb8NzHmYsuuAzM59uxL1Qxb0QefO8P77MHgw7pMn416+PGTiUrXVdCyY1A/qgxSW9sM338C2beDri/vLL+NuUR3Z0Qe3s7/bGmidE7y8vKhfv77dIOmUQdPXX0670ZtvvsmkSZMIDw93OJGkSK4yaNC1O0SGDDF/oYmIZEZy8rXfJ889B7c4AZGbOV0oAggJCWHu3LksXLiQP//8kyFDhhAbG8uAAQMA6Nevn91A7DfeeIOxY8cyf/58AgMDOX36NKdPn+bSpUtWfQWR7DdhAjzxhPkLrXdv2L7d6opExBV98QXs3m0uRv3CC1ZXYymnu3wG0Lt3b86dO8e4ceM4ffo0devWJTw8HH9/fwCOHj2Km9u1PPf+++8THx9Pz5497fYTGhrKeBcbbyGSYTYbfPihOW/R6tXmrfqRkVCpktWViYirSEq6dut9SAgUK2ZtPRZzylAEMHToUIYOHerwtfXr19v9fPjw4ewvSMQZeXrCsmUQFAS7dpmTO27eDLnkrhERyWaffAJ790LRouBgzsG8xikvn4nIbbjrLvj2WyhfHg4cMAdiX75sdVUi4uwSEiDlasqoUeZ8aHmcQpFIblCqFKxaBUWKwE8/waOPmqfFRUTS8/HH8PffUKIEpHNlJq9RKBLJLapVM5cD8faGlSth2DBzlWsRkRtdvQqTJpnPX34Zbli/NK9SKBLJTZo1g8WLzUHYs2fDm29aXZGIOKMPP4Tjx6FMGfjPf6yuxmkoFInkNj17wvTp5vOXXoKwMGvrERHnEhsLKbNXjx0L6az+kBcpFInkRsOHm7fXAgwYAD/8YG09IuI8Zs6EM2egYkXz94OkUigSya3eegsefti8w6RbN/jlF6srEhGrRUXBG2+Yz0NDzWk9JJVCkUhu5eYGCxfCAw9AdDQ89BAcO2Z1VSJipRkz4N9/oWpVeOwxq6txOgpFIrmZjw+sWGHemXbihDm548WLVlclIlb45x+YNs18PnEiuLtbW48TUigSye2KFDHnMCpVCn7/3byUFhdndVUiktPeess8a1ynDvToYXU1TkmhSCQvKF8evvsOChSA9evNwZXJyVZXJSI55fRpePdd8/mkSebldUlDvSKSV9StC8uXg4cHfPopjB5tdUUiklNefx2uXIHGjaFjR6urcVoKRSJ5SevWMG+e+fzNN81bc0Ukdzt2DN5/33z+6qvm5K7ikEKRSF7Tr5/5ixHMpUC+/NLaekQke736KsTHQ1AQtGpldTVOTaFIJC96+WUYPNhcG+3RR2HLFqsrEpHs8NdfMH+++VxniW5JoUgkL7LZYNYsc2zB1avQqRPs22d1VSKS1SZOhMREaNfOXBtRbkqhSCSv8vCAzz6Dhg3hwgVzDqMzZ6yuSkSyyp9/mgtEg3nHmdySQpFIXpY/P3zzjbkG0qFD0KEDXLpkdVUikhXGjzen3ujaFRo0sLoal6BQJJLXlSgB4eHg5wc7d5rrpSUmWl2ViNyJ3bth6VLzUvnEiVZX4zIUikQE7r7bPGOUL585+/WQIeYgbBFxTePGmX8+8gjUqmVtLS5EoUhETI0bm2OM3Nzgo4+u3bYvIq5l61b4+mvz7/L48VZX41IUikTkms6dr03oOG4cfPyxtfWIyO0bO9b8s39/uOcea2txMQpFImJvyBB46SXz+aBB8P331tYjIhm3YQOsWQOentcuoUmGKRSJSFqTJ0PfvpCUBD17ws8/W12RiNyKYcArr5jPBw2CwEBLy3FFCkUikpbNZq6R1qqVeYt+hw5w+LDVVYnIzaxeDT/+CD4+MGaM1dW4JIUiEXHMywu++AJq14bTp80ZcS9csLoqEXHk+rNEzzwDpUtbW4+LUigSkfQVKgTffQdlypjLgHTubC4LIiLOZeVK2LHDnJD1xRetrsZlKRSJyM0FBJhzFxUqBJs3m2ONkpOtrkpEUiQnX7vjbMQIc0JWyRSFIhG5tZo1YcWKa5fUQkI0uaOIs1i6FH77zfyHy8iRVlfj0hSKRCRjWrSAhQvN5++8A9OnW1qOiGAuyRMaaj5//nkoUsTaelycQpGIZNwjj8Bbb5nPR46EJUusrUckr1u0CPbvN9cuHD7c6mpcnkKRiNyekSPhuefM5/36mZPFiUjOi4+HCRPM5y+9BHfdZW09uYBCkYjcHpvNvHTWrZv5S7lrV/j9d6urEsl75s2DI0egVClzJnq5YwpFInL73N0hLAyaNoWLF6F9ezh50uqqRPKOK1euLdo8Zgz4+lpbTy6hUCQimZMvH3z1lbng5LFj8NBDEB1tdVUiecP775v/EClXDp56yupqcg2FIhHJvGLFIDzcnBdlzx7o0cO8pCYi2efSJZgyxXw+bhx4e1tbTy6iUCQid6ZCBfj2W3Mm3bVrzX+1ag4jkezz7rtw/jxUrgz9+1tdTa6iUCQid65BA/j8c3Os0aJF12bXFZGsdfHitWkxJkwADw9Ly8ltFIpEJGu0bw8ffGA+f+21a89FJOtMm2YGoxo1oHdvq6vJdRSKRCTrDBx4bXbdZ56Br7+2th6R3OTcuWszyU+caJ6ZlSylUCQiWSs0FJ580lyksndv2LbN6opEcoc33zQHWd97rzlPmGQ5hSIRyVo2G8yZA+3amXOpdOwIBw9aXZWIazt1CmbONJ+/+qr590yynEKRiGQ9T09z4PW995qn/Nu3N/8UkcyZPBmuXjUnTG3Xzupqci2FIhHJHgUKmLfqBwaaZ4o6doSYGGwbNhCwcSO2DRsgKcnqKkWc35Ej125c0FmibKVQJCLZp2RJWLUKihY1xxaVKIFH69Y0mDYNj9atzcC0fLnVVYo4t0mTICEBWrWCli2triZXUygSkexVtSqMHGk+v3rV/rUTJ6BnTwUjkfQcOAALFpjPJ02ytJS8QKFIRLJXUpK5TpMjKTNfjxihS2kijkyYYP7d6NABmjSxuppcT6FIRLLXpk1w/Hj6rxuGuaDspk05V5OIK/jtN/jkE/O5zhLlCKcMRbNmzSIwMBAfHx8aN27MtpvMc/L777/To0cPAgMDsdlszJgxI+cKFZFbO3UqY+1uFpxE8qLQUPMfDT17Qr16VleTJzhdKFqyZAkhISGEhoby888/U6dOHdq2bcvZs2cdtr98+TIVK1bk9ddfp2TJkjlcrYjcUqlSGWv30ksQFqbLaCIAO3eaY+1sNvMSmuQIpwtF06ZNY9CgQQwYMIDq1aszZ84cfH19mT9/vsP2DRs25K233uKRRx7B29s7h6sVkVtq3hzKlLn5bcRubuag6759oWZN+OwzhSPJ28aNM/987DGoXt3aWvIQp1peNz4+np07dzJ69OjUbW5ubgQHBxMZGZllnxMXF0dcXFzqz9HR0QAkJCSQkJCQZZ+Tss/r/8yr1A95uw9sb7+N+yOPgM2GLWVwNWD8f1BKmj8f27FjuE2bhm3vXujTB2PiRJLGjsXo3t0MTblMXj4eUqgPTDf2gy0yEo/vvsNwdyfx5ZfN2/Fzuew8Fm5nn04Vis6fP09SUhL+/v522/39/dm7d2+Wfc6UKVOY4OB05OrVq/H19c2yz7nemjVrsmW/rkb9kEf7wNubUqNGUeujj8j3zz+pm68UK8ZvAwdyqnBhKFwYj1mzqPj111T66iu8/vwTj0cfJap8efY98ginGjfOleEoTx4PN1AfmFL6oenYsRQHjjz4IHv274f9+60tLAdlx7Fw+fLlDLd1qlCUU0aPHk1ISEjqz9HR0ZQtW5Y2bdpQsGDBLP2shIQE1qxZQ+vWrfH09MzSfbsS9YP6gIcegvHjubp+Pb+tWUPN1q3xbNGCeu7u2A0h7dkTLl4k6d13cXv3XQodOUKjN97AqFOHpHHjMDp2zBUz+ub54wH1QYrr+8Hrxx/x+PVXDC8vAt5/n4By5awuL0dk57GQcjUoI5wqFPn5+eHu7s6ZM2fstp85cyZLB1F7e3s7HH/k6emZbX8xs3PfrkT9kMf7wNMTWrXiRFwcdVq1Sr8fihc3b0H+739h+nSYMQPbnj149OgB9eubA08feihXhKM8fTz8P/WBydPDA4/x4wGw/ec/eFaqZG1BFsiOY+F29udU56K9vLyoX78+ERERqduSk5OJiIigiSatEsl7ihY1w9HhwzB6NOTPb96V07Ej3HcfhIdfmwBSxMXZwsMhMhLy5YOXX7a6nDzJqUIRQEhICHPnzmXhwoX8+eefDBkyhNjYWAYMGABAv3797AZix8fHs3v3bnbv3k18fDwnTpxg9+7dHDx40KqvICJZrVgxc5XwQ4fghRfA19dcS619e7j/flizRuFIXFtyMu6hoebz554z1w2UHOd0oah3795MnTqVcePGUbduXXbv3k14eHjq4OujR49y6rrJ4E6ePEm9evWoV68ep06dYurUqdSrV4+nnnrKqq8gItmleHF48034+28ICQEfH/Nf1m3awAMPwLp1VlcocnuSkrBt2ECN+fOx7d4NBQrAqFFWV5VnOV0oAhg6dChHjhwhLi6OrVu30rhx49TX1q9fz4KUxfGAwMBADMNI81i/fn3OFy4iOcPfH95+2wxHw4eDtzf8+CM8+KC5ivjGjVZXKHJry5dDYCAerVtT+ZtvzG1ubrBhg7V15WFOGYpERDKkVCmYMQP++guefRa8vGD9eggKguBg2LzZ6gpFHFu+3LzT8sblbWJizO3Ll1tTVx6nUCQiri8gAGbOhIMH4emnzbvcIiKgWTNo2xZ++snqCkWuSUoyz3A6GgeXsm3ECM3qbgGFIhHJPcqWhfffhwMHYNAg8PCA1auhSRPzFv7t262uUPKyy5fNS2NPP33zBZANA44dg02bcq42ARSKRCQ3Kl8ePvwQ9u2DAQPA3R1WrYJGjaBTJ/j5Z6srlLzg5ElYtsycb6txYyhUCFq0gI8+ytj7r7upSHKGQpGI5F4VK8L8+bB3L/TrZw5i/eYbcwLIbt1gzx6rK5TcIinJPJ5mzzYXNq5Qwbys26uXOe5t2zZITITSpc0xbxlRqlS2lixpOdWM1iIi2aJyZVi40JwQb9Ik+OQTWLHCfPToAePHQ82aFhcpLiUmxhyrtnkzbNliPo+JsW/j5ga1a0PTpuZ8Wk2bmmcxk5MhMBBOnHA8rshmgzJloHnzHPkqco1CkYjkHVWqwOLFMGYMTJwIS5bAF1+Yd/r06gWhoVC9utVVirMxDDhy5FoA2rwZfv3VDDfXu+suc6b1++83H40agaP1NN3d4Z13zLvMbDb7YJSydM2MGWY7yVEKRSKS91SrBp9+aoajCRPMcR9Ll8Lnn0OfPjBunBmgJG9KSIBdu64FoC1bzPFBN6pQwf4sUM2aGQ8y3bubx93w4faDrsuUMQNR9+5Z8lXk9igUiUjeVbOmGYR++cW8hPbll+altc8+g8ceg7Fj4e67ra5SstuFC+bM6CkBaNs2uHLFvo2HB9x777UA1LSpOT7oTnTvDl26kLhuHbtXraJu+/Z4tGypM0QWUigSEald27yEtmuXGY6++goWLTID0uOPm+GoYkWrq5SsYBjmlA3XXwr788+07YoWvRZ+7r8fGjY0F2rNau7uGEFBnIiNpU5QkAKRxRSKRERS1KsHK1fCjh3m+KLvvoMFC8xxSP37wyuvmANkxXVcvWr+90wJQVu2wPnzadtVqXLtLND998M995gDpSVPUSgSEblRgwbw7bewdasZjr7/HubNM+9gGzjQvIutXDmrqxRHzpyxPwu0c6c5Ruh6Pj7mmZ+UANSkCfj5WVOvOBWFIhGR9DRuDOHh5v9gQ0Nh7Vr44AP4+GN46ikYPdocGCvWSE6G33+3HxD9119p2/n7X7sjrGlTc2yQl1fO1ytOT6FIRORWmjaFNWvMZRdCQ2HdOnOSvnnzYPBgMxxpor3bk5SEbcMGAjZuxJY/P2RkgPGlS+Yg6JQAFBkJUVH2bWw2cwD99SGoQoVrt7qL3IRCkYhIRjVvDj/8YIai0FAzJL33HsydC0OGwIsvmmcl5OaWL4fhw/E4fpwGANOmmWfc3nnH/lb0Y8fsL4Xt2ZN2kdT8+a/NDdS0qfm8UKGc/DaSiygUiYjcrpYtzTWsIiLMcLRlC0yfDnPmwLPPwgsvQIkSVlfpnJYvNyctvHEm5xMnzNnFBw40zwht3ux40dRy5ewHRNeqZd4uL5IFdCSJiGSGzQbBwdCqFaxebYajrVth6lTz0tpzz8Hzz2sAL5gB6NIl+OcfeOYZx0tbpGybN+/aNnd3847A6ydI1BguyUYKRSIid8Jmg7ZtoU0bWLXKnA1750544w2YNQuGDYORI815b1JkZjyNlZKTzXW9Ll60f0RFpd3m6BEVlXZJjJt58klzfqiGDc3LYyI5RKFIRCQr2Gzw0EPQvj18840ZjnbvhsmTzXFH//2v+fjhh4yNp8lKSUkQHX17IebGnx2d3bld7u5pxwQ5EhxsXp4UyWEKRSIiWclmg06doGNHWLHCnCH7l1/MBWinToXLl9O+58QJc5zNsmWOg1FiohlqMhJgHD2io7Pmu3l5QZEiULhw+o9ChdJ/7aef4MEHb/05upNPLKJQJCKSHWw26NYNunQxBxeHhsIffzhum3IW5vHHYf58M+hcH3ZiYrKmpnz5Mh5gHLXz8bmzz3/gAfOs2IkTjs882Wzm682b39nniGSSQpGISHZyczPPAhUtag7KvpnLl82ZtNPj63t7IebGbd7ed/x17oi7u3mZsGdPMwBdH4xS5hGaMcO5x1dJrqZQJCKSE86cyVi7p54yB247CjWentlXX07p3t28TDh8uP0t92XKmIEou8ZViWSAQpGISE7I6DiZxx7L/YOMu3eHLl1IXLeO3atWUbd9ezyc/Q48yRMUikREckLz5hpPcz13d4ygIE7ExlInKEiBSJyCm9UFiIjkCSnjaSDtOlwaTyPiFBSKRERySsp4moAA++1lyqR/O76I5BhdPhMRyUkaTyPitBSKRERymsbTiDglXT4TERERQaFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBHDiUDRr1iwCAwPx8fGhcePGbNu27abtP//8c6pWrYqPjw+1atXiu+++y6FKRUREJDdwylC0ZMkSQkJCCA0N5eeff6ZOnTq0bduWs2fPOmy/ZcsW+vTpw8CBA9m1axddu3ala9eu/PbbbzlcuYiIiLgqpwxF06ZNY9CgQQwYMIDq1aszZ84cfH19mT9/vsP277zzDu3ateOFF16gWrVqTJo0iXvvvZeZM2fmcOUiIiLiqpwuFMXHx7Nz506Cg4NTt7m5uREcHExkZKTD90RGRtq1B2jbtm267UVERERu5GF1ATc6f/48SUlJ+Pv722339/dn7969Dt9z+vRph+1Pnz7tsH1cXBxxcXGpP0dFRQFw4cIFEhIS7qT8NBISErh8+TL//PMPnp6eWbpvV6J+UB+kUD+Y1A/qgxTqh+ztg5iYGAAMw7hlW6cLRTlhypQpTJgwIc32ChUqWFCNiIiIZLeYmBgKFSp00zZOF4r8/Pxwd3fnzJkzdtvPnDlDyZIlHb6nZMmSt9V+9OjRhISEpP6cnJzMhQsXKFasGDab7Q6/gb3o6GjKli3LsWPHKFiwYJbu25WoH9QHKdQPJvWD+iCF+iF7+8AwDGJiYihduvQt2zpdKPLy8qJ+/fpERETQtWtXwAwtERERDB061OF7mjRpQkREBCNGjEjdtmbNGpo0aeKwvbe3N97e3nbbChcunBXlp6tgwYJ59mC/nvpBfZBC/WBSP6gPUqgfsq8PbnWGKIXThSKAkJAQ+vfvT4MGDWjUqBEzZswgNjaWAQMGANCvXz8CAgKYMmUKAMOHDycoKIi3336bDh068Nlnn7Fjxw4+/PBDK7+GiIiIuBCnDEW9e/fm3LlzjBs3jtOnT1O3bl3Cw8NTB1MfPXoUN7drN841bdqUTz75hFdeeYWXX36Zu+++mxUrVlCzZk2rvoKIiIi4GKcMRQBDhw5N93LZ+vXr02zr1asXvXr1yuaqbp+3tzehoaFpLtflNeoH9UEK9YNJ/aA+SKF+cJ4+sBkZuUdNREREJJdzuskbRURERKygUCQiIiKCQpGIiIgIoFCUbeLi4njxxRcpXbo0+fLlo3HjxqxZs8bqsnLMa6+9hs1mS3MHYIsWLbDZbGke7dq1s6jSrLVz507atWtHwYIFueuuu2jTpg27d+922HbLli00a9YMX19fSpYsybBhw7h06VLOFnyHLl26RGhoKO3ataNo0aLYbDYWLFiQpt3cuXMJCgrC398fb29vKlSowIABAzh8+HCato6OD5vNxuuvv579XyiTMtoPAEuXLuW+++6jcOHCFCtWjKCgIL799ts07ZKTk3nzzTepUKECPj4+1K5dm08//TSbv0nmbd++naFDh1KjRg3y589PuXLlePjhh9m/f39qm+TkZBYsWEDnzp0pW7Ys+fPnp2bNmrz66qtcvXo1zT5d7VjISB9A+t/LZrPRunVru7audhwA/P777/Tq1YuKFSvi6+uLn58fDzzwAF9//bVdu23btvHMM89Qv359PD09bzp5ck4dC05795mre+KJJ1i2bBkjRozg7rvvZsGCBTz00EOsW7eOZs2aWV1etjp+/DiTJ08mf/78Dl8vU6ZM6hxTKTIy06iz+/nnn2nWrBlly5YlNDSU5ORkZs+eTVBQENu2baNKlSqpbXfv3k2rVq2oVq0a06ZN4/jx40ydOpUDBw6watUqC7/F7Tl//jwTJ06kXLly1KlTx+GdoQC7du2iQoUKdO7cmSJFinDo0CHmzp3LN998w549e9L892/dujX9+vWz21avXr3s+hp3LKP98N577zFs2DA6dOjA66+/ztWrV1mwYAEdO3bkiy++oHv37qltx4wZw+uvv86gQYNo2LAhK1eu5NFHH8Vms/HII4/k0DfLuDfeeIPNmzfTq1cvateuzenTp5k5cyb33nsvP/30EzVr1uTy5csMGDCA++67j6effpoSJUoQGRlJaGgoERER/PDDD2n+x+hKx0JG+gBg0aJFad67Y8cO3nnnHdq0aWO33dWOA4AjR44QExND//79KV26NJcvX+aLL76gc+fOfPDBBwwePBiA7777jo8++ojatWtTsWLFNOHxRjlyLBiS5bZu3WoAxltvvZW67cqVK0alSpWMJk2aWFhZzujdu7fx4IMPGkFBQUaNGjXsXnO0Lbd46KGHjCJFihjnz59P3Xby5EmjQIECRvfu3e3atm/f3ihVqpQRFRWVum3u3LkGYHz//fc5VvOdunr1qnHq1CnDMAxj+/btBmB8/PHHGXrvjh07DMCYMmWK3XbAePbZZ7O61GyV0X64++67jYYNGxrJycmp26KioowCBQoYnTt3Tt12/Phxw9PT064fkpOTjebNmxtlypQxEhMTs+/LZNLmzZuNuLg4u2379+83vL29jccee8wwDMOIi4szNm/enOa9EyZMMABjzZo1dttd7VjISB+kZ+DAgYbNZjOOHTuWus0Vj4P0JCYmGnXq1DGqVKmSuu306dPG5cuXDcMwjGeffda4WSTJqWNBl8+ywbJly3B3d09NwwA+Pj4MHDiQyMhIjh07ZmF12Wvjxo0sW7aMGTNm3LRdYmKiy10qupVNmzYRHBxMsWLFUreVKlWKoKAgvvnmm9TvGx0dzZo1a+jbt6/ddPb9+vWjQIECLF26NMdrzyxvb+901xi8lcDAQAAuXrzo8PUrV644vKTijDLaD9HR0ZQoUcLubEjBggUpUKAA+fLlS922cuVKEhISeOaZZ1K32Ww2hgwZwvHjx4mMjMzaL5AFmjZtipeXl922u+++mxo1avDnn38C5jJOTZs2TfPebt26AaS2u5GrHAsZ6QNH4uLi+OKLLwgKCqJMmTKp213xOEiPu7s7ZcuWtfv77u/vb3fcZ0R2HwsKRdlg165d3HPPPWnWb2nUqBFAumNMXF1SUhLPPfccTz31FLVq1Uq33f79+8mfPz933XUXJUuWZOzYsSQkJORgpdkjLi7O4V9wX19f4uPj+e233wD49ddfSUxMpEGDBnbtvLy8qFu3Lrt27cqReq3wzz//cPbsWXbs2JG6bE+rVq3StFuwYAH58+cnX758VK9enU8++SSnS80WLVq0IDw8nPfee4/Dhw+zd+9enn32WaKiohg+fHhqu127dpE/f36qVatm9/6U3yGucowYhsGZM2fw8/O7abvTp08DOGzn6sdCRvrgu+++4+LFizz22GN22139OIiNjeX8+fP89ddfTJ8+nVWrVjn8+55ROXEsaExRNjh16hSlSpVKsz1l28mTJ3O6pBwxZ84cjhw5wtq1a9NtU6lSJVq2bEmtWrWIjY1l2bJlvPrqq+zfv58lS5bkYLVZr0qVKvz0008kJSXh7u4OQHx8PFu3bgXgxIkTgHl8AOkeI5s2bcqhinNeQEAAcXFxABQrVox33303zcDSpk2b8vDDD1OhQgVOnjzJrFmzeOyxx4iKimLIkCFWlJ1l3n33Xc6fP8+wYcMYNmwYYAaBiIgIuwWsT506hb+/f5rxNa72OyQsLIwTJ04wceLEm7Z78803KViwIO3bt7fbnhuOhYz0QVhYGN7e3vTs2dNuu6sfByNHjuSDDz4AwM3Nje7duzNz5sxM7SunjgWFomxw5coVh1OV+/j4pL6e2/zzzz+MGzeOsWPHUrx48XTbzZs3z+7nxx9/nMGDBzN37lz++9//ct9992V3qdnmmWeeYciQIQwcOJBRo0aRnJzMq6++mhqCUv67p/yZ3jGSG4+PFKtWreLq1av8+eefLF68mNjY2DRtNm/ebPfzk08+Sf369Xn55Zd54oknbvt0uzPx9fWlSpUqlClTho4dOxITE8P06dPp3r07mzZtonLlykDu+B2SchasSZMm9O/fP912kydPZu3atcyePZvChQvbvebqx0JG+iA6Oppvv/2Whx56KM33d/XjYMSIEfTs2ZOTJ0+ydOlSkpKSiI+Pz9S+cupY0OWzbJAvX77Ufw1fL+U6qLP/Rc6MV155haJFi/Lcc8/d9ntHjhwJcNMzTK7g6aef5uWXX+aTTz6hRo0a1KpVi7/++otRo0YBUKBAAeDaf//0jpHceHykaNmyJe3btyckJITPP/+cCRMm3PJfjl5eXgwdOpSLFy+yc+fOHKo0e/Tq1YujR4+yYMECevbsyYABA1i/fj3x8fGMGTMmtZ2r/w45ffo0HTp0oFChQqljLB1ZsmQJr7zyCgMHDszQv/Zd6VjIaB988cUXXL16Nc2lM3D946Bq1aoEBwfTr1+/1HGVnTp1wsiC1cWy61hQKMoGpUqVSj07cL2Ubbnh9vPrHThwgA8//JBhw4Zx8uRJDh8+zOHDh7l69SoJCQkcPnyYCxcupPv+smXLAty0jat47bXXOHPmDJs2beKXX35h+/btJCcnA3DPPfcA1059p3eM5LbjIz2VKlWiXr16hIWF3bJtbjhG/v77b8LDw+ncubPd9qJFi9KsWTO7fwmXKlWK06dPp/mfhyv8DomKiqJ9+/ZcvHiR8PDwdGtds2YN/fr1o0OHDsyZMyfD+3eFYyGjfQDmpbNChQrRsWPHNK+58nHgSM+ePdm+ffstb73PqOw4FhSKskHdunXZv38/0dHRdttTxpbUrVvXgqqyz4kTJ0hOTmbYsGFUqFAh9bF161b2799PhQoVbno9/e+//wa46WU3V1KkSBGaNWuWOth87dq1lClThqpVqwJQs2ZNPDw82LFjh9374uPj2b17d647Pm7mypUrREVF3bJdbjhGzpw5A5g3JNwoISGBxMTE1J/r1q3L5cuX09yx5Oy/Q65evUqnTp3Yv38/33zzDdWrV3fYbuvWrXTr1o0GDRqwdOlSPDwyPpLD2Y+FjPYBmOFm3bp19OjRw+FlMlc9DtKTcrkvI3/nMyJbjoVsv+k/D/rpp5/SzFN09epVo3Llykbjxo0trCx7nDt3zvjyyy/TPGrUqGGUK1fO+PLLL41ffvnFiIqKMq5evWr33uTkZKN3794GYOzcudOib5B9PvvsMwMwpk6dare9Xbt2RqlSpYzo6OjUbR999JEBGKtWrcrpMrNEevPzJCQkGBcuXEjTfuvWrYa7u7vx+OOPp247e/ZsmnbR0dFGpUqVDD8/vzRzwDij9Prh7Nmzhpubm9GiRQu7eYqOHTtmFChQwGjXrp3dtvTmpwkICHDK+WkSExONzp07Gx4eHsa3336bbrs//vjDKFasmFGjRg2Hx0UKVzwWMtoHKaZNm2YARkREhMPXXfE4MAzDOHPmTJpt8fHxxr333mvky5fPiImJSfP6zeYpysljQQOts0Hjxo3p1asXo0eP5uzZs1SuXJmFCxdy+PDhNAONcwM/Pz+6du2aZnvKXEUpr61fv54+ffrQp08fKleuzJUrV/jyyy/ZvHkzgwcP5t577825orPBxo0bmThxIm3atKFYsWL89NNPfPzxx7Rr187udmswL7M1bdqUoKAgBg8ezPHjx3n77bdp06aNyy15MnPmTC5evJh6J8zXX3/N8ePHAXjuuecwDIOyZcvSu3fv1OUPfv31Vz7++GMKFSrE2LFjU/c1a9YsVqxYQadOnShXrhynTp1i/vz5HD16lEWLFqWZA8aZ3KofihcvzpNPPslHH31Eq1at6N69OzExMcyePZsrV64wevTo1H2VKVOGESNG8NZbb5GQkEDDhg1ZsWIFmzZtIiwsLN3xKVYaOXIkX331FZ06deLChQssXrzY7vW+ffsSExND27Zt+ffff3nhhRfSLG9SqVKl1LvwXPFYyEgfXC8sLIzSpUvTokULh/tzxeMA4D//+Q/R0dE88MADBAQEcPr0acLCwti7dy9vv/126vjKI0eOpM7unXLm/NVXXwWgfPnyPP7440AOHwtZFq/EzpUrV4znn3/eKFmypOHt7W00bNjQCA8Pt7qsHHXj7NV///230atXLyMwMNDw8fExfH19jfr16xtz5syx+5ezqzp48KDRpk0bw8/Pz/D29jaqVq1qTJkyJd1/xWzatMlo2rSp4ePjYxQvXtx49tln7c4cuYry5csbgMPHoUOHjLi4OGP48OFG7dq1jYIFCxqenp5G+fLljYEDBxqHDh2y29fq1auN1q1bGyVLljQ8PT2NwoULG23atEn3X9LO5Fb9YBjmWbP33nvPqFu3rlGgQAGjQIECRsuWLY0ffvghzf6SkpKMyZMnG+XLlze8vLyMGjVqGIsXL87hb5VxQUFB6X7/lP/VHDp06KZt+vfvn7o/VzwWMtIHKfbu3WsARkhIyE336WrHgWEYxqeffmoEBwcb/v7+hoeHh1GkSBEjODjYWLlypV27devWpdtXQUFBqe1y8liwGUYWDAMXERERcXEaaC0iIiKCQpGIiIgIoFAkIiIiAigUiYiIiAAKRSIiIiKAQpGIiIgIoFAkIiIiAigUiYiIiAAKRSIiIiKAQpGIyE0dPnwYm83GE088YXUpIpLNFIpExGk9+eST2Gw2ihUrRlxcnNXliEgup1AkIk4pJiaGpUuXYrPZuHDhAitWrLC6JBHJ5RSKRMQpLVmyhNjYWP773//i5ubGvHnzrC5JRHI5hSIRcUrz5s3Dw8ODUaNG0bJlSyIiIjhy5EiadoGBgQQGBnLp0iWGDx9O6dKl8fb2pnbt2ixbtszhvg8fPkzv3r0pWrQoBQoUICgoiI0bNzJ+/HhsNhvr16/PUI0xMTGEhoZSo0YN8uXLR+HChWnbti0//vjjnXx1EbGIQpGIOJ0//viDn376iTZt2uDv70+/fv1ITk7m448/dtg+ISGBNm3asHr1anr06EHfvn3566+/ePjhh1m9erVd2xMnTtC0aVOWLl1K48aNGTZsGH5+frRu3ZqtW7dmuMYLFy7QpEkTJk6cSJEiRXj66afp0aMHO3fupGXLlrrcJ+KKDBERJxMSEmIAxqeffmoYhmHExMQY+fPnN8qVK2ckJSXZtS1fvrwBGF26dDHi4uJSt69du9YAjLZt29q179u3rwEYr732mt32efPmGYABGOvWrUvdfujQIQMw+vfvb9f+0UcfNQBj7ty5dtvPnDljlC1b1ihevLhx5cqVzHaBiFhAZ4pExKkkJCSwaNEiChYsSNeuXQEoUKAA3bp14+jRo6xdu9bh+6ZPn46Xl1fqz61ataJ8+fJs3749dVtcXByff/45JUqUYOTIkXbvHzBgAFWqVMlQjefPn2fJkiU8+OCDPPXUU3avlShRghdeeIFz586lW6uIOCcPqwsQEbneypUrOXfuHAMHDsTHxyd1e79+/Vi8eDHz5s2jTZs2du8pXLgwFSpUSLOvMmXKEBkZmfrzvn37iIuLo0GDBnh7e9u1tdlsNG3alH379t2yxu3bt5OUlERcXBzjx49P8/qBAwcA2Lt3Lx07drzl/kTEOSgUiYhTSbnLrF+/fnbbW7VqRUBAACtXruTChQsULVo09bVChQo53JeHhwfJycmpP0dHRwPm2RxH/P39M1TjhQsXANi8eTObN29Ot11sbGyG9icizkGXz0TEaRw7dix1YHRQUBA2my314e7uzokTJ4iLi2Px4sWZ2n/BggUBOHv2rMPXz5w5c1v7GTlyJIZhpPsIDQ3NVJ0iYg2dKRIRp7FgwQKSk5Np1qyZw/E9iYmJLFy4kHnz5jFs2LDb3n+VKlXw9vZm586dxMXF2V1CMwzD7lLbzTRs2BCbzZbh9iLiGhSKRMQpGIbBxx9/jM1mY+HChVSsWNFhu/379xMZGcmOHTto0KDBbX2Gt7c3PXv2JCwsjBkzZvDiiy+mvva///2PvXv3Zmg/JUuW5OGHH2bJkiW89dZbPP/889hsNrs2W7dupVatWvj6+t5WjSJiHYUiEXEKP/zwA4cOHSIoKCjdQATmXWKRkZHMmzfvtkMRwJQpU1i7di0vvfQSGzZsoF69euzbt49vvvmGdu3aER4ejpvbrUcWzJ49m3379jFq1CgWLVpEkyZNKFy4MMeOHWPHjh0cOHCAU6dOKRSJuBCNKRIRp5AywPpWq9H37t2bfPny8emnn3LlypXb/pyyZcsSGRlJr1692LJlCzNmzODs2bOsXr2aypUrA9fGDN1M0aJF2bJlC2+++SZeXl6EhYXx3nvv8dNPP1GjRg3+97//4efnd9v1iYh1bIZhGFYXISLiDJo1a0ZkZCRRUVEUKFDA6nJEJIfpTJGI5DmnTp1Ks23x4sVs3ryZ4OBgBSKRPEpnikQkzylWrBj16tWjevXquLu7s3v3btavX89dd93F5s2bqVWrltUliogFFIpEJM8ZM2YMX3/9NUePHiU2NpbixYvTsmVLxo4dS9WqVa0uT0QsolAkIiIigsYUiYiIiAAKRSIiIiKAQpGIiIgIoFAkIiIiAigUiYiIiAAKRSIiIiKAQpGIiIgIoFAkIiIiAigUiYiIiADwf3YJeZ72TsKxAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 }, { "cell_type": "markdown", @@ -174,8 +208,8 @@ { "cell_type": "code", "source": [ - "fig, ax = r.results[0].profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False);\n", - "ax.grid(True)\n", + "fig, ax = r.profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False);\n", + "ax[0].grid(True)\n", "plt.ylim(0, 0.5)\n", "plt.xlabel(\"Angle\")\n", "plt.title(\"Cosine curve estimated by SSM\")\n", @@ -184,13 +218,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:01.258754Z", - "start_time": "2024-06-08T12:10:01.102717Z" + "end_time": "2024-07-11T10:13:27.232310Z", + "start_time": "2024-07-11T10:13:27.165419Z" } }, "id": "c826947d0b98109e", - "execution_count": 34, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 }, { "cell_type": "markdown", @@ -214,12 +259,13 @@ "cell_type": "code", "source": [ "from matplotlib import collections as mc\n", + "import numpy as np\n", "\n", - "fig, ax = r.results[0].profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False, c_fit='black', c_scores='black');\n", + "fig, ax = r.profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False, c_fit='black', c_scores='black');\n", "\n", "thetas = np.linspace(0, 360, 1000)\n", - "fit = circumplex.circumplex.cosine_form(thetas, r.results[0].amplitude, r.results[0].displacement, r.results[0].elevation)\n", - "angles, scores = circumplex.circumplex.sort_angles(r.results[0].angles, r.results[0].scores)\n", + "fit = circumplex.utils.cosine_form(np.deg2rad(thetas), r.results['a_est'][0], np.deg2rad(r.results['d_est'][0]), r.results['e_est'][0])\n", + "angles, scores = circumplex.utils.sort_angles(r.details['angles'], r.scores[r.scales].values[0])\n", "\n", "lines = []\n", "for i, angle in enumerate(angles):\n", @@ -229,24 +275,35 @@ " lines.append([(0, fit[0]), (0, scores[i])])\n", "\n", "lc = mc.LineCollection(lines, colors='red', linewidths=10)\n", - "ax.add_collection(lc)\n", + "ax[0].add_collection(lc)\n", "\n", - "ax.grid(True)\n", + "ax[0].grid(True)\n", "plt.ylim(0, 0.5)\n", "plt.xlabel(\"Angle\")\n", - "plt.title(f\"Fit = {round(r.results[0].r2, 2)}\")\n", + "plt.title(f\"Fit = {round(r.results.fit_est[0], 2)}\")\n", "plt.show()" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:02.205870Z", - "start_time": "2024-06-08T12:10:01.977949Z" + "end_time": "2024-07-11T10:18:54.407439Z", + "start_time": "2024-07-11T10:18:54.330885Z" } }, "id": "3d4382669e2bbfa8", - "execution_count": 35, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 29 }, { "metadata": {}, @@ -298,13 +355,27 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:04.469487Z", - "start_time": "2024-06-08T12:10:04.458544Z" + "end_time": "2024-07-11T10:24:14.503662Z", + "start_time": "2024-07-11T10:24:14.495288Z" } }, "id": "d06f5b82ed8a562c", - "execution_count": 36, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", + "32 Items, 8 Scales, 2 normative data sets\n", + "Soldz, Budman, Demby, & Merry (1995)\n", + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 30 }, { "cell_type": "markdown", @@ -322,13 +393,191 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:05.287887Z", - "start_time": "2024-06-08T12:10:05.269950Z" + "end_time": "2024-07-11T10:24:18.295414Z", + "start_time": "2024-07-11T10:24:18.287189Z" } }, "id": "3828a5802369696e", - "execution_count": 37, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + " Gender PA BC DE FG HI JK LM NO PARPD SCZPD \\\n", + "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 3 \n", + "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 0 \n", + "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 1 \n", + "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 0 \n", + "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 0 \n", + "\n", + " SZTPD ASPD BORPD HISPD NARPD AVPD DPNPD OCPD \n", + "0 7 7 8 4 6 3 4 6 \n", + "1 2 0 1 2 3 0 1 0 \n", + "2 0 4 1 5 4 0 0 1 \n", + "3 0 0 1 0 0 0 0 0 \n", + "4 0 0 1 0 0 1 0 0 " + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GenderPABCDEFGHIJKLMNOPARPDSCZPDSZTPDASPDBORPDHISPDNARPDAVPDDPNPDOCPD
0Female1.501.501.251.002.002.502.252.504377846346
1Female0.000.250.000.251.251.752.252.251020123010
2Female0.000.000.000.000.000.000.000.000104154001
3Male2.001.751.752.502.001.752.002.501000100000
4Female0.250.500.250.000.000.000.000.000000100100
\n", + "
" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 31 }, { "cell_type": "markdown", @@ -346,13 +595,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:06.174739Z", - "start_time": "2024-06-08T12:10:06.010592Z" + "end_time": "2024-07-11T10:24:21.566765Z", + "start_time": "2024-07-11T10:24:21.474766Z" } }, "id": "4fca74a7a59559a", - "execution_count": 38, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 32 }, { "cell_type": "markdown", diff --git a/docs/tutorials/Random_exs.ipynb b/docs/tutorials/Random_exs.ipynb index 38f0a78..6631061 100644 --- a/docs/tutorials/Random_exs.ipynb +++ b/docs/tutorials/Random_exs.ipynb @@ -2,13 +2,12 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, "id": "initial_id", "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-02-15T14:42:04.126026Z", - "start_time": "2024-02-15T14:42:01.945946Z" + "end_time": "2024-07-09T21:39:29.760651Z", + "start_time": "2024-07-09T21:39:26.635185Z" } }, "source": [ @@ -24,43 +23,60 @@ " \"/Users/mitch/Library/CloudStorage/OneDrive-UniversityCollegeLondon/_Fellowship/Papers - Drafts/J2308_APA_SATP-Main/data/SATP Dataset v1.4.xlsx\"\n", " )" ], + "execution_count": 1, "outputs": [] }, { "cell_type": "code", - "execution_count": 2, "source": [ "%autoreload\n", "plt.style.use(\"ggplot\")\n", "scales = [\"PAQ1\", \"PAQ2\", \"PAQ3\", \"PAQ4\", \"PAQ5\", \"PAQ6\", \"PAQ7\", \"PAQ8\"]\n", "\n", - "ssm_res = circumplex.ssm_analyse(data, scales, [\"loud\"], [\"Language\"])\n", - "ssm_res.plot()" + "ssm_res = circumplex.ssm_analyze(data, scales, grouping=\"Language\", measures=[\"loud\"])\n", + "fig = circumplex.ssm_plot(ssm_res)\n", + "plt.show()" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-02-15T14:42:04.419852Z", - "start_time": "2024-02-15T14:42:04.127613Z" + "end_time": "2024-07-09T21:43:34.827932Z", + "start_time": "2024-07-09T21:43:28.062484Z" } }, "id": "7be48f6cc42a46b2", + "execution_count": 6, "outputs": [] }, { "cell_type": "code", - "execution_count": 3, - "source": [ - "ssm_res.results[0]" - ], + "source": "print(ssm_res)", "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-02-15T14:42:04.428488Z", - "start_time": "2024-02-15T14:42:04.419231Z" + "end_time": "2024-07-09T21:43:34.831685Z", + "start_time": "2024-07-09T21:43:34.829007Z" } }, "id": "78230ac68ea161a9", + "execution_count": 7, + "outputs": [] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-09T21:43:35.668664Z", + "start_time": "2024-07-09T21:43:34.832557Z" + } + }, + "cell_type": "code", + "source": [ + "fig, ax = ssm_res.profile_plot()\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "id": "e8504273f20f6030", + "execution_count": 8, "outputs": [] }, { diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index 46b356f..3793267 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -1,5 +1,15 @@ -from circumplex.circumplex import * - -# from circumplex import datasets -from circumplex import instrument from circumplex import utils +from circumplex.instrument import Instrument, instruments +from circumplex.ssm_analysis import ssm_analyze +from circumplex.ssm_results import SSMResults +from circumplex.visualization import ssm_plot, ssm_profile_plot + +__all__ = [ + "ssm_analyze", + "SSMResults", + "ssm_plot", + "ssm_profile_plot", + "Instrument", + "instruments", + "utils", + ] diff --git a/src/circumplex/circumplex.py b/src/circumplex/circumplex.py deleted file mode 100644 index 57de61c..0000000 --- a/src/circumplex/circumplex.py +++ /dev/null @@ -1,527 +0,0 @@ -# %% - -import matplotlib.pyplot as plt -from matplotlib import colormaps -import numpy as np -import pandas as pd -from scipy.optimize import curve_fit - -OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) -BOUNDS = ([0, 0, -np.inf], [np.inf, 360, np.inf]) - - -class SSMParams(object): - """ - A class to store the results of a single SSM analysis. - - Attributes: - scores (np.array): A numeric vector (or single row dataframe) containing one score for each of a - set of circumplex scales. - angles (tuple): A numeric vector containing the angular displacement of each circumplex scale - included in `scores`. - scales (list): A list of the names of the circumplex scales included in `scores`. - group (list): A list of the names of the groups included in `scores`. - measure (list): A list of the names of the measures included in `scores`. - elevation (float): The elevation of the SSM curve. - xval (float): The x-value of the SSM curve. - yval (float): The y-value of the SSM curve. - amplitude (float): The amplitude of the SSM curve. - displacement (float): The displacement of the SSM curve. - r2 (float): The R2 fit of the SSM curve. - """ - - def __init__( - self, - scores: np.array, - scales: list, - angles: tuple = OCTANTS, - group: list = None, - measure: list | str = None, - bounds: tuple = BOUNDS, - ): - self.scores = scores - self.angles = angles - self.scales = scales - self.group = group - self.measure = measure - ( - self.elevation, - self.xval, - self.yval, - self.amplitude, - self.displacement, - self.r2, - ) = ssm_parameters(self.scores, self.angles, bounds=bounds) - - @property - def label(self) -> str: - """Return a label for the SSMParams object.""" - if self.group is not None and self.measure is not None: - return f"{self.group}_{self.measure}" - elif self.measure is not None: - return self.measure - elif self.group is not None: - return self.group - else: - return "SSM" - - @property - def table(self) -> pd.DataFrame: - """Return a table of the results.""" - scale_angle = {scale: angle for scale, angle in zip(self.scales, self.angles)} - return pd.DataFrame( - self.params | scale_angle, - index=[self.label], - ) - - @property - def params(self) -> dict: - return { - "label": self.label, - "group": self.group, - "measure": self.measure, - "elevation": self.elevation, - "xval": self.xval, - "yval": self.yval, - "amplitude": self.amplitude, - "displacement": self.displacement, - "r2": self.r2, - } - - def __repr__(self): - # TODO: Add param results - return f"SSMParams({self.label}, scores={self.scores}, angles={self.angles})" - - def __str__(self): - # TODO: Add param results - return ( - "====================================\n" - f"Measure: {self.measure}\n" - f"Group: {self.group}\n" - f"Scales: {self.scales}\n" - f"Scale Angles: {self.angles}\n" - f"\nProfile [All]:\n" - f" Estimate\n" - f"Elevation: {round(self.elevation, 3)}\n" - f"X-Value: {round(self.xval, 3)}\n" - f"Y-Value: {round(self.yval, 3)}\n" - f"Amplitude: {round(self.amplitude, 3)}\n" - f"Displacement: {round(self.displacement, 3)}\n" - f"R2: {round(self.r2, 3)}\n" - ) - - def profile_plot(self, ax=None, **kwargs) -> plt.Axes: - """ - Plot the SSM profile. - - Returns: - plt.Axes: A tuple containing the figure and axis objects. - """ - return profile_plot( - self.amplitude, - self.displacement, - self.elevation, - self.r2, - self.angles, - self.scores, - self.label, - ax=ax, - **kwargs, - ) - - def plot(self) -> plt.Axes: - """ - Plot the results in the circumplex - - Returns: - plt.Axes: A tuple containing the figure and axis objects. - """ - fig, ax = plt.subplots(subplot_kw={"projection": "polar"}) - ax.plot( - np.deg2rad(self.displacement), - self.amplitude, - color="black", - marker="o", - markersize=10, - ) - - -class SSMResults(object): - """ - A class to store the results of a SSM analysis. - - Attributes: - results (list[SSMParams]): A list containing the SSMParams results of the SSM analysis. - measures (list): A list of the names of the measures included in `scores`. - grouping (list): A list of the names of the groups included in `scores`. - """ - - def __init__( - self, results: list[SSMParams] | SSMParams, measures=None, grouping=None - ): - if isinstance(results, SSMParams): - measures = [results.measure] - grouping = [results.group] - results = [results] - - self.results = results - self.measures = measures - self.grouping = grouping - - def __str__(self): - return "\n".join([str(res) for res in self.results]) - - @property - def groups(self) -> set: - """Return a list of the groups included in the analysis.""" - return set(val.group for val in self.results if val.group is not None) - - @property - def labels(self) -> set: - """Return a list of the labels included in the analysis.""" - return set(val.label for val in self.results) - - @property - def table(self) -> pd.DataFrame: - """ - Return a table of the results. - - Returns: - pd.DataFrame: A dataframe containing the results of the SSM analysis. - """ - df = pd.DataFrame() - for val in self.results: - df = pd.concat([df, val.table]) - return df - - def query_label(self, label: str) -> SSMParams: - """Query the results for a specific SSMParams by label.""" - for res in self.results: - if res.label == label: - return res - raise ValueError( - f"No results found for {label}" - ) # Raised if the label is never found - - def plot(self, colors=None, legend=True, *args, **kwargs) -> plt.Axes: - """ - Plot the results in the circumplex - - Returns: - plt.Axes: A tuple containing the figure and axis objects. - """ - fig, ax = plt.subplots(subplot_kw={"projection": "polar"}) - if colors is None: - colors = colormaps.get_cmap("tab20").colors - colors = iter(colors) - for res in self.results: - ax.plot( - np.deg2rad(res.displacement), - res.amplitude, - color=next(colors), - marker="o", - markersize=10, - label=res.label, - ) - fig.legend(loc="upper right", bbox_to_anchor=(1.2, 1)) - return fig, ax - - def profile_plots(self, axes=None) -> plt.Axes: - """ - Plot the SSM profiles. - - Returns: - plt.Axes: A tuple containing the figure and axis objects. - """ - if axes is None: - fig, axes = plt.subplots( - nrows=len(self.results), - figsize=(8, 4 * len(self.results)), - ) - for i, res in enumerate(self.results): - # BUG: Raises error if we only need a single plot - fig, ax = res.profile_plot(ax=axes.flatten()[i]) - plt.tight_layout() - # plt.show() - return fig, axes - - -# %% - - -def ssm_analyse( - data: pd.DataFrame, - scales: list, - measures: list | None = None, - grouping: list | None = None, - angles: tuple = OCTANTS, - grouped_angles: dict = None, -) -> SSMResults: - """ - Analyse a set of data using the SSM method. - - Args: - data (pd.DataFrame): A dataframe containing the data to be analysed. - scales (list): A list of the names of the circumplex scales to be included in the analysis. - measures (list, optional): A list of the names of the measures to be included in the analysis. Defaults to None. - grouping (list, optional): A list of the names of the groups to be included in the analysis. Defaults to None. - angles (tuple, optional): A tuple containing the angular displacement of each circumplex scale - included in `scores`. Defaults to OCTANTS. - grouped_angles (dict, optional): A dictionary containing the angular displacement of each circumplex scale - included in `scores` for each group. Defaults to None. - - Returns: - SSMResults: A SSMResults object containing the results of the analysis. - - """ - if grouping is not None and measures is not None: - return ssm_analyse_grouped_corrs( - data, scales, measures, grouping, angles, grouped_angles - ) - elif measures is not None: - return ssm_analyse_corrs(data, scales, measures, angles) - elif grouping is not None: - return ssm_analyse_means(data, scales, grouping, angles, grouped_angles) - else: - ssm = SSMParams(data[scales].mean(), scales, angles) - # ssm.param_calc() - return SSMResults(ssm) - - -def ssm_analyse_grouped_corrs( - data: pd.DataFrame, - scales: tuple, - measures: list, - grouping: list, - angles: tuple = OCTANTS, - grouped_angles: dict = None, -) -> SSMResults: - """ - Perform SSM analysis of correlations for a set of grouped data. - - Args: - data (pd.DataFrame): A dataframe containing the data to be analysed. - scales (tuple): A list of the names of the circumplex scales to be included in the analysis. - measures (list): A list of the names of the measures to be included in the analysis. - grouping (list): A list of the names of the groups to be included in the analysis. - angles (tuple, optional): A tuple containing the angular displacement of each circumplex scale - included in `scores`. Defaults to OCTANTS. - - Returns: - SSMResults: A SSMResults object containing the results of the analysis. - """ - res = [] - for group_var in grouping: - for group, group_data in data.groupby(group_var): - if grouped_angles is not None: - angles = grouped_angles[group] # grouped angles will override angles - try: - res.append( - ssm_analyse_corrs( - group_data, scales, measures, angles, group=group - ).results[0] - ) - except ValueError as e: - print(f"Error: {e} | in {group_var} = {group}") - - return SSMResults(res, measures, grouping) - - -def ssm_analyse_corrs( - data: pd.DataFrame, - scales: tuple, - measures: list, - angles: tuple = OCTANTS, - group: str | None = None, -) -> SSMResults: - """ - Perform SSM analysis of correlations for a set of data. - - Args: - data (pd.DataFrame): A dataframe containing the data to be analysed. - scales (tuple): A list of the names of the circumplex scales to be included in the analysis. - measures (list): A list of the names of the measures to be included in the analysis. - angles (tuple, optional): A tuple containing the angular displacement of each circumplex scale - included in `scores`. Defaults to OCTANTS. - group (str, optional): The name of the group to be included in the analysis. Defaults to None. - - Returns: - SSMResults: A SSMResults object containing the results of the analysis. - """ - res = [] - for measure in measures: - r = data[scales].corrwith(data[measure]) - ssm = SSMParams(r, scales, angles, measure=measure, group=group) - # ssm.param_calc() - res.append(ssm) - - return SSMResults(res, measures) - - -def ssm_analyse_means( - data: pd.DataFrame, - scales: tuple, - grouping: list, - angles: tuple = OCTANTS, - grouped_angles: dict = None, -) -> SSMResults: - """ - Perform SSM analysis of means for a set of data. - - Args: - data (pd.DataFrame): A dataframe containing the data to be analysed. - scales (tuple): A list of the names of the circumplex scales to be included in the analysis. - grouping (list): A list of the names of the groups to be included in the analysis. - angles (tuple, optional): A tuple containing the angular displacement of each circumplex scale - included in `scores`. Defaults to OCTANTS. - - Returns: - SSMResults: A SSMResults object containing the results of the analysis. - """ - means = data.groupby(grouping)[scales].mean() - res = [] - for group, scores in means.iterrows(): - if grouped_angles is not None: - angles = grouped_angles[group] - scores = means.loc[group] - ssm = SSMParams(scores, scales, angles, group=group) - # ssm.param_calc() - res.append(ssm) - - return SSMResults(res, grouping=grouping) - - -def cosine_form(theta, ampl, disp, elev): - """Cosine function with amplitude, dispersion and elevation parameters.""" - return elev + ampl * np.cos(np.deg2rad(theta - disp)) - - -def _r2_score(y_true: np.array, y_pred: np.array): - """Calculate the R2 score for a set of predictions.""" - ss_res = np.sum(np.square(y_true - y_pred)) - ss_tot = np.sum(np.square(y_true - np.mean(y_true))) - return 1 - (ss_res / ss_tot) - - -def ssm_parameters(scores, angles, bounds=BOUNDS) -> tuple: - """Calculate SSM parameters (without confidence intervals) for a set of scores. - - Args: - scores (np.array): A numeric vector (or single row dataframe) containing one score for each of a - set of circumplex scales. - angles (tuple): A numeric vector containing the angular displacement of each circumplex scale - included in `scores`. - bounds (tuple, optional): The bounds for each of the parameters of the curve optimisation. - Defaults to ([0, 0, -1], [np.inf, 360, 1]). - - Returns: - tuple: A tuple containing the elevation, x-value, y-value, amplitude, displacement, and R2 fit of the SSM curve. - - Examples: - >>> scores = np.array([-0.5, 0, 0.25, 0.51, 0.52, 0.05, -0.26, -0.7]) - >>> angles = OCTANTS - >>> results = ssm_parameters(scores, angles) - >>> [round(i, 3) for i in results] - [-0.016, -0.478, 0.333, 0.582, 145.158, 0.967] - """ - - # noinspection PyTupleAssignmentBalance - # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off - # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution - param, covariance = curve_fit( - cosine_form, xdata=angles, ydata=scores, bounds=bounds - ) - r2 = _r2_score(scores, cosine_form(angles, *param)) - ampl, disp, elev = param - - def polar2cart(r, theta): - x = r * np.cos(theta) - y = r * np.sin(theta) - return x, y - - xval, yval = polar2cart(ampl, np.deg2rad(disp)) - return elev, xval, yval, ampl, disp, r2 - - -def profile_plot( - amplitude, - displacement, - elevation, - r2, - angles, - scores, - label, - ax=None, - reorder_scales=True, - incl_pred=True, - incl_fit=True, - incl_disp=True, - incl_amp=True, - c_scores="red", - c_fit="black", -) -> plt.Axes: - """ - Plot the SSM profile. - - Args: - reorder_scales: - incl_pred: - incl_fit: - incl_disp: - incl_amp: - - Returns: - plt.Axes: A tuple containing the figure and axis objects. - """ - - if ax is None: - fig, ax = plt.subplots(figsize=(8, 4)) - else: - fig = ax.get_figure() - - if reorder_scales: - angles, scores = sort_angles(angles, scores) - if angles[-1] == 360: - angles = (0,) + angles - scores = (scores[-1],) + scores - - if incl_pred: - thetas = np.linspace(0, 360, 1000) - fit = cosine_form(thetas, amplitude, displacement, elevation) - ax.plot(thetas, fit, color=c_fit) - - ax.plot(angles, scores, color=c_scores, marker="o") - # ax.scatter(self.angles, self.scores, marker="o", color="black") - if incl_disp: - ax.axvline(displacement, color="black", linestyle="--") - ax.text( - displacement + 5, - elevation, - f"d = {int(displacement)}", - ) - if incl_amp: - ax.axhline(amplitude + elevation, color="black", linestyle="--") - ax.text(0, amplitude + elevation * 0.9, f"a = {amplitude:.2f}") - - if incl_fit: - ax.text(0, elevation * 0.5, f"R2 = {r2:.2f}") - - ax.set_xticks(OCTANTS) - ax.set_xticklabels( - ["0", "45", "90", "135", "180", "225", "270", "315"], fontsize=14 - ) - ax.set_xlabel("Angle [deg]", fontsize=16) - ax.set_ylabel("Score", fontsize=16) - ax.set_title(f"{label} Profile", fontsize=20) - return fig, ax - - -def sort_angles(angles, scores): - """Sort angles, scores, and scales in order of scale.""" - # Zip the values and labels together - zipped = list(zip(angles, scores)) - # Sort the list of zipped tuples - zipped.sort(key=lambda x: x[0]) - # Unzip the list of tuples - angles, scores = zip(*zipped) - return angles, scores diff --git a/src/circumplex/core/__init__.py b/src/circumplex/core/__init__.py index c51b736..ed205cf 100644 --- a/src/circumplex/core/__init__.py +++ b/src/circumplex/core/__init__.py @@ -1,6 +1,3 @@ -from ssm_analysis import ssm_analyze -from ssm_results import SSMResults -from visualization import ssm_plot from instrument import Instrument, instruments __all__ = [ diff --git a/src/circumplex/core/instrument.py b/src/circumplex/core/instrument.py index af6bd0d..d901aab 100644 --- a/src/circumplex/core/instrument.py +++ b/src/circumplex/core/instrument.py @@ -1,5 +1,6 @@ +from typing import Any, Dict + import pandas as pd -from typing import Dict, Any class Instrument: diff --git a/src/circumplex/core/utils.py b/src/circumplex/core/utils.py deleted file mode 100644 index 6adcd0f..0000000 --- a/src/circumplex/core/utils.py +++ /dev/null @@ -1,38 +0,0 @@ -import numpy as np -from typing import Tuple - - -def cosine_form(theta, ampl, disp, elev): - """Cosine function with amplitude, dispersion and elevation parameters.""" - return elev + ampl * np.cos(theta - disp) - - -def angle_median(angles: np.ndarray) -> float: - """ - Calculate the median of circular data. - - Args: - angles (np.ndarray): Array of angles in radians. - - Returns: - float: Median angle in radians. - """ - return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) - - -def r2_score(y_true: np.array, y_pred: np.array): - """Calculate the R2 score for a set of predictions.""" - ss_res = np.sum(np.square(y_true - y_pred)) - ss_tot = np.sum(np.square(y_true - np.mean(y_true))) - return 1 - (ss_res / ss_tot) - - -OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) - - -def sort_angles( - angles: np.ndarray, scores: np.ndarray -) -> Tuple[np.ndarray, np.ndarray]: - """Sort angles and corresponding scores in ascending order.""" - sorted_indices = np.argsort(angles) - return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] diff --git a/src/circumplex/datasets.py b/src/circumplex/datasets.py index 9f3bcd2..3a122c9 100644 --- a/src/circumplex/datasets.py +++ b/src/circumplex/datasets.py @@ -1,7 +1,9 @@ # %% +from importlib.resources import files + import pandas as pd + from circumplex import instrument -from importlib.resources import files _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) JZ2017 = instrument.load_instrument("CSIP").attach_data(pd.read_csv(_jz2017_path)) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index 7b85a6e..20e1b26 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -10,7 +10,8 @@ import numpy as np import pandas as pd -from circumplex import SSMResults, ssm_analyse +import circumplex.ssm_analysis as ssm +import circumplex.ssm_results as ssm_results INSTRUMENT_JSONS = { "CSIP": str(files("circumplex.instruments").joinpath("CSIP.json")), @@ -318,8 +319,8 @@ def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrum def ssm_analyse( self, measures: list[str] = None, grouping: list[str] = None - ) -> SSMResults: - return ssm_analyse( + ) -> ssm_results.SSMResults: + return ssm.ssm_analyze( self.data, self.scales.abbrev, measures=measures, diff --git a/src/circumplex/core/ssm_analysis.py b/src/circumplex/ssm_analysis.py similarity index 94% rename from src/circumplex/core/ssm_analysis.py rename to src/circumplex/ssm_analysis.py index 1bbb71d..a2bd365 100644 --- a/src/circumplex/core/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -1,25 +1,31 @@ -import pandas as pd +from __future__ import annotations + +import warnings +from typing import Callable, List, Optional, Tuple, Union + import numpy as np +import pandas as pd from scipy.optimize import curve_fit -from typing import Optional, List, Union, Callable -from circumplex.core.ssm_results import SSMResults -from circumplex.core.utils import OCTANTS, cosine_form, r2_score + +import circumplex.ssm_results as ssm_results +import circumplex.utils as utils BOUNDS = ([0, 0, -np.inf], [np.inf, 2 * np.pi, np.inf]) +OCTANTS = utils.OCTANTS def ssm_analyze( data: pd.DataFrame, scales: List[str], - angles: Optional[List[float]] = OCTANTS, + angles: Optional[Tuple[float]] = OCTANTS, measures: Optional[List[str]] = None, grouping: Optional[str] = None, contrast: Optional[str] = "none", - boots: int = 2000, + boots: int = 500, interval: float = 0.95, listwise: bool = True, measures_labels: Optional[List[str]] = None, -) -> SSMResults: + ) -> ssm_results.SSMResults: """ Perform analyses using the Structural Summary Method. @@ -48,9 +54,9 @@ def ssm_analyze( assert all( scale in data.columns for scale in scales ), "All scales must be present in data" - assert isinstance(angles, list) and all( + assert isinstance(angles, tuple) and all( isinstance(a, (int, float)) for a in angles - ), "angles must be a list of numbers" + ), "angles must be a tuple of numbers" assert isinstance(boots, int) and boots > 0, "boots must be a positive integer" assert 0 < interval < 1, "interval must be between 0 and 1" assert isinstance(listwise, bool), "listwise must be a boolean" @@ -123,17 +129,6 @@ def ssm_analyze( data, scales, angles_rad, None, "none", boots, interval, listwise ) - # Calculate scores - if measures is not None: - scores = corr_scores( - data[scales], data[measures], data[grouping] if grouping else None, listwise - ) - else: - scores = ( - data[scales] - .groupby(data[grouping] if grouping else pd.Series(["All"] * len(data))) - .mean() - ) # Create the call string call_str = ( @@ -143,8 +138,9 @@ def ssm_analyze( ) # Create and return the SSMResults object - return SSMResults( + return ssm_results.SSMResults( results=results["results"], + scales=scales, scores=results["scores"], details=results["details"], call=call_str, @@ -154,7 +150,7 @@ def ssm_analyze( def ssm_analyze_means( data: pd.DataFrame, scales: List[str], - angles: List[float], + angles: Tuple[float], grouping: Optional[str] = None, contrast: str = "none", boots: int = 2000, @@ -250,7 +246,7 @@ def bs_function(data, index, angles, contrast, listwise): def ssm_by_group( - scores: pd.DataFrame, angles: List[float], contrast: str + scores: pd.DataFrame, angles: Tuple[float], contrast: str ) -> np.ndarray: """ Calculate SSM parameters for each group, potentially with contrast. @@ -282,7 +278,7 @@ def ssm_by_group( return results -def group_parameters(scores: np.ndarray, angles: List[float]) -> np.ndarray: +def group_parameters(scores: np.ndarray, angles: Tuple[float]) -> np.ndarray: """ Calculate the SSM parameters as a vector for each group where rows are groups. @@ -302,7 +298,7 @@ def group_parameters(scores: np.ndarray, angles: List[float]) -> np.ndarray: return out -def ssm_parameters(scores: np.ndarray, angles: List[float], bounds=BOUNDS) -> np.array: +def ssm_parameters(scores: np.ndarray, angles: Tuple[float], bounds=BOUNDS) -> np.array: """Calculate SSM parameters (without confidence intervals) for a set of scores. Args: @@ -328,9 +324,9 @@ def ssm_parameters(scores: np.ndarray, angles: List[float], bounds=BOUNDS) -> np # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution param, covariance = curve_fit( - cosine_form, xdata=angles, ydata=scores, bounds=bounds + utils.cosine_form, xdata=angles, ydata=scores, bounds=bounds ) - r2 = r2_score(scores, cosine_form(angles, *param)) + r2 = utils.r2_score(scores, utils.cosine_form(angles, *param)) ampl, disp, elev = param def polar2cart(r, theta): @@ -345,7 +341,7 @@ def polar2cart(r, theta): def ssm_bootstrap( bs_input: pd.DataFrame, bs_function: Callable, - angles: List[float], + angles: Tuple[float], boots: int, interval: float, contrast: str, @@ -414,7 +410,7 @@ def ssm_bootstrap( def ssm_analyze_corrs( data: pd.DataFrame, scales: List[str], - angles: List[float], + angles: Tuple[float], measures: List[str], grouping: Optional[str] = None, contrast: str = "none", @@ -444,11 +440,22 @@ def ssm_analyze_corrs( # Select circumplex scales, measure variables, and grouping variable if grouping is not None: bs_input = data[scales + measures + [grouping]].copy() + # Perform listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() bs_input["Group"] = bs_input[grouping].astype("category") + if bs_input["Group"].nunique() != data[grouping].nunique(): + warnings.warn("Listwise deletion removed some groups.") + else: bs_input = data[scales + measures].copy() + # Perform listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() bs_input["Group"] = "All" bs_input["Group"] = bs_input["Group"].astype("category") + if bs_input.empty: + raise ValueError("No data remains after listwise deletion.") # Check that this combination of arguments is executable n_measures = len(measures) @@ -463,10 +470,6 @@ def ssm_analyze_corrs( "ensure there is 1 measure and a dichotomous grouping variable." ) - # Perform listwise deletion if requested - if listwise: - bs_input = bs_input.dropna() - # Select and label results if measures_labels is None: measure_names = measures @@ -658,6 +661,7 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: if __name__ == "__main__": ######## SCRATCH ######## from importlib.resources import files + import matplotlib.pyplot as plt _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) diff --git a/src/circumplex/core/ssm_results.py b/src/circumplex/ssm_results.py similarity index 88% rename from src/circumplex/core/ssm_results.py rename to src/circumplex/ssm_results.py index 98ce4d1..4690835 100644 --- a/src/circumplex/core/ssm_results.py +++ b/src/circumplex/ssm_results.py @@ -1,19 +1,24 @@ -import pandas as pd -from typing import Dict, Any +from __future__ import annotations + +from typing import Any, Dict, List +import pandas as pd from matplotlib import pyplot as plt -from circumplex.core.visualization import ssm_profile_plot + +import circumplex.visualization as vis class SSMResults: def __init__( self, results: pd.DataFrame, + scales: List[str], scores: pd.DataFrame, details: Dict[str, Any], call: str, ): self.results = results + self.scales = scales self.scores = scores self.details = details self.call = call @@ -72,15 +77,18 @@ def profile_plot(self, **kwargs): axes = [axes] for i, (ax, (_, row)) in enumerate(zip(axes, results.iterrows())): - fig, ax = ssm_profile_plot( - scores=scores.iloc[i].values[:-3], + fig, ax = vis.ssm_profile_plot( + scores=scores.iloc[i][self.scales], angles=details["angles"], amplitude=row["a_est"], displacement=row["d_est"], elevation=row["e_est"], r2=row["fit_est"], - title=f"{scores.iloc[i].values[-1]} Profile", + title=f"{results.iloc[i]['label']} Profile", ax=ax, **kwargs, ) + + plt.tight_layout() + return fig, axes diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 1acc968..5c137fe 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -1,29 +1,38 @@ +from typing import Tuple + import numpy as np -import pandas as pd -from circumplex.instrument import Scales, Instrument - - -def standardize( - data: pd.DataFrame, - scales: Scales, - angles: np.array, - instrument: Instrument, - sample: int = 1, - prefix: str = "", - suffix: str = "_z", -): - scale_names = scales.abbrev - assert len(scale_names) == len(angles) - - key = instrument.norms.get_sample(sample) - assert len(scale_names) == len(key) - - for i in range(len(angles)): - scale_i = scale_names[i] - new_var = f"{prefix}{scale_i}{suffix}" - index_i = key["angle"][i] - m_i = key["m"][i] - s_i = key["sd"][i] - data[new_var] = (data[scale_i] - m_i) / s_i - - return data + +OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) + + +def cosine_form(theta, ampl, disp, elev): + """Cosine function with amplitude, dispersion and elevation parameters.""" + return elev + ampl * np.cos(theta - disp) + + +def angle_median(angles: np.ndarray) -> float: + """ + Calculate the median of circular data. + + Args: + angles (np.ndarray): Array of angles in radians. + + Returns: + float: Median angle in radians. + """ + return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) + + +def r2_score(y_true: np.array, y_pred: np.array): + """Calculate the R2 score for a set of predictions.""" + ss_res = np.sum(np.square(y_true - y_pred)) + ss_tot = np.sum(np.square(y_true - np.mean(y_true))) + return 1 - (ss_res / ss_tot) + + +def sort_angles( + angles: np.ndarray, scores: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """Sort angles and corresponding scores in ascending order.""" + sorted_indices = np.argsort(angles) + return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] diff --git a/src/circumplex/core/visualization.py b/src/circumplex/visualization.py similarity index 93% rename from src/circumplex/core/visualization.py rename to src/circumplex/visualization.py index d63f649..2464a99 100644 --- a/src/circumplex/core/visualization.py +++ b/src/circumplex/visualization.py @@ -1,14 +1,18 @@ +from __future__ import annotations + +from typing import List, Optional, Tuple + +import matplotlib.patches as patches import matplotlib.pyplot as plt -import seaborn as sns import numpy as np import pandas as pd -from typing import Optional, List, Tuple -from circumplex import SSMResults -import matplotlib.patches as patches -from circumplex.core.utils import cosine_form, OCTANTS, sort_angles +import seaborn as sns + +import circumplex.ssm_results as ssm_results +import circumplex.utils as utils -def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): +def ssm_plot(ssm_object: ssm_results.SSMResults, fontsize: int = 12, **kwargs): """ Create a figure from SSM results. @@ -21,7 +25,7 @@ def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): matplotlib.figure.Figure: A figure object representing the plot. """ assert isinstance( - ssm_object, SSMResults + ssm_object, ssm_results.SSMResults ), "ssm_object must be an SSMResults instance" assert fontsize > 0, "fontsize must be a positive number" @@ -34,7 +38,7 @@ def ssm_plot(ssm_object: SSMResults, fontsize: int = 12, **kwargs): def ssm_plot_circle( - ssm_object: SSMResults, + ssm_object: ssm_results.SSMResults, amax: Optional[float] = None, legend_font_size: int = 12, scale_font_size: int = 12, @@ -205,7 +209,7 @@ def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): def ssm_plot_contrast( - ssm_object: SSMResults, + ssm_object: ssm_results.SSMResults, axislabel: str = "Difference", xy: bool = True, color: str = "red", @@ -363,20 +367,20 @@ def ssm_profile_plot( fig = ax.get_figure() assert len(scores) == len(angles), "Scores and angles must be the same length." - assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." + # assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." assert 0 <= r2 <= 1, "R2 must be between 0 and 1." assert 0 <= amplitude, "Amplitude must be a positive number." assert 0 <= displacement <= 360, "Displacement must be between 0 and 360." if reorder_scales: - angles, scores = sort_angles(angles, scores) + angles, scores = utils.sort_angles(angles, scores) if angles[-1] == 360: angles = (0,) + angles scores = (scores[-1],) + scores if incl_pred: thetas = np.linspace(0, 360, 1000) - fit = cosine_form( + fit = utils.cosine_form( np.deg2rad(thetas), amplitude, np.deg2rad(displacement), elevation ) ax.plot(thetas, fit, color=c_fit) @@ -392,17 +396,20 @@ def ssm_profile_plot( if incl_amp: ax.axhline(amplitude + elevation, color="black", linestyle="--") ax.text( - 0, amplitude + elevation * 0.9, f"a = {amplitude:.2f}", fontsize=fontsize + 0, elevation + amplitude * 0.5, f"a = {amplitude:.2f}", fontsize=fontsize ) if incl_fit: - ax.text(0, elevation * 0.5, f"R2 = {r2:.2f}", fontsize=fontsize) + ylim = ax.get_ylim() + ax.text( + 0, ylim[0] + 0.25 * (ylim[1] - ylim[0]), f"R2 = {r2:.2f}", fontsize=fontsize + ) if incl_elev: ax.axhline(elevation, color="black", linestyle="--") ax.text(0, elevation, f"e = {elevation:.2f}", fontsize=fontsize) - ax.set_xticks(OCTANTS) + ax.set_xticks(utils.OCTANTS) ax.set_xticklabels( ["0", "45", "90", "135", "180", "225", "270", "315"], fontsize=fontsize ) @@ -410,5 +417,4 @@ def ssm_profile_plot( ax.set_ylabel("Score", fontsize=fontsize + 2) ax.set_title(title, fontsize=fontsize + 4) - plt.tight_layout() return fig, ax From 2b4438ba1f5092e3ecfc2418ab230931bbd9c67c Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Thu, 11 Jul 2024 14:17:31 +0100 Subject: [PATCH 12/97] `ssm_parameters` always accepts and returns degrees --- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 24 +-- src/circumplex/__init__.py | 3 +- src/circumplex/ssm_analysis.py | 25 ++-- src/circumplex/visualization.py | 3 +- tests/test_analysis.py | 51 ------- tests/test_ssm_analysis.py | 164 +++++++++++++++++++++ 6 files changed, 190 insertions(+), 80 deletions(-) delete mode 100644 tests/test_analysis.py create mode 100644 tests/test_ssm_analysis.py diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index 866fb47..3822f0a 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -20,8 +20,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-07-11T10:13:24.397218Z", - "start_time": "2024-07-11T10:13:23.642241Z" + "end_time": "2024-07-11T13:16:34.292181Z", + "start_time": "2024-07-11T13:16:33.593084Z" } }, "source": [ @@ -82,8 +82,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:13:24.510307Z", - "start_time": "2024-07-11T10:13:24.398223Z" + "end_time": "2024-07-11T13:16:34.451726Z", + "start_time": "2024-07-11T13:16:34.293225Z" } }, "id": "b2b2c99827c47a27", @@ -133,8 +133,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:13:27.097333Z", - "start_time": "2024-07-11T10:13:24.512490Z" + "end_time": "2024-07-11T13:16:36.945120Z", + "start_time": "2024-07-11T13:16:34.453249Z" } }, "id": "21f5a12726008489", @@ -176,8 +176,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:13:27.163979Z", - "start_time": "2024-07-11T10:13:27.098006Z" + "end_time": "2024-07-11T13:16:38.593371Z", + "start_time": "2024-07-11T13:16:38.515247Z" } }, "id": "c90c1bcb4a07781b", @@ -193,7 +193,7 @@ "output_type": "display_data" } ], - "execution_count": 4 + "execution_count": 5 }, { "cell_type": "markdown", @@ -218,8 +218,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:13:27.232310Z", - "start_time": "2024-07-11T10:13:27.165419Z" + "end_time": "2024-07-11T13:16:45.499564Z", + "start_time": "2024-07-11T13:16:45.423564Z" } }, "id": "c826947d0b98109e", @@ -235,7 +235,7 @@ "output_type": "display_data" } ], - "execution_count": 5 + "execution_count": 6 }, { "cell_type": "markdown", diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index 3793267..297372a 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -1,10 +1,11 @@ -from circumplex import utils +from circumplex import ssm_analysis, utils from circumplex.instrument import Instrument, instruments from circumplex.ssm_analysis import ssm_analyze from circumplex.ssm_results import SSMResults from circumplex.visualization import ssm_plot, ssm_profile_plot __all__ = [ + "ssm_analysis", "ssm_analyze", "SSMResults", "ssm_plot", diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index a2bd365..467311d 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -79,9 +79,6 @@ def ssm_analyze( measures ), "measures_labels must have the same length as measures" - # Convert angles from degrees to radians - angles_rad = np.deg2rad(angles) - # Determine analysis type and forward to appropriate subfunction if measures is not None: if grouping is not None: @@ -89,7 +86,7 @@ def ssm_analyze( results = ssm_analyze_corrs( data, scales, - angles_rad, + angles, measures, grouping, contrast, @@ -103,7 +100,7 @@ def ssm_analyze( results = ssm_analyze_corrs( data, scales, - angles_rad, + angles, measures, None, contrast, @@ -116,7 +113,7 @@ def ssm_analyze( if grouping is not None: # Multiple group means results = ssm_analyze_means( - data, scales, angles_rad, grouping, contrast, boots, interval, listwise + data, scales, angles, grouping, contrast, boots, interval, listwise ) else: # Single group means @@ -126,7 +123,7 @@ def ssm_analyze( "Set contrast = 'none' or add the measures or grouping arguments." ) results = ssm_analyze_means( - data, scales, angles_rad, None, "none", boots, interval, listwise + data, scales, angles, None, "none", boots, interval, listwise ) @@ -230,7 +227,7 @@ def bs_function(data, index, angles, contrast, listwise): "boots": boots, "interval": interval, "listwise": listwise, - "angles": np.rad2deg(angles), + "angles": angles, "contrast": contrast, "score_type": "Mean", "results_type": "Profile" if contrast == "none" else "Contrast", @@ -324,9 +321,9 @@ def ssm_parameters(scores: np.ndarray, angles: Tuple[float], bounds=BOUNDS) -> n # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution param, covariance = curve_fit( - utils.cosine_form, xdata=angles, ydata=scores, bounds=bounds + utils.cosine_form, xdata=np.deg2rad(angles), ydata=scores, bounds=bounds ) - r2 = utils.r2_score(scores, utils.cosine_form(angles, *param)) + r2 = utils.r2_score(scores, utils.cosine_form(np.deg2rad(angles), *param)) ampl, disp, elev = param def polar2cart(r, theta): @@ -335,7 +332,7 @@ def polar2cart(r, theta): return x, y xval, yval = polar2cart(ampl, disp) - return np.array([elev, xval, yval, ampl, disp, r2]) + return np.array([elev, xval, yval, ampl, np.rad2deg(disp), r2]) def ssm_bootstrap( @@ -401,8 +398,6 @@ def ssm_bootstrap( # Combine results and convert radians to degrees for displacement results = pd.concat([bs_est, bs_lci, bs_uci], axis=1) - for col in ["d_est", "d_lci", "d_uci"]: - results[col] = np.rad2deg(results[col]) return results @@ -537,7 +532,7 @@ def bs_function(data, index, angles, contrast, listwise): "boots": boots, "interval": interval, "listwise": listwise, - "angles": np.rad2deg(angles), + "angles": angles, "contrast": contrast, "score_type": "Correlation", "results_type": "Profile" if contrast == "none" else "Contrast", @@ -670,7 +665,7 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: results = ssm_analyze( data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - angles=[90, 135, 180, 225, 270, 315, 0, 45], + angles=(90, 135, 180, 225, 270, 315, 0, 45), # grouping="Gender", # contrast='model', measures=["NARPD", "ASPD"], diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index 2464a99..f0f7870 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -368,7 +368,8 @@ def ssm_profile_plot( assert len(scores) == len(angles), "Scores and angles must be the same length." # assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." - assert 0 <= r2 <= 1, "R2 must be between 0 and 1." + if r2 is not None: + assert 0 <= r2 <= 1, "R2 must be between 0 and 1." assert 0 <= amplitude, "Amplitude must be a positive number." assert 0 <= displacement <= 360, "Displacement must be between 0 and 360." diff --git a/tests/test_analysis.py b/tests/test_analysis.py deleted file mode 100644 index 24a4803..0000000 --- a/tests/test_analysis.py +++ /dev/null @@ -1,51 +0,0 @@ -import numpy as np -import pandas as pd -import pytest - -import circumplex - -SCALES = ("V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8") - - -def fixed_data(angles=circumplex.OCTANTS, ampl=0.5, disp=180, elev=0): - return circumplex.cosine_form(np.array(angles), ampl, disp, elev) - - -@pytest.fixture -def ssm_params(): - scores = fixed_data() - ssm_params = circumplex.SSMParams( - scores, SCALES, circumplex.OCTANTS, group="group", measure="measure" - ) - return ssm_params - - -def test_ssm_parameters(): - # elev, xval, yval, ampl, disp, r2 - fix_data = fixed_data() - fixed_ssm = circumplex.ssm_parameters(fix_data, circumplex.OCTANTS) - np.testing.assert_allclose(fixed_ssm, (0.0, -0.5, 0, 0.5, 180, 1.0), atol=1e-4) - - fix_data = fixed_data(ampl=0.5, disp=45, elev=0) - fixed_ssm = circumplex.ssm_parameters(fix_data, circumplex.OCTANTS) - np.testing.assert_allclose( - fixed_ssm, (0.0, 0.35355, 0.35355, 0.5, 45, 1.0), atol=1e-4 - ) - - fix_data = fixed_data(ampl=0.3, disp=90, elev=0.1) - fixed_ssm = circumplex.ssm_parameters(fix_data, circumplex.OCTANTS) - np.testing.assert_allclose(fixed_ssm, (0.1, 0.0, 0.3, 0.3, 90, 1.0), atol=1e-4) - - -def test_label(ssm_params): - assert ssm_params.label == "group_measure" - - -def test_table(ssm_params): - assert isinstance(ssm_params.table, pd.DataFrame) - - -def test_params(ssm_params): - params = ssm_params.params - assert isinstance(params, dict) - assert len(params) == 9 diff --git a/tests/test_ssm_analysis.py b/tests/test_ssm_analysis.py new file mode 100644 index 0000000..ece9f9d --- /dev/null +++ b/tests/test_ssm_analysis.py @@ -0,0 +1,164 @@ +import numpy as np +import pandas as pd +import pytest + +from circumplex import SSMResults, ssm_analysis, utils + +SCALES = ("V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8") +OCTANTS = utils.OCTANTS + + +def fixed_data(angles=OCTANTS, ampl=0.5, disp=180, elev: float = 0): + return utils.cosine_form(np.deg2rad(angles), ampl, np.deg2rad(disp), elev) + + +def generate_circumplex_data(angles, amplitude, displacement, elevation): + """Generate circumplex data with known parameters.""" + scores = elevation + amplitude * np.cos(np.deg2rad(angles) - np.deg2rad(displacement)) + return scores + + +@pytest.fixture +def sample_data(): + np.random.seed(42) + return pd.DataFrame({ + 'PA' : np.random.rand(100), + 'BC' : np.random.rand(100), + 'DE' : np.random.rand(100), + 'FG' : np.random.rand(100), + 'HI' : np.random.rand(100), + 'JK' : np.random.rand(100), + 'LM' : np.random.rand(100), + 'NO' : np.random.rand(100), + 'measure1': np.random.rand(100), + 'measure2': np.random.rand(100), + 'group' : np.random.choice(['A', 'B'], size=100) + } + ) + + +@pytest.fixture +def scales(): + return ['PA', 'BC', 'DE', 'FG', 'HI', 'JK', 'LM', 'NO'] + + +@pytest.fixture +def angles(): + return OCTANTS + + +def test_ssm_analyze_basic(sample_data, scales, angles): + result = ssm_analysis.ssm_analyze(sample_data, scales, angles, boots=50) + assert isinstance(result, SSMResults) + assert len(result.results) == 1 # One row for overall results + + +def test_ssm_analyze_with_measures(sample_data, scales, angles): + result = ssm_analysis.ssm_analyze(sample_data, scales, angles, measures=['measure1', 'measure2'], boots=50) + assert isinstance(result, SSMResults) + assert len(result.results) == 2 # One row for each measure + + +def test_ssm_analyze_with_grouping(sample_data, scales, angles): + result = ssm_analysis.ssm_analyze(sample_data, scales, angles, grouping='group', boots=50) + assert isinstance(result, SSMResults) + assert len(result.results) == 2 # One row for each group + + +def test_ssm_analyze_with_contrast(sample_data, scales, angles): + result = ssm_analysis.ssm_analyze(sample_data, scales, angles, grouping='group', contrast='test', boots=50) + assert isinstance(result, SSMResults) + assert len(result.results) == 1 # One row for the contrast + + +def test_ssm_parameters_return(angles): + scores = np.array([0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9]) + angles_rad = np.deg2rad(angles) + params = ssm_analysis.ssm_parameters(scores, angles_rad) + assert len(params) == 6 # Should return 6 parameters + + +def test_group_parameters(angles): + scores = np.array([[0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9], + [0.4, 0.6, 0.2, 0.3, 0.7, 0.5, 0.3, 0.8]] + ) + angles_rad = np.deg2rad(angles) + params = ssm_analysis.group_parameters(scores, angles_rad) + assert len(params) == 12 # Should return 12 parameters (6 for each group) + + +def test_ssm_bootstrap(sample_data, scales, angles): + bs_input = sample_data[scales + ['group']] + + def bs_function(data, index, angles, contrast, listwise): + return np.random.rand(6) # Mock function + + result = ssm_analysis.ssm_bootstrap( + bs_input, bs_function, np.deg2rad(angles), + 100, 0.95, 'none', True, bs_input['group'] + ) + assert isinstance(result, pd.DataFrame) + assert result.shape[1] == 18 # 6 parameters * 3 (est, lci, uci) + + +def test_invalid_input(sample_data, angles): + with pytest.raises(AssertionError): + ssm_analysis.ssm_analyze(sample_data, ['invalid_scale'], angles, boots=50) + + +def test_missing_data(sample_data, scales, angles): + data_with_nan = sample_data.copy() + data_with_nan.loc[0, 'PA'] = np.nan + result = ssm_analysis.ssm_analyze(data_with_nan, scales, angles, boots=50) + assert isinstance(result, SSMResults) + + +def test_ssm_parameters(): + # elev, xval, yval, ampl, disp, r2 + fix_data = fixed_data() + fixed_ssm = ssm_analysis.ssm_parameters(fix_data, utils.OCTANTS) + np.testing.assert_allclose(fixed_ssm, (0.0, -0.5, 0, 0.5, 180, 1.0), atol=1e-4) + + fix_data = fixed_data(ampl=0.5, disp=45, elev=0) + fixed_ssm = ssm_analysis.ssm_parameters(fix_data, utils.OCTANTS) + np.testing.assert_allclose( + fixed_ssm, (0.0, 0.35355, 0.35355, 0.5, 45, 1.0), atol=1e-4 + ) + + fix_data = fixed_data(ampl=0.3, disp=90, elev=0.1) + fixed_ssm = ssm_analysis.ssm_parameters(fix_data, utils.OCTANTS) + np.testing.assert_allclose(fixed_ssm, (0.1, 0.0, 0.3, 0.3, 90, 1.0), atol=1e-4) + + +@pytest.mark.parametrize("amplitude, displacement, elevation", [ + (1.0, 3, 0.5), # 3 degrees + (1.0, 90, 0.5), # 90 degrees + (1.0, 180, 0.5), # 180 degrees + (1.0, 270, 0.5), # 270 degrees + (1.0, 45, 0.5), # 45 degrees + (2.0, 30, 1.0), # Larger amplitude + (0.2, 60, 0.1), # Smaller amplitude + (1.5, 135, 0.5), # Arbitrary values + ] + ) +def test_ssm_parameters_correctness(amplitude, displacement, elevation): + scores = generate_circumplex_data(OCTANTS, amplitude, displacement, elevation) + + # Calculate expected x and y values + expected_x = amplitude * np.cos(np.deg2rad(displacement)) + expected_y = amplitude * np.sin(np.deg2rad(displacement)) + expected_r2 = 1.0 # Perfect fit for simulated data + + # Run ssm_parameters + params = ssm_analysis.ssm_parameters(scores, OCTANTS) + + # Extract results + result_elevation, result_x, result_y, result_amplitude, result_displacement, result_r2 = params + + # Assert correctness with some tolerance for floating-point precision + np.testing.assert_allclose(result_elevation, elevation, atol=1e-7) + np.testing.assert_allclose(result_x, expected_x, atol=1e-7) + np.testing.assert_allclose(result_y, expected_y, atol=1e-7) + np.testing.assert_allclose(result_amplitude, amplitude, atol=1e-7) + np.testing.assert_allclose(result_displacement, displacement, atol=1e-7) + np.testing.assert_allclose(result_r2, expected_r2, atol=1e-7) From 3565192b94e0b7cfd22cf3b1028643238e336f98 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Thu, 11 Jul 2024 14:55:05 +0100 Subject: [PATCH 13/97] Add visualisation tests --- src/circumplex/ssm_analysis.py | 1 - tests/test_ssm_analysis.py | 101 ++++++++++------ tests/test_visualisation.py | 214 +++++++++++++++++++++++++++++++++ 3 files changed, 278 insertions(+), 38 deletions(-) create mode 100644 tests/test_visualisation.py diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index 467311d..ffd27dd 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -126,7 +126,6 @@ def ssm_analyze( data, scales, angles, None, "none", boots, interval, listwise ) - # Create the call string call_str = ( f"ssm_analyze(data, scales={scales}, angles={angles}, measures={measures}, " diff --git a/tests/test_ssm_analysis.py b/tests/test_ssm_analysis.py index ece9f9d..fc43b93 100644 --- a/tests/test_ssm_analysis.py +++ b/tests/test_ssm_analysis.py @@ -14,32 +14,35 @@ def fixed_data(angles=OCTANTS, ampl=0.5, disp=180, elev: float = 0): def generate_circumplex_data(angles, amplitude, displacement, elevation): """Generate circumplex data with known parameters.""" - scores = elevation + amplitude * np.cos(np.deg2rad(angles) - np.deg2rad(displacement)) + scores = elevation + amplitude * np.cos( + np.deg2rad(angles) - np.deg2rad(displacement) + ) return scores @pytest.fixture def sample_data(): np.random.seed(42) - return pd.DataFrame({ - 'PA' : np.random.rand(100), - 'BC' : np.random.rand(100), - 'DE' : np.random.rand(100), - 'FG' : np.random.rand(100), - 'HI' : np.random.rand(100), - 'JK' : np.random.rand(100), - 'LM' : np.random.rand(100), - 'NO' : np.random.rand(100), - 'measure1': np.random.rand(100), - 'measure2': np.random.rand(100), - 'group' : np.random.choice(['A', 'B'], size=100) + return pd.DataFrame( + { + "PA" : np.random.rand(100), + "BC" : np.random.rand(100), + "DE" : np.random.rand(100), + "FG" : np.random.rand(100), + "HI" : np.random.rand(100), + "JK" : np.random.rand(100), + "LM" : np.random.rand(100), + "NO" : np.random.rand(100), + "measure1": np.random.rand(100), + "measure2": np.random.rand(100), + "group" : np.random.choice(["A", "B"], size=100), } ) @pytest.fixture def scales(): - return ['PA', 'BC', 'DE', 'FG', 'HI', 'JK', 'LM', 'NO'] + return ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"] @pytest.fixture @@ -54,19 +57,25 @@ def test_ssm_analyze_basic(sample_data, scales, angles): def test_ssm_analyze_with_measures(sample_data, scales, angles): - result = ssm_analysis.ssm_analyze(sample_data, scales, angles, measures=['measure1', 'measure2'], boots=50) + result = ssm_analysis.ssm_analyze( + sample_data, scales, angles, measures=["measure1", "measure2"], boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 2 # One row for each measure def test_ssm_analyze_with_grouping(sample_data, scales, angles): - result = ssm_analysis.ssm_analyze(sample_data, scales, angles, grouping='group', boots=50) + result = ssm_analysis.ssm_analyze( + sample_data, scales, angles, grouping="group", boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 2 # One row for each group def test_ssm_analyze_with_contrast(sample_data, scales, angles): - result = ssm_analysis.ssm_analyze(sample_data, scales, angles, grouping='group', contrast='test', boots=50) + result = ssm_analysis.ssm_analyze( + sample_data, scales, angles, grouping="group", contrast="test", boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 1 # One row for the contrast @@ -79,23 +88,32 @@ def test_ssm_parameters_return(angles): def test_group_parameters(angles): - scores = np.array([[0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9], - [0.4, 0.6, 0.2, 0.3, 0.7, 0.5, 0.3, 0.8]] - ) + scores = np.array( + [ + [0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9], + [0.4, 0.6, 0.2, 0.3, 0.7, 0.5, 0.3, 0.8], + ] + ) angles_rad = np.deg2rad(angles) params = ssm_analysis.group_parameters(scores, angles_rad) assert len(params) == 12 # Should return 12 parameters (6 for each group) def test_ssm_bootstrap(sample_data, scales, angles): - bs_input = sample_data[scales + ['group']] + bs_input = sample_data[scales + ["group"]] def bs_function(data, index, angles, contrast, listwise): return np.random.rand(6) # Mock function result = ssm_analysis.ssm_bootstrap( - bs_input, bs_function, np.deg2rad(angles), - 100, 0.95, 'none', True, bs_input['group'] + bs_input, + bs_function, + np.deg2rad(angles), + 100, + 0.95, + "none", + True, + bs_input["group"], ) assert isinstance(result, pd.DataFrame) assert result.shape[1] == 18 # 6 parameters * 3 (est, lci, uci) @@ -103,12 +121,12 @@ def bs_function(data, index, angles, contrast, listwise): def test_invalid_input(sample_data, angles): with pytest.raises(AssertionError): - ssm_analysis.ssm_analyze(sample_data, ['invalid_scale'], angles, boots=50) + ssm_analysis.ssm_analyze(sample_data, ["invalid_scale"], angles, boots=50) def test_missing_data(sample_data, scales, angles): data_with_nan = sample_data.copy() - data_with_nan.loc[0, 'PA'] = np.nan + data_with_nan.loc[0, "PA"] = np.nan result = ssm_analysis.ssm_analyze(data_with_nan, scales, angles, boots=50) assert isinstance(result, SSMResults) @@ -130,17 +148,19 @@ def test_ssm_parameters(): np.testing.assert_allclose(fixed_ssm, (0.1, 0.0, 0.3, 0.3, 90, 1.0), atol=1e-4) -@pytest.mark.parametrize("amplitude, displacement, elevation", [ - (1.0, 3, 0.5), # 3 degrees - (1.0, 90, 0.5), # 90 degrees - (1.0, 180, 0.5), # 180 degrees - (1.0, 270, 0.5), # 270 degrees - (1.0, 45, 0.5), # 45 degrees - (2.0, 30, 1.0), # Larger amplitude - (0.2, 60, 0.1), # Smaller amplitude - (1.5, 135, 0.5), # Arbitrary values - ] - ) +@pytest.mark.parametrize( + "amplitude, displacement, elevation", + [ + (1.0, 3, 0.5), # 3 degrees + (1.0, 90, 0.5), # 90 degrees + (1.0, 180, 0.5), # 180 degrees + (1.0, 270, 0.5), # 270 degrees + (1.0, 45, 0.5), # 45 degrees + (2.0, 30, 1.0), # Larger amplitude + (0.2, 60, 0.1), # Smaller amplitude + (1.5, 135, 0.5), # Arbitrary values + ], + ) def test_ssm_parameters_correctness(amplitude, displacement, elevation): scores = generate_circumplex_data(OCTANTS, amplitude, displacement, elevation) @@ -153,7 +173,14 @@ def test_ssm_parameters_correctness(amplitude, displacement, elevation): params = ssm_analysis.ssm_parameters(scores, OCTANTS) # Extract results - result_elevation, result_x, result_y, result_amplitude, result_displacement, result_r2 = params + ( + result_elevation, + result_x, + result_y, + result_amplitude, + result_displacement, + result_r2, + ) = params # Assert correctness with some tolerance for floating-point precision np.testing.assert_allclose(result_elevation, elevation, atol=1e-7) diff --git a/tests/test_visualisation.py b/tests/test_visualisation.py new file mode 100644 index 0000000..a180097 --- /dev/null +++ b/tests/test_visualisation.py @@ -0,0 +1,214 @@ +import matplotlib.pyplot as plt +import pandas as pd +import pytest +from matplotlib.collections import PathCollection +from matplotlib.patches import Circle, Wedge + +from circumplex import SSMResults, visualization + +SCALES = ["V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8"] + + +@pytest.fixture +def mock_ssm_results(): + results = pd.DataFrame( + { + "label" : ["Group A", "Group B"], + "e_est" : [0.5, 0.7], + "x_est" : [1.0, -0.5], + "y_est" : [0.5, 1.0], + "a_est" : [1.12, 1.12], + "d_est" : [26.57, 116.57], + "fit_est": [1.0, 1.0], + "e_lci" : [0.3, 0.5], + "x_lci" : [0.8, -0.7], + "y_lci" : [0.3, 0.8], + "a_lci" : [0.9, 0.9], + "d_lci" : [20.0, 110.0], + "fit_lci": [0.7, 0.8], + "e_uci" : [0.7, 0.9], + "x_uci" : [1.2, -0.3], + "y_uci" : [0.7, 1.2], + "a_uci" : [1.3, 1.3], + "d_uci" : [33.0, 123.0], + "fit_uci": [0.9, 1.0], + } + ) + scores = pd.DataFrame( + { + "V1" : [1.50, 0.20], + "V2" : [1.56, 1.05], + "V3" : [1.00, 1.70], + "V4" : [0.15, 1.76], + "V5" : [-0.50, 1.20], + "V6" : [-0.56, 0.35], + "V7" : [0, -0.30], + "V8" : [0.85, -0.36], + "label": ["Group A", "Group B"], + } + ) + details = { + "angles" : (0, 45, 90, 135, 180, 225, 270, 315), + "score_type" : "Mean", + "results_type": "Profile", + "contrast" : "none", + } + return SSMResults( + results=results, scores=scores, details=details, call="mock_call", scales=SCALES + ) + + +def test_ssm_plot(mock_ssm_results): + fig = visualization.ssm_plot(mock_ssm_results) + assert isinstance(fig, plt.Figure) + assert len(fig.axes) == 1 # Assuming ssm_plot creates a single plot + ax = fig.axes[0] + + # Check if the plot contains the expected elements + assert ax.get_legend() is not None, "Legend is missing from the plot" + assert len(ax.get_lines()) > 0, "No lines found in the plot" + assert ( + len([c for c in ax.get_children() if isinstance(c, PathCollection)]) > 0 + ), "No scatter points found in the plot" + + plt.close(fig) + + +def test_ssm_plot_circle(mock_ssm_results): + fig = visualization.ssm_plot_circle(mock_ssm_results) + assert isinstance(fig, plt.Figure) + ax = fig.axes[0] + children = ax.get_children() + + # Check axis limits + assert ax.get_xlim() == (-5.5, 5.5) + assert ax.get_ylim() == (-5.5, 5.5) + + # Check if circular grid is present (5 concentric circles) + circles = [child for child in children if isinstance(child, Circle)] + assert ( + len(circles) == 5 + ), f"Expected 5 circular grid lines, but found {len(circles)}" + + # Check if radial lines are present (8 lines for octants) + radial_lines = [child for child in children if isinstance(child, plt.Line2D)] + assert ( + len(radial_lines) >= 8 + ), f"Expected at least 8 radial lines, but found {len(radial_lines)}" + + # Check if angle labels are present + angle_labels = [ + child + for child in children + if isinstance(child, plt.Text) and "°" in child.get_text() + ] + assert ( + len(angle_labels) == 8 + ), f"Expected 8 angle labels, but found {len(angle_labels)}" + + # Check if wedges (confidence regions) are plotted + wedges = [child for child in children if isinstance(child, Wedge)] + assert len(wedges) == len( + mock_ssm_results.results + ), f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + + # Check if scatter points are plotted + scatter_points = [child for child in children if isinstance(child, PathCollection)] + assert ( + len(scatter_points) == 1 + ), f"Expected 1 scatter collection, but found {len(scatter_points)}" + assert ( + len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results) + ), f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + + # Check if legend is present + assert ax.get_legend() is not None, "Legend is missing from the plot" + + plt.close(fig) + + +def test_ssm_plot_contrast(mock_ssm_results): + fig = visualization.ssm_plot_circle(mock_ssm_results) + assert isinstance(fig, plt.Figure) + ax = fig.axes[0] + children = ax.get_children() + + # Check axis limits + assert ax.get_xlim() == (-5.5, 5.5) + assert ax.get_ylim() == (-5.5, 5.5) + + # Check if circular grid is present (5 concentric circles) + circles = [child for child in children if isinstance(child, Circle)] + assert ( + len(circles) == 5 + ), f"Expected 5 circular grid lines, but found {len(circles)}" + + # Check if radial lines are present (8 lines for octants) + radial_lines = [child for child in children if isinstance(child, plt.Line2D)] + assert ( + len(radial_lines) >= 8 + ), f"Expected at least 8 radial lines, but found {len(radial_lines)}" + + # Check if angle labels are present + angle_labels = [ + child + for child in children + if isinstance(child, plt.Text) and "°" in child.get_text() + ] + assert ( + len(angle_labels) == 8 + ), f"Expected 8 angle labels, but found {len(angle_labels)}" + + # Check if wedges (confidence regions) are plotted + wedges = [child for child in children if isinstance(child, Wedge)] + assert len(wedges) == len( + mock_ssm_results.results + ), f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + + # Check if scatter points are plotted + scatter_points = [child for child in children if isinstance(child, PathCollection)] + assert ( + len(scatter_points) == 1 + ), f"Expected 1 scatter collection, but found {len(scatter_points)}" + assert ( + len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results) + ), f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + + # Check if legend is present + assert ax.get_legend() is not None, "Legend is missing from the plot" + + plt.close(fig) # Close the figure to free up memory + + +def test_ssm_plot_profile(mock_ssm_results): + fig, axes = mock_ssm_results.profile_plot() + assert isinstance(fig, plt.Figure) + assert len(axes) == len(mock_ssm_results.results) + + for ax in axes: + # Check if the main line plot exists + lines = [child for child in ax.get_children() if isinstance(child, plt.Line2D)] + assert any( + len(line.get_xdata()) > 2 for line in lines + ), "Main plot line is missing" + + # Check for x-axis labels (angles) + assert len(ax.get_xticklabels()) == 8, "Incorrect number of x-axis labels" + + # Check if y-axis label is present + assert ax.get_ylabel() != "", "Y-axis label is missing" + + # Check if title is present + assert ax.get_title() != "", "Plot title is missing" + + plt.close(fig) + + +def test_invalid_input(): + with pytest.raises((AssertionError, TypeError)): + visualization.ssm_plot("not an SSMResults object") + + +# Run the tests +if __name__ == "__main__": + pytest.main() From 8217bb391b0e88328646274bde9109a5e661aefc Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Thu, 11 Jul 2024 19:37:50 +0100 Subject: [PATCH 14/97] Revert to allowing negative displacements for cis The confidence intervals and plotting don't work correctly when the bounds are forced to (0, 2pi). Therefore we allow negative angles for the CIs only. --- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 644 ++++++++++++++++++--- docs/tutorials/using-instruments.ipynb | 71 ++- src/circumplex/ssm_analysis.py | 3 +- src/circumplex/ssm_results.py | 27 +- src/circumplex/utils.py | 51 +- src/circumplex/visualization.py | 9 +- tests/test_ssm_analysis.py | 2 + tests/test_visualisation.py | 6 +- 8 files changed, 679 insertions(+), 134 deletions(-) diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index 3822f0a..da81e2b 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -20,8 +20,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-07-11T13:16:34.292181Z", - "start_time": "2024-07-11T13:16:33.593084Z" + "end_time": "2024-07-11T18:37:02.172464Z", + "start_time": "2024-07-11T18:37:01.505069Z" } }, "source": [ @@ -29,7 +29,7 @@ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", + "# %matplotlib inline\n", "degree_sign = u'\\N{DEGREE SIGN}'" ], "outputs": [], @@ -57,7 +57,7 @@ { "cell_type": "code", "source": [ - "angles = (90, 135, 180, 225, 270, 315, 360, 45)\n", + "angles = (90, 135, 180, 225, 270, 315, 0, 45)\n", "alabel = (\"PA\", \"BC\", \"DE\", \"FG\", \"HI\", \"JK\", \"LM\", \"NO\")\n", "\n", "# Create plot ---------------------------------------------------------------\n", @@ -82,8 +82,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T13:16:34.451726Z", - "start_time": "2024-07-11T13:16:34.293225Z" + "end_time": "2024-07-11T18:37:02.338368Z", + "start_time": "2024-07-11T18:37:02.173524Z" } }, "id": "b2b2c99827c47a27", @@ -93,7 +93,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -120,7 +120,7 @@ "import matplotlib.pyplot as plt\n", "\n", "jz_data = JZ2017\n", - "r = circumplex.ssm_analyze(jz_data.data, jz_data.scales.abbrev, measures = [\"NARPD\"])\n", + "r = circumplex.ssm_analyze(jz_data.data, jz_data.scales.abbrev, angles=angles, measures = [\"NARPD\"])\n", "plt.figure(figsize=(8, 5))\n", "plt.bar(r.scales, r.scores[r.scales].values[0], color='red')\n", "plt.ylim(0, 0.5)\n", @@ -133,8 +133,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T13:16:36.945120Z", - "start_time": "2024-07-11T13:16:34.453249Z" + "end_time": "2024-07-11T18:37:04.774698Z", + "start_time": "2024-07-11T18:37:02.341401Z" } }, "id": "21f5a12726008489", @@ -176,8 +176,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T13:16:38.593371Z", - "start_time": "2024-07-11T13:16:38.515247Z" + "end_time": "2024-07-11T18:37:04.841796Z", + "start_time": "2024-07-11T18:37:04.775420Z" } }, "id": "c90c1bcb4a07781b", @@ -187,13 +187,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGECAYAAAA4IlRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABdeElEQVR4nO3dd1yV5f/H8ddhi1tRVBw4UnNv0zQ0wVG5Z+WIzMpy/agsM8WVWpmaqVmmWUrmqLSlqeRKyZkNy1VuxT1RAeH+/XF/IZGDIAL3OfB+Ph7n0X2uc537fM7VLXy4r2UzDMNAREREJIdzsToAEREREUegpEhEREQEJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEJAew2WwMGDDA6jAynb+/P0899ZTVYYg4LSVFIjnQH3/8QZcuXShTpgxeXl74+fkRFBTE+++/b3Vo2cIPP/yAzWajRIkSxMfHWx2OiKSRkiKRHGbz5s3Uq1eP3377jX79+jF9+nSeeeYZXFxceO+996wOL1sICwvD39+fkydP8tNPP1kdjoikkZvVAYhI1nrzzTfJnz8/27Zto0CBAkleO336dJbGcu3aNby9vbP0MzNbVFQUy5cvZ8KECXzyySeEhYURGBhodVgikga6UySSw/zzzz9UrVo1WUIEULRo0WRlCxYsoEGDBnh7e1OwYEEeeughVq1alaTOzJkzqVq1Kp6enpQoUYIXX3yRixcvJqnTrFkzqlWrxo4dO3jooYfw9vbm9ddfByA6OprQ0FAqVKiAp6cnpUqVYujQoURHRyc5x+rVq2nSpAkFChQgT548VKpUKfEcaREWFkalSpXw8vKibt26bNiwIfG1tWvXYrPZ+Prrr5O97/PPP8dmsxEREZHqZ3z99ddcv36drl270qNHD7766itu3LiRrF7COKdly5ZRrVo1PD09qVq1KitXrkxWd926ddSrVw8vLy/Kly/Phx9+yKhRo7DZbKnGc/HiRYYMGUKpUqXw9PSkQoUKvPXWW+rWE7HDZhiGYXUQIpJ1WrVqRUREBJs3b6ZatWp3rDt69GhGjRpF48aN6dixIx4eHmzZsoVSpUoxceJEAEaNGsXo0aMJDAykffv27N27lw8++IA6deqwadMm3N3dATMp2rt3L3FxcfTo0YNq1arh6+tL27ZtadOmDT///DPPPvss999/P3/88QezZs3i0UcfZdmyZQDs3r2bOnXqUKNGDXr16oWnpycHDhxg69atrF+//o7fw2azUa1aNSIjIxk0aBCenp7MnDmT06dPs3XrVqpVq4ZhGJQpU4YGDRqwdOnSJO9/9NFH2bt3LwcOHEi1fdu0aUNsbCxr1qzhyJEj+Pv7s2jRIrp27Zosppo1a3L69GleeOEF8ubNy7Rp04iMjOTIkSMULlwYgF9//ZVGjRpRvHhxnn/+eeLi4pgxYwZFihTht99+49Yf4f7+/jRr1ox58+YB5p24Ro0acfz4cZ577jlKly7N5s2bmT9/PoMGDWLq1Kmpfh+RHMUQkRxl1apVhqurq+Hq6mo0atTIGDp0qPHjjz8aMTExSert37/fcHFxMTp27GjExcUleS0+Pt4wDMM4ffq04eHhYbRs2TJJnenTpxuAMXfu3MSygIAAAzBmzZqV5Fzz5883XFxcjI0bNyYpnzVrlgEYmzZtMgzDMKZMmWIAxpkzZ+76OwMGYGzfvj2x7PDhw4aXl5fRsWPHxLJhw4YZnp6exsWLFxPLTp8+bbi5uRmhoaGpfs6pU6cMNzc3Y/bs2YlljRs3Ntq3b283Jg8PD+PAgQOJZb/99psBGO+//35iWdu2bQ1vb2/j+PHjiWX79+833NzcjNt/hJcpU8bo06dP4vOxY8cauXPnNvbt25ek3muvvWa4uroaR44cSfU7ieQk6j4TyWGCgoKIiIigXbt2/Pbbb7z99tu0atUKPz8/vvnmm8R6y5YtIz4+npEjR+LikvRHRUK3zZo1a4iJiWHIkCFJ6vTr1498+fLx/fffJ3mfp6cnwcHBScqWLFnC/fffT+XKlTl79mzi4+GHHwbMbi0gsbtv+fLl6er6adSoEXXr1k18Xrp0adq3b8+PP/5IXFwcAL179yY6OjrJnaJFixZx8+ZNevbsmepnfPHFF7i4uNC5c+fEsscff5wVK1Zw4cKFZPUDAwMpX7584vMaNWqQL18+/v33XwDi4uJYs2YNHTp0oESJEon1KlSoQJs2bVKNZ8mSJTRt2pSCBQsmadvAwEDi4uKSdB+KiMYUieRI9evX56uvvuLChQts3bqVYcOGceXKFbp06cJff/0FmGOPXFxcqFKlSornOXz4MACVKlVKUu7h4UG5cuUSX0/g5+eHh4dHkrL9+/eze/duihQpkuRRsWJF4L/B3927d+fBBx/kmWeewdfXlx49erB48eI0J0j33XdfsrKKFSty7do1zpw5A0DlypWpX78+YWFhiXXCwsJ44IEHqFChQqqfkTD+6ty5cxw4cIADBw5Qu3ZtYmJiWLJkSbL6pUuXTlZWsGDBxATq9OnTXL9+3e5npyWe/fv3s3LlymRtmzDwO6sH1os4Os0+E8nBPDw8qF+/PvXr16dixYoEBwezZMkSQkNDM+XzcuXKlawsPj6e6tWrM3nyZLvvKVWqVOJ7N2zYwNq1a/n+++9ZuXIlixYt4uGHH2bVqlW4urpmSIy9e/dm8ODBHDt2jOjoaH755RemT5+e6vv279/Ptm3bAPsJWFhYGM8++2ySspRiNjJoqGd8fDxBQUEMHTrU7usJiaeImJQUiQgA9erVA+DkyZMAlC9fnvj4eP766y9q1apl9z1lypQBYO/evZQrVy6xPCYmhoMHD6ZpKnr58uX57bffaNGiRaqzqVxcXGjRogUtWrRg8uTJjB8/nuHDh7N27dpUP2v//v3Jyvbt24e3tzdFihRJLOvRowchISEsXLiQ69ev4+7uTvfu3VP9HmFhYbi7uzN//vxkyc7PP//MtGnTOHLkiN27QykpWrQoXl5edgd4p2XQd/ny5bl69aqWBBBJI3WfieQwa9eutXsn4ocffgD+6wrr0KEDLi4ujBkzJlkXVcL7AwMD8fDwYNq0aUnOOWfOHC5dusSjjz6aajzdunXj+PHjzJ49O9lr169fJyoqCoDz588nez0hWbt96r49ERER7Ny5M/H50aNHWb58OS1btkySxPj4+NCmTRsWLFhAWFgYrVu3xsfHJ9Xzh4WF0bRpU7p3706XLl2SPF555RUAFi5cmOp5buXq6kpgYCDLli3jxIkTieUHDhxgxYoVqb6/W7duRERE8OOPPyZ77eLFi9y8efOu4hHJ7nSnSCSHGThwINeuXaNjx45UrlyZmJgYNm/ezKJFi/D3908cCF2hQgWGDx/O2LFjadq0KZ06dcLT05Nt27ZRokQJJkyYQJEiRRg2bBijR4+mdevWtGvXjr179zJz5kzq16+fpsHJvXr1YvHixTz//POsXbuWBx98kLi4OPbs2cPixYv58ccfqVevHmPGjGHDhg08+uijlClThtOnTzNz5kxKlixJkyZNUv2catWq0apVqyRT8sFcduB2vXv3pkuXLgCMHTs21XNv2bKFAwcOpLi/mp+fH3Xq1CEsLIxXX3011fPdatSoUaxatYoHH3yQ/v37ExcXx/Tp06lWrRq7du2643tfeeUVvvnmGx577DGeeuop6tatS1RUFH/88QdLly7l0KFDaUr4RHIMaye/iUhWW7FihfH0008blStXNvLkyWN4eHgYFSpUMAYOHGicOnUqWf25c+catWvXNjw9PY2CBQsaAQEBxurVq5PUmT59ulG5cmXD3d3d8PX1Nfr3729cuHAhSZ2AgACjatWqdmOKiYkx3nrrLaNq1aqJn1O3bl1j9OjRxqVLlwzDMIzw8HCjffv2RokSJQwPDw+jRIkSxuOPP55surk9gPHiiy8aCxYsMO677z7D09PTqF27trF27Vq79aOjo42CBQsa+fPnN65fv57q+QcOHGgAxj///JNinVGjRhmA8dtvvyWJ6Xa3T6s3DPO7165d2/Dw8DDKly9vfPzxx8ZLL71keHl5pfreK1euGMOGDTMqVKhgeHh4GD4+Pkbjxo2NSZMmJVuGQSSn0+KNIiK3uXnzJiVKlKBt27bMmTPH6nDs6tChA7t377Y7VkpE0kdjikREbrNs2TLOnDlD7969rQ4FMMdW3Wr//v388MMPNGvWzJqARLIp3SkSEfmfLVu28PvvvzN27Fh8fHySDMy2UvHixXnqqacS13764IMPiI6O5tdff7U7/V9E0kcDrUVE/ueDDz5gwYIF1KpVK3H/MEfQunVrFi5cSGRkJJ6enjRq1Ijx48crIRLJYA57p2jGjBm88847REZGUrNmTd5//30aNGhgt+68efOSbR3g6elpd2dqEREREXscckzRokWLCAkJITQ0lJ07d1KzZk1atWp1xyXp8+XLx8mTJxMft28vICIiInInDpkUTZ48mX79+hEcHEyVKlWYNWsW3t7ezJ07N8X32Gw2ihUrlvjw9fXNwohFRETE2TncmKKYmBh27NjBsGHDEstcXFwIDAwkIiIixfddvXqVMmXKEB8fT506dRg/fjxVq1a1Wzc6OjrJCrjx8fGcP3+ewoULp7rNgIiIiDgPwzC4cuUKJUqUwMXlzveCHC4pOnv2LHFxccnu9Pj6+rJnzx6776lUqRJz586lRo0aXLp0iUmTJtG4cWN2795NyZIlk9WfMGGC3VVsRUREJHs6evSo3ZzgVg6XFKVHo0aNaNSoUeLzxo0bc//99/Phhx/aXaJ/2LBhhISEJD6/dOkSpUuX5uDBg+TNmzdDY4uNjWXt2rU0b94cd3f3DD23M1E7qA0SqB1Mage1QQK1Q+a2wZUrVyhbtmyafr87XFLk4+ODq6srp06dSlJ+6tQpihUrlqZzuLu7U7t27RR3kfb09MTT0zNZeaFChciXL9/dB30HsbGxeHt7U7hw4Rx7sYPaAdQGCdQOJrWD2iCB2iFz2yDhfGkZHuNwA609PDyoW7cu4eHhiWXx8fGEh4cnuRt0J3Fxcfzxxx8UL148s8IUERGRbMbh7hQBhISE0KdPH+rVq0eDBg2YOnUqUVFRiWsR9e7dGz8/PyZMmADAmDFjeOCBB6hQoQIXL17knXfe4fDhwzzzzDNWfg0RERFxIg6ZFHXv3p0zZ84wcuRIIiMjqVWrFitXrkwcfH3kyJEkI8gvXLhAv379iIyMpGDBgtStW5fNmzdTpUoVq76CiIiIOBmHTIoABgwYwIABA+y+tm7duiTPp0yZwpQpU7IgKhEREcmuHG5MkYiIiIgVlBSJiIiIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIiIiKAkiIRERERQEmRiIiICKCkSERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIiIiKAkiIRERERQEmRiIiICKCkSERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIlkjLg7b+vX4bdiAbf16iIuzOiIREbmNwyZFM2bMwN/fHy8vLxo2bMjWrVvT9L4vvvgCm81Ghw4dMjdAkbT66ivw98ctKIh6kyfjFhQE/v5muYiIOAyHTIoWLVpESEgIoaGh7Ny5k5o1a9KqVStOnz59x/cdOnSIl19+maZNm2ZRpCKp+Oor6NIFjh1LWn78uFmuxEhExGE4ZFI0efJk+vXrR3BwMFWqVGHWrFl4e3szd+7cFN8TFxfHk08+yejRoylXrlwWRiuSgrg4GDwYDCP5awllQ4aoK01ExEG4WR3A7WJiYtixYwfDhg1LLHNxcSEwMJCIiIgU3zdmzBiKFi1K37592bhx4x0/Izo6mujo6MTnly9fBiA2NpbY2Nh7/AZJJZwvo8/rbHJiO9jWr8ft9jtEtzIMOHqUm2FhGJ07g4dH1gVnoZx4LdijdlAbJFA7ZG4b3M05HS4pOnv2LHFxcfj6+iYp9/X1Zc+ePXbf8/PPPzNnzhx27dqVps+YMGECo0ePTla+atUqvL297zrmtFi9enWmnNfZ5KR28NuwgXppqOfWpw9GcDDXCxXiWtGiXC9alChfX64XLcq1okWJKlqUGz4+GK6umR5zVspJ18KdqB3UBgnUDpnTBteuXUtzXYdLiu7WlStX6NWrF7Nnz8bHxydN7xk2bBghISGJzy9fvkypUqVo2bIl+fLly9D4YmNjWb16NUFBQbi7u2fouZ1JTmwHW+7cMHlyqvUMd3dssbF4nz2L99mz8Ndfyeu4ukLJkhj+/lCmDEaZMuaxvz9GmTLg5wdOkjTlxGvBHrWD2iCB2iFz2yChNygtHC4p8vHxwdXVlVOnTiUpP3XqFMWKFUtW/59//uHQoUO0bds2sSw+Ph4ANzc39u7dS/ny5ZO8x9PTE09Pz2Tncnd3z7QLMjPP7UxyVDs0bgy5csH16/Zft9mgZEls//4L587BoUNw8KD539uObTExcPgwtsOH7Z/LzQ1KlzZntfn7Q9mySY+LFwcXxxpCmKOuhTtQO6gNEqgdMqcN7uZ8DpcUeXh4ULduXcLDwxOn1cfHxxMeHs6AAQOS1a9cuTJ//PFHkrI33niDK1eu8N5771GqVKmsCFskqYsXoWPHOydEAFOnmgmNr6/5aNgwed34eIiMtJsscfAgHDkCsbHw77/mwx4PDzNpuj1ZSjj29XW4pElEJKs5XFIEEBISQp8+fahXrx4NGjRg6tSpREVFERwcDEDv3r3x8/NjwoQJeHl5Ua1atSTvL1CgAECycpEscewYtGkDf/4JefPC//0fzJ2bdFp+yZJmQtSpU+rnc3GBEiXMR+PGyV+Pi4OTJ1O8y8SRIxATAwcOmA97vLygTJmU7zQVKfJfIncvbl3EMnduaN7cabr9RCT7c8ikqHv37pw5c4aRI0cSGRlJrVq1WLlyZeLg6yNHjuCiv2rFEe3eDa1bmwlQsWKwYgXUqgUjR3Jz7Vp2rVhBrTZtcMvIZOB/440oWRLsrdF186a5LlJKd5qOHYMbN2DvXvNhT65c9pOlhOPChVNPmr76CgYPxu3YMXMA+uTJZszvvZe25FBEJJM5ZFIEMGDAALvdZQDr1q2743vnzZuX8QGJpGbDBmjf3uw6q1zZTIj8/c3XXF0xAgI4HhVFzYCArL074uZm3gUqUwYCApK/HhtrJkYp3Wk6ftzsBvz7b/NhT548/yVI9pKnn36Crl2Tr9mUsIjl0qVKjETEcg6bFIk4laVL4cknzW6qxo3h22+hUCGro0obd3czcSlb1v7r0dFw9GjyZCnh+cmTcPWq2V3455/2z2GzpbyIpc1mLmLZvr260kTEUkqKRO7VtGnmL3XDgA4d4PPPze6m7MLTEypUMB/23LhhjltK6U7TqVP2E6IE/1vEko0boVmzDA9fRCStlBSJpFd8PLz2Grzzjvn8hRfMBCmn3e3w8oKKFc2HPfPmwf8mSdzRyZMZGpaIyN1SUiSSHjEx8PTTEBZmPh8/3kyQMmKGVnaTMK4qNcWLZ2oYIiKpUVIkcrcuXzYHBYeHm4OY58yB3r2tjspxNW1qzjI7fjzlbrRSpezPnBMRyUKa1y5yN06cgIceMhOiPHng+++VEKXG1dWcdg8p30l78cWc1+0oIg5HSZFIWv39NzRqBL/9Zq4AvX49tGxpdVTOoVMnc4aen1/S8oQB6R9+CJcuZX1cIiK3UFIkkhabNsGDD5qzrO67DzZvhjp1rI7KuXTqBIcOcXP1araHhHBz9Wpz1lnZsuZstX797jxLTUQkkykpEknN119DYCBcuGDuTbZ5M5QrZ3VUzilhEcuHHsIICDBXwv7iC3Ns1pIl8NFHVkcoIjmYkiKRO5k5Ezp3NtfiadvWXJnZx8fqqLKXBg1g4kTzeMgQuG2DZxGRrKKkSMQew4DXXzcHABsGPPusuXeXt7fVkWVP//d/8MgjZvLZrRtERVkdkYjkQEqKRG4XGwtPPQUTJpjPx4yBWbPMLh7JHC4u8OmnUKIE7NkDAwdaHZGI5EBKikRudeUKPPYYfPaZOUV8zhwYMUKLMmYFHx9zixQXF/jkE1iwwOqIRCSHUVIkkiAy0txFftUqs5vs22/NVasl6wQEwMiR5vHzz8O+fdbGIyI5ipIiETB/+TZqBL/+CkWKwLp10KaN1VHlTG+8YW4MGxUF3bub44xERLKAkiKRX36Bxo3NHd3Ll4eICKhf3+qoci5XV3NPOR8f2LULXnnF6ohEJIdQUiQ52zffwMMPw7lzUK+euQZR+fJWRyUlSsD8+ebx9OnmWlEiIplMSZHkXB9+CB07wvXr5nTwtWuhaFGro5IErVv/d5fo6afh8GFr4xGRbE9JkeQ8hmEO5n3+eYiPN3/hLl9ubvAqjuXNN81VxC9ehMcfN5dLEBHJJEqKJGeJjYW+fWHsWPP5yJHw8cdag8hRubub24Dkz2+O9RoxwuqIRCQbU1IkOcfVq9C+vbkGjouLuc/W6NFag8jR+fub60UBvPUW/PijpeGISPalpEhyhtOnoXlzWLECcuWCZcvMXdnFOXTuDP37m8e9esHJk9bGIyLZkpIiyf4OHDCn3G/fbu7KvnatubmrOJfJk6FGDThzBnr2hLg4qyMSkWxGSZFkb1u3mgnRP/9A2bLmlPuGDa2OStLDywsWL4bcueGnn/7bm05EJIMoKZLs6/vvzS6zM2egTh1zoG7FilZHJfeiUiWYOdM8Dg2FjRutjUdEshUlRZI9zZljDqq+dg1atTK37fD1tToqyQi9e5uP+Hhzmv7Zs1ZHJCLZhJIiyV4MA8aMgWeeMcec9OljbuyaN6/VkUlGmjHDvGt0/DgEB5v/30VE7pGSIsk+bt6E554zu1UAXn/dnH7v7m5tXJLx8uSBRYvA0xO++w6mTrU6IhHJBpQUSfYQFWVu2TF7trkG0cyZ5mrIWoMo+6pZ05yRBvDqq+bsQhGRe6CkSJzfmTPQooV5x8DLC7788r81bSR769/fXMMoNha6d4dLl6yOSEScmJIicW7//gsPPghbtkChQhAeDh06WB2VZBWbzdymxd/fvBaee07ji0Qk3ZQUifPasQMaNYL9+6FMGdi0yVyTSHKWAgXM/dHc3MxxRh9/bHVEIuKklBSJc1q5EgICzO07atUy1yCqXNnqqMQqDRvC+PHm8aBB8Oef1sYjIk5JSZE4n08/NbfpiIqCwEBYvx6KF7c6KrHaSy9BmzZw4wZ062ZeHyIid0FJkTgPwzDvBjz1lDn9/sknzVWr8+WzOjJxBC4uZsJcvDj8/bd5x0hE5C4oKRLnEBcHL74Iw4ebz199FT77DDw8rI1LHEuRIhAWZg7AnjsXPv/c6ohExIkoKRLHd/06dOkCH3xg/rKbNg0mTjTvDIjcrnlzGDHCPH7uOXMgvohIGui3iji2c+fMcUPLlpmrFy9ZAgMHWh2VOLoRI+Chh+DqVejRA6KjrY5IRJyAkiJxXIcOmWsQbd5sTrtevdpcqE8kNW5uZtdZ4cKwcycMHWp1RCLiBJQUiWPatctcg2jvXihVCn7+GZo2tToqcSZ+fua4MzC7XJctszQcEXF8SorE8axZY3Z9REZC9ermGkRVq1odlTijRx4xp+oDPP00HDlibTwi4tCUFIljWbDAXGvmyhVzwOzGjeZf/CLpNX48NGgAFy7A44+b+6SJiNihpEgcg2HA229Dr17mGkQ9esCKFZA/v9WRibPz8ICFC831rDZvhtBQqyMSEQelpEisFxcHgwebaw+B2d0RFmbONhPJCOXK/bcn2sSJ5qB9EZHbKCkSa924Ad27w/vvm88nT4ZJk7QGkWS8rl3NdYsMA3r2NMesiYjcQr95xDoXLkDLlvDll2YXxxdfwP/9n9VRSXY2ZYo5eP/0abOrNj7e6ohExIEoKRJrHDkCTZqYA6nz54cffzTvGIlkply5YPFi8PY2ZzlOnGh1RCLiQBw2KZoxYwb+/v54eXnRsGFDtm7dmmLdr776inr16lGgQAFy585NrVq1mD9/fhZGK3cUF4dt/Xr8NmzAtn49/PqruQbRX3+ZM8s2boRmzayOUnKKypVhxgzzeORIcw0sEREcNClatGgRISEhhIaGsnPnTmrWrEmrVq04ffq03fqFChVi+PDhRERE8PvvvxMcHExwcDA//vhjFkcuyXz1Ffj74xYURL3Jk3ELCoK6deHECXPtoYgIsztDJCv16WOOK4qLM6fpnztndUQi4gAcMimaPHky/fr1Izg4mCpVqjBr1iy8vb2ZO3eu3frNmjWjY8eO3H///ZQvX57BgwdTo0YNftZfgNb66itzI9djx5KWG4b536FDzdWqRbKazQYzZ8J995nX59NP/3ddikiO5XBJUUxMDDt27CAwMDCxzMXFhcDAQCIiIlJ9v2EYhIeHs3fvXh566KHMDFXuJGGafUq/aGw2eOMNs56IFfLmNccXeXjAN9+YW4GISI7mZnUAtzt79ixxcXH4+vomKff19WXPnj0pvu/SpUv4+fkRHR2Nq6srM2fOJCgoyG7d6Ohoom/ZNfvy5csAxMbGEpvBq90mnC+jz+vobOvX43b7HaJbGQYcPcrNtWsxAgKyLjAL5dRr4XYO1Q5Vq+Ly9tu4DhmC8cor3HzgAahTJ0s+2qHawSJqA5PaIXPb4G7O6XBJUXrlzZuXXbt2cfXqVcLDwwkJCaFcuXI0szOAd8KECYwePTpZ+apVq/D29s6U+FbnsMXi/DZsoF4a6u1asYLjUVGZHo8jyWnXQkocph3KlKH+Aw9Q4pdfiO7QgfWTJ3Mzk34O2OMw7WAhtYFJ7ZA5bXDt2rU017UZhmN1pMfExODt7c3SpUvp0KFDYnmfPn24ePEiy5cvT9N5nnnmGY4ePWp3sLW9O0WlSpXi7Nmz5MuX756/w61iY2NZvXo1QUFBuLu7Z+i5HZlt/XpzUHUqbq5enaPuFOXEa+F2DtkOFy7g1qABtsOHie/enbjPPjO7eDORQ7ZDFlMbmNQOmdsGly9fxsfHh0uXLqX6O97h7hR5eHhQt25dwsPDE5Oi+Ph4wsPDGTBgQJrPEx8fnyTxuZWnpyeedraQcHd3z7QLMjPP7ZCaN4eSJZMPsk5gs0HJkrg1bw6urlkbm8Vy3LWQAodqh6JFzf3RmjbFZdEiXIKCoG/fLPloh2oHi6gNTGqHzGmDuzmfww20BggJCWH27Nl8+umn/P333/Tv35+oqCiCg4MB6N27N8OGDUusP2HCBFavXs2///7L33//zbvvvsv8+fPp2bOnVV9BXF2hWzf7ryX8BT51ao5LiMSBNWoEb75pHg8cCLt3WxuPiGQ5h7tTBNC9e3fOnDnDyJEjiYyMpFatWqxcuTJx8PWRI0dwuWVvrKioKF544QWOHTtGrly5qFy5MgsWLKC7Vki2zs2b8P335nG+fPC/weyAeQdp6lTo1MmS0ERS9MorsHatucJ6t26wbZu5+rWI5Aj3nBR9/fXXLFy4kD179nDt2jUOHDgAwJ49e/jmm2948skn8fPzu+vzDhgwIMXusnXr1iV5Pm7cOMaNG3fXnyGZKCwM9u6FwoVh/35u7tjBrhUrqNWmTY7sMhMn4eICn30GNWuaK64PHgyzZ1sdlYhkkXQnRfHx8Tz++OMsXboUgFy5cnH9+vXE1wsWLMjw4cOJi4tL0tUlOUBMDCTM7nv1VShYECMggONRUdQMCFBCJI6taFFYsACCguDjj6FFC+jRw+qoRCQLpHtM0ZQpU1iyZAnPPfccFy5c4OWXX07yuq+vL02bNuX7hC4UyTk++QQOHoRixeDFF62ORuTutWgBw4ebx88+C/+7Ay4i2Vu6k6J58+ZRv359Zs6cSb58+bDZmb5aoUIFDh48eE8BipO5cQPGjjWPhw/XeAxxXqGh0LQpXLli3ilKYTariGQf6U6KDhw4QNOmTe9Yp3DhwpzTRos5y6xZcPy4uadZv35WRyOSfm5u8Pnn5ri4HTvgtdesjkhEMlm6k6JcuXJx6dKlO9Y5fPgwBQoUSO9HiLO5ehUmTDCPR44EO2tBiTiVkiVh3jzzeOpUc480Ecm20p0U1a5dmx9//JEbN27Yff38+fOsXLmSBx54IN3BiZOZPh1On4by5aFPH6ujEckYjz0G//d/5nFwMBw9am08IpJp0p0UDRo0iGPHjtG5c2eO3bZq8T///EPHjh25dOkSgwYNuucgxQlcvAhvv20ejxoFOXxVVslmJk6EevXg/Hl4/HFzHS4RyXbSPSW/ffv2vPrqq7z11luUKVOG3LlzA1C0aFHOnTuHYRiMGDGChx9+OMOCFQc2ZQpcuABVqpi/NESyEw8P+OILqF0bNm0yE3+tjSaS7dzTNh8TJkzgxx9/5LHHHsPb2xtXV1fi4+Np3bo1K1assLsTvWRDZ8+aSRHAmDFah0iyp/Ll/1vIcfx4WLPG2nhEJMOl+07RkSNH8PDwICgoiKA07IYu2dg775jTlmvXho4drY5GJPN07w7h4WZy1LMn/PYb/G/7IRFxfum+U1S2bFlef/31jIxFnNHJk/D+++bx2LHmNgki2dnUqVCtGpw6Bb16QXy81RGJSAZJ92+wggULUrhw4YyMRZzRhAlw/bq5w/gjj1gdjUjm8/aGRYsgVy5YvRreesvqiEQkg6Q7KWratClbtmzJyFjE2Rw5Ah9+aB6PGwd2VjUXyZaqVDGXoAAYMcIcfC0iTi/dSdGECRP4/fffGTNmDDc1PTVnGjfO3Py1eXPQLEPJaYKD4YknIC7OnHF5/rzVEYnIPUr3QOu3336b6tWrM3r0aD788ENq1qyJr69vsj3QbDYbc+bMuedAxcEcOABz55rHmposOZHNZm5rs3Wr+e+hb1/46ivdMRVxYulOiuYlLH0PnDx5kpMnT9qtp6Qomxo92vwL+ZFHoHFjq6MRsUbevOb4okaNYNkys0tt4ECroxKRdEp3UnTw4MGMjEOcyV9/QViYeTxmjLWxiFitTh1zWYrBg+Hll+HBB80yEXE66U6KypQpk5FxiDMJDQXDgE6doG5dq6MRsd7AgfDTT7B8ubmW0c6d5l0kEXEqWlRG7s6vv8LSpea4Cd0lEjHZbOYYu1KlzPFFzz9v/uEgIk7lnpOisLAwgoKCKFKkCJ6enhQpUoSWLVvy+eefZ0R84mhGjDD/+8QTULWqtbGIOJJChcz90Vxd4fPP4ZNPrI5IRO5SupOiuLg4OnfuTO/evQkPDycqKooSJUoQFRXFmjVr6NWrF507dyZeq71mHxER8P335g/90FCroxFxPI0bmyu7AwwYYI6/ExGnke6kaNq0aXz99dc8+OCDbNq0iWvXrnHw4EGuXbvG5s2badKkCcuWLeP9hC0gxPkl3CV66im47z5LQxFxWK++CkFB5krv3bub/xURp5DupOjTTz+lYsWKhIeH06hRoySvPfDAA6xZs4aKFSvyiW4hZw9r15obYbq7/5cciUhyLi4wf765Ueyff8KQIVZHJCJplO6kaN++fbRr1w53d3e7r7u7u9O2bVv27duX7uDEQRgGvPGGefzss6CZhyJ35usLCxaYA7A/+ggWL7Y6IhFJg3QnRR4eHkRFRd2xTlRUFB4eHun9CHEUK1fC5s3g5QXDh1sdjYhzCAyEYcPM43794J9/rI1HRFKV7qSodu3aLF68mBMnTth9/eTJkyxevJg6WsTMud16l2jAAChe3Np4RJzJ6NHmYo6XL0OPHuZegSLisNKdFIWEhHDu3Dnq1avHu+++y/bt2zl69Cjbt29n0qRJ1K1bl/PnzxMSEpKR8UpWW7bMXIguTx4YOtTqaESci5sbLFxoTtffvh1ee83qiETkDtK9onXbtm2ZNGkSr732GkNv+2VpGAZubm5MmjSJxx577J6DFIvExf03qHrIEChSxNJwRJxSqVLmmkXt28OUKfDww9CmDbb16/HbsAFb7tzQvLm51IWIWCrdSRGYd4s6dOhAWFgYu3bt4vLly+TLl4/atWvzxBNPUK5cuYyKU6ywaBHs3g0FCsBLL1kdjYjzatfO3Bvtvffg8cchb17cTp6kHsDkyVCypPlap05WRyqSo91TUgRQrlw5RmiKdvZz8+Z/CzS+8oqZGIlI+r31FnzzDRw8CFevJn3t+HHo0sXcQkeJkYhltPeZ2PfZZ+YeTj4+MGiQ1dGIOD83t5QXckzYJ23IELPbWkQske6k6N1338XHxyfF2WcnTpygSJEiTJs2Ld3BiUWio81ZM2BOKc6Tx9p4RLKDjRshMjLl1w0Djh4164mIJdKdFC1ZsoSaNWtSokQJu6+XKFGCWrVq8cUXX6Q7OLHIxx/DkSNQogT07291NCLZw8mTGVtPRDJcupOi/fv3UzWVXdKrVq3K/v370/sRYoVr12DcOPP4jTcgVy5r4xHJLtK6xpfWAhOxTLqTouvXr5M7d+471vHy8uLq7QMKxbF98IF5i79MGejb1+poRLKPpk3NWWY2m/3XbTZz+n7Tplkbl4gkSndSVLp0aTZv3nzHOhEREZQsWTK9HyFZ7coVmDjRPA4NBW3RIpJxXF3NafdgPzEyDJg0SesViVgo3UnRo48+ys8//8zcuXPtvv7xxx/z888/07Zt23QHJ1nsvffg7FmoWBF69bI6GpHsp1Mnc9q9n1/S8oQk6ZtvID4+6+MSEeAe1il67bXXWLhwIf369WPBggUEBQXh5+fH8ePHWbVqFRs2bKBEiRIMS9gQURzbhQvmX6lgzjxzu+clrETEnk6doH17bq5dy64VK6jVpg1usbHmAo9hYWYX2oQJVkcpkiOl+zdfkSJFWLt2LT179mTdunWsW7cOm82G8b/1NurXr09YWBhFtDWEc3j3Xbh0CapVg27drI5GJHtzdcUICOB4VBQ1AwLA3R1mz4bgYLMLu1QpeOEFq6MUyXHu6XZApUqV2LZtG9u2bWPr1q1cunSJAgUK0KBBA+rVq5dRMUpmO30apk41j8eOBRet6SmS5Z56ylynaORIGDjQ7GJr397qqERylAzpI6lfvz7169fn5s2b/PHHHwDExsbi7u6eEaeXzPbWWxAVBfXq6YewiJXeeMNMjGbPhh494KefoFEjq6MSyTHu6pbAwYMHmTt3Lvv27Uv22nfffYefnx/16tWjXr16FC9enMWLF2dYoJJJjh+HmTPN43HjUp4uLCKZz2Yz/z0+8gjcuAFt24Kdn7cikjnuKimaPXs2/fr1w9PTM0n5gQMH6NatG2fOnKF06dLcf//9XLhwgSeffJJff/01QwOWDDZ+vPnDt0kTaNnS6mhExM0NFi0y79yeOwdt2phd3CKS6e4qKfr555+pVasWZcqUSVL+3nvvcePGDV588UUOHjzIn3/+yZdffklcXBzTp0/P0IAlAx06ZN6mB90lEnEkefLAd99BuXLw77/w2GNmF7eIZKq77j5r0KBBsvKVK1fi4eHB+PHjE8s6dOhA06ZN2ajNDR3XmDEQGwuBgRAQYHU0InIrX19YsQIKF4Zt26B7d7h50+qoRLK1u0qKzpw5g4+PT5Ky8+fP888//9CwYUPy5s2b5LXatWtz/Pjxe49SMt6+ffDpp+Zxwl5nIuJYKlaEb78FLy/4/ntzmv7/lj0RkYx3V0mRu7s7586dS1K2Y8cOALtT8FPbG00sNGqUuXJu27bQsKHV0YhISho1goULzaUyZs+GN9+0OiKRbOuukqKKFSsSHh6epGzVqlXYbDYaN26crP6JEycorh2fHc8ff8AXX5jHY8ZYG4uIpK5DB5g2zTweMQLmzbMyGpFs666Sos6dO7N//36ef/55fv/9d5YuXcpHH31Enjx5aN26dbL6mzZtokKFCukKbMaMGfj7++Pl5UXDhg3ZunVrinVnz55N06ZNKViwIAULFiQwMPCO9XO8kSPNW/Bdu0KtWlZHIyJp8eKL8Oqr5nG/frBqlbXxiGRDd5UUDRkyhOrVq/PRRx9Ru3ZtunfvzpUrVxg9enSyrrLt27dz4MABgoKC7jqoRYsWERISQmhoKDt37qRmzZq0atWK0ylMS123bh2PP/44a9euJSIiglKlStGyZUuNZ7Jn+3ZYtsy8FT96tNXRiMjdGD8ennjCHHDduTPs2mV1RCLZyl0lRd7e3mzatInRo0fTunVrnnzySZYvX86QIUOS1d25cyft27enXbt2dx3U5MmT6devH8HBwVSpUoVZs2bh7e3N3Llz7dYPCwvjhRdeoFatWlSuXJmPP/6Y+Pj4ZF19gnnrHaBnT7j/fmtjEZG74+ICc+dC8+Zw9aq5htHhw1ZHJZJt3PU2H3ny5GFEwi/WO3j22Wd59tln7zqgmJgYduzYwbBhwxLLXFxcCAwMJCIiIk3nuHbtGrGxsRQqVMju69HR0URHRyc+v3z5MmBuTRIbG3vXMd9Jwvky+rzpYdu0CbeVKzHc3Lg5bJg5HT+LOFI7WEVtYFI7mNLdDi4usHgxbs2bY/vzT4zWrbm5bh2k8PPOkelaMKkdMrcN7uacNsNwrPmdJ06cwM/Pj82bN9Polj1/hg4dyvr169myZUuq53jhhRf48ccf2b17N15eXsleHzVqFKPtdB19/vnneHt739sXcFSGwYNvvIHP7t0catmS37QDt4hT8zp7lodefZVc585xtkoVIkaNIt7Dw+qwRBzOtWvXeOKJJ7h06RL58uW7Y90M2RDWkUycOJEvvviCdevW2U2IAIYNG0ZISEji88uXLyeOQ0qtwe5WbGwsq1evJigoyNINcm3h4bjt3o3h6YnfrFn4lSyZpZ/vKO1gJbWBSe1gypB2qF0bo3lzfP76i0cXLSIuLMy8k+QkdC2Y1A6Z2wYJvUFp4XBJkY+PD66urpw6dSpJ+alTpyhWrNgd3ztp0iQmTpzImjVrqFGjRor1PD09k+3fBuY6TJl1QWbmuVNlGOa6RIDt+edxL1vWmjiwuB0chNrApHYw3VM71KljTpxo1QqXL7/EpXRpmDw5Q+PLCroWTGqHzGmDuzmfw/1J4eHhQd26dZMMkk4YNH1rd9rt3n77bcaOHcvKlSvtLiSZo33/PWzZAt7e8NprVkcjIhmpefP/1i2aMsV8iEi6OFxSBBASEsLs2bP59NNP+fvvv+nfvz9RUVEEBwcD0Lt37yQDsd966y1GjBjB3Llz8ff3JzIyksjISK5evWrVV3Ac8fHwxhvm8cCBkMrdNhFxQk88AW+9ZR6/9BIsWWJtPCJOyuG6zwC6d+/OmTNnGDlyJJGRkdSqVYuVK1fi6+sLwJEjR3C5pd/8gw8+ICYmhi5duiQ5T2hoKKP+122UY335Jfz2G+TLB0OHWh2NiGSWV16BI0dgxgzo1cv8A6hpU6ujEnEqDpkUAQwYMIABAwbYfW3dunVJnh86dCjzA3JGcXHm6tUAISFOOWVXRNLIZoP33oPjx81xRu3awaZNUKWK1ZGJOA2H7D6TDPL557Bnj5kM2VlgU0SyGVdX8999o0Zw8aK5uOOJE1ZHJeI0lBRlV7GxiTPOGDoU8ue3NBwRySK5csE338B995ndaY8+CncxJVkkJ1NSlF198gn8+y/4+kIK3ZAikk35+MDKlVC0qLk/WpcuWbqCvYizUlKUHd24AWPHmsevvw63bdYrIjlAuXLmchze3rB6NfTrZ65ZJiIpUlKUHX30ERw7BiVLQjr2nxORbKJePXN6vqsrfPrpfxMvRMQuJUXZTVQUvPmmeTxiBKSw1YmI5BCPPAKzZpnH48aZfzSJiF1KirKb6dPh9Gnz1vn/FrsUkRzumWf+u0vUvz9895218Yg4KCVF2cmlS/+tajtqFOTwPXRE5BajRsFTT5mr3HfvDtu2WR2RiMNRUpSdTJ0KFy5A5crmsv8iIglsNrPrrGVLuHbNnKr/zz9WRyXiUJQUZRfnzsG775rHY8aYAytFRG7l7g5Ll0Lt2nDmDLRubf5XRAAlRdnHO+/AlStQsyZ07mx1NCLiqPLmNafqlykDBw6Y24Fcu2Z1VCIOQUlRdhAZCdOmmcfjxoGL/reKyB0ULw4rVkDBgvDLL2Z3e1yc1VGJWE6/PbODiRPh+nVo2NAcJyAikpr77ze3A/H0hOXLYeBALe4oOZ6SImd39Ch88IF5PG6cOZhSRCQtmjSBsDDz58YHH8Dbb1sdkYillBQ5u3HjICYGAgKgRQuroxERZ9O5M0yZYh6/9pqZJInkUEqKnNk//8Dcueax7hKJSHoNHgwhIeZxcDCEh1sbj4hFlBQ5szFj4OZNc1ptkyZWRyMizuydd6BbN4iNhU6d4PffrY5IJMspKXJWf/8NCxaYx2PHWhuLiDg/Fxdz09iHHoLLl809044etToqkSylpMhZhYaay/V36GDuhC0icq+8vGDZMnNm2vHj0KYNXLxodVQiWUZJkTPatQuWLDHHEI0ZY3U0IpKdFCwIK1eaaxnt3g0dO0J0tNVRiWQJJUXOKGG36x49oHp1a2MRkeyndGn44Qdz9et16/7bSFYkm1NS5Gy2bIFvvzX7/0eNsjoaEcmuatWCL78ENzf44gsYNszqiEQynZIiZ/PGG+Z/+/SBihWtjUVEsregIJgzxzx++22YPt3aeEQymZIiZ7JuHaxZY+50ndCFJiKSmXr3NtdBAxg0CL7+2tp4RDKRkiJnYRgwYoR53K8f+PtbGo6I5CCvvw7PPWf+HHriCdi82eqIRDKFkiJnsWoV/PyzOWV2+HCroxGRnMRmM7vOHnsMbtyAtm1h716roxLJcEqKnIFh/DeW6IUXoEQJa+MRkZwnYcB1gwZw/ry5kn5kpNVRiWQoJUXOYPly2L4dcueGV1+1OhoRyaly5zZnv5YvD4cOmXeOrl61OiqRDKOkyNHFx/83lmjIECha1NJwRCSHK1rUXNzRxwd27DD3S7t50+qoRDKEkiJHt3gx/Pkn5M8PL71kdTQiIlChAnz3HeTKBStWwPPPm938Ik5OSZEju3nT3OMM4OWXzeX3RUQcQcOG5hgjFxdzLSNtTC3ZgJIiRzZ/PuzbZ96mHjzY6mhERJJq1w5mzDCPQ0Phk0+sjUfkHikpclQxMTB6tHn82mvmHkQiIo7m+ef/2wKkXz9zvJGIk1JS5KjmzIHDh82dqvv3tzoaEZGUvfkm9OwJcXHQpQvs3Gl1RCLpoqTIEV2//t+y+sOHg7e3tfGIiNyJzWb+IdeiBURFwSOPmFP2RZyMkiJH9MEHcOIElC4NzzxjdTQiIqnz8IAvv4QaNeDUKXNxx/PnrY5K5K4oKXI0V6/ChAnm8ciR4OlpbTwiImmVPz/88AOULGluA9KunXnnW8RJKClyNNOmwdmz5jogffpYHY2IyN3x8zMHW+fPD5s2/TfWSMQJKClyJBcvwjvvmMejR5t7DYmIOJuqVWHZMrNL7auvICREizuKU1BS5EjefddMjKpWhe7drY5GRCT9mjWDTz81j6dNg8mTLQ1HJC2UFDmKM2dg6lTzeMwYcHW1NBwRkXvWo8d/d79fftlcAVvEgSkpchRvv20Osq5TBzp2tDoaEZGM8dJLMHCgedynD6xfb208InegpMgRnDgB06ebx+PGmWt+iIhkBzYbTJkCnTqZK/V36AC7d1sdlYhdSoocwfjxcOMGNG5sru0hIpKduLrCggXmz7iLF6FNGzhyBNv69fht2IBt/XrNUBOHoKTIaocPw0cfmce6SyQi2VWuXPDNN1CpEhw9ChUq4BYURL3Jk3ELCgJ/f3OmmoiFlBRZbexYiI01l8dv3tzqaEREMk/hwjB4sHkcG5v0tePHzX3TlBiJhZQUWWn/fpg3zzweO9bSUEREMl1cnDlcwJ6EdYyGDFFXmlhGSZGVRo0y//E/+ig0amR1NCIimWvjRjh2LOXXDcPsWtu4MetiErmFQyZFM2bMwN/fHy8vLxo2bMjWrVtTrLt79246d+6Mv78/NpuNqQlr/Ti6P/+EhQvNY90lEpGc4OTJtNU7dChTwxBJicMlRYsWLSIkJITQ0FB27txJzZo1adWqFadPn7Zb/9q1a5QrV46JEydSrFixLI72HoSGmn8VdekCtWtbHY2ISOYrXjxt9UJCzGn82kxWspjDJUWTJ0+mX79+BAcHU6VKFWbNmoW3tzdz5861W79+/fq888479OjRA09n2VF+xw5zMKHNZu5xJiKSEzRtCiVL3nmWrasrXLhgJkbly8P775tLlohkAYfacTQmJoYdO3YwbNiwxDIXFxcCAwOJiIjIsM+Jjo4mOjo68fnly5cBiI2NJfb2GRH3KOF8t57X9Y03cAHiH3+cuPvuSz4LIxuy1w45jdrApHYw5dR2sL37Lq49eoDNhu2WTWKN/yVKcfPnw+XLuI4fj+3IERg0COOtt4h/9VXig4PBWf74vQs59Vq4VWa2wd2c06GSorNnzxIXF4evr2+Scl9fX/bs2ZNhnzNhwgRG27lDs2rVKry9vTPsc261evVqAAr9/TdNV64k3sWFn5o2JeqHHzLl8xxVQjvkZGoDk9rBlOPawdOT4kOHUv3jj8l17lxi8fXChfmzb19OenuDtze2d9+lTHg4FZcsIdfx47gOGkT0mDHs69qVIw8/jOHubuGXyBw57lqwIzPa4Nq1a2mu61BJUVYZNmwYISEhic8vX75MqVKlaNmyJfny5cvQz4qNjWX16tUEBQXh7u6Oa8JA8KeeIqBv3wz9LEd2ezvkRGoDk9rBlKPb4ZFHYNQobqxbx5+rV1MtKAj3Zs2o7epKkhGW7dvDO+8QN3cuLm+9hfeJE9T64ANq/vADca+/jtGzJ2SDtsvR18L/ZGYbJPQGpYVDJUU+Pj64urpy6tSpJOWnTp3K0EHUnp6edscfubu7Z9oF6e7ujvvGjbBuHXh44BIaiksOvPgzs42dhdrApHYw5dh2cHeHFi04Hh1NzRYtUm4Dd3cYNAj69TNX/584Edvhw7g99xy89RaMGAE9e4KbQ/06S5ccey3cIjPa4G7O51ADrT08PKhbty7h4eGJZfHx8YSHh9PI2dfxMQwYPtw8fu45KF3a2nhERJxJrlzmatj//APvvgtFi8K//0JwMNx/P8yfr0Uf5Z45VFIEEBISwuzZs/n000/5+++/6d+/P1FRUQQHBwPQu3fvJAOxY2Ji2LVrF7t27SImJobjx4+za9cuDhw4YNVXsMu2YgX88ov5D/uW+EVE5C54e5sz0/79F95+G3x84MAB6N0bqlY1139TciTp5HBJUffu3Zk0aRIjR46kVq1a7Nq1i5UrVyYOvj5y5Agnb1kA7MSJE9SuXZvatWtz8uRJJk2aRO3atXnmmWes+gr/iYszd4Fevx7Xl14yywYMSPtaHSIiYl/u3PDKK3DwIEyYAIUKwd698MQTUL06LF4M8fFWRylOxiE7YQcMGMCAAQPsvrZu3bokz/39/TFumdbpML76CgYPxu3YMeollNls5l8yIiKSMfLkgddegxdeMNc0mjQJ/v4buneHatXM7ZQ6dgQXh7sHIA5IV0lm+Oorc6Xq2/f4MQyz/1u7QIuIZKx8+cxxm4cOmYlQ/vzmdkpdukCdOrBs2X+bzoqkQElRRouLMwcD3ukfn3aBFhHJHPnzm9soHTxozkzLmxd++828W1SvHnz7rZIjSZGSooymXaBFRKxXsCCMGWMmR6+/bo5B2rkT2rWDBg1gxQolR5KMkqKMltZdoNNaT0RE0q9wYXjzTbNb7dVXzdlr27ebC0g2agSrVik5kkRKijJaWmeWaQaaiEjW8fGBiRPNO0cvvWQuj7JlC7RqZW5UGx6u5EiUFGW41HaBttmgVCmznoiIZK2iRc0Zav/+a47v9PSETZsgMBCaNYP1662OUCykpCijubrCe++Zx7cnRgnPp04164mIiDWKFYMpU8zkaOBA8PCADRvMxOjhh+Hnn62OUCygpCgzdOoES5eCn1/S8pIlzfJOnayJS0REkipRAqZNM7cP6d/f3Gtt7Vrzbn7LlhARYXWEkoWUFGWWTp3g0CFurl7N9pAQbq5ebfZlKyESEXE8JUvCzJmwfz88+6y5wezq1dC4MbRpA1u3Wh2hZAElRZnJ1RUjIIDjDz2EERCgLjMREUdXpgx8+CHs2wd9+5o/t1euhIYN4bHHYMcOqyOUTKSkSERE5HZly8LHH5v7qfXpY24T8v335gKQ7dvDrl1WRyiZQEmRiIhISsqXh3nzzP3UevY0k6NvvoHataFzZ/jjD6sjlAykpEhERCQ1FSvC/Pmwezc8/rg5m/irr6BGDejWzSwXp6ekSEREJK0qV4bPPzfvEHXrZpYtWQLVq5vJ0p491sbnjOLisK1fj9+GDdjWr7d0b1AlRSIiIneralVYtMjcbLZTJ3M17C++MMt79TJnsUnqvvoK/P1xCwqi3uTJuAUFgb+/WW4BJUUiIiLpVaMGfPkl/PqrOQA7Ph4WLDDvKD31lLn+kdj31VfQpUvyTdSPHzfLLUiMlBSJiIjcq1q1YNkyc7PZxx4zk6NPP4VKlcyp/QcPWh2hYzAMiIqCI0fghRfs7zeXUDZkSJZ3pbll6aeJiIhkZ3Xrwrffmos9jhoFK1bA3Lnw2WcQHAzDh5trISW4dTxN7tzQvLljr2mXkNRcvJj649Il++U3b6btc44ehY0bza1XsoiSIhERkYzWoAH88IO5TUhoqLk69uzZ5vT+Z56B1183E6fBg3E7dox6AJMnmytrv/de5u1+EB8PV6+mPYGxVy8j7t7YbPbvEt3u5Ml7/6y7oKRIREQkszRqBKtWmRvMhobCTz/BBx+YCZK9OyYJ42lS2iczPh4uX767JOb25/Hx9/693NygYEEoUCDpI3/+5GX2Hlu3mhvvpqZ48XuP9S4oKRIREclsTZpAeDisXw8jRpjdQvYk3D3p1csck3R7UnP5ctrusKTGwyNtyUtKiU6uXObdnvR66CHzrtjx4/a/j81mvt60afo/Ix2UFImIiGSVgAAYPTr1uyTXrpkrZ6fEyyt9d2gSHl5e9/pN7o2rq9lN2KVL8q60hGRr6tQsH1+lpEhERCQrRUamrV7fvhAUZP/OjdVJTUbo1MnsJhw8OOm0/JIlzYQos8ZV3YGSIhERkayU1nEyPXtm6cwrS3TqBO3bc3PtWnatWEGtNm1ws3AGnpIiERGRrNS0qUOOp7GMqytGQADHo6KoGRBg6ZIEWrxRREQkKyWMp4Hkg5UtHE8jSopERESyXsJ4Gj+/pOUlS6Y8HV8ynbrPRERErOBg42lESZGIiIh1HGg8jaj7TERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgI4cFI0Y8YM/P398fLyomHDhmzduvWO9ZcsWULlypXx8vKievXq/PDDD1kUqYiIiGQHDpkULVq0iJCQEEJDQ9m5cyc1a9akVatWnD592m79zZs38/jjj9O3b19+/fVXOnToQIcOHfjzzz+zOHIRERFxVg6ZFE2ePJl+/foRHBxMlSpVmDVrFt7e3sydO9du/ffee4/WrVvzyiuvcP/99zN27Fjq1KnD9OnTszhyERERcVYOlxTFxMSwY8cOAgMDE8tcXFwIDAwkIiLC7nsiIiKS1Ado1apVivVFREREbudmdQC3O3v2LHFxcfj6+iYp9/X1Zc+ePXbfExkZabd+ZGSk3frR0dFER0cnPr906RIA58+fJzY29l7CTyY2NpZr165x7tw53N3dM/TczkTtoDZIoHYwqR3UBgnUDpnbBleuXAHAMIxU6zpcUpQVJkyYwOjRo5OVly1b1oJoREREJLNduXKF/Pnz37GOwyVFPj4+uLq6curUqSTlp06dolixYnbfU6xYsbuqP2zYMEJCQhKfx8fHc/78eQoXLozNZrvHb5DU5cuXKVWqFEePHiVfvnwZem5nonZQGyRQO5jUDmqDBGqHzG0DwzC4cuUKJUqUSLWuwyVFHh4e1K1bl/DwcDp06ACYSUt4eDgDBgyw+55GjRoRHh7OkCFDEstWr15No0aN7Nb39PTE09MzSVmBAgUyIvwU5cuXL8de7LdSO6gNEqgdTGoHtUECtUPmtUFqd4gSOFxSBBASEkKfPn2oV68eDRo0YOrUqURFRREcHAxA79698fPzY8KECQAMHjyYgIAA3n33XR599FG++OILtm/fzkcffWTl1xAREREn4pBJUffu3Tlz5gwjR44kMjKSWrVqsXLlysTB1EeOHMHF5b+Jc40bN+bzzz/njTfe4PXXX+e+++5j2bJlVKtWzaqvICIiIk7GIZMigAEDBqTYXbZu3bpkZV27dqVr166ZHNXd8/T0JDQ0NFl3XU6jdlAbJFA7mNQOaoMEagfHaQObkZY5aiIiIiLZnMMt3igiIiJiBSVFIiIiIigpEhEREQGUFGWa6OhoXn31VUqUKEGuXLlo2LAhq1evtjqsLPPmm29is9mSzQBs1qwZNpst2aN169YWRZqxduzYQevWrcmXLx958+alZcuW7Nq1y27dzZs306RJE7y9vSlWrBiDBg3i6tWrWRvwPbp69SqhoaG0bt2aQoUKYbPZmDdvXrJ6s2fPJiAgAF9fXzw9PSlbtizBwcEcOnQoWV1714fNZmPixImZ/4XSKa3tALB48WIeeOABChQoQOHChQkICOD7779PVi8+Pp63336bsmXL4uXlRY0aNVi4cGEmf5P027ZtGwMGDKBq1arkzp2b0qVL061bN/bt25dYJz4+nnnz5tGuXTtKlSpF7ty5qVatGuPGjePGjRvJzuls10Ja2gBS/l42m42goKAkdZ3tOgDYvXs3Xbt2pVy5cnh7e+Pj48NDDz3Et99+m6Te1q1beeGFF6hbty7u7u53XDw5q64Fh5195uyeeuopli5dypAhQ7jvvvuYN28ejzzyCGvXrqVJkyZWh5epjh07xvjx48mdO7fd10uWLJm4xlSCtKw06uh27txJkyZNKFWqFKGhocTHxzNz5kwCAgLYunUrlSpVSqy7a9cuWrRowf3338/kyZM5duwYkyZNYv/+/axYscLCb3F3zp49y5gxYyhdujQ1a9a0OzMU4Ndff6Vs2bK0a9eOggULcvDgQWbPns13333Hb7/9luz/f1BQEL17905SVrt27cz6Gvcsre3w/vvvM2jQIB599FEmTpzIjRs3mDdvHo899hhffvklnTp1Sqw7fPhwJk6cSL9+/ahfvz7Lly/niSeewGaz0aNHjyz6Zmn31ltvsWnTJrp27UqNGjWIjIxk+vTp1KlTh19++YVq1apx7do1goODeeCBB3j++ecpWrQoERERhIaGEh4ezk8//ZTsF6MzXQtpaQOA+fPnJ3vv9u3bee+992jZsmWScme7DgAOHz7MlStX6NOnDyVKlODatWt8+eWXtGvXjg8//JBnn30WgB9++IGPP/6YGjVqUK5cuWTJ4+2y5FowJMNt2bLFAIx33nknsez69etG+fLljUaNGlkYWdbo3r278fDDDxsBAQFG1apVk7xmryy7eOSRR4yCBQsaZ8+eTSw7ceKEkSdPHqNTp05J6rZp08YoXry4cenSpcSy2bNnG4Dx448/ZlnM9+rGjRvGyZMnDcMwjG3bthmA8cknn6Tpvdu3bzcAY8KECUnKAePFF1/M6FAzVVrb4b777jPq169vxMfHJ5ZdunTJyJMnj9GuXbvEsmPHjhnu7u5J2iE+Pt5o2rSpUbJkSePmzZuZ92XSadOmTUZ0dHSSsn379hmenp7Gk08+aRiGYURHRxubNm1K9t7Ro0cbgLF69eok5c52LaSlDVLSt29fw2azGUePHk0sc8brICU3b940atasaVSqVCmxLDIy0rh27ZphGIbx4osvGndKSbLqWlD3WSZYunQprq6uidkwgJeXF3379iUiIoKjR49aGF3m2rBhA0uXLmXq1Kl3rHfz5k2n6ypKzcaNGwkMDKRw4cKJZcWLFycgIIDvvvsu8ftevnyZ1atX07NnzyTL2ffu3Zs8efKwePHiLI89vTw9PVPcYzA1/v7+AFy8eNHu69evX7fbpeKI0toOly9fpmjRoknuhuTLl488efKQK1euxLLly5cTGxvLCy+8kFhms9no378/x44dIyIiImO/QAZo3LgxHh4eScruu+8+qlatyt9//w2Y2zg1btw42Xs7duwIkFjvds5yLaSlDeyJjo7myy+/JCAggJIlSyaWO+N1kBJXV1dKlSqV5N+7r69vkus+LTL7WlBSlAl+/fVXKlasmGz/lgYNGgCkOMbE2cXFxTFw4ECeeeYZqlevnmK9ffv2kTt3bvLmzUuxYsUYMWIEsbGxWRhp5oiOjrb7D9zb25uYmBj+/PNPAP744w9u3rxJvXr1ktTz8PCgVq1a/Prrr1kSrxXOnTvH6dOn2b59e+K2PS1atEhWb968eeTOnZtcuXJRpUoVPv/886wONVM0a9aMlStX8v7773Po0CH27NnDiy++yKVLlxg8eHBivV9//ZXcuXNz//33J3l/ws8QZ7lGDMPg1KlT+Pj43LFeZGQkgN16zn4tpKUNfvjhBy5evMiTTz6ZpNzZr4OoqCjOnj3LP//8w5QpU1ixYoXdf+9plRXXgsYUZYKTJ09SvHjxZOUJZSdOnMjqkLLErFmzOHz4MGvWrEmxTvny5WnevDnVq1cnKiqKpUuXMm7cOPbt28eiRYuyMNqMV6lSJX755Rfi4uJwdXUFICYmhi1btgBw/PhxwLw+gBSvkY0bN2ZRxFnPz8+P6OhoAAoXLsy0adOSDSxt3Lgx3bp1o2zZspw4cYIZM2bw5JNPcunSJfr3729F2Blm2rRpnD17lkGDBjFo0CDATATCw8OTbGB98uRJfH19k42vcbafIWFhYRw/fpwxY8bcsd7bb79Nvnz5aNOmTZLy7HAtpKUNwsLC8PT0pEuXLknKnf06eOmll/jwww8BcHFxoVOnTkyfPj1d58qqa0FJUSa4fv263aXKvby8El/Pbs6dO8fIkSMZMWIERYoUSbHenDlzkjzv1asXzz77LLNnz+b//u//eOCBBzI71Ezzwgsv0L9/f/r27cvQoUOJj49n3LhxiUlQwv/3hP+mdI1kx+sjwYoVK7hx4wZ///03CxYsICoqKlmdTZs2JXn+9NNPU7duXV5//XWeeuqpu77d7ki8vb2pVKkSJUuW5LHHHuPKlStMmTKFTp06sXHjRipUqABkj58hCXfBGjVqRJ8+fVKsN378eNasWcPMmTMpUKBAktec/VpISxtcvnyZ77//nkceeSTZ93f262DIkCF06dKFEydOsHjxYuLi4oiJiUnXubLqWlD3WSbIlStX4l/Dt0roB3X0f8jp8cYbb1CoUCEGDhx41+996aWXAO54h8kZPP/887z++ut8/vnnVK1alerVq/PPP/8wdOhQAPLkyQP89/8/pWskO14fCZo3b06bNm0ICQlhyZIljB49OtW/HD08PBgwYAAXL15kx44dWRRp5ujatStHjhxh3rx5dOnSheDgYNatW0dMTAzDhw9PrOfsP0MiIyN59NFHyZ8/f+IYS3sWLVrEG2+8Qd++fdP0174zXQtpbYMvv/ySGzduJOs6A+e/DipXrkxgYCC9e/dOHFfZtm1bjAzYXSyzrgUlRZmgePHiiXcHbpVQlh2mn99q//79fPTRRwwaNIgTJ05w6NAhDh06xI0bN4iNjeXQoUOcP38+xfeXKlUK4I51nMWbb77JqVOn2LhxI7///jvbtm0jPj4egIoVKwL/3fpO6RrJbtdHSsqXL0/t2rUJCwtLtW52uEb+/fdfVq5cSbt27ZKUFypUiCZNmiT5S7h48eJERkYm++XhDD9DLl26RJs2bbh48SIrV65MMdbVq1fTu3dvHn30UWbNmpXm8zvDtZDWNgCz6yx//vw89thjyV5z5uvAni5durBt27ZUp96nVWZcC0qKMkGtWrXYt28fly9fTlKeMLakVq1aFkSVeY4fP058fDyDBg2ibNmyiY8tW7awb98+ypYte8f+9H///Rfgjt1uzqRgwYI0adIkcbD5mjVrKFmyJJUrVwagWrVquLm5sX379iTvi4mJYdeuXdnu+riT69evc+nSpVTrZYdr5NSpU4A5IeF2sbGx3Lx5M/F5rVq1uHbtWrIZS47+M+TGjRu0bduWffv28d1331GlShW79bZs2ULHjh2pV68eixcvxs0t7SM5HP1aSGsbgJncrF27ls6dO9vtJnPW6yAlCd19afk3nxaZci1k+qT/HOiXX35Jtk7RjRs3jAoVKhgNGza0MLLMcebMGePrr79O9qhatapRunRp4+uvvzZ+//1349KlS8aNGzeSvDc+Pt7o3r27ARg7duyw6Btkni+++MIAjEmTJiUpb926tVG8eHHj8uXLiWUff/yxARgrVqzI6jAzRErr88TGxhrnz59PVn/Lli2Gq6ur0atXr8Sy06dPJ6t3+fJlo3z58oaPj0+yNWAcUUrtcPr0acPFxcVo1qxZknWKjh49auTJk8do3bp1krKU1qfx8/NzyPVpbt68abRr185wc3Mzvv/++xTr/fXXX0bhwoWNqlWr2r0uEjjjtZDWNkgwefJkAzDCw8Ptvu6M14FhGMapU6eSlcXExBh16tQxcuXKZVy5ciXZ63dapygrrwUNtM4EDRs2pGvXrgwbNozTp09ToUIFPv30Uw4dOpRsoHF24OPjQ4cOHZKVJ6xVlPDaunXrePzxx3n88cepUKEC169f5+uvv2bTpk08++yz1KlTJ+uCzgQbNmxgzJgxtGzZksKFC/PLL7/wySef0Lp16yTTrcHsZmvcuDEBAQE8++yzHDt2jHfffZeWLVs63ZYn06dP5+LFi4kzYb799luOHTsGwMCBAzEMg1KlStG9e/fE7Q/++OMPPvnkE/Lnz8+IESMSzzVjxgyWLVtG27ZtKV26NCdPnmTu3LkcOXKE+fPnJ1sDxpGk1g5FihTh6aef5uOPP6ZFixZ06tSJK1euMHPmTK5fv86wYcMSz1WyZEmGDBnCO++8Q2xsLPXr12fZsmVs3LiRsLCwFMenWOmll17im2++oW3btpw/f54FCxYkeb1nz55cuXKFVq1aceHCBV555ZVk25uUL18+cRaeM14LaWmDW4WFhVGiRAmaNWtm93zOeB0APPfcc1y+fJmHHnoIPz8/IiMjCQsLY8+ePbz77ruJ4ysPHz6cuLp3wp3zcePGAVCmTBl69eoFZPG1kGHplSRx/fp14+WXXzaKFStmeHp6GvXr1zdWrlxpdVhZ6vbVq//991+ja9euhr+/v+Hl5WV4e3sbdevWNWbNmpXkL2dndeDAAaNly5aGj4+P4enpaVSuXNmYMGFCin/FbNy40WjcuLHh5eVlFClSxHjxxReT3DlyFmXKlDEAu4+DBw8a0dHRxuDBg40aNWoY+fLlM9zd3Y0yZcoYffv2NQ4ePJjkXKtWrTKCgoKMYsWKGe7u7kaBAgWMli1bpviXtCNJrR0Mw7xr9v777xu1atUy8uTJY+TJk8do3ry58dNPPyU7X1xcnDF+/HijTJkyhoeHh1G1alVjwYIFWfyt0i4gICDF75/wq+bgwYN3rNOnT5/E8znjtZCWNkiwZ88eAzBCQkLueE5nuw4MwzAWLlxoBAYGGr6+voabm5tRsGBBIzAw0Fi+fHmSemvXrk2xrQICAhLrZeW1YDOMDBgGLiIiIuLkNNBaREREBCVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIid3To0CFsNhtPPfWU1aGISCZTUiQiDuvpp5/GZrNRuHBhoqOjrQ5HRLI5JUUi4pCuXLnC4sWLsdlsnD9/nmXLllkdkohkc0qKRMQhLVq0iKioKP7v//4PFxcX5syZY3VIIpLNKSkSEYc0Z84c3NzcGDp0KM2bNyc8PJzDhw8nq+fv74+/vz9Xr15l8ODBlChRAk9PT2rUqMHSpUvtnvvQoUN0796dQoUKkSdPHgICAtiwYQOjRo3CZrOxbt26NMV45coVQkNDqVq1Krly5aJAgQK0atWKn3/++V6+uohYREmRiDicv/76i19++YWWLVvi6+tL7969iY+P55NPPrFbPzY2lpYtW7Jq1So6d+5Mz549+eeff+jWrRurVq1KUvf48eM0btyYxYsX07BhQwYNGoSPjw9BQUFs2bIlzTGeP3+eRo0aMWbMGAoWLMjzzz9P586d2bFjB82bN1d3n4gzMkREHExISIgBGAsXLjQMwzCuXLli5M6d2yhdurQRFxeXpG6ZMmUMwGjfvr0RHR2dWL5mzRoDMFq1apWkfs+ePQ3AePPNN5OUz5kzxwAMwFi7dm1i+cGDBw3A6NOnT5L6TzzxhAEYs2fPTlJ+6tQpo1SpUkaRIkWM69evp7cJRMQCulMkIg4lNjaW+fPnky9fPjp06ABAnjx56NixI0eOHGHNmjV23zdlyhQ8PDwSn7do0YIyZcqwbdu2xLLo6GiWLFlC0aJFeemll5K8Pzg4mEqVKqUpxrNnz7Jo0SIefvhhnnnmmSSvFS1alFdeeYUzZ86kGKuIOCY3qwMQEbnV8uXLOXPmDH379sXLyyuxvHfv3ixYsIA5c+bQsmXLJO8pUKAAZcuWTXaukiVLEhERkfh87969REdHU69ePTw9PZPUtdlsNG7cmL1796Ya47Zt24iLiyM6OppRo0Yle33//v0A7Nmzh8ceeyzV84mIY1BSJCIOJWGWWe/evZOUt2jRAj8/P5YvX8758+cpVKhQ4mv58+e3ey43Nzfi4+MTn1++fBkw7+bY4+vrm6YYz58/D8CmTZvYtGlTivWioqLSdD4RcQzqPhMRh3H06NHEgdEBAQHYbLbEh6urK8ePHyc6OpoFCxak6/z58uUD4PTp03ZfP3Xq1F2d56WXXsIwjBQfoaGh6YpTRKyhO0Ui4jDmzZtHfHw8TZo0sTu+5+bNm3z66afMmTOHQYMG3fX5K1WqhKenJzt27CA6OjpJF5phGEm62u6kfv362Gy2NNcXEeegpEhEHIJhGHzyySfYbDY+/fRTypUrZ7fevn37iIiIYPv27dSrV++uPsPT05MuXboQFhbG1KlTefXVVxNf++yzz9izZ0+azlOsWDG6devGokWLeOedd3j55Zex2WxJ6mzZsoXq1avj7e19VzGKiHWUFImIQ/jpp584ePAgAQEBKSZEYM4Si4iIYM6cOXedFAFMmDCBNWvW8Nprr7F+/Xpq167N3r17+e6772jdujUrV67ExSX1kQUzZ85k7969DB06lPnz59OoUSMKFCjA0aNH2b59O/v37+fkyZNKikSciMYUiYhDSBhgndpu9N27dydXrlwsXLiQ69ev3/XnlCpVioiICLp27crmzZuZOnUqp0+fZtWqVVSoUAH4b8zQnRQqVIjNmzfz9ttv4+HhQVhYGO+//z6//PILVatW5bPPPsPHx+eu4xMR69gMwzCsDkJExBE0adKEiIgILl26RJ48eawOR0SymO4UiUiOc/LkyWRlCxYsYNOmTQQGBiohEsmhdKdIRHKcwoULU7t2bapUqYKrqyu7du1i3bp15M2bl02bNlG9enWrQxQRCygpEpEcZ/jw4Xz77bccOXKEqKgoihQpQvPmzRkxYgSVK1e2OjwRsYiSIhERERE0pkhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBID/BzJ0E4hMu2nnAAAAAElFTkSuQmCC" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 5 + "execution_count": 4 }, { "cell_type": "markdown", @@ -218,8 +218,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T13:16:45.499564Z", - "start_time": "2024-07-11T13:16:45.423564Z" + "end_time": "2024-07-11T18:37:04.908090Z", + "start_time": "2024-07-11T18:37:04.843764Z" } }, "id": "c826947d0b98109e", @@ -229,13 +229,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 6 + "execution_count": 5 }, { "cell_type": "markdown", @@ -286,8 +286,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:18:54.407439Z", - "start_time": "2024-07-11T10:18:54.330885Z" + "end_time": "2024-07-11T18:37:04.974845Z", + "start_time": "2024-07-11T18:37:04.908734Z" } }, "id": "3d4382669e2bbfa8", @@ -297,13 +297,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGECAYAAAA4IlRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB060lEQVR4nO3dd1QVV9vG4d+hF0URFFFU7MYK9o4Ne8duVLBrDCoaY4k1KoliL7GLscReYhcLiorYY4kt9oodEOlnvj/8OG8IoIDAOcBzrcVKmNkzPJtRuZnZs7dKURQFIYQQQogsTk/bBQghhBBC6AIJRUIIIYQQSCgSQgghhAAkFAkhhBBCABKKhBBCCCEACUVCCCGEEICEIiGEEEIIQEKREEIIIQQgoUgIIYQQApBQJITQogcPHqBSqfD29tZ2KUIIIaFICJF2vL29UalUCX6MHj06wWP27dvHpEmT0rfQf3n69CmdOnUiZ86cWFhY0KZNG+7du5ekY6Oiopg8eTJFihTB2NiYIkWKMHXqVKKjoxNsf/HiRVq3bk2uXLkwMzOjbNmyzJ8/PzW7I4RIBgNtFyCEyPymTJlC4cKF42wrW7YshQoVIiwsDENDQ832ffv2sWjRIq0Eow8fPlC/fn2CgoIYO3YshoaGzJkzBycnJy5fvoyVldVnj//222/ZsmULvXv3pnLlypw5c4bx48fz6NEjli1bFqftoUOHaNWqFY6OjowfP55s2bJx9+5dnjx5kpZdFEJ8hoQiIUSaa9asGZUrV05wn4mJSTpXk7jFixdz584dzp49S5UqVYBPtZctW5ZZs2Yxffr0RI89d+4cmzdvZvz48UyZMgWAgQMHYm1tzezZsxkyZAjly5cHIDg4mJ49e9KiRQu2bt2Knp7ctBdCF8jfRCGE1vx3TJGrqyuLFi0CiPOoLb1s3bqVKlWqaAIRQKlSpWjYsCGbN2/+7LF+fn4AdOnSJc72Ll26oCgKmzZt0mzbsGEDgYGBTJs2DT09PUJDQ1Gr1anYEyFESsidIiFEmgsKCuL169dxtllbW8drN2DAAJ49e4aPjw9r165N0rk/fPhAeHj4F9sZGhqSI0eORPer1WquXLlC79694+2rWrUqhw4dIiQkhOzZsyd4fEREBACmpqZxtpuZmQFw4cIFzbbDhw9jYWHB06dPadu2Lbdv38bc3JwePXowZ84cnbp7JkRWIqFICJHmGjVqFG+boijxttWoUYMSJUrg4+PDt99+m6RzDxkyhDVr1nyxnZOTE76+vonuf/v2LREREdja2sbbF7vt2bNnlCxZMsHjY7efOnUqzvip2DtIT58+1Wy7c+cO0dHRtGnThj59+uDp6Ymvry8LFizg/fv3/PHHH1/sjxAi9UkoEkKkuUWLFlGiRIk0OfeoUaOSFKAsLS0/uz8sLAwAY2PjePti79zEtklI8+bNKVSoECNHjsTMzIxKlSoREBDAuHHjMDAwiHPshw8f+PjxIwMHDtS8bda+fXsiIyNZunQpU6ZMoXjx4l/skxAidUkoEkKkuapVqyY60PprlS5dmtKlS3/1eWIfe8U+Bvu32Mdz/3009m8mJibs3buXTp064eLiAnwKWDNmzGDatGlky5Yt3tfq2rVrnHN069aNpUuX4u/vL6FICC2QUCSEyNCCgoI+ewcnlpGREbly5Up0f65cuTA2Nub58+fx9sVuy5cv32e/RpkyZbh27Rp///037969o3Tp0piamjJ8+HCcnJw07fLly8f169exsbGJc3yePHkAePfu3Rf7I4RIfRKKhBA6Jblvmw0dOjRVxhTp6elRrlw5zp8/H29fQEAARYoUSXSQ9b+pVCrKlCmj+Xzfvn2o1eo446oqVaqEj48PT58+jTNG6dmzZwDkzp37i19HCJH6JBQJIXSKubk5AO/fvydnzpxfbJ9aY4oAOnTowOjRozl//rzmcd+tW7c4evQoI0eOjNP25s2bmJmZUbBgwUTPFxYWxvjx47G1tY3zqKxTp0788ssvrFy5kgYNGmi2r1ixAgMDA+rVq/fFWoUQqU9CkRBCp1SqVAkAd3d3mjRpgr6+fry5f/4ttcYUAQwePJjly5fTokULRo4ciaGhIbNnz8bGxoYRI0bEafvNN9/Eu/vUqVMn8uXLR+nSpQkODmbVqlXcu3ePvXv3xrnL5OjoSO/evVm1ahXR0dGa82zZsoUxY8Z88TGdECJtSCgSQuiU9u3b8/3337Nx40bWrVuHoiifDUWpKXv27Pj6+jJ8+HCmTp2KWq2mXr16zJkzJ0mPtCpXrszq1atZunQppqam1KlThw0bNuDg4BCv7ZIlSyhYsCCrV69mx44dFCpUiDlz5jBs2LDU75gQIklUSkKThQghhBBCZDGyzIcQQgghBBKKhBBCCCEACUVCCCGEEIAOh6JFixZhb2+PiYkJ1apV4+zZs4m29fb2jrOitkqlkgUVhRBCCJEsOhmKNm3ahIeHBxMnTuTixYtUqFCBJk2a8PLly0SPsbCw4Pnz55qPhw8fpmPFQgghhMjodDIUzZ49m379+uHm5kbp0qVZsmQJZmZmrFq1KtFjVCoVefPm1Xz8d/p8IYQQQojP0bl5iiIjI7lw4QJjxozRbNPT06NRo0b4+/snetyHDx8oVKgQarWaihUrMn369DhT7f9bREREnEUf1Wo1b9++xcrKKtlLDAghhBBCdymKQkhICPny5UNP7/P3gnQuFL1+/ZqYmJh4d3psbGy4efNmgseULFmSVatWUb58eYKCgvDy8qJmzZpcv34dOzu7eO09PT2ZPHlymtQvhBBCCN3z+PHjBDPBv+lcKEqJGjVqUKNGDc3nNWvW5JtvvmHp0qX8/PPP8dqPGTMGDw8PzedBQUEULFiQ+/fvJ2nBx+SIiori2LFj1K9fH0NDw1Q9ty7JCv2UPmYeWaGfWaGPkDX6mRX6mJZCQkIoXLhwkn6+61wosra2Rl9fn8DAwDjbAwMDyZs3b5LOYWhoiKOjI//880+C+42NjTE2No63PVeuXFhYWCS/6M+IiorCzMwMKyurTP2HOSv0U/qYeWSFfmaFPkLW6GdW6GNaiv2eJWV4jM4NtDYyMqJSpUocOXJEs02tVnPkyJE4d4M+JyYmhqtXr2Jra5tWZQohhBAik9G5O0UAHh4e9OrVi8qVK1O1alXmzp1LaGgobm5uAPTs2ZP8+fPj6ekJwJQpU6hevTrFihXj/fv3zJw5k4cPH9K3b19tdkMIIYQQGYhOhqLOnTvz6tUrJkyYwIsXL3BwcODAgQOawdePHj2KM4L83bt39OvXjxcvXmBpaUmlSpU4ffo0pUuX1lYXhBBCCJHB6GQoAhgyZAhDhgxJcJ+vr2+cz+fMmcOcOXPSoSohhBBCZFY6N6ZICCGEEEIbJBQJIYQQQiChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIIIYQQgIQiIYQQQghAQpEQQgghBCChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIIIYQQgIQiIYQQQghAQpEQQgghBCChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIIIYQQgIQiIYQQQghAQpEQQgghBCChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIIIYQQgIQiIYQQQghAQpEQQgghBCChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIIIYQQgIQiIYQQQghAQpEQQgghBCChSAghhBACkFAkhBBCCAFIKBJCCCGEACQUCSGEEEIAEoqEEEIIIQAJRUIkSUxMDMePH+fEiRMcP36cmJgYbZckhBAilelsKFq0aBH29vaYmJhQrVo1zp49m6TjNm7ciEqlom3btmlboMgytm/fjr29Pc7OzsyePRtnZ2fs7e3Zvn27tksTQgiRinQyFG3atAkPDw8mTpzIxYsXqVChAk2aNOHly5efPe7BgweMHDmSOnXqpFOlIrPbvn07HTp04MmTJ3G2P336lA4dOkgwEkKITEQnQ9Hs2bPp168fbm5ulC5dmiVLlmBmZsaqVasSPSYmJobu3bszefJkihQpko7ViswqJiaGoUOHoihKvH2x24YNGyaP0oQQIpMw0HYB/xUZGcmFCxcYM2aMZpuenh6NGjXC398/0eOmTJlCnjx56NOnD35+fp/9GhEREURERGg+Dw4OBiAqKoqoqKiv7EFcsedL7fPqmszYz+PHj8e7Q/RviqLw+PFjDh8+TIMGDdKxsrSTGa9jQrJCP7NCHyFr9DMr9DEtJef7pnOh6PXr18TExGBjYxNnu42NDTdv3kzwmJMnT7Jy5UouX76cpK/h6enJ5MmT420/dOgQZmZmya45KXx8fNLkvLomM/SzedeuGIaF0QiIf48oAU2bEqJS0aBSJWxtbbG1tSVfvnzY2tpibW2Nvr5+Glec+jLDdUyKrNDPrNBHyBr9zAp9TAsfP35McludC0XJFRISQo8ePVi+fDnW1tZJOmbMmDF4eHhoPg8ODqZAgQI0btwYCwuLVK0vKioKHx8fnJ2dMTQ0TNVz65LM1E8Dg+T/tVAUhfPnz8fbbmRkROHChSlWrBjFixenWLFimg87Ozv09HTrCXZmuo6fkxX6mRX6CFmjn1mhj2kp9mlQUuhcKIr9zTowMDDO9sDAQPLmzRuv/d27d3nw4AGtWrXSbFOr1cCnH263bt2iaNGicY4xNjbG2Ng43rkMDQ3T7A9cWp5bl2SVfv6XmZkZv82axZ07dzQfd+/eJTIyklu3bnHr1q14x5iYmFC0aFGKFy8e7yNfvnyoVCot9OSTrHIds0I/s0IfIWv0Myv0MS0k53umc6HIyMiISpUqceTIEc1r9Wq1miNHjjBkyJB47UuVKsXVq1fjbPvpp58ICQlh3rx5FChQID3KFlmcgb4+AwcOjLMtJiaGR48exQlKsR/3798nPDyc69evc/369XjnMzU1pWjRopQsWVJzhyk2MOXNm1ergUkIITIrnQtFAB4eHvTq1YvKlStTtWpV5s6dS2hoKG5ubgD07NmT/Pnz4+npiYmJCWXLlo1zfM6cOQHibRciKRQgNSKHvr4+hQsXJl++fOTIkQMTExPNozlDQ0OePn1KUFBQgseGhYVx7do1rl27Fm9fbGD65ptv4t1hyp07d4oD078nqDQ3N6d+/foZcjyUEEKklE6Gos6dO/Pq1SsmTJjAixcvcHBw4MCBA5rB148ePdK5sRgic1Cr1USEh2P6FeeIiori5MmTHDx4kFOnTnHu3Lk4bzsmJPaRroGBAeHh4Z8dGPi5wGRhYZHg47jixYtjZWWV6Dm3b9/O0KFDNW/bzZ49Gzs7O+bNm0f79u2T2HMhhMjYdDIUAQwZMiTBx2UAvr6+nz3W29s79QsSmZ6iKAwZMoRfoqKSHYoUYMvmzWzZsoVDhw7FG9hnbW2No6Mj33zzDaVLl6Zo0aLY2tqSN29eLC0t44V8RVEICwsjMDCQp0+f8vjxY27fvs1ff/3FpUuXePDgQYJ1BAcHc+HCBS5cuBBvn6WlZZzHcLEfN2/exNXVNd58TLETVG7dulWCkRAiS9DZUCREelIUhaFDh/Lbb7/xSwqODwkJoXPnzprPc+fOTbNmzahfvz61atWiWLFiyXqspVKpMDMzo3DhwhQuXDje/nfv3nH69GlOnDiBj48Ply5dirO/SJEi2NnZoSgK9+7d4+nTp7x7945z585x7ty5JNWgKAoqlYphw4bRpk0beZQmhMj0JBSJLE9RFEaMGMGCBQuAT2+FER6e7PMUKlSIbt260bZtWypXrpymj3gtLS1p0aIFLVq04Ndff+Xx48fs2bOHrVu3cuzYMe7du8e9e/fIkSMH/fr1o3fv3kRFRcUb8H3t2jXevXuX6NeJnaDSz8+PevXqpVl/hBBCF0goElmaoij8+OOPzJkzB4ClS5diNHJkskORmZkZ9+7d09pYtwIFCjBo0CAGDRrEo0ePWLduHatXr+aff/7By8uL2bNn0759e8aNG4eLiwtYWEBISNK/QP36kD07JGO+DyGEyGhktLLIshRF4aeffmLmzJkALFq0iP79+6foXAb6+joz+L9gwYKMHTuWW7dusWfPHho2bIharWbr1q04OjrSoUMHYv5/Li8hhBD/oxv/iguhBZMnT2b69OkAzJs3j8GDB3/aERwMikJUZCQL5s/HKlcuVHx6Tb+AnR1rf/+dmOhoUJT/fejgHRQ9PT1atGjB4cOHuXLlCl27dkWlUrFt2zZCQ0O1XZ4QQugcCUUiS5o6dapm/bvZs2fj7u4eZ/+BAweoUKEC7u7uvH37llKlSrF27VrmzZtHly5dMtyg43LlyrFhwwauXLkib5IJIUQiJBSJLOeXX35h/PjxAPz6668MHz5cs+/x48e0bt2aZs2acePGDaytrVmyZAnXrl2jc+fOGS4M/VfZsmXZtm0b5ubm2i5FCCF0joQikaXMmjWLMWPGADBt2jRGjRoFfJq0cdGiRZQuXZrdu3djaGjIiBEjuHPnDgMGDMjwYei/9HVk/JMQQugSeftMZBnz5s1j5MiRAEyaNImxY8cCcOvWLXr37s3p06cBqFmzJsuXL6d06dJaq1UXxajVZK5oKIQQccmviyJLWLRoEcOGDQM+LRg8YcIEFEVh2bJlODo6cvr0abJly8bChQvx8/PL/IHo/weT//vjwvnzlC9XTjOovIOLC2/fvKFJ48aogAaVKqGWt9aEEJmYhCKR6S1dulSzZMyPP/7IlClTePPmDe3atWPAgAGEhYXRsGFDrl+/znfffaczr9ant0qVKnHmzBm6deuGgYEB27Ztw8HBgT59+mBubs6JEydYtmyZtssUQog0kzX/9RdZxsqVKxk4cCAAI0aMwNPTk5MnT1K+fHl27dqFoaEhXl5eHDp0iIIFC2q5Wu0zNDSkU6dO+Pn5UaxYMR4/fkzXrl2pXbs2AKNGjdIsGiuEEJmNhCKRaa1Zs4Z+/foBMHToUGbMmMG8efOoX78+z58/p1SpUpw9e5YRI0Zk2btDialUqRIXL16kV69eqNVqDh48SI4cOQgJCWHQoEHxFo8VQojMQH4SiExp/fr1uLm5oSgKgwcP5ueff6Zbt24MHz6cmJgYunXrxvnz53FwcNB2qTore/bseHt7s27dOkxNTQkKCgJgz549bNq0ScvVCSFE6pNQJDKdTZs20bNnTxRFoX///gwbNowaNWqwadMmDAwMmD9/PuvWrZO5epKoe/funDlzhiJFimi29e/fn9evX2uxKiGESH0SikSmsnXrVrp3745araZ37950796dGjVqcP36dWxtbfH19eX7779HpVJpu9QMpXz58pw/f54mTZoAEBISQr169eRtNCFEpiKhSGQaO3fupGvXrsTExNCzZ0/q16+Ps7Mzb968oXLlyly4cIFatWppu8wMy9LSkn379uHm5gbA9evXqVevHuHh4VquTAghUoeEIpEp7Nmzh06dOhEdHU23bt2wt7enR48eREZG0r59e44fP46tra22y8zw9PT0WLVqleaOkZ+fH/Xq1ZNHaUKITEFCkcjw9u/fj4uLC1FRUXTq1AkjIyOmTJkCwA8//MCWLVswMzPTcpWZy7Zt2zQhMyAggOrVq/PPP/9ouSohhPg6EopEhnbo0CHatWtHZGQkbdu2JTw8HG9vb/T09Fi6dCkzZsyQ1+3TgLm5Ob///rvm87t371K7dm2uXLmixaqEEOLryE8LkWEdPXqUNm3aEBERQYsWLXj37h1//vknxsbGbNu2jf79+2u7xEytUaNG9O7dGwBjY2MCAwNxcnLC399fy5UJIUTKSCgSGdLx48dp2bIl4eHhNG7cmGfPnnH8+HGyZ8/O/v37adu2rbZLzBK8vLzImzcvERER2NnZ8f79exo1asShQ4e0XZoQQiSbhCKR4Zw8eZIWLVoQFhZG/fr1efToEZcuXcLa2ppjx45Rv359bZeYZVhaWrJo0SIAXrx4QY0aNfj48SMtW7Zkx44dWq5OCCGSR0KRyFD8/f1p1qwZoaGh1K1bl2fPnnHz5k3y5cuHn58flSpV0naJWU779u1p37490dHRRERExBn0LsFICJGRSCgSGcbZs2dp2rQpHz58oHbt2rx48YJbt26RP39+fH19KVWqlLZLzLIWLlxIzpw5uXjxIlWqVKFbt25ER0dLMBJCZCgSikSGcOHCBRo3bkxwcDDVq1fn5cuX3L59Gzs7O3x9fSlevLi2S8zSbG1tmTVrFgCTJk1iwoQJcYLRzp07tVugEEIkgYQiofMuX76Ms7MzQUFBVK1alTdv3nD79m0KFCiAr68vxYoV03aJAnBzc6Nhw4aEh4czcOBAvL29NcGoY8eO7Nq1S9slCiHEZ0koEjrt6tWrNGrUiHfv3lG5cmVCQ0O5c+eOJhAVLVpU2yWK/6dSqVi2bBlmZmb4+vri7e3NmjVr6Nq1K9HR0XTo0IH9+/dru0whhEiUhCKhs65fv07Dhg158+aNZgD19evXyZs3L0ePHo2zarvQDUWKFGHq1KkAjBw5ksDAQH7//Xc6d+5MdHQ0Li4unDx5UstVCiFEwiQUCZ108+ZNGjZsyKtXr3B0dMTc3Jzz589jaWnJoUOH5JGZDnN3d6dq1aoEBwczePBg9PX1Wbt2Lc2bNycsLIyWLVty+fJlbZcphBDxSCgSOuf27ds0aNCAwMBAKlSogK2tLSdOnMDc3Jz9+/dTrlw5bZcoPkNfX5+VK1diaGjIn3/+yZYtWzA0NGTLli3UqVOHoKAgmjRpwu3bt7VdqhBCxCGhSOiUu3fv0qBBA54/f065cuUoVaoU+/btw9jYmN27d1OtWjVtlyiSoGzZsowdOxaA77//njdv3mBmZsbu3btxcHDg5cuXODs78/jxYy1XKoQQ/yOhSOiM+/fvU79+fZ4+fUrp0qVp2LAhmzZtQl9fny1btshM1RnMmDFjKF26NC9fvmTEiBEA5MiRg4MHD1KiRAkePXpEkyZNePfunZYrFUKITyQUCZ3w8OFD6tevz+PHjylZsiSurq7MnTsXgGXLltGqVSvtFiiSzdjYmJUrV6JSqVizZg0HDx4EIE+ePPj4+JA/f35u3LhB+/btiYiI0HK1QgghoUjogMePH1O/fn0ePnxI8eLFGTNmDKNHjwZg4sSJmpXYRcZTvXp13N3dARgwYAAfPnwAoGDBguzdu5fs2bPj6+tL7969URRFm6UKIYSEIqFdT58+pUGDBty/f58iRYowe/ZsBg8ejFqtxs3NjYkTJ2q7RPGVpk6dir29PQ8fPmTcuHGa7RUqVGDr1q0YGBiwYcOGOPuEEEIbJBQJrXn+/DkNGjTgn3/+wd7eHm9vb3r37s3Hjx9p0qQJS5cuRaVSabtM8ZWyZcvG0qVLAViwYAH+/v6afY0bN2b58uUAeHp6atoJIYQ2SCgSWhEYGEjDhg25ffs2BQsWZOfOnfTt21czL1Hsa9wic2jcuDGurq4oikKfPn3ijCFydXVl0qRJAAwePJi9e/dqqUohRFYnoUiku1evXtGwYUNu3LiBnZ0dhw4dYuTIkZr1zGLHmojMZdasWdjY2HDjxg2mT58eZ9+ECRNwdXVFrVbTpUsXrl27pqUqhRBZmYQika7evHlDo0aNuH79Ora2thw9epRFixZx+PBhzMzM+PPPP7G1tdV2mSIN5MqVi4ULFwIwffp0rl69qtkXu25a/fr1+fDhA61ateLVq1faKlUIkUVJKBLp5t27dzg7O3PlyhVsbGw4duwYR48eZcGCBQCsW7cOBwcH7RYp0pSLiwtt27YlOjqaPn36EBMTo9kXO+t10aJFefDgAR06dCAyMlKL1QohshoJRSJdvH//nsaNG3Pp0iVy587N0aNHefbsGUOGDAFg2rRptGvXTstVirSmUqlYtGgROXLk4Ny5c8ybNy/OfisrK/7880+yZ8/OiRMn+O677+RVfSFEupFQJNJccHAwTZs25fz581hbW3P06FGMjIxwcXEhOjqabt26MWbMGG2XKdJJvnz58PLyAuCnn37i3r17cfaXLl2ajRs3olKpWLFiheZOohBCpDUJRSJNhYSE0KxZMwICAsiVKxeHDx+mQIECtGrVinfv3lG1alVWrFghr95nMX369KF+/fqEhYXRr1+/eHeDmjdvzsyZMwEYPny4ZjZsIYRISxKKRJoJDQ2lRYsWnD59mpw5c+Lj40O5cuXo0aMHN2/exM7Ojp07d2JqaqrtUkU6U6lULF++HFNTU44ePcrq1avjtfHw8IjzRtrdu3e1UKkQIiuRUCTSxMePH2nZsiV+fn7kyJEDHx8fKlasyPTp09m9ezfGxsbs2LFD3jTLwooWLcrPP/8MfApAz58/j7NfpVKxZMkSqlWrxvv372nfvj0fP37URqlCiCxCQpFIdWFhYbRu3RpfX1+yZ8/OwYMHqVy5Mvv372fChAkA/Pbbb1SuXFnLlQptGzp0KJUrVyYoKEgz6P7fjI2N2bp1K3ny5OHKlSv0799fBl4LIdKMzoaiRYsWYW9vj4mJCdWqVePs2bOJtt2+fTuVK1cmZ86cmJub4+DgwNq1a9Ox2qwtJiaG48ePc+LECXx8fGjbti1HjhwhW7ZsHDhwgGrVqnHv3j26deuGoigMGDAANzc3bZctdICBgQErV67EwMCA7du3s23btnht7Ozs2Lx5M/r6+qxfv14z15EQQqQ2nQxFmzZtwsPDg4kTJ3Lx4kUqVKhAkyZNePnyZYLtc+XKxbhx4/D39+fKlSu4ubnh5uYmgzPTwfbt27G3t8fZ2ZnZs2fTokULDh06hJGREfv27aNmzZp8/PiR9u3b8/79e6pVqxbvNWyRtZUvX57Ro0cD8N133/Hu3bt4bZycnJgxYwbw6VHbyZMn07VGIUTWoJOhaPbs2fTr1w83NzdKly7NkiVLMDMzY9WqVQm2r1evHu3ateObb76haNGiDB06lPLly8s/nGls+/btdOjQgSdPnsTbFxkZyatXr1AUhf79+/PXX3+RJ08etm7dirGxsRaqFbrsp59+olSpUgQGBjJixIgE2wwfPpzOnTsTHR1Nx44d441BEkKIr6VzoSgyMpILFy7QqFEjzTY9PT0aNWoUZ3XtxCiKwpEjR7h16xZ169ZNy1KztJiYGIYOHZro+A6VSsWwYcOYP38+69evR19fn82bN2NnZ5fOlYqMwNjYmJUrV6JSqVi9ejWHDx+O1yZ23qIyZcrw4sULOnbsKDNeCyFSlYG2C/iv169fExMTg42NTZztNjY23Lx5M9HjgoKCyJ8/PxEREejr67N48WKcnZ0TbBsRERFnle7g4GAAoqKiiIqKSoVe/E/s+VL7vNp2/PjxBO8QxVIUhcePH2t+6//ll1+oWbNmhv4+ZNZr+W/a7GOVKlUYPHgwixYtol+/fly6dAlzc/M4bYyNjdm8eTM1atTg1KlTjBo1SjOfUXLItcw8skI/s0If01Jyvm8qRcde5Xj27Bn58+fn9OnT1KhRQ7N91KhRHD9+nICAgASPU6vV3Lt3jw8fPnDkyBF+/vlndu7cSb169eK1nTRpEpMnT463fcOGDZiZmaVaXzKj5l27YhgWlqxjQvX18dm6VSZoFF8UFhaGu7s7r169onXr1vTu3TvBdgEBAXh6egIwZswYqlWrlp5lCiEykI8fP9KtWzeCgoKwsLD4bFudC0WRkZGYmZmxdetW2rZtq9neq1cv3r9/z65du5J0nr59+/L48eMEB1sndKeoQIECvH79+ovfsOSKiorCx8cHZ2dnDA0NU/Xc2mBgZYUqJCRZx6izZSPm7ds0qij9ZLZrmRBd6OPBgwdp1aoVKpUKPz8/qlatmmC7H374gXnz5pEzZ07Onj2Lvb19kr+GLvQzrWWFPkLW6GdW6GNaCg4OxtraOkmhSOcenxkZGVGpUiWOHDmiCUVqtZojR44kOI9JYtRqdZzg82/GxsYJDvY1NDRMsz9waXluXaenUqGXifqeFa6lNvvYsmVLevTowdq1axkwYAAXL17EyMgoXrsZM2Zw5swZAgIC6NGjBydOnEiw3efItcw8skI/s0If00Jyvmc6N9AaPr1yu3z5ctasWcONGzcYNGgQoaGhmrltevbsGWcBUU9PT3x8fLh37x43btxg1qxZrF27lm+//VZbXRBCfIU5c+aQO3durl+/rnlM9l9GRkZs2rSJnDlzEhAQIIsKCyG+mk6Gos6dO+Pl5cWECRNwcHDg8uXLHDhwQDP4+tGjR3Fexw0NDWXw4MGUKVOGWrVqsW3bNtatW0ffvn211QUhxFewsrJiwYIFAEybNo3r168n2K5QoUKsWbMG+DSVR1IfrwshREK+OhTt2LGDTp06Ub58eYoVK6bZfvPmTWbMmMHTp09TdN4hQ4bw8OFDIiIiCAgIiDOQ0tfXF29vb83nU6dO5c6dO4SFhfH27VtOnz5N586dU9wnIYT2derUidatWxMVFUWfPn2IiYlJsF3r1q3x8PAAwNXVlQcPHqRjlUKIzCTFoUitVtO5c2c6dOjAtm3buHfvHvfv39fst7S0ZNy4cfz++++pUqgQImtRqVQsXrwYCwsLAgICPru8h6enp2bh2M6dO8v8RUKIFElxKJozZw5btmxhwIABvHv3jpEjR8bZb2NjQ506ddi7d+9XFymEyJry58+vmYdo7NixcX7x+rd/jy86e/Ys48aNS88yhRCZRIpDkbe3N1WqVNH8JpfQHDTFihVL9B8xkUEFBzNu7FhUQK2aNfkQEkLxYsVQATWqVycyIgIUJe7H/0+OKURK9O3bFycnJz5+/MiAAQMSnUW9UKFCmsfqXl5eCc6KLYQQn5PiUPTPP/9Qp06dz7axsrLizZs3Kf0SQgd9+PCB3377DYCRI0fi7u7OP//8Q4ECBRgyZIhM0ChSnZ6eHsuXL8fExAQfHx/NwOqEtGnThkGDBgGf3lJ99epVepUphMgEUhyKTE1NCQoK+mybhw8fkjNnzpR+CaGDVq9ezbt37yhWrBgRERGsXr0alUqFt7c32bJl03Z5IpMqXry4ZhZ6Dw8PXrx4kWhbLy8vSpcuzfPnz+nTp0+id5aEEOK/UhyKHB0dOXjwIOHh4Qnuf/v2LQcOHKB69eopLk7olpiYGObMmQN8mmF84MCBAIwbN+6Ldw2F+FoeHh5UrFiRd+/e8f333yfazszMjD/++ANjY2N2797N4sWL07FKIURGluJQ5O7uzpMnT3BxcYm3MOjdu3dp164dQUFBuLu7f3WRQjfs2LGD+/fvY2Vlxf79+wkKCqJatWpMmDBB26WJLMDAwICVK1eir6/P1q1b2bFjR6Jty5cvz4wZMwAYMWIE165dS68yhRAZWIpDUZs2bfjxxx/Zv38/hQoVYtasWQDkyZOHEiVK4Ofnx08//USDBg1SrVihPYqiaN4CKleuHKdPnyZ79uxs2LBBpp0X6cbBwYEff/wRgO+++473798n2vb777+nWbNmRERE0LVrV8KSuZCxECLr+arJGz09PTl48CAtW7bEzMwMfX191Go1TZs2Zf/+/QmuRC8yplOnTnH27FmMjIw4ceIEAIsWLaJIkSJarkxkNePHj6dkyZI8f/6cH374IdF2sWPdbGxsuHbtGqNGjUrHKoUQGVGKQ9GjR4948eIFzs7O7Nq1ixcvXhAZGcnr16/Zu3cvTZo0Sc06hZbF3gk0MjJCrVbTrVs3WVtOaIWJiQkrVqwAYMWKFRw9ejTRtnny5NG8rbZw4UJ2796dLjUKITKmFIeiwoULM3bs2NSsReio27dva9aU+vDhA/b29ixevFhevxdaU7t2bQYPHgxAv379+PjxY6JtmzRpolkGpE+fPgQGBqZLjUKIjCfFocjS0hIrK6vUrEXoqDlz5mhea9bX12f9+vXkyJFDy1WJrM7T05MCBQpw7969Lw72nz59OuXLl+fVq1f069dPXtMXQiQoxaGoTp06BAQEpGYtQge9evWK1atXaz7/6aefqFmzphYrEuITCwsLlixZAnwK7ufOnUu0rbGxMevWrcPIyIjdu3fH+TMthBCxUhyKPD09uXLlClOmTCE6Ojo1axI6ZPHixURERABQqVIlWVNK6JTmzZvTvXt31Go1ffr0+exCsOXKlWPatGnAp9f0nz9/nl5lCiEyCIOUHjhjxgzKlSvH5MmTWbp0KRUqVMDGxibeOBOVSsXKlSu/ulCR/sLCwvDy8gLA0NCQdevWyev3QufMnTuXgwcPcvXqVWbMmMFPP/2UaNvhw4eze/duTpw4wfz583F1dZU/00IIjRSHotiFFwGeP3+e6G9dEooyLi8vLz58+ADAr7/+SqlSpbRckRDxWVtbM3/+fLp168bPP/+Mi4sL33zzzaedFhYQEqJpqw8cj/3kxg0wNY1/wuzZZRFjIbKoFIei+/fvp2YdQsdERkYyffp04NO6U0OHDtVyRUIkrkuXLmzYsIE9e/bQp08f/Pz80NfX13ZZQogMJsWhqFChQqlZh9AxvXv31qxrt2vXLvT0vmqeTyHSlEql4rfffuP48eP4+/uzePHiz66PJoQQCZGfdCKeixcvsn79egBatGjxv0cRQugwOzs7zXpnY8aM4eHDh1quSAiR0Xx1KFq/fj3Ozs7kzp0bY2NjcufOTePGjdmwYUNq1CfSWXh4OB06dAD+99u3EBlF//79qVu3LqGhoQwYMACZjUgIkRwpDkUxMTG4uLjQs2dPjhw5QmhoKPny5SM0NJTDhw/To0cPXFxcUKvVqVmvSGNjx47VjBfr2LEjBQoU0HJFQiSdnp4ey5cvx9jYmIMHDxIVFaXtkoQQGUiKQ9H8+fPZsWMHtWrV4tSpU3z8+JH79+/z8eNHTp8+Te3atdm5cycLFixIzXpFGjp27Bhz5szRfC7LuIiMqESJEkyaNAmAiP8fFyeEEEmR4lC0Zs0aSpQowZEjR6hRo0acfdWrV+fw4cOUKFFCZo7NIIKCgnB1ddV87uzsTIUKFbRXkBBfYcSIETg6Oqbo8VmUTEYrRJaV4lB0+/ZtWrdunejEZ4aGhrRq1Yrbt2+nuDiRfjw8PHj06JFm8s0RI0ZouSIhUs7Q0DDF86OFh4fz7t27VK5ICJERpDgUGRkZERoa+tk2oaGhGBkZpfRLiHRy8OBBVq1aBYCiKJQtW5bGjRtruSohvo6jo2OK/v1RFEXm5RIii0pxKHJ0dGTz5s08e/Yswf3Pnz9n8+bNVKxYMcXFibQXFBRE3759ATA3Nwdg5MiR8ZZrESIjMjY2TtFxa9euZdeuXalcjRBC16U4FHl4ePDmzRsqV67MrFmzOH/+PI8fP+b8+fN4eXlRqVIl3r59i4eHR2rWK1LZDz/8wJMnT8iTJw+hoaHY2trStWtXbZclRKpISbSPvbs0YMAA3rx5k7oFCSF0WopntG7VqhVeXl6MHj2aUaNGxdmnKAoGBgZ4eXnRsmXLry5SpI1Dhw6xfPlyALJly8bLly9xd3eXR54iSzM2NqZ0sWL8/fffDBkyhD/++EPbJQkh0kmKQxF8ulvUtm1b1q9fz+XLlwkODsbCwgJHR0e6detGkSJFUqtOkcqCg4Pp168fAK1bt+bPP//E3NycAQMGaLkyIbRLxacFr2vUqMHGjRtxcXHRTGgqhMjcvioUARQpUoTx48enRi0iHY0aNYpHjx5RuHBhPnz4AEDfvn2xtLTUcmVCaF+VKlUYPXo006ZNY9CgQdStW5c8efJouywhRBqTtc+yoCNHjrB06VLg0wSNR48eRU9PT964EeJfJkyYQPny5Xn9+jWDBw9GUWTRECEyuxSHolmzZmFtbZ3o22fPnj0jd+7czJ8/P8XFidQXEhJCnz59ABg8eDB+fn4AdOjQgcKFC2uzNCF0ipGREd7e3hgYGLBt2zY2bdqk7ZKEEGksxaFoy5YtVKhQgXz58iW4P1++fDg4OLBx48YUFydS3+jRo3n48CH29vYMHTpUs3DvyJEjtVyZEGkgOBgUhT82bEAFX/z4Y8OGT8f8P0dHR3766ScAvvvuO168eJHOHRBCpKcUh6I7d+5QpkyZz7YpU6YMd+7cSemXEKns2LFjLF68GIAVK1awatUqoqOjqVOnDlWqVNFydUKkHVtb2xS3Gzt2LI6Ojrx9+5aBAwfKYzQhMrEUh6KwsDDNZH+JMTEx0QziFdr14cMHzWOzAQMGULVqVZYsWQLIXSKR+dWpUwc7O7tEJyVVqVQUKFCAOnXqxNtnaGjImjVrMDQ0ZNeuXaxfvz6tyxVCaEmKQ1HBggU5ffr0Z9v4+/tjZ2eX0i8hUtGYMWO4f/8+BQsWZMaMGaxcuZKgoCBKlCghc0mJTE9fX5958+YBJBiMFEVh7ty56OvrJ3h8uXLlmDhxIgDu7u7yGE2ITCrFoahFixacPHlSs2bWf61YsYKTJ0/SqlWrFBcnUsfx48dZuHAh8Om6mJmZMXfuXODTwq96evISosj82rdvz9atW8mfP3+Kjh81ahSOjo68e/dO3kYTIpNK8U/D0aNHY2NjQ79+/WjQoAGenp78/vvveHp6Ur9+fQYMGEC+fPkYM2ZMatYrkik0NFTz2Kxfv344Ozuzbds2Hj58SO7cuenRo4eWKxQi/bRv354HDx7g4+ODh4eH5r8Arq6u3L59O9FjDQ0NWb16NQYGBuzYsYPNmzenV9lCiHSS4skbc+fOzbFjx/j222/x9fXF19cXlUql+e2pSpUqrF+/nty5c6dasSL5xo0bx927d7Gzs2PmzJkoisLMmTOBT2/TmJqaarlCIdKXvr4+Tk5OhIaG4uTkRL169Th//jwnTpzAxcWFM2fOJDpeskKFCowbN47JkyczZMgQGjRoIP/GCZGJfNWM1iVLluTcuXOcO3eOs2fPEhQURM6cOalatSqVK1dOrRpFCvn5+WnmiVq+fDk5cuTg+PHjXLhwARMTEwYPHqzlCoXQPgMDAzZu3EjFihW5du0aAwcO5Pfff090UPbYsWPZsWMHV65cYciQITJ/kRCZSKoMJqlSpQrfffcdo0aNokaNGujr6xMVFZUapxYp9PHjR3r37o2iKPTu3ZumTZsCnybdBOjVq5f8hivE/7O1tWXTpk3o6+uzbt06zZuZCTEyMmL16tXo6+uzefNmtm/fno6VCiHSUrJC0f3791m1alWCz9337NlD/vz5qVy5MpUrV8bW1laeuWvR+PHj+eeff8ifP78mCN28eZPdu3ejUqkYPny4lisUQrfUrVuXX3/9FYChQ4dy9uzZRNtWrFiRH3/8Efg0M/ybN2/SpUYhRNpKVihavnw5/fr1w9jYOM72f/75h06dOvHq1SsKFizIN998w7t37+jevTuXLl1K1YLFl50+fZo5c+YAsGzZMnLmzAnA7NmzAWjdujUlS5bUVnlC6CwPDw/at29PVFQUHTp04PXr14m2nTBhAqVLlyYwMJBhw4alX5FCiDSTrFB08uRJHBwcKFSoUJzt8+bNIzw8nO+++4779+9z7do1tm3bRkxMjOZVcJE+wsLCcHNzQ1EUXF1dad68OQCBgYH8/vvvgEzWKERiVCoVq1evpnjx4jx+/Jju3bsTExOTYFtjY2NWr16Nnp4e69atY8+ePelcrRAitSX78VnVqlXjbT9w4ABGRkZMnz5ds61t27bUqVNHs+CoSB8TJkzg9u3b2Nraau4MASxevJiIiAiqVq1KrVq1tFihELrNwsKC7du3Y2ZmxqFDh5gyZUqibatWrcqIESOATzPFv3//Pp2qFEKkhWSFolevXmFtbR1n29u3b7l79y7VqlUje/bscfY5Ojry9OnTr69SJIm/v78mCC1duhRLS0vg06DrRYsWAZ/uEiX2Vo0Q4pOyZcuybNkyAKZMmcK+ffsSbTt58mRKlCjBs2fPNHMeCSEypmSFIkNDw3gDCi9cuACQ4Cv4X1obTaSe8PBwevfujVqtpkePHnFmEl+zZg1v3ryhcOHCtGvXTotVCpFxdO/eXTNtxbfffsuDBw8SbGdqasqqVas0j94OHDiQjlUKIVJTskJRiRIlOHLkSJxthw4dQqVSUbNmzXjtnz17luTVqcXXmTRpEjdv3iRv3ryaJTwAYmJiNIOuhw0bhoHBV01NJUSWMnv2bKpWrcq7d+/o0KED4eHhCbarVasW7u7uwKeZ44ODg9OzTCFEKklWKHJxceHOnTsMHDiQK1eusHXrVpYtW0a2bNk08+D826lTpyhWrFiKClu0aBH29vaYmJhQrVq1z74eu3z5curUqYOlpSWWlpY0atTos+0zm7Nnz2pmqV66dCm5cuXS7Nu9ezd37twhZ86c9O7dW1slCpEhGRsbs2XLFqysrLhw4QJDhw5NtO20adMoUqQIT5484YcffkjHKoUQqSVZoWjYsGGUK1eOZcuW4ejoSOfOnQkJCWHy5MnxHpWdP3+ef/75B2dn52QXtWnTJjw8PJg4cSIXL16kQoUKNGnShJcvXybY3tfXl65du3Ls2DH8/f0pUKAAjRs3zhLjmcLDw3Fzc0OtVtO9e3dat24dZ7+XlxcAgwYNIlu2bNooUYgMrWDBgmzYsAGVSsWyZcvw9vZOsJ25uTkrV64EPk2F8d+76kII3ZesUGRmZsapU6eYPHkyTZs2pXv37uzatSvBOTouXrxImzZt4v2QTorZs2fTr18/3NzcKF26NEuWLMHMzIxVq1Yl2H79+vUMHjwYBwcHSpUqxYoVK1Cr1VniH6UpU6bw999/Y2Njw7x58+LsO3PmDKdOncLQ0JDvv/9eSxUKkfE1btyYyZMnA59+wfjrr78SbFevXj3NOKS+ffvy4cOHdKtRCPH1kj3AJFu2bIwfP/6L7fr370///v2TXVBkZCQXLlxgzJgxmm16eno0atQIf3//JJ3j48ePREVFxXmM9G8RERFERERoPo99/h8VFZXqy5PEni8tlj05f/68ZgbeBQsWYGFhEefrxD5S69q1K9bW1mm69Epa9lNXSB8zj5T0c9SoUZw+fZoDBw7g4uKCv7+/ZmLUf5s6dSp79+7lwYMH/Pjjj3HG+KUnuZaZR1boY1pKzvdNpcQua68jnj17Rv78+Tl9+jQ1atTQbB81ahTHjx8nICDgi+cYPHgwBw8e5Pr165iYmMTbP2nSJM1vff+2YcMGzMzMvq4D6SQqKooRI0bw6NEj6tSpo5krJdbz58/57rvvUKvVzJs3L96Em0KI5AsJCcHDw4NXr15RtWpVRo8ejZ5e/Bvuf/31FxMnTgQ+jTUqU6ZMepcqhPh/Hz9+pFu3bgQFBWFhYfHZtpnuVaRffvmFjRs34uvrm2AgAhgzZkyc+USCg4M145C+9A1LrqioKHx8fHB2dsbQ0DDVzjtx4kQePXpE7ty52bRpU7z5o4YNG4ZaraZJkyYMGjQo1b5uYtKqn7pE+ph5fE0/ixcvTt26dTl79iw3btxIcFB18+bNefToEStXrmTVqlVcuHAh3X/hkmuZeWSFPqal5LwNqnOhyNraGn19fQIDA+NsDwwMJG/evJ891svLi19++YXDhw9Tvnz5RNsZGxvHW78NPs3DlFZ/4FLz3BcvXmTGjBkA/Pbbb/GmPXj79q1mMOjIkSPT9S9RWn4PdYX0MfNIST+rVavGwoUL6d+/P+PHj6dGjRrUr18/XrtZs2Zx8OBB7t69y+TJk+PMMJ+e5FpmHlmhj2khOd+zZA20Tg9GRkZUqlQpziDp2EHT/36c9l8zZszg559/5sCBAwlOJJlZREZG4urqSkxMDJ06dcLFxSVemyVLlvDx40cqVKhAw4YNtVClEJlb3759cXV1Ra1W06VLlwTfdM2RI4dmVuy5c+dy+vTp9C5TCJFMOheK4NNK1cuXL2fNmjXcuHGDQYMGERoaipubGwA9e/aMMxD7119/Zfz48axatQp7e3tevHjBixcvMuWbH9OmTePq1atYW1snuNhuREQECxYsAGRJDyHSikqlYtGiRVSoUIGXL1/SqVOnBAdzNmvWjF69eqEoCr179yYsLEwL1QohkkonQ1Hnzp3x8vJiwoQJODg4cPnyZQ4cOICNjQ0Ajx494vnz55r2v/32G5GRkXTo0AFbW1vNR+wcPZnFpUuXNIvuLlq0iNy5c8drs2HDBl68eEH+/Pnp3LlzepcoRJZhZmbG1q1byZEjB6dPn2bUqFEJtpszZw62trbcunWLSZMmpW+RQohk0clQBDBkyBAePnxIREQEAQEBVKtWTbPP19c3zgRqDx48QFGUeB+Z6R+gyMhI3NzciI6OxsXFhY4dO8ZroyiKJggOHTpUnj0LkcaKFSvGmjVrgE+PyDZv3hyvjaWlJUuWLAE+jXvMSrPtC5HR6GwoEnF5enry119/YWVlxaJFixJ8LHbgwAH+/vtvsmfPnqI5ooQQydemTRtGjx4NQJ8+fbhx40a8Nq1bt6Zbt26o1Wrc3NzizJMmhNAdEooygL/++oupU6cCsHDhQs1jxP+KvUvUr18/cuTIkW71CZHV/fzzz9SvX58PHz7g4uKS4HjG+fPnkydPHv7++29+/vlnLVQphPgSCUU6LioqCldXV6Kjo2nXrl2i44QuXbrE0aNH0dfX/+yilUKI1GdgYMAff/xBvnz5uHHjBv369eO/8+JaWVmxePFi4NN8ahcvXtRGqUKIz5BQpOM8PT25fPkyuXLl4rfffkv0bbJZs2YB0KlTJwoWLJieJQohABsbGzZv3oyBgQEbN25M8O3Q2PGAMTExuLq6EhkZqYVKhRCJkVCkw/766y/NbfbPPTZ7/PgxGzduBIi33IcQIv3UqlVL8xjbw8MjwfUaY98cvXr1qjxGE0LHSCjSUVFRUZq3zdq1a0eXLl0SbTt//nxiYmKoV68elSpVSscqhRD/5e7uTqdOnYiOjqZjx468fPkyzv7cuXNrHqN5enpy4cIFbZQphEiAhCId9csvv3Dp0iVy5crF4sWLE31sFhQUxNKlS4FPkzUKIbRLpVKxYsUKSpUqxdOnT+natSsxMTFx2nTo0IHOnTsTExNDr1695G00IXSEhCIddOXKFc1t9QULFnx2zbcVK1YQEhLCN998Q7NmzdKrRCHEZ2TPnp1t27Zhbm7O0aNHmTBhQrw2CxcuJE+ePFy/fp0pU6ZooUohxH9JKNIxsW+bRUVF0bZtW7p27frZtnPnzgU+jSXS05PLKYSuKF26NCtWrABg+vTp7N69O85+a2trfvvtN+DTUkXnz59P9xqFEHHJT1Ed8+uvv3Lp0iUsLS0/+7YZwJYtW3jy5Al58uShe/fu6VilECIpunTpgru7OwA9evTg3r17cfa3b9+eLl26aN5Gk8doQmiXhCIdcvXqVc1t9C89Nvv3kh7ff/89JiYm6VKjECJ5Zs6cSY0aNQgKCsLFxSXeorCxb5Zev36dyZMna6lKIQRIKNIZ/35s1qZNG7p16/bZ9seOHePSpUuYmpoyaNCgdKpSCJFcRkZGbN68mdy5c3P58mWGDBkSZ7+VlZVmbbRff/1V1kYTQoskFOmIGTNmcPHixSQ9NoP/Tdbo5uaGlZVVepQohEghOzs7/vjjD/T09Fi1ahUrV66Ms79t27aatdFcXV0JDw/XUqVCZG0SinTAtWvXNLfNFyxYgK2t7WfbX79+nX379qFSqRg+fHh6lCiE+EoNGzbUrGH43XffxVvmY/78+djY2HDjxg0mTZqkhQqFEBKKtOzfj81iV9L+ktmzZwPQrl07ihUrltYlCiFSyY8//kirVq2IiIjAxcWFt2/favZZWVlp5hybOXMmAQEB2ipTiCxLQpGWzZgxgwsXLmBpacmSJUu++NjsxYsXrFu3DpDJGoXIaPT09FizZg1FihThwYMH9OzZE7Vardnfpk0bvv32W3mMJoSWSCjSosuXL2sem82fP/+Lj83g05sqkZGR1KhRgxo1aqR1iUKIVGZpacm2bdswMTFh7969eHp6xtk/b9488ubNy82bNxOc9FEIkXYkFGlJREQEPXr0ICoqinbt2iVpnqHQ0FDNmklyl0iIjMvBwUHzd3n8+PH4+Pho9uXKlYtly5YBn16oOHPmjFZqFCIrklCkJRMnTuTatWvkyZOHpUuXfvGxGcDq1at59+4dRYsWpU2bNulQpRAirbi5udG3b18URaFbt248fvxYs69Vq1aaR2uurq7x5jYSQqQNCUVacPr0aWbOnAnAsmXLyJ079xePiYmJYc6cOQAMHz4cfX39NK1RCJH2FixYQMWKFXn9+jUdO3YkMjJSs2/u3Lnky5ePW7duMXbsWC1WKUTWIaEonYWGhmp+A+zVq1eS7/js3LmTe/fukStXLlxdXdO2SCFEujAxMWHr1q3kzJmTgIAARowYodlnaWmpWTtt7ty5HD16VFtlCpFlSChKZ6NGjeLu3bsUKFCAefPmJfm42CU9Bg8ejLm5eVqVJ4RIZ4ULF9a8Ubpw4UI2bNig2desWTMGDBgAgKurK+/fv9dGiUJkGRKK0tGhQ4c0gytXr15Njhw5knTc6dOnOXPmDEZGRvGWCBBCZHwtWrTgp59+AqBfv35cv35ds8/Ly4uiRYvy+PFjzeKyQoi0IaEonbx7947evXsDMGTIEBo2bJjkY2PvEvXo0QMbG5s0qU8IoV2TJk2iUaNGfPz4kfbt2xMcHAxAtmzZWLt2LXp6eqxdu5Zt27ZpuVIhMi8JRelk+PDhPH36lOLFi/Prr78m+bg7d+6wc+dOADw8PNKoOiGEtunr67Nhwwbs7Oy4ffs2ffr0QVEUAGrUqMHo0aMBGDBgAC9evNBmqUJkWhKK0oG/vz8bNmxAT0+P33//HTMzsyQfO2fOHBRFoUWLFpQuXToNqxRCaFvu3LnZsmULhoaGbN26lblz52r2TZw4EQcHB968eaN5lV8IkbokFKWxwMBAfvvtN+DTukfVq1dP8rGvX7/G29sbIM5bKUKIzKt69eqa6Td++OEH/Pz8ADAyMmLt2rUYGRmxd+9ezZtpQmQGwcHB3LhxQ9tlSChKS4qiMHjwYIKDgylXrhwTJ05M1vG//fYbYWFhVKxYkXr16qVNkUIInTN48GC6detGTEwMnTt31jwuK1u2LNOnTwc+PZK/e/euNssUItUMHTqUihUrsnbtWq3WIaEotVhYgEoV50Olp8efu3ejAFeuXsXYxCRuGwuLRE8XHh7OwoULgU9LeiRlxmshROagUqlYtmwZZcqU4fnz53Tp0oXo6GjgUxhycnIiNDSUXr16ERMTo+Vqhfg6W7duxdvbm8jISAoXLqzVWiQU6ah169bx8uVLChYsSIcOHbRdjhAinZmbm7Nt2zayZcvG8ePHGTduHAB6enp4e3uTPXt2Tp06pXk7VYiM6NmzZ5q5uEaPHk3t2rW1Wo+EIh2kVquZNWsW8OmWoqGhoZYrEkJoQ8mSJVm9ejUAM2bMYMeOHQDY29trJn8dP348f/31l9ZqFCKlYtf2e/v2LZUqVUr2EJO0IKFIB+3bt4+bN29iYWFB3759tV2OEEKLOnTooJmOw9XVlTt37mj+v02bNkRFRdGtWzdZNFZkOAsXLsTHxwdTU1PWrVuHkZGRtkuSUKSLYm+HDxgwAIvPjDsSQmQNv/zyC7Vr1yY4OBgXFxc+fvyISqVi+fLl5M2bl7///puRI0dqu0whkuzq1auMGjUKgJkzZ1KqVCktV/SJhCIdc/78eY4fP46BgYFM6S+EAMDQ0JBNmzZhY2PD1atXGThwIIqikDt3btasWQPA4sWL+fPPP7VcqRBfFhYWRteuXYmIiKB58+YMHjxY2yVpSCjSMbFjibp06YKdnZ2WqxFC6Ip8+fKxadMm9PX1Wbt2LcuWLQOgcePGmnnMevfuzbNnz7RZphBfNHLkSK5fv46NjQ2rV6/WqberJRTpkIcPH7JlyxZAJmsUQsTn5OSEp6cnAO7u7pw7dw6AadOm4ejoyJs3b+jVqxdqtVqbZQqRqD///FOzMPrvv/9Onjx5tFxRXBKKdMi8efOIiYmhUaNGODg4aLscIYQOGjlyJG3btiUyMpIOHTrw5s0bjI2N2bBhA6amphw+fJjZs2dru0wh4nn69KlmYfQRI0bQuHFjLVcUn4QiHfH+/XuWL18OyF0iIUTiVCoV3t7eFCtWjEePHtG9e3diYmIoVaqU5jX9sWPHcvHiRS1XKsT/qNVqevbsyZs3b6hYsaJmZnZdI6FIRyxbtowPHz5QtmxZmjRpou1yhBA6LEeOHGzbtg1TU1MOHjzI1KlTAejbty/t27cnKiqKHj16EB4eruVKhfhk5syZHD16FDMzMzZs2KATr98nREKRDoiMjNT8hjdixAidGnQmhNBN5cuXZ+nSpQBMnjyZAwcOaF7Tz58/P3fu3GHlypVarlIIOHfuHD/99BMACxYsoGTJklquKHESinTApk2bePbsGXnz5qVr167aLkcIkUH06NGDj4aGqBWFps2agUpFLisrnjx9igIc8vHB0Mgo3rqMn1t3UYjUFBISQrdu3YiOjqZjx464ublpu6TPklCkZYqiaCZrdHd3x9jYWMsVCSEyEhMTE22XIESCFEVh4MCB/PPPPxQsWJClS5fq/JMQCUVadvjwYa5cuYK5ublmUTwhhEgq3f4RI7KyFStWsGHDBvT19dmwYQOWlpbaLumLJBRpWexkjX369CFXrlxarkYIIYT4en/99Rfff/89ANOnT6dWrVparihpJBRpUYxazcGDB9HT02PYsGHaLkcIIYT4aiEhIXTs2JGIiAhatGiRodblk1CkRZGRkQC4uLhQuHBhLVcjhBBCfB1FURgwYAB37tzBzs6ONWvWoKeXcaJGxqk0E4qKigJkskYhRPpStF2AyLSWLVvGH3/8gb6+Pps2bcLKykrbJSWLhCItq127NtWqVdN2GUKILEQmdRRp4fLlywwdOhQAT09PatasqeWKkk8nQ9GiRYuwt7fHxMSEatWqcfbs2UTbXr9+HRcXF+zt7VGpVMydOzf9Ck0FGelZqxBCBwUHg6Lwx4YNqCBJH2ZRUWzevFlbFYtMKDg4mE6dOhEREUHLli0z7BMQnQtFmzZtwsPDg4kTJ3Lx4kUqVKhAkyZNePnyZYLtP378SJEiRfjll1/ImzdvOlf7dfT09GjVqpW2yxBCZAK2trZJale0aFEAevfuzd9//52WJYksQlEUXF1duXPnDgUKFMDb2ztDjSP6N52revbs2fTr1w83NzdKly7NkiVLMDMzY9WqVQm2r1KlCjNnzqRLly4ZbuJDIyOjDPsHRwihW+rUqYOdnd0XJ8e7e/cu+vr6hIaG0rZtW4KCgtKpQpFZ/frrr+zYsQMjIyO2bNmS4cYR/ZuBtgv4t8jISC5cuMCYMWM02/T09GjUqBH+/v6p9nUiIiKIiIjQfB4cHAx8GvgcO/g5uQxI/iRqhoaGKf56uia2H5mlPwmRPmYembWfs2bNokuXLqhUKhTlf8OpY4PSxIkT2blzJ5cvXwbgzp07NGnShOPHj2fYX9Ay67X8N13u4+HDhxk3bhwAc+fOpWLFijpXZ3Lq0alQ9Pr1a2JiYrCxsYmz3cbGhps3b6ba1/H09GTy5Mnxth86dAgzM7MUnbN5dDSGyTwmOjqaffv2pejr6SofHx9tl5DmpI+ZR2brp7GxMaNGjWLFihW8efNGs93Kyoo+ffrg4OBAuXLlOHr0KGvWrOHDhw8EBARQpEgRxo0bR/78+bVY/dfJbNcyIbrWx8DAQEaOHIlaraZRo0bY2trq5M+0jx8/JrmtSvn3rxNa9uzZM/Lnz8/p06epUaOGZvuoUaM4fvw4AQEBnz3e3t6eYcOGfXEixITuFBUoUIDXr19jkcKFEg2srFCFhCTrGCV7dqL/9Q9XRhYVFYWPjw/Ozs4YGiY3HmYM0sfMI7P3MyYmBl9fX00f69Wrh76+fpw2QUFBdO3alcOHDwOgr6/P999/z7hx48iRI4c2yk6RzH4tQTf7GBYWRr169bh06RKVKlXi2LFjOrsOX3BwMNbW1gQFBX3xZ7xO3SmytrZGX1+fwMDAONsDAwNTdRC1sbFxguOPDA0N0/UPnOr/v2Zmkt7fQ22QPmYembWfhoaGNGzYkIiICBo2bJhgH62trfHx8aFjx45s3bqVmJgY5s6dy/r165k2bRq9e/eOF6R0WWa9lv+mK31UFAV3d3cuXbqEtbU127dvJ3v27NouK1HJ+Z7p1ENkIyMjKlWqxJEjRzTb1Go1R44ciXPnSAghROpYu3YtlStXBj79wvjq1Sv69+9PlSpV8PPz03J1QhctWbJEM1P1xo0bKViwoLZLSjU6FYoAPDw8WL58OWvWrOHGjRsMGjSI0NBQ3NzcAOjZs2ecgdiRkZFcvnyZy5cvExkZydOnT7l8+TL//POPtroghBAZhomJCdu2bcPa2pqIiAgqVKhAjhw5uHTpEnXr1qVLly48evRI22UKHeHr64u7uzsAv/zyCw0bNtRyRalL50JR586d8fLyYsKECTg4OHD58mUOHDigGXz96NEjnj9/rmn/7NkzHB0dcXR05Pnz53h5eeHo6Ejfvn211QUhhMhQChYsyPbt2zE0NOSvv/6if//+9O/fH5VKxaZNmyhVqhSTJk1K1oBVkfncu3cPFxcXoqOj6dKlS6acfFjnQhHAkCFDePjwIREREQQEBMRZBsPX1xdvb2/N5/b29iiKEu/D19c3/QsXQogMqk6dOvz2228AzJw5E2dnZy5cuEDdunUJCwtj8uTJlCpVio0bN6JD7+eIdBIcHEyrVq14+/YtVapUYdWqVV+cEysj0slQJIQQIv316dOH4cOHA5+GKsT+grl582YKFizI48eP6dq1K3Xr1uXixYtarlakl5iYGLp27crff/9Nvnz52LlzJ6amptouK01IKBJCCKExY8YMmjZtSlhYGG3atOHFixd07NiRGzduMHnyZExNTTl58iSVK1emX79+iS7BJDKP0aNHs2/fPkxNTdm1axf58uXTdklpRkKREEIIDQMDAzZu3EipUqV48uQJ7dq1Izw8HDMzMyZMmMCtW7fo2rUriqKwYsUKihcvzqxZs4iMjNR26SINeHt74+Xlpfn/2DcVMysJRaklmStV/7Fhw6djhBBCx+TIkYM///wTS0tLAgIC6NWrF2q1GoACBQqwYcMG/Pz8qFixIsHBwYwcOZJy5crp5GzGIuWOHj1K//79AZgwYQKdOnXSckVpT0JRKkvqStVJbSeEENpQvHhxtm3bhqGhIZs3b+bHH3+Ms7927dqcPXuWFStWkCdPHm7fvk2LFi1o3rx5qi7LJLTj6tWrtGvXjqioKDp37szEiRO1XVK6kFCUyr60UrVKpaJAgQLUqVMnnSsTQojkqV+/PqtWrQLAy8uLhQsXxtmvr69Pnz59uH37NiNHjsTQ0JD9+/dTrlw5PDw8eP/+vRaqFl/ryZMnNG/enODgYOrWrauZqDEryBq9TEf6+vrMmzcPIF4wiv187ty5GWr6fCFE1vXtt98ybdo0ANzd3dm5c2e8Njly5GDmzJlcu3aNli1bEh0dzZw5cyhRogTLly8nJiYmnasWKRUcHEyLFi148uQJpUqVYseOHQkui5VZSShKA+3bt2fr1q3xVpy2s7Nj69attG/fXkuVCSFE8o0ZM4b+/fujKApdu3blzJkzCbYrUaIEu3fvZv/+/ZQqVUqzZEjlypU5ceJEOlctkisyMhIXFxeuXLlC3rx52b9/P7ly5dJ2WelKQlEaad++PQ8ePMDHxwcPDw98fHy4f/++BCIhRIajUqlYtGgRLVq0IDw8nFatWnHnzp1E2zdt2pQrV64wZ84ccuTIweXLl3FycqJz5848fPgwHSsXSaVWq+nXrx+HDx/G3NycvXv3Ym9vr+2y0p2EojSkr6+Pk5MTdevWxcnJSR6ZCSEyrNhX9StVqsTr169xdnbmyZMnibY3NDRk2LBh3LlzhwEDBqBSqdi8eTOlSpVi4sSJsmSIDlEUhREjRvD777+jr6/Pli1bqFixorbL0goJRUIIIZIkW7Zs7N27l+LFi/Pw4UOcnZ159erVZ4/JnTs3S5Ys4eLFi9StW5fw8HCmTJlCyZIlZckQHfHzzz8zd+5cAFauXEmzZs20W5AWSSgSQgiRZDY2Nhw+fJgCBQpw8+ZNmjZtSlBQ0BePc3BwwNfXly1btlCoUCGePHlC165dqVOnDhcuXEiHykVC5s+fr3ndft68efTq1UvLFWmXhCIhhBDJUrBgQXx8fMidOzcXL16kVatWSXocplKp6NChAzdu3GDKlCmYmppy6tQpqlSpQt++fQkMDEyH6kWsNWvWMHToUAAmT56Mu7u7livSPglFQgghkq1kyZIcPHiQHDly4OfnR4cOHYiIiEjSsaampowfP55bt27RrVs3FEVh5cqVlChRQpYM+Y+YmBiOHz/OiRMnOH78eKpNb7Bt2zZ69+4NwLBhwxg/fnyqnDejk1AkhBAiRRwdHdm7dy+mpqbs378/WcEIPi0Zsn79ek6ePEmlSpU0S4aULVuWvXv3ZvnxRtu3b8fe3h5nZ2dmz56Ns7Mz9vb2bN++/avP26VLF9RqNa6ursyaNSvRCYezGglFQgghUqxWrVrs3r0bExMT9uzZg4uLS7KCUew5zp49y8qVK8mTJw937tyhZcuWWXrJkO3bt9OhQ4d4b/g9ffqUDh06pDgYbd++nc6dOxMdHU337t1ZsWJFlpmtOinkOyGEEOKrNGzYkD179mBqasrevXtTFIz09PTo3bs3d+7c4YcffsDQ0JADBw5Qrlw5hg8fnmWWDImMjOTZs2cMHjw4wTtlsduGDRuW7Edp/w1Ea9askali/sNA2wUIIYTI+Bo2bMju3btp1aoVe/fupX379mzfvj3ZS0RYWFgwY8YM+vXrh4eHB3v27GHu3LmsW7eOadOm0adPH80P8n+PtzE3N6d+/fo680M+IiKCd+/e8ebNG96+fRvvI6Htb9684cOHD188t6IoPH78GD8/P+rVq5ekeiQQJY2EIiGEEKki9o5Ry5Yt2bdvH61bt2b79u2Ym5sn+1zFixdn9+7dHDhwgOHDh3Pz5k0GDBjA4sWLmTdvHm/evGHo0KGax0uzZ8/Gzs6OefPmperKAeHh4UkONP/+PDQ0NNlfKwiwSM4B9etD9uwQHPzZZuvXr8fV1VUCURJIKBJCCJFqGjRowJ49e2jVqhWHDh3C2dmZvXv3YmlpmaLzNW3alIYNG7J48WImTpzIX3/9lejdkdjxNgmtMRkWFpbkQPPv7WFhYSmqGz49ErS0tCRXrlxxPqysrOJty5UrF9kaNoQUhKnPWbRoEUOGDAGgR48erF69WgLRZ0goEkIIkaoaNGjA4cOHadGiBf7+/jg5OXHw4EFsbW1TdD5DQ0OGDh1Kt27d+Omnn1i2bFmC7WLH23z77bdUrlyZd+/eaQJOeHh4ivujp6f3xUCT0PYcOXIkbxBzKg54VhSFqVOnMmHCBAC+//575s6dK4Oqv0BCkRBCiFRXo0YNTpw4QePGjbl69Sq1a9fGx8eHIkWKpPicuXPnpmvXromGolhhYWH4+fnF225gYJDkQPPv7dmzZ89QYUKtVjNixAjN0h0TJ05k4sSJ8tp9EkgoEkIIkSbKli3LyZMncXZ25t69e9SoUYPdu3dTtWrV5J/MwgJCQqgHJHX2omgzM674+WlCTvbs2TN9MAgLC6NXr15s2bIFgLlz52pmrRZflnGirxBCiAynSJEinDx5kgoVKvDy5UucnJzYtm1bunxtA319KlasiL29PRYWFpk+EL169YqGDRuyZcsWDA0N+f333yUQJZOEIiGEEGnK1tYWPz8/WrRoQXh4OB07dmTmzJlZfsbq1HTz5k2qV6+Ov78/OXPm5NChQ/To0UPbZWU4EoqEEEKkuezZs7Nz506GDBmCoiiMGjWKAQMGJHuSRxHf4cOHqVmzJvfu3aNw4cL4+/snef4iEZeEIiGEEOnCwMCABQsWMG/ePFQqFcuXL8fJySneUhYi6SIiI2nSpAnv3r2jRo0aBAQEUKpUKW2XlWFJKBJCCJGu3N3d2bdvH5aWlgQEBFCpUiV8fX21XVaGFBERgVqtpnfv3hw9epTcuXNru6QMTUKREEKIdNe0aVPOnz+Pg4MDL1++pFGjRnh5eck4oxRYunQpK1aswMTERNulZHgSioQQQmhFkSJFOHXqFD169CAmJoYffviB5s2bExgYqO3SMgxzMzP69++f6d+sSy8SioQQQmiNmZkZa9as4bfffsPExIQDBw5Qrlw59u7dq+3SMgRZsiN1SSgSQgihVSqVioEDB3L+/HnKly/Pq1evaNmyJYMGDSL4C4udCpGaJBQJIYTQCWXKlCEgIEAz4eCSJUsoU6aM3DUS6UZCkRBCCJ1hYmLC3LlzOXLkCEWKFOHJkye0bNnyq1arzzCCg0FRUMfE4L16NVa5cqHi08zcHVxcCPn//XE+5E5aqpJQJIQQQuc0aNCAq1evMmLECPT09IiKjtZ2SekiICCAmjVr4ubmxtu3b3FwcOD06dP06NFD3i5LBxKKhBBC6CQzMzO8vLw4c+ZMhlqlPiWePHlCr169qF69OgEBAWTLlo1ff/2Vs2fP4ujoqO3ysgwDbRcghBBCfE6VKlVQzM0hJETbpaS6Z8+e4enpybJly4iMjATA1dWV6dOnY2trC0BUVJQ2S8xSJBQJIYTQeZltFp4HDx4wd+5cli5dSnh4OAB169bFy8uLKlWqaLm6rCtz348UQgiROfxnkPHLwEBGjhiBmakpKj6FpuLFijF/3jyCg4J0chCyoiicOHECFxcXihYtyrx58wgPD6dWrVocOXIEX19fCURaJqFICCFEhpMnTx68vLy4desWbdu2JWfOnPzzzz8MHToUOzs7+vbty/Hjx1Gr1doulWfPnuHl5UWFChVwcnJi+/btqNVqGjVqxMGDB/Hz86NBgwYyK7UOkFAkhBAiw8qbNy+urq7cu3ePxYsXU6pUKUJCQli5ciX16tWjSJEijBgxgmPHjqXr2JwHDx6wcOFCnJ2dKVCgAD/88ANXr17F1NSU/v37c+3aNXx8fGjcuLGEIR0iY4qEEEJkeNmyZWPQoEEMGDAAPz8/1q5dy5YtW3j48CGzZ89m9uzZ5MiRgwYNGlC7dm1q1aqFo6MjRkZGX/21FUXhyZMnnDx5kpMnT3L8+HGuX78ep02tWrXo2bMnHTt2xNLS8qu/pkgbEoqEEEJkGnp6ejg5OeHk5MSCBQvYt28fu3fvZu/evbx+/ZodO3awY8cOAAwNDSlRogSlS5emVKlS5M+fn3z58pE3b16yZcuGiYkJJiYmREdHExYWRnh4OG/evOHZs2c8e/aMe/fucf36da5fv87bt2/j1VG7dm1atWpFu3btKFq0qDa+HSKZJBQJIYTIlExNTXFxccHFxYWYmBjOnTvHiRMnOHnyJKdPn+bNmzeaUPO19PX1cXR0pFatWtSqVYuGDRuSK1euVOiFSE8SioQQQmR6+vr6VK9enerVqzNq1CgUReHRo0f8/fffXL9+ndu3b/P8+XOeP39OYGAgHz9+JDw8nPDwcAwMDDAxMcHU1JScOXNq7igVKFCA0qVLU6ZMGUqVKoWpqam2uym+koQiIYQQWY5KpaJQoUIUKlSIZs2aabscoSPk7TMhhBBCCHQ4FC1atAh7e3tMTEyoVq0aZ8+e/Wz7LVu2UKpUKUxMTChXrhz79u1Lp0qFEEIIkRnoZCjatGkTHh4eTJw4kYsXL1KhQgWaNGnCy5cvE2x/+vRpunbtSp8+fbh06RJt27albdu2XLt2LZ0rF0IIIURGpZOhaPbs2fTr1w83NzdKly7NkiVLMDMzY9WqVQm2nzdvHk2bNuWHH37gm2++4eeff6ZixYosXLgwnSsXQgghREalc6EoMjKSCxcu0KhRI802PT09GjVqhL+/f4LH+Pv7x2kP0KRJk0TbCyGEEEL8l869ffb69WtiYmKwsbGJs93GxoabN28meMyLFy8SbP/ixYsE20dERBAREaH5PCgoCIC3b9+m+jTwUVFRfPz4kTdv3mBoaJiq59YlWaGf0sfMIyv0Myv0EbJGP7NCH9NSSEgI8Gnm8S/RuVCUHjw9PZk8eXK87YULF9ZCNUIIIYRIayEhIeTIkeOzbXQuFFlbW6Ovr09gYGCc7YGBgeTNmzfBY/LmzZus9mPGjMHDw0PzuVqt5u3bt1hZWaX6wnzBwcEUKFCAx48fY2Fhkarn1iVZoZ/Sx8wjK/QzK/QRskY/s0If05KiKISEhJAvX74vttW5UGRkZESlSpU4cuQIbdu2BT6FliNHjjBkyJAEj6lRowZHjhxh2LBhmm0+Pj7UqFEjwfbGxsYYGxvH2ZYzZ87UKD9RFhYWWeIPc1bop/Qx88gK/cwKfYSs0c+s0Me08qU7RLF0LhQBeHh40KtXLypXrkzVqlWZO3cuoaGhuLm5AdCzZ0/y58+Pp6cnAEOHDsXJyYlZs2bRokULNm7cyPnz51m2bJk2uyGEEEKIDEQnQ1Hnzp159eoVEyZM4MWLFzg4OHDgwAHNYOpHjx6hp/e/F+dq1qzJhg0b+Omnnxg7dizFixdn586dlC1bVltdEEIIIUQGo5OhCGDIkCGJPi7z9fWNt61jx4507NgxjatKPmNjYyZOnBjvcV1mkxX6KX3MPLJCP7NCHyFr9DMr9FFXqJSkvKMmhBBCCJHJ6dzkjUIIIYQQ2iChSAghhBACCUVCCCGEEICEojQTERHBjz/+SL58+TA1NaVatWr4+Phou6xUM23aNFQqVbw3/OrVq4dKpYr30bRpUy1VmnQXLlygadOmWFhYkD17dho3bszly5cTbHv69Glq166NmZkZefPmxd3dnQ8fPqRvwV/w4cMHJk6cSNOmTcmVKxcqlQpvb+947ZYvX46TkxM2NjYYGxtTuHBh3NzcePDgQby2CV1blUrFL7/8kvYdSkRS+wmwefNmqlevTs6cObGyssLJyYm9e/fGa6dWq5kxYwaFCxfGxMSE8uXL88cff6RxTxJ37tw5hgwZQpkyZTA3N6dgwYJ06tSJ27dvx6nZ29ub1q1bU6BAAczNzSlbtixTp04lPDw83jl17VompY+fq1ulUuHs7Bynra5dx+vXr9OxY0eKFCmCmZkZ1tbW1K1bl927d8dpd/bsWQYPHkylSpUwNDT87KTCunYdMzqdffsso3N1dWXr1q0MGzaM4sWL4+3tTfPmzTl27Bi1a9fWdnlf5cmTJ0yfPh1zc/ME99vZ2WnmkIqVlJlEtenixYvUrl2bAgUKMHHiRNRqNYsXL8bJyYmzZ89SsmRJTdvLly/TsGFDvvnmG2bPns2TJ0/w8vLizp077N+/X4u9iOv169dMmTKFggULUqFChQTf2gS4dOkShQsXpnXr1lhaWnL//n2WL1/Onj17+Ouvv+JdO2dnZ3r27Blnm6OjY1p144uS2s8FCxbg7u5OixYt+OWXXwgPD8fb25uWLVuybds22rdvr2k7btw4fvnlF/r160eVKlXYtWsX3bp1Q6VS0aVLl3Tq2f/8+uuvnDp1io4dO1K+fHlevHjBwoULqVixImfOnKFs2bJ8/PgRNzc3qlevzsCBA8mTJw/+/v5MnDiRI0eOcPTo0Xg/XHXpWialjwBr166Nd+z58+eZN28ejRs3jrNd167jw4cPCQkJoVevXuTLl4+PHz+ybds2WrduzdKlS+nfvz8A+/btY8WKFZQvX54iRYrEC4b/pUvXMcNTRKoLCAhQAGXmzJmabWFhYUrRokWVGjVqaLGy1NG5c2elQYMGipOTk1KmTJk4+xLalhE0b95csbS0VF6/fq3Z9uzZMyVbtmxK+/bt47Rt1qyZYmtrqwQFBWm2LV++XAGUgwcPplvNXxIeHq48f/5cURRFOXfunAIoq1evTtKx58+fVwDF09MzznZA+e6771K71K+S1H4WL15cqVKliqJWqzXbgoKClGzZsimtW7fWbHvy5IliaGgYp59qtVqpU6eOYmdnp0RHR6ddZxJx6tQpJSIiIs6227dvK8bGxkr37t0VRVGUiIgI5dSpU/GOnTx5sgIoPj4+cbbr2rVMSh8T06dPH0WlUimPHz/WbNPF65iQ6OhopUKFCkrJkiU12168eKF8/PhRURRF+e6775TP/ajWteuY0cnjszSwdetW9PX1NakfwMTEhD59+uDv78/jx4+1WN3XOXHiBFu3bmXu3LmfbRcdHa1zj5M+x8/Pj0aNGmFlZaXZZmtri5OTE3v27NH0JTg4GB8fH7799ts40+337NmTbNmysXnz5nSvPTHGxsaJrv/3Jfb29gC8f/8+wf1hYWEJPpLRhqT2Mzg4mDx58sS5W2JhYUG2bNkwNTXVbNu1axdRUVEMHjxYs02lUjFo0CCePHmCv79/6nYgCWrWrImRkVGcbcWLF6dMmTLcuHED+LREUs2aNeMd265dOwBNu//SlWuZlD4mJCIigm3btuHk5ISdnZ1muy5ex4To6+tToECBOH/XbGxs4vyZTApduY4ZnYSiNHDp0iVKlCgRb42aqlWrAiQ6TkXXxcTE8P3339O3b1/KlSuXaLvbt29jbm5O9uzZyZs3L+PHjycqKiodK02+iIiIBP8RMjMzIzIykmvXrgFw9epVoqOjqVy5cpx2RkZGODg4cOnSpXSpNy28efOGly9fcv78ec2SOg0bNozXztvbG3Nzc0xNTSldujQbNmxI71JTpF69ehw4cIAFCxbw4MEDbt68yXfffUdQUBBDhw7VtLt06RLm5uZ88803cY6P/furK9dYURQCAwOxtrb+bLsXL14AJNhO169lUvq4b98+3r9/T/fu3eNs1+XrGBoayuvXr7l79y5z5sxh//79Cf5dSypdv44ZiYwpSgPPnz/H1tY23vbYbc+ePUvvklLFkiVLePjwIYcPH060TdGiRalfvz7lypUjNDSUrVu3MnXqVG7fvs2mTZvSsdrkKVmyJGfOnCEmJgZ9fX0AIiMjCQgIAODp06fAp2sLJHp9/fz80qni1Jc/f34iIiIAsLKyYv78+fEGrtasWZNOnTpRuHBhnj17xqJFi+jevTtBQUEMGjRIG2Un2fz583n9+jXu7u64u7sDn4LCkSNH4iwe/fz5c2xsbOKNv9G1v7/r16/n6dOnTJky5bPtZsyYgYWFBc2aNYuzPSNcy6T0cf369RgbG9OhQ4c423X5Oo4YMYKlS5cCoKenR/v27Vm4cGGKzpURrmNGIqEoDYSFhSU4HbuJiYlmf0bz5s0bJkyYwPjx48mdO3ei7VauXBnn8x49etC/f3+WL1/O8OHDqV69elqXmiKDBw9m0KBB9OnTh1GjRqFWq5k6daomBMVes9j/JnZ9M+K1jbV//37Cw8O5ceMG69atIzQ0NF6bU6dOxfm8d+/eVKpUibFjx+Lq6prsW/7pyczMjJIlS2JnZ0fLli0JCQlhzpw5tG/fHj8/P4oVKwZkjL+/sXe5atSoQa9evRJtN336dA4fPszixYvJmTNnnH26fi2T0sfg4GD27t1L8+bN4/VPl6/jsGHD6NChA8+ePWPz5s3ExMQQGRmZonPp+nXMaOTxWRowNTXV/Mb9b7HPezPiH9KffvqJXLly8f333yf72BEjRgB89g6Ttg0cOJCxY8eyYcMGypQpQ7ly5bh79y6jRo0CIFu2bMD/rl1i1zcjXttY9evXp1mzZnh4eLBlyxYmT578xd9ejYyMGDJkCO/fv+fChQvpVGnKdOzYkUePHuHt7U2HDh1wc3PD19eXyMhIxo0bp2mn639/X7x4QYsWLciRI4dm/GJCNm3axE8//USfPn2SdMdAl65lUvu4bds2wsPD4z06A92+jqVKlaJRo0b07NlTM2axVatWKKmw6pYuXceMSEJRGrC1tdXcYfi32G26/nr6f925c4dly5bh7u7Os2fPePDgAQ8ePCA8PJyoqCgePHjA27dvEz2+QIECAJ9towumTZtGYGAgfn5+XLlyhXPnzqFWqwEoUaIE8L9b74ld34x2bRNTtGhRHB0dWb9+/RfbZoTre+/ePQ4cOEDr1q3jbM+VKxe1a9eO89u2ra0tL168iPcDShf+/gYFBdGsWTPev3/PgQMHEq3Fx8eHnj170qJFC5YsWZLk8+vCtUxqH+HTo7McOXLQsmXLePt0+Tr+V4cOHTh37twXX71PKl24jhmVhKI04ODgwO3btwkODo6zPXZ8ioODgxaqSrmnT5+iVqtxd3encOHCmo+AgABu375N4cKFP/vM/969ewCffeymKywtLaldu7ZmIPnhw4exs7OjVKlSAJQtWxYDAwPOnz8f57jIyEguX76c4a7t54SFhREUFPTFdhnh+gYGBgKfXhb4r6ioKKKjozWfOzg48PHjx3hvPGn77294eDitWrXi9u3b7Nmzh9KlSyfYLiAggHbt2lG5cmU2b96MgUHSR0lo+1omtY/wKdwcO3YMFxeXBB+T6ep1TEjso7yk/H1LCm1fxwxNqxMCZFJnzpyJN09ReHi4UqxYMaVatWparCxlXr16pezYsSPeR5kyZZSCBQsqO3bsUK5cuaIEBQUp4eHhcY5Vq9VK586dFUC5cOGClnqQMhs3blQAxcvLK872pk2bKra2tkpwcLBm24oVKxRA2b9/f3qXmSSJzd8TFRWlvH37Nl77gIAARV9fX+nRo4dm28uXL+O1Cw4OVooWLapYW1vHm2NGGxLr58uXLxU9PT2lXr16ceYpevz4sZItWzaladOmcbYlNr9N/vz5tTK/TXR0tNK6dWvFwMBA2bt3b6Lt/v77b8XKykopU6ZMgtc1li5ey6T2Mdbs2bMVQDly5EiC+3XxOgYGBsbbFhkZqVSsWFExNTVVQkJC4u3/3DxFungdMzoZaJ0GqlWrRseOHRkzZgwvX76kWLFirFmzhgcPHsQbiJwRWFtb07Zt23jbY+cqit3n6+tL165d6dq1K8WKFSMsLIwdO3Zw6tQp+vfvT8WKFdOv6GQ6ceIEU6ZMoXHjxlhZWXHmzBlWr15N06ZN47yuDZ8es9WsWRMnJyf69+/PkydPmDVrFo0bN9a55UwWLlzI+/fvNW/a7N69mydPngDw/fffoygKBQoUoHPnzprlFa5evcrq1avJkSMH48eP15xr0aJF7Ny5k1atWlGwYEGeP3/OqlWrePToEWvXro03x0x6+lI/c+fOTe/evVmxYgUNGzakffv2hISEsHjxYsLCwhgzZozmXHZ2dgwbNoyZM2cSFRVFlSpV2LlzJ35+fqxfvz7R8S1pacSIEfz555+0atWKt2/fsm7dujj7v/32W0JCQmjSpAnv3r3jhx9+iLd8SdGiRTVv2enitUxKH/9t/fr15MuXj3r16iV4Pl28jgMGDCA4OJi6deuSP39+Xrx4wfr167l58yazZs3SjF18+PChZubu2LvSU6dOBaBQoUL06NED0M3rmOFpO5VlVmFhYcrIkSOVvHnzKsbGxkqVKlWUAwcOaLusVPXf2avv3bundOzYUbG3t1dMTEwUMzMzpVKlSsqSJUvi/Haui/755x+lcePGirW1tWJsbKyUKlVK8fT0TPQ3LT8/P6VmzZqKiYmJkjt3buW7776Lc+dIVxQqVEgBEvy4f/++EhERoQwdOlQpX768YmFhoRgaGiqFChVS+vTpo9y/fz/OuQ4dOqQ4OzsrefPmVQwNDZWcOXMqjRs3TvQ39fT0pX4qyqe7YgsWLFAcHByUbNmyKdmyZVPq16+vHD16NN75YmJilOnTpyuFChVSjIyMlDJlyijr1q1L5179j5OTU6L9i/1n/P79+59t06tXL835dPFaJqWPsW7evKkAioeHx2fPqWvX8Y8//lAaNWqk2NjYKAYGBoqlpaXSqFEjZdeuXXHaHTt2LNHvg5OTk6adLl7HjE6lKKkw3F0IIYQQIoOTgdZCCCGEEEgoEkIIIYQAJBQJIYQQQgASioQQQgghAAlFQgghhBCAhCIhhBBCCEBCkRBCCCEEIKFICCGEEAKQUCSEEEIIAUgoEkKIz3rw4AEqlQpXV1dtlyKESGMSioQQOqt3796oVCqsrKyIiIjQdjlCiExOQpEQQieFhISwefNmVCoVb9++ZefOndouSQiRyUkoEkLopE2bNhEaGsrw4cPR09Nj5cqV2i5JCJHJSSgSQuiklStXYmBgwKhRo6hfvz5Hjhzh4cOH8drZ29tjb2/Phw8fGDp0KPny5cPY2Jjy5cuzdevWBM/94MEDOnfuTK5cuciWLRtOTk6cOHGCSZMmoVKp8PX1TVKNISEhTJw4kTJlymBqakrOnDlp0qQJJ0+e/JquCyG0REKREELn/P3335w5c4bGjRtjY2NDz549UavVrF69OsH2UVFRNG7cmEOHDuHi4sK3337L3bt36dSpE4cOHYrT9unTp9SsWZPNmzdTrVo13N3dsba2xtnZmYCAgCTX+PbtW2rUqMGUKVOwtLRk4MCBuLi4cOHCBerXry+P+4TIiBQhhNAxHh4eCqD88ccfiqIoSkhIiGJubq4ULFhQiYmJidO2UKFCCqC0adNGiYiI0Gw/fPiwAihNmjSJ0/7bb79VAGXatGlxtq9cuVIBFEA5duyYZvv9+/cVQOnVq1ec9t26dVMAZfny5XG2BwYGKgUKFFBy586thIWFpfRbIITQArlTJITQKVFRUaxduxYLCwvatm0LQLZs2WjXrh2PHj3i8OHDCR43Z84cjIyMNJ83bNiQQoUKce7cOc22iIgItmzZQp48eRgxYkSc493c3ChZsmSSanz9+jWbNm2iQYMG9O3bN86+PHny8MMPP/Dq1atEaxVC6CYDbRcghBD/tmvXLl69ekWfPn0wMTHRbO/Zsyfr1q1j5cqVNG7cOM4xOXPmpHDhwvHOZWdnh7+/v+bzW7duERERQeXKlTE2No7TVqVSUbNmTW7duvXFGs+dO0dMTAwRERFMmjQp3v47d+4AcPPmTVq2bPnF8wkhdIOEIiGETol9y6xnz55xtjds2JD8+fOza9cu3r59S65cuTT7cuTIkeC5DAwMUKvVms+Dg4OBT3dzEmJjY5OkGt++fQvAqVOnOHXqVKLtQkNDk3Q+IYRukMdnQgid8fjxY83AaCcnJ1QqleZDX1+fp0+fEhERwbp161J0fgsLCwBevnyZ4P7AwMBknWfEiBEoipLox8SJE1NUpxBCO+ROkRBCZ3h7e6NWq6ldu3aC43uio6NZs2YNK1euxN3dPdnnL1myJMbGxly4cIGIiIg4j9AURYnzqO1zqlSpgkqlSnJ7IUTGIKFICKETFEVh9erVqFQq1qxZQ5EiRRJsd/v2bfz9/Tl//jyVK1dO1tcwNjamQ4cOrF+/nrlz5/Ljjz9q9v3+++/cvHkzSefJmzcvnTp1YtOmTcycOZORI0eiUqnitAkICKBcuXKYmZklq0YhhPZIKBJC6ISjR49y//59nJycEg1E8OktMX9/f1auXJnsUATg6enJ4cOHGT16NMePH8fR0ZFbt26xZ88emjZtyoEDB9DT+/LIgsWLF3Pr1i1GjRrF2rVrqVGjBjlz5uTx48ecP3+eO3fu8Pz5cwlFQmQgMqZICKETYgdYf2k1+s6dO2Nqasoff/xBWFhYsr9OgQIF8Pf3p2PHjpw+fZq5c+fy8uVLDh06RLFixYD/jRn6nFy5cnH69GlmzJiBkZER69evZ8GCBZw5c4YyZcrw+++/Y21tnez6hBDao1IURdF2EUIIoQtq166Nv78/QUFBZMuWTdvlCCHSmdwpEkJkOc+fP4+3bd26dZw6dYpGjRpJIBIii5I7RUKILMfKygpHR0dKly6Nvr4+ly9fxtfXl+zZs3Pq1CnKlSun7RKFEFogoUgIkeWMGzeO3bt38+jRI0JDQ8mdOzf169dn/PjxlCpVStvlCSG0REKREEIIIQQypkgIIYQQApBQJIQQQggBSCgSQgghhAAkFAkhhBBCABKKhBBCCCEACUVCCCGEEICEIiGEEEIIQEKREEIIIQQgoUgIIYQQAoD/A0pf/0OupxNPAAAAAElFTkSuQmCC" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 29 + "execution_count": 6 }, { "metadata": {}, @@ -355,8 +355,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:24:14.503662Z", - "start_time": "2024-07-11T10:24:14.495288Z" + "end_time": "2024-07-11T18:37:04.979706Z", + "start_time": "2024-07-11T18:37:04.975364Z" } }, "id": "d06f5b82ed8a562c", @@ -370,12 +370,12 @@ "" ] }, - "execution_count": 30, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 30 + "execution_count": 7 }, { "cell_type": "markdown", @@ -393,8 +393,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:24:18.295414Z", - "start_time": "2024-07-11T10:24:18.287189Z" + "end_time": "2024-07-11T18:37:04.986807Z", + "start_time": "2024-07-11T18:37:04.980309Z" } }, "id": "3828a5802369696e", @@ -572,12 +572,12 @@ "" ] }, - "execution_count": 31, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 31 + "execution_count": 8 }, { "cell_type": "markdown", @@ -595,8 +595,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-07-11T10:24:21.566765Z", - "start_time": "2024-07-11T10:24:21.474766Z" + "end_time": "2024-07-11T18:37:05.101974Z", + "start_time": "2024-07-11T18:37:04.987319Z" } }, "id": "4fca74a7a59559a", @@ -612,7 +612,7 @@ "output_type": "display_data" } ], - "execution_count": 32 + "execution_count": 9 }, { "cell_type": "markdown", @@ -634,11 +634,11 @@ "cell_type": "code", "source": [ "df = circumplex.utils.standardize(\n", - " data=jz2017.data, \n", - " scales=jz2017.scales, \n", - " angles=np.array((90, 135, 180, 225, 270, 315, 360, 45)), \n", - " instrument=circumplex.instrument.load_instrument('IIPSC'), \n", - " sample=1,\n", + " data = jz2017.data,\n", + " scales = jz2017.scales.abbrev,\n", + " angles = angles,\n", + " instrument = circumplex.instrument.load_instrument('IIPSC'),\n", + " sample = 1\n", ")\n", "\n", "jz2017s = jz2017.attach_data(df)\n", @@ -647,13 +647,375 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:10:06.839534Z", - "start_time": "2024-06-08T12:10:06.793322Z" + "end_time": "2024-07-11T18:37:05.122121Z", + "start_time": "2024-07-11T18:37:05.102632Z" } }, "id": "6f8df300b9442ef0", - "execution_count": 39, - "outputs": [] + "outputs": [ + { + "data": { + "text/plain": [ + " Gender PA BC DE FG HI JK LM NO PARPD ... \\\n", + "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 ... \n", + "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 ... \n", + "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 ... \n", + "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 ... \n", + "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 ... \n", + "... ... ... ... ... ... ... ... ... ... ... ... \n", + "1161 Male 0.00 1.00 1.00 2.50 2.50 2.50 1.75 1.00 3 ... \n", + "1162 Female 0.00 0.00 0.00 0.00 0.00 0.00 2.25 0.00 1 ... \n", + "1163 Male 0.00 0.50 0.25 0.25 0.00 0.25 0.75 0.50 2 ... \n", + "1164 Female 0.50 0.25 0.00 0.25 0.25 0.25 0.25 0.50 3 ... \n", + "1165 Female 1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.75 4 ... \n", + "\n", + " DPNPD OCPD PA_z BC_z DE_z FG_z HI_z JK_z \\\n", + "0 4 6 1.121212 1.025362 0.409357 -0.050132 0.633880 1.307918 \n", + "1 1 0 -1.151515 -0.786232 -1.052632 -0.841689 -0.185792 0.428152 \n", + "2 0 1 -1.151515 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", + "3 0 0 1.878788 1.387681 0.994152 1.532982 0.633880 0.428152 \n", + "4 0 0 -0.772727 -0.423913 -0.760234 -1.105541 -1.551913 -1.624633 \n", + "... ... ... ... ... ... ... ... ... \n", + "1161 3 4 -1.151515 0.300725 0.116959 1.532982 1.180328 1.307918 \n", + "1162 0 0 -1.151515 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", + "1163 0 1 -1.151515 -0.423913 -0.760234 -0.841689 -1.551913 -1.331378 \n", + "1164 0 2 -0.393939 -0.786232 -1.052632 -0.841689 -1.278689 -1.331378 \n", + "1165 1 5 0.363636 -1.148551 -1.052632 -1.105541 -1.551913 -1.624633 \n", + "\n", + " LM_z NO_z \n", + "0 0.951515 1.84375 \n", + "1 0.951515 1.53125 \n", + "2 -1.775758 -1.28125 \n", + "3 0.648485 1.84375 \n", + "4 -1.775758 -1.28125 \n", + "... ... ... \n", + "1161 0.345455 -0.03125 \n", + "1162 0.951515 -1.28125 \n", + "1163 -0.866667 -0.65625 \n", + "1164 -1.472727 -0.65625 \n", + "1165 -0.563636 -0.34375 \n", + "\n", + "[1166 rows x 27 columns]" + ], + "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", + " \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", + " \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", + "
GenderPABCDEFGHIJKLMNOPARPD...DPNPDOCPDPA_zBC_zDE_zFG_zHI_zJK_zLM_zNO_z
0Female1.501.501.251.002.002.502.252.504...461.1212121.0253620.409357-0.0501320.6338801.3079180.9515151.84375
1Female0.000.250.000.251.251.752.252.251...10-1.151515-0.786232-1.052632-0.841689-0.1857920.4281520.9515151.53125
2Female0.000.000.000.000.000.000.000.000...01-1.151515-1.148551-1.052632-1.105541-1.551913-1.624633-1.775758-1.28125
3Male2.001.751.752.502.001.752.002.501...001.8787881.3876810.9941521.5329820.6338800.4281520.6484851.84375
4Female0.250.500.250.000.000.000.000.000...00-0.772727-0.423913-0.760234-1.105541-1.551913-1.624633-1.775758-1.28125
..................................................................
1161Male0.001.001.002.502.502.501.751.003...34-1.1515150.3007250.1169591.5329821.1803281.3079180.345455-0.03125
1162Female0.000.000.000.000.000.002.250.001...00-1.151515-1.148551-1.052632-1.105541-1.551913-1.6246330.951515-1.28125
1163Male0.000.500.250.250.000.250.750.502...01-1.151515-0.423913-0.760234-0.841689-1.551913-1.331378-0.866667-0.65625
1164Female0.500.250.000.250.250.250.250.503...02-0.393939-0.786232-1.052632-0.841689-1.278689-1.331378-1.472727-0.65625
1165Female1.000.000.000.000.000.001.000.754...150.363636-1.148551-1.052632-1.105541-1.551913-1.624633-0.563636-0.34375
\n", + "

1166 rows × 27 columns

\n", + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 }, { "metadata": {}, @@ -664,21 +1026,22 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:10:07.655949Z", - "start_time": "2024-06-08T12:10:07.639165Z" + "end_time": "2024-07-11T18:37:08.478026Z", + "start_time": "2024-07-11T18:37:05.122651Z" } }, "cell_type": "code", "source": [ - "results = circumplex.ssm_analyse(\n", + "results = circumplex.ssm_analyze(\n", " data = jz2017s.data,\n", " scales=['PA_z', 'BC_z', 'DE_z', 'FG_z', 'HI_z', 'JK_z', 'LM_z', 'NO_z'],\n", - " angles=(90, 135, 180, 225, 270, 315, 360, 45),\n", + " angles=(90, 135, 180, 225, 270, 315, 0, 45),\n", + " boots=2000\n", ")" ], "id": "876dadadc07e23a9", - "execution_count": 40, - "outputs": [] + "outputs": [], + "execution_count": 11 }, { "metadata": {}, @@ -689,15 +1052,34 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:10:08.456914Z", - "start_time": "2024-06-08T12:10:08.442393Z" + "end_time": "2024-07-11T18:37:08.480559Z", + "start_time": "2024-07-11T18:37:08.478703Z" } }, "cell_type": "code", - "source": "results.table", + "source": "print(results)", "id": "7c587d1d7f7c35fd", - "execution_count": 41, - "outputs": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Call:\n", + "ssm_analyze(data, scales=['PA_z', 'BC_z', 'DE_z', 'FG_z', 'HI_z', 'JK_z', 'LM_z', 'NO_z'], angles=(90, 135, 180, 225, 270, 315, 0, 45), measures=None, grouping=None, contrast=none, boots=2000, interval=0.95, listwise=True, measures_labels=None)\n", + "\n", + "\n", + "Profile [All]:\n", + "Parameter Estimate [LCI, UCI]\n", + "Elevation -0.225 [ -0.260, -0.191]\n", + "X-Value 0.131 [ 0.097, 0.162]\n", + "Y-Value -0.015 [ -0.049, 0.018]\n", + "Amplitude 0.131 [ 0.098, 0.166]\n", + "Displacement 353.525 [ -20.381, 8.445]\n", + "Model Fit 0.710 [ 0.570, 0.803]\n" + ] + } + ], + "execution_count": 12 }, { "metadata": {}, @@ -706,68 +1088,144 @@ "id": "e2934188eaee0af" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-08T12:10:09.704555Z", - "start_time": "2024-06-08T12:10:09.414973Z" - } - }, - "cell_type": "code", - "source": "results.plot()", - "id": "17120bfc93c74a9d", - "execution_count": 42, - "outputs": [] + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Visualizing the results with a table and figure\n", + "\n", + "Next, we can produce a table to display our results. With only a single set of parameters, this table is probably overkill, but in future analyses we will see how this function saves a lot of time and effort. To create the table, simply pass the " + ], + "id": "dd96575f63243c4" }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:10:10.138441Z", - "start_time": "2024-06-08T12:10:09.946040Z" + "end_time": "2024-07-11T18:37:08.484858Z", + "start_time": "2024-07-11T18:37:08.481101Z" } }, "cell_type": "code", - "source": "results.results[0].profile_plot()", - "id": "c5ae6bacbc5bb83d", - "execution_count": 43, - "outputs": [] + "source": "results.table()", + "id": "d131c20346a3427f", + "outputs": [ + { + "data": { + "text/plain": [ + " Profile Elevation X-Value Y-Value Amplitude Displacement Fit\n", + "0 All -0.225058 0.130532 -0.014815 0.13137 353.524846 0.709645" + ], + "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", + "
ProfileElevationX-ValueY-ValueAmplitudeDisplacementFit
0All-0.2250580.130532-0.0148150.13137353.5248460.709645
\n", + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 13 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Next, let's leverage the fact that we are working within a circumplex space by creating a nice-looking circular plot by mapping the amplitude parameter to the points' distance from the center of the circle and the displacement parameter to the points' rotation from due-east (as is conventional). This, again, is as simple as passing the results object to the `ssm_plot()` function.", + "id": "1ca7363331b47a53" }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:10:10.859562Z", - "start_time": "2024-06-08T12:10:10.815447Z" + "end_time": "2024-07-11T18:37:08.488424Z", + "start_time": "2024-07-11T18:37:08.486840Z" } }, "cell_type": "code", - "source": [ - "from circumplex import OCTANTS\n", - "cor_res = circumplex.ssm_analyse(jz2017s.data, jz2017s.scales.abbrev, measures=['NARPD'])\n", - "cor_res.table" + "source": "print(results)", + "id": "70f4997f4f1d875b", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Call:\n", + "ssm_analyze(data, scales=['PA_z', 'BC_z', 'DE_z', 'FG_z', 'HI_z', 'JK_z', 'LM_z', 'NO_z'], angles=(90, 135, 180, 225, 270, 315, 0, 45), measures=None, grouping=None, contrast=none, boots=2000, interval=0.95, listwise=True, measures_labels=None)\n", + "\n", + "\n", + "Profile [All]:\n", + "Parameter Estimate [LCI, UCI]\n", + "Elevation -0.225 [ -0.260, -0.191]\n", + "X-Value 0.131 [ 0.097, 0.162]\n", + "Y-Value -0.015 [ -0.049, 0.018]\n", + "Amplitude 0.131 [ 0.098, 0.166]\n", + "Displacement 353.525 [ -20.381, 8.445]\n", + "Model Fit 0.710 [ 0.570, 0.803]\n" + ] + } ], - "id": "fb8c38caf15ab6fa", - "execution_count": 44, - "outputs": [] + "execution_count": 14 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:10:11.999274Z", - "start_time": "2024-06-08T12:10:11.817975Z" + "end_time": "2024-07-11T18:37:08.601881Z", + "start_time": "2024-07-11T18:37:08.489077Z" } }, "cell_type": "code", - "source": "cor_res.results[0].profile_plot()", - "id": "11edf672affbfd8e", - "execution_count": 45, - "outputs": [] - }, - { - "metadata": {}, - "cell_type": "code", - "execution_count": null, - "source": "\n", - "id": "efcee9158a27aa8d", - "outputs": [] + "source": "fig = circumplex.ssm_plot(results)", + "id": "17120bfc93c74a9d", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 15 } ], "metadata": { diff --git a/docs/tutorials/using-instruments.ipynb b/docs/tutorials/using-instruments.ipynb index 4083590..abe57c4 100644 --- a/docs/tutorials/using-instruments.ipynb +++ b/docs/tutorials/using-instruments.ipynb @@ -18,8 +18,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-06-22T14:13:32.855401Z", - "start_time": "2024-06-22T14:13:32.839738Z" + "end_time": "2024-07-11T14:46:02.630893Z", + "start_time": "2024-07-11T14:46:02.614580Z" } }, "source": [ @@ -29,8 +29,17 @@ "%load_ext autoreload\n", "%autoreload 2" ], - "outputs": [], - "execution_count": 3 + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "execution_count": 11 }, { "cell_type": "markdown", @@ -70,8 +79,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T11:58:38.323890Z", - "start_time": "2024-06-08T11:58:38.304523Z" + "end_time": "2024-07-11T14:46:04.574244Z", + "start_time": "2024-07-11T14:46:04.554387Z" } }, "id": "afc9791b88c08ae9", @@ -88,7 +97,7 @@ ] } ], - "execution_count": 7 + "execution_count": 12 }, { "cell_type": "markdown", @@ -111,8 +120,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-06-08T12:02:08.358157Z", - "start_time": "2024-06-08T12:02:07.769628Z" + "end_time": "2024-07-11T14:46:06.307446Z", + "start_time": "2024-07-11T14:46:06.291792Z" } }, "id": "8ff381ed31a876fa", @@ -128,7 +137,7 @@ ] } ], - "execution_count": 18 + "execution_count": 13 }, { "cell_type": "markdown", @@ -145,8 +154,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:02:09.294138Z", - "start_time": "2024-06-08T12:02:09.274364Z" + "end_time": "2024-07-11T14:46:07.525697Z", + "start_time": "2024-07-11T14:46:07.512705Z" } }, "cell_type": "code", @@ -248,7 +257,7 @@ ] } ], - "execution_count": 19 + "execution_count": 14 }, { "metadata": {}, @@ -259,8 +268,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:02:56.736978Z", - "start_time": "2024-06-08T12:02:56.714448Z" + "end_time": "2024-07-11T14:46:08.592671Z", + "start_time": "2024-07-11T14:46:08.582386Z" } }, "cell_type": "code", @@ -278,7 +287,7 @@ ] } ], - "execution_count": 23 + "execution_count": 15 }, { "metadata": {}, @@ -289,8 +298,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:04:34.780774Z", - "start_time": "2024-06-08T12:04:34.760906Z" + "end_time": "2024-07-11T14:46:10.278642Z", + "start_time": "2024-07-11T14:46:10.258908Z" } }, "cell_type": "code", @@ -311,13 +320,13 @@ ] } ], - "execution_count": 27 + "execution_count": 16 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-08T12:03:00.996825Z", - "start_time": "2024-06-08T12:03:00.976837Z" + "end_time": "2024-07-11T14:46:11.978006Z", + "start_time": "2024-07-11T14:46:11.962478Z" } }, "cell_type": "code", @@ -403,7 +412,7 @@ ] } ], - "execution_count": 25 + "execution_count": 17 }, { "metadata": {}, @@ -422,8 +431,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-06-22T14:13:36.636970Z", - "start_time": "2024-06-22T14:13:36.617817Z" + "end_time": "2024-07-11T14:46:14.198824Z", + "start_time": "2024-07-11T14:46:14.177613Z" } }, "cell_type": "code", @@ -456,13 +465,13 @@ ] } ], - "execution_count": 4 + "execution_count": 18 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-22T14:14:22.299841Z", - "start_time": "2024-06-22T14:14:22.285164Z" + "end_time": "2024-07-11T14:46:15.069758Z", + "start_time": "2024-07-11T14:46:15.053171Z" } }, "cell_type": "code", @@ -536,13 +545,13 @@ ] } ], - "execution_count": 5 + "execution_count": 19 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-06-22T14:36:34.235809Z", - "start_time": "2024-06-22T14:36:34.221077Z" + "end_time": "2024-07-11T13:55:47.032197Z", + "start_time": "2024-07-11T13:55:47.016643Z" } }, "cell_type": "code", @@ -576,7 +585,7 @@ ], "id": "5926c67e18f9c763", "outputs": [], - "execution_count": 12 + "execution_count": 10 }, { "metadata": { diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index ffd27dd..460b954 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -10,7 +10,7 @@ import circumplex.ssm_results as ssm_results import circumplex.utils as utils -BOUNDS = ([0, 0, -np.inf], [np.inf, 2 * np.pi, np.inf]) +BOUNDS = ([0, -2 * np.pi, -np.inf], [np.inf, 2 * np.pi, np.inf]) OCTANTS = utils.OCTANTS @@ -397,6 +397,7 @@ def ssm_bootstrap( # Combine results and convert radians to degrees for displacement results = pd.concat([bs_est, bs_lci, bs_uci], axis=1) + results["d_est"] = results["d_est"] % 360 # normalize to 0-360 return results diff --git a/src/circumplex/ssm_results.py b/src/circumplex/ssm_results.py index 4690835..932e748 100644 --- a/src/circumplex/ssm_results.py +++ b/src/circumplex/ssm_results.py @@ -59,13 +59,38 @@ def summary(self): f"Bootstrap Resamples: {self.details['boots']}", f"Confidence Level: {self.details['interval']}", f"Listwise Deletion: {self.details['listwise']}", - f"Scale Displacements: {self.details['angles'].tolist()}\n", + f"Scale Displacements: {self.details['angles']}\n", ] ) output.extend(str(self).split("\n")[2:]) # Add the formatted results return "\n".join(output) + def table(self): + table = pd.DataFrame( + columns=[ + "Profile", + "Elevation", + "X-Value", + "Y-Value", + "Amplitude", + "Displacement", + "Fit", + ], + index=self.results.index, + ) + for i, (_, row) in enumerate(self.results.iterrows()): + table.loc[i] = [ + row["label"], + row["e_est"], + row["x_est"], + row["y_est"], + row["a_est"], + row["d_est"], + row["fit_est"], + ] + return table + def profile_plot(self, **kwargs): results = self.results scores = self.scores diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 5c137fe..7435cd3 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -1,6 +1,9 @@ -from typing import Tuple +from typing import List, Tuple, Union import numpy as np +import pandas as pd + +from circumplex.instrument import Instrument OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) @@ -36,3 +39,49 @@ def sort_angles( """Sort angles and corresponding scores in ascending order.""" sorted_indices = np.argsort(angles) return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] + + +def standardize( + data: pd.DataFrame, + scales: Union[List[str], pd.Index], + angles: List[float], + instrument: Instrument, + sample: int = 1, + prefix: str = "", + suffix: str = "_z", + ) -> pd.DataFrame: + """ + Standardize circumplex scales using normative data. + + Args: + data (pd.DataFrame): A DataFrame containing at least circumplex scales. + scales (Union[List[str], pd.Index]): The column names for the variables in data that contain circumplex scales to be standardized. + angles (List[float]): A numeric list containing the angular displacement of each circumplex scale (in degrees). + instrument (Dict[str, Any]): An instrument object containing normative data. + sample (int): An integer corresponding to the normative sample to use in standardizing the scale scores (default = 1). + prefix (str): A string to include at the beginning of the newly calculated scale variables' names (default = ""). + suffix (str): A string to include at the end of the newly calculated scale variables' names (default = "_z"). + + Returns: + pd.DataFrame: A DataFrame that matches data except that new variables are appended that contain standardized versions of scales. + """ + assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" + assert all( + scale in data.columns for scale in scales + ), "All scales must be present in data" + assert len(scales) == len(angles), "scales and angles must have the same length" + assert isinstance(sample, int), "sample must be an integer" + assert isinstance(prefix, str), "prefix must be a string" + assert isinstance(suffix, str), "suffix must be a string" + + norms = instrument.norms + key = norms.table.query("sample == @sample") + assert len(key) == len(scales) + + for scale, angle in zip(scales, angles): + new_var = f"{prefix}{scale}{suffix}" + m = key.query("scale == @scale")["m"].values[0] + sd = key.query("scale == @scale")["sd"].values[0] + data[new_var] = (data[scale] - m) / sd + + return data diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index f0f7870..1dbcb69 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -69,7 +69,7 @@ def ssm_plot_circle( angles = np.round(ssm_object.details["angles"]).astype(int) if amax is None: - amax = np.ceil(df["a_uci"].max() * 10) / 10 + amax = df["a_uci"].abs().max() * 1.5 # Convert results to numbers usable by seaborn df_plot = df.copy() @@ -96,16 +96,17 @@ def ssm_plot_circle( colors = sns.color_palette(palette, n_colors=len(df_plot)) # Plot confidence regions - for i, (_, row) in enumerate(df_plot.iterrows()): + for i, row in df_plot.iterrows(): wedge = patches.Wedge( (0, 0), row["a_uci"], row["d_lci"], row["d_uci"], width=row["a_uci"] - row["a_lci"], - fc=colors[i], - alpha=0.3, + fc=list(colors[i]) + [0.5], # face opacity at 0.5 linestyle=row["linestyle"], + edgecolor=list(colors[i]) + [1], # edge opacity at 1 + linewidth=2, ) ax.add_patch(wedge) diff --git a/tests/test_ssm_analysis.py b/tests/test_ssm_analysis.py index fc43b93..9eff411 100644 --- a/tests/test_ssm_analysis.py +++ b/tests/test_ssm_analysis.py @@ -182,6 +182,8 @@ def test_ssm_parameters_correctness(amplitude, displacement, elevation): result_r2, ) = params + result_displacement = result_displacement % 360 # Normalize to 0-360 degrees + # Assert correctness with some tolerance for floating-point precision np.testing.assert_allclose(result_elevation, elevation, atol=1e-7) np.testing.assert_allclose(result_x, expected_x, atol=1e-7) diff --git a/tests/test_visualisation.py b/tests/test_visualisation.py index a180097..839bf99 100644 --- a/tests/test_visualisation.py +++ b/tests/test_visualisation.py @@ -48,10 +48,10 @@ def mock_ssm_results(): } ) details = { - "angles" : (0, 45, 90, 135, 180, 225, 270, 315), - "score_type" : "Mean", + "angles" : (0, 45, 90, 135, 180, 225, 270, 315), + "score_type": "Mean", "results_type": "Profile", - "contrast" : "none", + "contrast" : "none", } return SSMResults( results=results, scores=scores, details=details, call="mock_call", scales=SCALES From 2697e7485202efdc133ea63f128708585af1a827 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:13:45 +0000 Subject: [PATCH 15/97] Refactor API for better consistency and documentation - Standardize naming with ssm_analyze instead of ssm_analyse - Add comprehensive docstrings using NumPy style - Add examples to key functions - Fix circular imports between modules - Add centralized parameter validation - Improve typing with more specific return annotations - Add consistent plot methods to SSMResults --- src/circumplex/instrument.py | 17 +- src/circumplex/ssm_analysis.py | 343 ++++++++++++++++++++++++-------- src/circumplex/ssm_results.py | 39 +++- src/circumplex/utils.py | 52 ++++- src/circumplex/visualization.py | 159 ++++++++++----- 5 files changed, 477 insertions(+), 133 deletions(-) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index 20e1b26..be85acf 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -317,9 +317,24 @@ def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrum self._data = data return self - def ssm_analyse( + def ssm_analyze( self, measures: list[str] = None, grouping: list[str] = None ) -> ssm_results.SSMResults: + """ + Perform Structural Summary Method analysis on the instrument's data. + + Parameters + ---------- + measures : list of str, optional + Variables to be correlated with the circumplex scales. + grouping : list of str, optional + Variable name that indicates group membership of each observation. + + Returns + ------- + SSMResults + An object containing the results and description of the analysis. + """ return ssm.ssm_analyze( self.data, self.scales.abbrev, diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index 460b954..87dbb7f 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -1,7 +1,7 @@ from __future__ import annotations import warnings -from typing import Callable, List, Optional, Tuple, Union +from typing import Callable, List, Optional, Tuple, Union, Dict, Any import numpy as np import pandas as pd @@ -14,18 +14,117 @@ OCTANTS = utils.OCTANTS +def validate_ssm_input( + data: pd.DataFrame, + scales: List[str], + angles: Tuple[float], + measures: Optional[List[str]] = None, + grouping: Optional[str] = None, + contrast: str = "none", + boots: int = 500, + interval: float = 0.95, + listwise: bool = True, + measures_labels: Optional[List[str]] = None, +) -> None: + """ + Validate input parameters for SSM analysis functions. + + Raises ValueError with helpful messages if validation fails. + + Parameters + ---------- + data : pd.DataFrame + A DataFrame containing at least circumplex scales. + scales : List[str] + The variable names for the circumplex scales to be analyzed. + angles : Tuple[float] + Angular displacement of each circumplex scale (in degrees). + measures : Optional[List[str]] + Variables to be correlated with the circumplex scales. + grouping : Optional[str] + Variable name that indicates group membership of each observation. + contrast : str + Type of contrast to run ("none", "model", or "test"). + boots : int + Number of bootstrap resamples for estimating confidence intervals. + interval : float + Confidence level for estimating the confidence intervals. + listwise : bool + Whether to use listwise deletion for missing values. + measures_labels : Optional[List[str]] + Labels for each measure provided in measures. + + Returns + ------- + None + """ + # Data validation + if not isinstance(data, pd.DataFrame): + raise ValueError("data must be a pandas DataFrame") + + # Scales validation + if not all(scale in data.columns for scale in scales): + missing = set(scales) - set(data.columns) + raise ValueError(f"Scales missing from data: {missing}") + + # Angles validation + if not (isinstance(angles, tuple) and all(isinstance(a, (int, float)) for a in angles)): + raise ValueError("angles must be a tuple of numbers") + if len(angles) != len(scales): + raise ValueError(f"angles and scales must have the same length (angles: {len(angles)}, scales: {len(scales)})") + + # Bootstrap validation + if not (isinstance(boots, int) and boots > 0): + raise ValueError("boots must be a positive integer") + + # Interval validation + if not (0 < interval < 1): + raise ValueError("interval must be between 0 and 1") + + # Listwise validation + if not isinstance(listwise, bool): + raise ValueError("listwise must be a boolean") + + # Contrast validation + if contrast not in ["none", "model", "test"]: + raise ValueError("contrast must be 'none', 'model', or 'test'") + + # Measures validation + if measures is not None and not all(measure in data.columns for measure in measures): + missing = set(measures) - set(data.columns) + raise ValueError(f"Measures missing from data: {missing}") + + # Grouping validation + if grouping is not None and grouping not in data.columns: + raise ValueError(f"grouping variable '{grouping}' not found in data") + + # Measures labels validation + if measures_labels is not None: + if measures is None: + raise ValueError("measures must be provided when measures_labels is provided") + if len(measures_labels) != len(measures): + raise ValueError("measures_labels must have the same length as measures") + + # Contrast possibility validation + if contrast != "none" and measures is None and grouping is None: + raise ValueError( + "Without specifying measures or grouping, no contrasts are possible. " + "Set contrast = 'none' or add the measures or grouping arguments." + ) + + def ssm_analyze( data: pd.DataFrame, scales: List[str], - angles: Optional[Tuple[float]] = OCTANTS, + angles: Tuple[float] = OCTANTS, measures: Optional[List[str]] = None, grouping: Optional[str] = None, - contrast: Optional[str] = "none", - boots: int = 500, + contrast: str = "none", + boots: int = 500, interval: float = 0.95, listwise: bool = True, measures_labels: Optional[List[str]] = None, - ) -> ssm_results.SSMResults: +) -> ssm_results.SSMResults: """ Perform analyses using the Structural Summary Method. @@ -34,50 +133,73 @@ def ssm_analyze( correlation-based analyses, uses one or more groups to stratify the data, and calculates contrasts between groups or measures. - Args: - data (pd.DataFrame): A DataFrame containing at least circumplex scales. - scales (List[str]): The variable names for the circumplex scales to be analyzed. - angles (Optional[List[float]]): Angular displacement of each circumplex scale (in degrees). - measures (Optional[List[str]]): Variables to be correlated with the circumplex scales. - grouping (Optional[str]): Variable name that indicates group membership of each observation. - contrast (str): Type of contrast to run ("none", "model", or "test"). - boots (int): Number of bootstrap resamples for estimating confidence intervals. - interval (float): Confidence level for estimating the confidence intervals. - listwise (bool): Whether to use listwise deletion for missing values. - measures_labels (Optional[List[str]]): Labels for each measure provided in measures. - - Returns: - SSMResults: An object containing the results and description of the analysis. + Parameters + ---------- + data : pd.DataFrame + A DataFrame containing at least circumplex scales. + scales : List[str] + The variable names for the circumplex scales to be analyzed. + angles : Tuple[float], optional + Angular displacement of each circumplex scale (in degrees). + Default is (0, 45, 90, 135, 180, 225, 270, 315). + measures : Optional[List[str]], optional + Variables to be correlated with the circumplex scales. + grouping : Optional[str], optional + Variable name that indicates group membership of each observation. + contrast : str, optional + Type of contrast to run ("none", "model", or "test"). + Default is "none". + boots : int, optional + Number of bootstrap resamples for estimating confidence intervals. + Default is 500. + interval : float, optional + Confidence level for estimating the confidence intervals. + Default is 0.95. + listwise : bool, optional + Whether to use listwise deletion for missing values. + Default is True. + measures_labels : Optional[List[str]], optional + Labels for each measure provided in measures. + + Returns + ------- + SSMResults + An object containing the results and description of the analysis. + + Examples + -------- + >>> import pandas as pd + >>> from circumplex import ssm_analyze + >>> + >>> # Simple analysis of means + >>> results = ssm_analyze( + ... data, + ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + ... angles=(0, 45, 90, 135, 180, 225, 270, 315) + ... ) + >>> + >>> # Analysis with correlations and groups + >>> results = ssm_analyze( + ... data, + ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + ... angles=(0, 45, 90, 135, 180, 225, 270, 315), + ... measures=["Extraversion", "Neuroticism"], + ... grouping="Gender" + ... ) """ - - assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" - assert all( - scale in data.columns for scale in scales - ), "All scales must be present in data" - assert isinstance(angles, tuple) and all( - isinstance(a, (int, float)) for a in angles - ), "angles must be a tuple of numbers" - assert isinstance(boots, int) and boots > 0, "boots must be a positive integer" - assert 0 < interval < 1, "interval must be between 0 and 1" - assert isinstance(listwise, bool), "listwise must be a boolean" - assert contrast in [ - "none", - "model", - "test", - ], "contrast must be 'none', 'model', or 'test'" - - if measures is not None: - assert all( - measure in data.columns for measure in measures - ), "All measures must be present in data" - - if grouping is not None: - assert grouping in data.columns, "grouping must be a column in data" - - if measures_labels is not None: - assert len(measures_labels) == len( - measures - ), "measures_labels must have the same length as measures" + # Validate all input parameters + validate_ssm_input( + data=data, + scales=scales, + angles=angles, + measures=measures, + grouping=grouping, + contrast=contrast, + boots=boots, + interval=interval, + listwise=listwise, + measures_labels=measures_labels + ) # Determine analysis type and forward to appropriate subfunction if measures is not None: @@ -146,28 +268,59 @@ def ssm_analyze( def ssm_analyze_means( data: pd.DataFrame, scales: List[str], - angles: Tuple[float], + angles: Tuple[float], grouping: Optional[str] = None, contrast: str = "none", boots: int = 2000, interval: float = 0.95, listwise: bool = True, -) -> dict: +) -> Dict[str, Any]: """ Perform analyses using the mean-based Structural Summary Method. - Args: - data (pd.DataFrame): A DataFrame containing at least circumplex scales. - scales (List[str]): The variable names for the circumplex scales to be analyzed. - angles (List[float]): Angular displacement of each circumplex scale (in radians). - grouping (Optional[str]): Variable name that indicates group membership of each observation. - contrast (str): Type of contrast to run ("none", "model", or "test"). - boots (int): Number of bootstrap resamples for estimating confidence intervals. - interval (float): Confidence level for estimating the confidence intervals. - listwise (bool): Whether to use listwise deletion for missing values. - - Returns: - dict: A dictionary containing the results and description of the analysis. + This function calculates SSM parameters based on the mean scores of + circumplex scales, optionally grouped by a categorical variable. + + Parameters + ---------- + data : pd.DataFrame + A DataFrame containing at least circumplex scales. + scales : List[str] + The variable names for the circumplex scales to be analyzed. + angles : Tuple[float] + Angular displacement of each circumplex scale (in degrees). + grouping : Optional[str], optional + Variable name that indicates group membership of each observation. + contrast : str, optional + Type of contrast to run ("none", "model", or "test"). + Default is "none". + boots : int, optional + Number of bootstrap resamples for estimating confidence intervals. + Default is 2000. + interval : float, optional + Confidence level for estimating the confidence intervals. + Default is 0.95. + listwise : bool, optional + Whether to use listwise deletion for missing values. + Default is True. + + Returns + ------- + Dict[str, Any] + A dictionary containing the results and description of the analysis: + - results: DataFrame with SSM parameters for each group + - details: Dictionary with analysis details + - call: String representation of the function call + - scores: DataFrame with mean scores for each scale and group + + Examples + -------- + >>> results_dict = ssm_analyze_means( + ... data, + ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + ... angles=(0, 45, 90, 135, 180, 225, 270, 315), + ... grouping="Gender" + ... ) """ # Select circumplex scales and grouping variable (if applicable) if grouping is not None: @@ -405,7 +558,7 @@ def ssm_bootstrap( def ssm_analyze_corrs( data: pd.DataFrame, scales: List[str], - angles: Tuple[float], + angles: Tuple[float], measures: List[str], grouping: Optional[str] = None, contrast: str = "none", @@ -413,24 +566,58 @@ def ssm_analyze_corrs( interval: float = 0.95, listwise: bool = True, measures_labels: Optional[List[str]] = None, -) -> dict: +) -> Dict[str, Any]: """ Perform analyses using the correlation-based Structural Summary Method. - Args: - data (pd.DataFrame): A DataFrame containing at least circumplex scales and measures. - scales (List[str]): The variable names for the circumplex scales to be analyzed. - angles (List[float]): Angular displacement of each circumplex scale (in radians). - measures (List[str]): Variables to be correlated with the circumplex scales. - grouping (Optional[str]): Variable name that indicates group membership of each observation. - contrast (str): Type of contrast to run ("none", "model", or "test"). - boots (int): Number of bootstrap resamples for estimating confidence intervals. - interval (float): Confidence level for estimating the confidence intervals. - listwise (bool): Whether to use listwise deletion for missing values. - measures_labels (Optional[List[str]]): Labels for each measure provided in measures. - - Returns: - dict: A dictionary containing the results and description of the analysis. + This function calculates SSM parameters based on the correlations between + circumplex scales and external measures, optionally grouped by a categorical variable. + + Parameters + ---------- + data : pd.DataFrame + A DataFrame containing at least circumplex scales and measures. + scales : List[str] + The variable names for the circumplex scales to be analyzed. + angles : Tuple[float] + Angular displacement of each circumplex scale (in degrees). + measures : List[str] + Variables to be correlated with the circumplex scales. + grouping : Optional[str], optional + Variable name that indicates group membership of each observation. + contrast : str, optional + Type of contrast to run ("none", "model", or "test"). + Default is "none". + boots : int, optional + Number of bootstrap resamples for estimating confidence intervals. + Default is 2000. + interval : float, optional + Confidence level for estimating the confidence intervals. + Default is 0.95. + listwise : bool, optional + Whether to use listwise deletion for missing values. + Default is True. + measures_labels : Optional[List[str]], optional + Labels for each measure provided in measures. + + Returns + ------- + Dict[str, Any] + A dictionary containing the results and description of the analysis: + - results: DataFrame with SSM parameters for each measure-group combination + - details: Dictionary with analysis details + - call: String representation of the function call + - scores: DataFrame with correlation scores between measures and scales + + Examples + -------- + >>> results_dict = ssm_analyze_corrs( + ... data, + ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + ... angles=(0, 45, 90, 135, 180, 225, 270, 315), + ... measures=["Extraversion", "Neuroticism"], + ... measures_labels=["Extraversion Scale", "Neuroticism Scale"] + ... ) """ # Select circumplex scales, measure variables, and grouping variable if grouping is not None: diff --git a/src/circumplex/ssm_results.py b/src/circumplex/ssm_results.py index 932e748..9a2aaa2 100644 --- a/src/circumplex/ssm_results.py +++ b/src/circumplex/ssm_results.py @@ -1,9 +1,11 @@ from __future__ import annotations -from typing import Any, Dict, List +from typing import Any, Dict, List, Tuple, Optional import pandas as pd from matplotlib import pyplot as plt +from matplotlib.figure import Figure +from matplotlib.axes import Axes import circumplex.visualization as vis @@ -91,7 +93,40 @@ def table(self): ] return table - def profile_plot(self, **kwargs): + def plot(self, **kwargs) -> Figure: + """ + Create a figure from SSM results. + + This is a convenience wrapper for ssm_plot(). + + Parameters + ---------- + **kwargs + Additional arguments to pass to ssm_plot(). + + Returns + ------- + matplotlib.figure.Figure + A figure object representing the plot. + """ + return vis.ssm_plot(self, **kwargs) + + def profile_plot(self, **kwargs) -> Tuple[Figure, List[Axes]]: + """ + Create profile plots from SSM results. + + Creates one profile plot for each component in the results. + + Parameters + ---------- + **kwargs + Additional arguments to pass to ssm_profile_plot(). + + Returns + ------- + Tuple[matplotlib.figure.Figure, List[matplotlib.axes.Axes]] + A tuple containing the figure and axes objects. + """ results = self.results scores = self.scores details = self.details diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 7435cd3..655e4a4 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -1,15 +1,39 @@ -from typing import List, Tuple, Union +from typing import List, Tuple, Union, Optional, Any import numpy as np import pandas as pd -from circumplex.instrument import Instrument +# Import Instrument type for type annotation only +from typing import TYPE_CHECKING +if TYPE_CHECKING: + from circumplex.instrument import Instrument +# Common constants OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) -def cosine_form(theta, ampl, disp, elev): - """Cosine function with amplitude, dispersion and elevation parameters.""" +def cosine_form(theta: np.ndarray, ampl: float, disp: float, elev: float) -> np.ndarray: + """ + Cosine function with amplitude, displacement and elevation parameters. + + This is the mathematical model used in the Structural Summary Method. + + Parameters + ---------- + theta : np.ndarray + Angular positions in radians. + ampl : float + Amplitude of the cosine curve. + disp : float + Angular displacement in radians. + elev : float + Elevation (mean level) of the cosine curve. + + Returns + ------- + np.ndarray + Predicted values at each theta position. + """ return elev + ampl * np.cos(theta - disp) @@ -26,8 +50,24 @@ def angle_median(angles: np.ndarray) -> float: return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) -def r2_score(y_true: np.array, y_pred: np.array): - """Calculate the R2 score for a set of predictions.""" +def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: + """ + Calculate the R² coefficient of determination for a set of predictions. + + Measures how well the predictions match the observed data. + + Parameters + ---------- + y_true : np.ndarray + True values. + y_pred : np.ndarray + Predicted values. + + Returns + ------- + float + R² value between 0 and 1, where 1 indicates perfect prediction. + """ ss_res = np.sum(np.square(y_true - y_pred)) ss_tot = np.sum(np.square(y_true - np.mean(y_true))) return 1 - (ss_res / ss_tot) diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index 1dbcb69..be9987e 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -1,33 +1,59 @@ from __future__ import annotations -from typing import List, Optional, Tuple +from typing import List, Optional, Tuple, Union, Any import matplotlib.patches as patches import matplotlib.pyplot as plt import numpy as np import pandas as pd import seaborn as sns +from matplotlib.figure import Figure +from matplotlib.axes import Axes -import circumplex.ssm_results as ssm_results +# Import only the utils module to avoid circular imports import circumplex.utils as utils +# Forward type hint for SSMResults to avoid circular imports +# This is needed because ssm_results imports visualization +from typing import TYPE_CHECKING +if TYPE_CHECKING: + from circumplex.ssm_results import SSMResults -def ssm_plot(ssm_object: ssm_results.SSMResults, fontsize: int = 12, **kwargs): + +def ssm_plot(ssm_object: 'SSMResults', fontsize: int = 12, **kwargs) -> Figure: """ Create a figure from SSM results. - Args: - ssm_object (SSMResults): The results output of ssm_analyze. - fontsize (int): Font size of text in the figure, in points (default = 12). - **kwargs: Additional arguments to pass on to the plotting function. - - Returns: - matplotlib.figure.Figure: A figure object representing the plot. + Creates either a circular plot or a contrast plot depending on the + type of results in ssm_object. + + Parameters + ---------- + ssm_object : SSMResults + The results output of ssm_analyze. + fontsize : int, optional + Font size of text in the figure, in points. + Default is 12. + **kwargs + Additional arguments to pass on to the plotting function. + + Returns + ------- + matplotlib.figure.Figure + A figure object representing the plot. + + Examples + -------- + >>> from circumplex import ssm_analyze, ssm_plot + >>> results = ssm_analyze(data, scales, angles) + >>> fig = ssm_plot(results) + >>> fig.savefig('ssm_plot.png', dpi=300) """ - assert isinstance( - ssm_object, ssm_results.SSMResults - ), "ssm_object must be an SSMResults instance" - assert fontsize > 0, "fontsize must be a positive number" + # Input validation + if not hasattr(ssm_object, 'details') or not hasattr(ssm_object, 'results'): + raise ValueError("ssm_object must be an SSMResults instance") + if not isinstance(fontsize, (int, float)) or fontsize <= 0: + raise ValueError("fontsize must be a positive number") sns.set(style="whitegrid", font_scale=fontsize / 12) @@ -38,7 +64,7 @@ def ssm_plot(ssm_object: ssm_results.SSMResults, fontsize: int = 12, **kwargs): def ssm_plot_circle( - ssm_object: ssm_results.SSMResults, + ssm_object: 'SSMResults', amax: Optional[float] = None, legend_font_size: int = 12, scale_font_size: int = 12, @@ -47,7 +73,7 @@ def ssm_plot_circle( angle_labels: Optional[List[str]] = None, palette: Optional[str] = "husl", **kwargs, -): +) -> Figure: """ Create a Circular Plot of SSM Results using Seaborn. @@ -210,13 +236,13 @@ def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): def ssm_plot_contrast( - ssm_object: ssm_results.SSMResults, + ssm_object: 'SSMResults', axislabel: str = "Difference", xy: bool = True, color: str = "red", linesize: float = 1.25, fontsize: int = 12, -): +) -> Figure: """ Create a Difference Plot of SSM Contrast Results using Seaborn. @@ -319,12 +345,12 @@ def ssm_plot_contrast( def ssm_profile_plot( - scores: np.ndarray, - angles: np.ndarray, + scores: Union[np.ndarray, List[float]], + angles: Union[np.ndarray, List[float], Tuple[float, ...]], amplitude: float, displacement: float, elevation: float, - r2: float = None, + r2: Optional[float] = None, title: str = "SSM Profile", reorder_scales: bool = True, incl_pred: bool = True, @@ -335,32 +361,73 @@ def ssm_profile_plot( c_scores: str = "red", c_fit: str = "black", fontsize: int = 12, - ax: Optional[plt.Axes] = None, -) -> Tuple[plt.Figure, plt.Axes]: + ax: Optional[Axes] = None, +) -> Tuple[Figure, Axes]: """ - Plot the SSM profile. - - Args: - incl_elev: - scores (np.ndarray): Array of scores for each scale. - angles (np.ndarray): Array of angles for each scale. - amplitude (float): Amplitude of the cosine function. - displacement (float): Displacement of the cosine function. - elevation (float): Elevation of the cosine function. - r2 (float): R-squared value for the fit. - title (str): Title of the plot. - reorder_scales (bool): Whether to reorder scales based on angles. - incl_pred (bool): Whether to include the predicted fit line. - incl_fit (bool): Whether to include the R-squared value. - incl_disp (bool): Whether to include the displacement line. - incl_amp (bool): Whether to include the amplitude line. - c_scores (str): Color for the score points. - c_fit (str): Color for the fit line. - fontsize (int): Base font size for the plot. - ax (Optional[plt.Axes]): Existing axes to plot on. If None, creates new figure and axes. - - Returns: - Tuple[plt.Figure, plt.Axes]: A tuple containing the figure and axis objects. + Plot the SSM profile showing scale scores and fitted cosine curve. + + Creates a profile plot with observed scores and the fitted cosine curve, + optionally showing displacement, amplitude, elevation, and fit statistics. + + Parameters + ---------- + scores : array-like + Array of scores for each scale. + angles : array-like + Array of angles for each scale (in degrees). + amplitude : float + Amplitude of the cosine function. + displacement : float + Angular displacement of the cosine function (in degrees). + elevation : float + Elevation (mean level) of the cosine function. + r2 : float, optional + R-squared value for the fit. + title : str, optional + Title of the plot. Default is "SSM Profile". + reorder_scales : bool, optional + Whether to reorder scales based on angles. Default is True. + incl_pred : bool, optional + Whether to include the predicted fit line. Default is True. + incl_fit : bool, optional + Whether to include the R-squared value. Default is True. + incl_disp : bool, optional + Whether to include the displacement line. Default is True. + incl_amp : bool, optional + Whether to include the amplitude line. Default is True. + incl_elev : bool, optional + Whether to include the elevation line. Default is False. + c_scores : str, optional + Color for the score points. Default is "red". + c_fit : str, optional + Color for the fit line. Default is "black". + fontsize : int, optional + Base font size for the plot. Default is 12. + ax : matplotlib.axes.Axes, optional + Existing axes to plot on. If None, creates new figure and axes. + + Returns + ------- + Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes] + A tuple containing the figure and axis objects. + + Examples + -------- + >>> import numpy as np + >>> from circumplex import ssm_profile_plot + >>> + >>> # Create a profile plot + >>> scores = np.array([0.5, 0.7, 0.3, -0.2, -0.5, -0.3, 0.1, 0.4]) + >>> angles = (0, 45, 90, 135, 180, 225, 270, 315) + >>> fig, ax = ssm_profile_plot( + ... scores=scores, + ... angles=angles, + ... amplitude=0.6, + ... displacement=30, + ... elevation=0.1, + ... r2=0.85, + ... title="Example Profile" + ... ) """ if ax is None: fig, ax = plt.subplots(figsize=(10, 5)) From 04e05bb00a54b311b35b0486af6c2e7e27fba90f Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:25:30 +0000 Subject: [PATCH 16/97] Update Python version, project dependencies and add uv.lock --- .python-version | 2 +- pyproject.toml | 7 +- uv.lock | 3592 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 3597 insertions(+), 4 deletions(-) create mode 100644 uv.lock diff --git a/.python-version b/.python-version index 2419ad5..bd28b9c 100644 --- a/.python-version +++ b/.python-version @@ -1 +1 @@ -3.11.9 +3.9 diff --git a/pyproject.toml b/pyproject.toml index d0cbc5d..aac03a8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,12 +7,13 @@ authors = [ ] dependencies = [ "numpy>=1.25.2", - "matplotlib>=3.8.1", "scipy>=1.9.3", "pandas[excel,performance]>=2.2.2", + "matplotlib>=3.9.4", + "seaborn>=0.13.2", ] readme = "README.md" -requires-python = ">= 3.8" +requires-python = ">= 3.9" [project.urls] repository = "https://github.com/MitchellAcoustics/circumplex" @@ -22,7 +23,7 @@ documentation = "https://circumplex.readthedocs.io/en/latest/" requires = ["hatchling"] build-backend = "hatchling.build" -[tool.rye] +[tool.uv] managed = true dev-dependencies = [ "pytest>=8.2.2", diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..ee777f1 --- /dev/null +++ b/uv.lock @@ -0,0 +1,3592 @@ +version = 1 +revision = 1 +requires-python = ">=3.9" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version < '3.10'", +] + +[[package]] +name = "anyio" +version = "4.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/73/199a98fc2dae33535d6b8e8e6ec01f8c1d76c9adb096c6b7d64823038cde/anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a", size = 181126 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/fa/57ec2c6d16ecd2ba0cf15f3c7d1c3c2e7b5fcb83555ff56d7ab10888ec8f/argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08", size = 42798 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/6a/e8a041599e78b6b3752da48000b14c8d1e8a04ded09c88c714ba047f34f5/argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea", size = 15124 }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/e9/184b8ccce6683b0aa2fbb7ba5683ea4b9c5763f1356347f1312c32e3c66e/argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3", size = 1779911 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/13/838ce2620025e9666aa8f686431f67a29052241692a3dd1ae9d3692a89d3/argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367", size = 29658 }, + { url = "https://files.pythonhosted.org/packages/b3/02/f7f7bb6b6af6031edb11037639c697b912e1dea2db94d436e681aea2f495/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d", size = 80583 }, + { url = "https://files.pythonhosted.org/packages/ec/f7/378254e6dd7ae6f31fe40c8649eea7d4832a42243acaf0f1fff9083b2bed/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae", size = 86168 }, + { url = "https://files.pythonhosted.org/packages/74/f6/4a34a37a98311ed73bb80efe422fed95f2ac25a4cacc5ae1d7ae6a144505/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c", size = 82709 }, + { url = "https://files.pythonhosted.org/packages/74/2b/73d767bfdaab25484f7e7901379d5f8793cccbb86c6e0cbc4c1b96f63896/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86", size = 83613 }, + { url = "https://files.pythonhosted.org/packages/4f/fd/37f86deef67ff57c76f137a67181949c2d408077e2e3dd70c6c42912c9bf/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f", size = 84583 }, + { url = "https://files.pythonhosted.org/packages/6f/52/5a60085a3dae8fded8327a4f564223029f5f54b0cb0455a31131b5363a01/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e", size = 88475 }, + { url = "https://files.pythonhosted.org/packages/8b/95/143cd64feb24a15fa4b189a3e1e7efbaeeb00f39a51e99b26fc62fbacabd/argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082", size = 27698 }, + { url = "https://files.pythonhosted.org/packages/37/2c/e34e47c7dee97ba6f01a6203e0383e15b60fb85d78ac9a15cd066f6fe28b/argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f", size = 30817 }, + { url = "https://files.pythonhosted.org/packages/5a/e4/bf8034d25edaa495da3c8a3405627d2e35758e44ff6eaa7948092646fdcc/argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93", size = 53104 }, +] + +[[package]] +name = "arrow" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/e2/2b4651eff771f6fd900d233e175ddc5e2be502c7eb62c0c42f975c6d36cd/async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627", size = 10019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/9f/3c3503693386c4b0f245eaf5ca6198e3b28879ca0a40bde6b0e319793453/async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224", size = 6111 }, +] + +[[package]] +name = "attrs" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/7c/fdf464bcc51d23881d110abd74b512a42b3d5d376a55a831b44c603ae17f/attrs-25.1.0.tar.gz", hash = "sha256:1c97078a80c814273a76b2a298a932eb681c87415c11dee0a6921de7f1b02c3e", size = 810562 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/30/d4986a882011f9df997a55e6becd864812ccfcd821d64aac8570ee39f719/attrs-25.1.0-py3-none-any.whl", hash = "sha256:c75a69e28a550a7e93789579c22aa26b0f5b83b75dc4e08fe092980051e1090a", size = 63152 }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/3c/adaf39ce1fb4afdd21b611e3d530b183bb7759c9b673d60db0e347fd4439/beautifulsoup4-4.13.3.tar.gz", hash = "sha256:1bd32405dacc920b42b83ba01644747ed77456a65760e285fbc47633ceddaf8b", size = 619516 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/49/6abb616eb3cbab6a7cca303dc02fdf3836de2e0b834bf966a7f5271a34d8/beautifulsoup4-4.13.3-py3-none-any.whl", hash = "sha256:99045d7d3f08f91f0d656bc9b7efbae189426cd913d830294a15eefa0ea4df16", size = 186015 }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "bottleneck" +version = "1.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/61/9fb34409d58f04e1929da41666a055c36f9495903ff669b80c893bdee65f/bottleneck-1.4.2.tar.gz", hash = "sha256:fa8e8e1799dea5483ce6669462660f9d9a95649f6f98a80d315b84ec89f449f4", size = 103563 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/f3/7e76090a8ab7f2d5f123ba6cad556c7c324bcef2320b1aa3e6a8f87c0f1d/Bottleneck-1.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:125436df93751a226eab1732783aa8f6125e88e779587aa61be071fb66e41f9d", size = 98563 }, + { url = "https://files.pythonhosted.org/packages/b7/db/5a600f6c071e93284e8480684b971a7cce334d9e6b6d57386cc391537d14/Bottleneck-1.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c6df9a60ec6ab88fec934ca864266ba95edd89c490af71dc9cd8afb2a54ebd9", size = 360776 }, + { url = "https://files.pythonhosted.org/packages/e3/8f/8d0322287dd208bd35b2814152726d6f7ec9346c9ad2abae18e23e9ef15e/Bottleneck-1.4.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e2fe327dc2d0564e295a5857a252755103f8c6e05b07d3ff80a69afaa9f5065", size = 356085 }, + { url = "https://files.pythonhosted.org/packages/20/1b/05dd0433052f62b416d3af4d58556f377518b1d35f76872c53e79bd7818f/Bottleneck-1.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6b7790ca8658cd69e3cc0d0e4ff0e9829d60849bf7945fbd7344fbce05b2bbb8", size = 365247 }, + { url = "https://files.pythonhosted.org/packages/b6/6b/eb7a04afa8d4641a498b62a24db5a491ab3d6945890e9f5d5f852ba0aa8c/Bottleneck-1.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6282fa925ac3768f66e3547f89a512376d3f9de7ef53bdd37aa29232fd864054", size = 356080 }, + { url = "https://files.pythonhosted.org/packages/4e/91/53353689ed860403f421900ec0ce67dfa763bd39d07d9da5b69c48b3941a/Bottleneck-1.4.2-cp310-cp310-win32.whl", hash = "sha256:e56a206fbf48e3b8054a964398bf1ed843e9625d3c6bdbeb7898cb48bf97441b", size = 106941 }, + { url = "https://files.pythonhosted.org/packages/d7/25/32643c8e8646f30121e5c67a0c0579dbc910f3bf9e121683f28165c6d374/Bottleneck-1.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:eb0c611d15b0fd8f511d288e8964e4725b4b3b0d9d310880cf0ff6b8dd03c859", size = 111622 }, + { url = "https://files.pythonhosted.org/packages/88/b8/31a1cc8279bf11a60c04b844a42666927307a47bb48964cbd92ec9f40e3e/Bottleneck-1.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b6902ebf3e85315b481bc084f10c5770f8240275ad1e039ac69c7c8d2013b040", size = 98565 }, + { url = "https://files.pythonhosted.org/packages/16/64/09d72babae7cc29341c52f2e9381066672743d4f797c86b1e735205d5fc8/Bottleneck-1.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2fd34b9b490204f95288f0dd35d37042486a95029617246c88c0f94a0ab49fe", size = 364986 }, + { url = "https://files.pythonhosted.org/packages/7e/d6/39e957e9df9ab16df9c531e8ddf71594877063d27aa036dd105b66d3b3b3/Bottleneck-1.4.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:122845e3106c85465551d4a9a3777841347cfedfbebb3aa985cca110e07030b1", size = 360256 }, + { url = "https://files.pythonhosted.org/packages/ff/cb/d287febe0e6504194ba94cf4a6d80df66a0031ca33a32b30f00c030238cc/Bottleneck-1.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1f61658ebdf5a178298544336b65020730bf86cc092dab5f6579a99a86bd888b", size = 369507 }, + { url = "https://files.pythonhosted.org/packages/dc/1e/9310f058ddee71798a76ab15c5c1ad71f0a5c3c6348f7faab9b6da038484/Bottleneck-1.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7c7d29c044a3511b36fd744503c3e697e279c273a8477a6d91a2831d04fd19e0", size = 360282 }, + { url = "https://files.pythonhosted.org/packages/96/cb/c1f2a37e86e9fa47845259f0a8f32d550f7f27b908432369de055be9f7c4/Bottleneck-1.4.2-cp311-cp311-win32.whl", hash = "sha256:c663cbba8f52011fd82ee08c6a85c93b34b19e0e7ebba322d2d67809f34e0597", size = 106936 }, + { url = "https://files.pythonhosted.org/packages/d3/eb/3fd23404bbc612cf9e4883c3c2b359bd14528e234d5c40bb29bcfd591ef8/Bottleneck-1.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:89651ef18c06616850203bf8875c958c5d316ea48d8ba60d9b450199d39ae391", size = 111617 }, + { url = "https://files.pythonhosted.org/packages/d2/26/6f5124e31a67f75e2a3b9239cc382145326e91fc45e7d7bc9ebffa05fdfa/Bottleneck-1.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a74ddd0417f42eeaba37375f0fc065b28451e0fba45cb2f99e88880b10b3fa43", size = 98681 }, + { url = "https://files.pythonhosted.org/packages/c4/93/e100b6eda77f2aecf5f16157b8c04dd3463913ba188b582650cd77ccf42b/Bottleneck-1.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:070d22f2f62ab81297380a89492cca931e4d9443fa4b84c2baeb52db09c3b1b4", size = 365422 }, + { url = "https://files.pythonhosted.org/packages/82/2b/c6fea2bb048d04c13b8564052818a198d50ce58d5f439ec69c2b0c458703/Bottleneck-1.4.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fc4e7645bd425c05e05acd5541e9e09cb4179e71164e862f082561bf4509eac", size = 361844 }, + { url = "https://files.pythonhosted.org/packages/8f/4c/811475885bd60cf0cb28822568d0c0c3c7d7de4fbccd2ebb66863e7dc726/Bottleneck-1.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:037315c56605128a39f77d19af6a6019dc8c21a63694a4bfef3c026ed963be2e", size = 370369 }, + { url = "https://files.pythonhosted.org/packages/fd/ee/0a8157e6bbd2168bf6171811534a5a73a35f54c453dd7d86a323773b5bd7/Bottleneck-1.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99778329331d5fae8df19772a019e8b73ba4d9d1650f110cd995ab7657114db0", size = 361786 }, + { url = "https://files.pythonhosted.org/packages/fa/6b/e8fda0510b8fa0f3f9a3586efc941abe9d546198e95ae5690c3c83370b36/Bottleneck-1.4.2-cp312-cp312-win32.whl", hash = "sha256:7363b3c8ce6ca433779cd7e96bcb94c0e516dcacadff0011adcbf0b3ac86bc9d", size = 107149 }, + { url = "https://files.pythonhosted.org/packages/22/25/908b75a329a05b82d717661aa95a1968d9dae0e68c654d5e16bfe0d6fbb6/Bottleneck-1.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:48c6b9d9287c4102b803fcb01ae66ae7ef6b310b711b4b7b7e23bf952894dc05", size = 111766 }, + { url = "https://files.pythonhosted.org/packages/2e/65/148e146ca8c16af9881a0db1d8d1849d49a5186fc9f065c79a8d25d6fc0c/Bottleneck-1.4.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c1c885ad02a6a8fa1f7ee9099f29b9d4c03eb1da2c7ab25839482d5cce739021", size = 98701 }, + { url = "https://files.pythonhosted.org/packages/80/96/6540ac9a9943b0d6f0199eddbde55e878f970d2bdda31207dc3e7a195c2b/Bottleneck-1.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7a1b023de1de3d84b18826462718fba548fed41870df44354f9ab6a414ea82f", size = 365443 }, + { url = "https://files.pythonhosted.org/packages/d0/aa/ccae264aac3b2621fa8a98c7afe033f22a352467cbf85fa2799d176ec31b/Bottleneck-1.4.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c9dbaf737b605b30c81611f2c1d197c2fd2e46c33f605876c1d332d3360c4fc", size = 361849 }, + { url = "https://files.pythonhosted.org/packages/f3/b3/5f96d7bb23a291b835bf0a34eec359c55613f6c4262ad1bb161d897499c0/Bottleneck-1.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7ebbcbe5d4062e37507b9a81e2aacdb1fcccc6193f7feff124ef2b5a6a5eb740", size = 370654 }, + { url = "https://files.pythonhosted.org/packages/51/05/9d1ababa3fd34014b708351270307320c0bc595d2d66c2ba2b9b92f0d618/Bottleneck-1.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:964f6ac4118ddab3bbbac79d4f726b093459be751baba73ee0aa364666e8068e", size = 362054 }, + { url = "https://files.pythonhosted.org/packages/92/e3/123488804830604432f84a2c43e611b8e1971e230b9466a7315850d22a58/Bottleneck-1.4.2-cp313-cp313-win32.whl", hash = "sha256:2db287f6ecdbb1c998085eca9b717fec2bfc48a4ab6ae070a9820ba8ab59c90b", size = 107160 }, + { url = "https://files.pythonhosted.org/packages/54/f0/e1640ccd8468c61693092f38f835ef35a68a1ea72c3388683148b3800aa6/Bottleneck-1.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:26b5f0531f7044befaad95c20365dd666372e66bdacbfaf009ff65d60285534d", size = 111774 }, + { url = "https://files.pythonhosted.org/packages/ed/98/8827f1248dbbd23730a1894be6c5a70bebf57f6d20def7fc6e685f10a869/Bottleneck-1.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:72d6aa95cdd782833d2589f81434fd865ba004b8938e07920b6ef02796ce8918", size = 98543 }, + { url = "https://files.pythonhosted.org/packages/52/0a/18fb215a850ad413dd8f6602ba4d26dfddfbcae09b0af7b38e3803406b24/Bottleneck-1.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b33e83665e7daf7f513fe1f7b04b13944d44b6635c45d5a9c89c9e5ed11811b6", size = 359784 }, + { url = "https://files.pythonhosted.org/packages/cd/29/d0c02454677690a05a894b58904e9f2c07febc4f07d3a21b0779bfdfcfcc/Bottleneck-1.4.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52248f3e0fead78c17912fb086a585c86f567019247d21c69e87645241b97b02", size = 354977 }, + { url = "https://files.pythonhosted.org/packages/85/3b/6aa6476f93696ac8dc8eaad2a18a41c56d6afaa829abe3486dce4a135c56/Bottleneck-1.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:dce1a3c5ff89a56fb2678c9bda17b89f60f710d6002ab7cd72b7661bc3fae64d", size = 364430 }, + { url = "https://files.pythonhosted.org/packages/5a/8a/987aecb4cedd2f2c9a768579065bfd576ff2019afc945e1a63f7ebd86ecc/Bottleneck-1.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:48d2e101d99a9d72aa86da1a048d2094f4e1db0cf77519d1c33239f9d62da162", size = 355345 }, + { url = "https://files.pythonhosted.org/packages/0e/ea/681c32f0b3bc08262dd4b3ec96baa7cb87448110949af87390e2452953d6/Bottleneck-1.4.2-cp39-cp39-win32.whl", hash = "sha256:9d7b12936516f944e3d981a64038f99acb21f0e99f92fad16d9a468248c2b231", size = 106964 }, + { url = "https://files.pythonhosted.org/packages/af/ae/bfeebdef6dcb775d44a2325b933a3f4ad2d37aff31ae9d94facd0eb42c1b/Bottleneck-1.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:7b459d08f1f3e2da85db0a9e2d3e6e3541105f5866e9026dbca32dafc5106f2b", size = 111637 }, +] + +[[package]] +name = "certifi" +version = "2025.1.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 }, + { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220 }, + { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605 }, + { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910 }, + { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200 }, + { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565 }, + { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635 }, + { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218 }, + { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486 }, + { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911 }, + { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632 }, + { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820 }, + { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, + { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, + { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, + { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, + { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, + { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, + { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, + { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, + { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, + { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, + { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, + { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, + { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, + { url = "https://files.pythonhosted.org/packages/7f/c0/b913f8f02836ed9ab32ea643c6fe4d3325c3d8627cf6e78098671cafff86/charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41", size = 197867 }, + { url = "https://files.pythonhosted.org/packages/0f/6c/2bee440303d705b6fb1e2ec789543edec83d32d258299b16eed28aad48e0/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f", size = 141385 }, + { url = "https://files.pythonhosted.org/packages/3d/04/cb42585f07f6f9fd3219ffb6f37d5a39b4fd2db2355b23683060029c35f7/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2", size = 151367 }, + { url = "https://files.pythonhosted.org/packages/54/54/2412a5b093acb17f0222de007cc129ec0e0df198b5ad2ce5699355269dfe/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770", size = 143928 }, + { url = "https://files.pythonhosted.org/packages/5a/6d/e2773862b043dcf8a221342954f375392bb2ce6487bcd9f2c1b34e1d6781/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4", size = 146203 }, + { url = "https://files.pythonhosted.org/packages/b9/f8/ca440ef60d8f8916022859885f231abb07ada3c347c03d63f283bec32ef5/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537", size = 148082 }, + { url = "https://files.pythonhosted.org/packages/04/d2/42fd330901aaa4b805a1097856c2edf5095e260a597f65def493f4b8c833/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496", size = 142053 }, + { url = "https://files.pythonhosted.org/packages/9e/af/3a97a4fa3c53586f1910dadfc916e9c4f35eeada36de4108f5096cb7215f/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78", size = 150625 }, + { url = "https://files.pythonhosted.org/packages/26/ae/23d6041322a3556e4da139663d02fb1b3c59a23ab2e2b56432bd2ad63ded/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7", size = 153549 }, + { url = "https://files.pythonhosted.org/packages/94/22/b8f2081c6a77cb20d97e57e0b385b481887aa08019d2459dc2858ed64871/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6", size = 150945 }, + { url = "https://files.pythonhosted.org/packages/c7/0b/c5ec5092747f801b8b093cdf5610e732b809d6cb11f4c51e35fc28d1d389/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294", size = 146595 }, + { url = "https://files.pythonhosted.org/packages/0c/5a/0b59704c38470df6768aa154cc87b1ac7c9bb687990a1559dc8765e8627e/charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5", size = 95453 }, + { url = "https://files.pythonhosted.org/packages/85/2d/a9790237cb4d01a6d57afadc8573c8b73c609ade20b80f4cda30802009ee/charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765", size = 102811 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + +[[package]] +name = "circumplex" +version = "0.1.4" +source = { editable = "." } +dependencies = [ + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "matplotlib", version = "3.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pandas", extra = ["excel", "performance"] }, + { name = "scipy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "scipy", version = "1.15.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "seaborn" }, +] + +[package.dev-dependencies] +dev = [ + { name = "jupyter" }, + { name = "markdown" }, + { name = "mkdocs" }, + { name = "mkdocs-jupyter" }, + { name = "mkdocs-material" }, + { name = "mkdocstrings", extra = ["python"] }, + { name = "pymdown-extensions" }, + { name = "pytest" }, +] + +[package.metadata] +requires-dist = [ + { name = "matplotlib", specifier = ">=3.9.4" }, + { name = "numpy", specifier = ">=1.25.2" }, + { name = "pandas", extras = ["excel", "performance"], specifier = ">=2.2.2" }, + { name = "scipy", specifier = ">=1.9.3" }, + { name = "seaborn", specifier = ">=0.13.2" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "jupyter", specifier = ">=1.0.0" }, + { name = "markdown", specifier = ">=3.6" }, + { name = "mkdocs", specifier = ">=1.6.0" }, + { name = "mkdocs-jupyter", specifier = ">=0.24.7" }, + { name = "mkdocs-material", specifier = ">=9.5.26" }, + { name = "mkdocstrings", extras = ["python"], specifier = ">=0.25.1" }, + { name = "pymdown-extensions", specifier = ">=10.8.1" }, + { name = "pytest", specifier = ">=8.2.2" }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180 }, +] + +[[package]] +name = "contourpy" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/f6/31a8f28b4a2a4fa0e01085e542f3081ab0588eff8e589d39d775172c9792/contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4", size = 13464370 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/e0/be8dcc796cfdd96708933e0e2da99ba4bb8f9b2caa9d560a50f3f09a65f3/contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7", size = 265366 }, + { url = "https://files.pythonhosted.org/packages/50/d6/c953b400219443535d412fcbbc42e7a5e823291236bc0bb88936e3cc9317/contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42", size = 249226 }, + { url = "https://files.pythonhosted.org/packages/6f/b4/6fffdf213ffccc28483c524b9dad46bb78332851133b36ad354b856ddc7c/contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7", size = 308460 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/118fc917b4050f0afe07179a6dcbe4f3f4ec69b94f36c9e128c4af480fb8/contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab", size = 347623 }, + { url = "https://files.pythonhosted.org/packages/f9/a4/30ff110a81bfe3abf7b9673284d21ddce8cc1278f6f77393c91199da4c90/contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589", size = 317761 }, + { url = "https://files.pythonhosted.org/packages/99/e6/d11966962b1aa515f5586d3907ad019f4b812c04e4546cc19ebf62b5178e/contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41", size = 322015 }, + { url = "https://files.pythonhosted.org/packages/4d/e3/182383743751d22b7b59c3c753277b6aee3637049197624f333dac5b4c80/contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d", size = 1262672 }, + { url = "https://files.pythonhosted.org/packages/78/53/974400c815b2e605f252c8fb9297e2204347d1755a5374354ee77b1ea259/contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223", size = 1321688 }, + { url = "https://files.pythonhosted.org/packages/52/29/99f849faed5593b2926a68a31882af98afbeac39c7fdf7de491d9c85ec6a/contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f", size = 171145 }, + { url = "https://files.pythonhosted.org/packages/a9/97/3f89bba79ff6ff2b07a3cbc40aa693c360d5efa90d66e914f0ff03b95ec7/contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b", size = 216019 }, + { url = "https://files.pythonhosted.org/packages/b3/1f/9375917786cb39270b0ee6634536c0e22abf225825602688990d8f5c6c19/contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad", size = 266356 }, + { url = "https://files.pythonhosted.org/packages/05/46/9256dd162ea52790c127cb58cfc3b9e3413a6e3478917d1f811d420772ec/contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49", size = 250915 }, + { url = "https://files.pythonhosted.org/packages/e1/5d/3056c167fa4486900dfbd7e26a2fdc2338dc58eee36d490a0ed3ddda5ded/contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66", size = 310443 }, + { url = "https://files.pythonhosted.org/packages/ca/c2/1a612e475492e07f11c8e267ea5ec1ce0d89971be496c195e27afa97e14a/contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081", size = 348548 }, + { url = "https://files.pythonhosted.org/packages/45/cf/2c2fc6bb5874158277b4faf136847f0689e1b1a1f640a36d76d52e78907c/contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1", size = 319118 }, + { url = "https://files.pythonhosted.org/packages/03/33/003065374f38894cdf1040cef474ad0546368eea7e3a51d48b8a423961f8/contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d", size = 323162 }, + { url = "https://files.pythonhosted.org/packages/42/80/e637326e85e4105a802e42959f56cff2cd39a6b5ef68d5d9aee3ea5f0e4c/contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c", size = 1265396 }, + { url = "https://files.pythonhosted.org/packages/7c/3b/8cbd6416ca1bbc0202b50f9c13b2e0b922b64be888f9d9ee88e6cfabfb51/contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb", size = 1324297 }, + { url = "https://files.pythonhosted.org/packages/4d/2c/021a7afaa52fe891f25535506cc861c30c3c4e5a1c1ce94215e04b293e72/contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c", size = 171808 }, + { url = "https://files.pythonhosted.org/packages/8d/2f/804f02ff30a7fae21f98198828d0857439ec4c91a96e20cf2d6c49372966/contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67", size = 217181 }, + { url = "https://files.pythonhosted.org/packages/c9/92/8e0bbfe6b70c0e2d3d81272b58c98ac69ff1a4329f18c73bd64824d8b12e/contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f", size = 267838 }, + { url = "https://files.pythonhosted.org/packages/e3/04/33351c5d5108460a8ce6d512307690b023f0cfcad5899499f5c83b9d63b1/contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6", size = 251549 }, + { url = "https://files.pythonhosted.org/packages/51/3d/aa0fe6ae67e3ef9f178389e4caaaa68daf2f9024092aa3c6032e3d174670/contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639", size = 303177 }, + { url = "https://files.pythonhosted.org/packages/56/c3/c85a7e3e0cab635575d3b657f9535443a6f5d20fac1a1911eaa4bbe1aceb/contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c", size = 341735 }, + { url = "https://files.pythonhosted.org/packages/dd/8d/20f7a211a7be966a53f474bc90b1a8202e9844b3f1ef85f3ae45a77151ee/contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06", size = 314679 }, + { url = "https://files.pythonhosted.org/packages/6e/be/524e377567defac0e21a46e2a529652d165fed130a0d8a863219303cee18/contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09", size = 320549 }, + { url = "https://files.pythonhosted.org/packages/0f/96/fdb2552a172942d888915f3a6663812e9bc3d359d53dafd4289a0fb462f0/contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd", size = 1263068 }, + { url = "https://files.pythonhosted.org/packages/2a/25/632eab595e3140adfa92f1322bf8915f68c932bac468e89eae9974cf1c00/contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35", size = 1322833 }, + { url = "https://files.pythonhosted.org/packages/73/e3/69738782e315a1d26d29d71a550dbbe3eb6c653b028b150f70c1a5f4f229/contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb", size = 172681 }, + { url = "https://files.pythonhosted.org/packages/0c/89/9830ba00d88e43d15e53d64931e66b8792b46eb25e2050a88fec4a0df3d5/contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b", size = 218283 }, + { url = "https://files.pythonhosted.org/packages/53/a1/d20415febfb2267af2d7f06338e82171824d08614084714fb2c1dac9901f/contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3", size = 267879 }, + { url = "https://files.pythonhosted.org/packages/aa/45/5a28a3570ff6218d8bdfc291a272a20d2648104815f01f0177d103d985e1/contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7", size = 251573 }, + { url = "https://files.pythonhosted.org/packages/39/1c/d3f51540108e3affa84f095c8b04f0aa833bb797bc8baa218a952a98117d/contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84", size = 303184 }, + { url = "https://files.pythonhosted.org/packages/00/56/1348a44fb6c3a558c1a3a0cd23d329d604c99d81bf5a4b58c6b71aab328f/contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0", size = 340262 }, + { url = "https://files.pythonhosted.org/packages/2b/23/00d665ba67e1bb666152131da07e0f24c95c3632d7722caa97fb61470eca/contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b", size = 313806 }, + { url = "https://files.pythonhosted.org/packages/5a/42/3cf40f7040bb8362aea19af9a5fb7b32ce420f645dd1590edcee2c657cd5/contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da", size = 319710 }, + { url = "https://files.pythonhosted.org/packages/05/32/f3bfa3fc083b25e1a7ae09197f897476ee68e7386e10404bdf9aac7391f0/contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14", size = 1264107 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/1019d34473a736664f2439542b890b2dc4c6245f5c0d8cdfc0ccc2cab80c/contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8", size = 1322458 }, + { url = "https://files.pythonhosted.org/packages/22/85/4f8bfd83972cf8909a4d36d16b177f7b8bdd942178ea4bf877d4a380a91c/contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294", size = 172643 }, + { url = "https://files.pythonhosted.org/packages/cc/4a/fb3c83c1baba64ba90443626c228ca14f19a87c51975d3b1de308dd2cf08/contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087", size = 218301 }, + { url = "https://files.pythonhosted.org/packages/76/65/702f4064f397821fea0cb493f7d3bc95a5d703e20954dce7d6d39bacf378/contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8", size = 278972 }, + { url = "https://files.pythonhosted.org/packages/80/85/21f5bba56dba75c10a45ec00ad3b8190dbac7fd9a8a8c46c6116c933e9cf/contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b", size = 263375 }, + { url = "https://files.pythonhosted.org/packages/0a/64/084c86ab71d43149f91ab3a4054ccf18565f0a8af36abfa92b1467813ed6/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973", size = 307188 }, + { url = "https://files.pythonhosted.org/packages/3d/ff/d61a4c288dc42da0084b8d9dc2aa219a850767165d7d9a9c364ff530b509/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18", size = 345644 }, + { url = "https://files.pythonhosted.org/packages/ca/aa/00d2313d35ec03f188e8f0786c2fc61f589306e02fdc158233697546fd58/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8", size = 317141 }, + { url = "https://files.pythonhosted.org/packages/8d/6a/b5242c8cb32d87f6abf4f5e3044ca397cb1a76712e3fa2424772e3ff495f/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6", size = 323469 }, + { url = "https://files.pythonhosted.org/packages/6f/a6/73e929d43028a9079aca4bde107494864d54f0d72d9db508a51ff0878593/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2", size = 1260894 }, + { url = "https://files.pythonhosted.org/packages/2b/1e/1e726ba66eddf21c940821df8cf1a7d15cb165f0682d62161eaa5e93dae1/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927", size = 1314829 }, + { url = "https://files.pythonhosted.org/packages/b3/e3/b9f72758adb6ef7397327ceb8b9c39c75711affb220e4f53c745ea1d5a9a/contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8", size = 265518 }, + { url = "https://files.pythonhosted.org/packages/ec/22/19f5b948367ab5260fb41d842c7a78dae645603881ea6bc39738bcfcabf6/contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c", size = 249350 }, + { url = "https://files.pythonhosted.org/packages/26/76/0c7d43263dd00ae21a91a24381b7e813d286a3294d95d179ef3a7b9fb1d7/contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca", size = 309167 }, + { url = "https://files.pythonhosted.org/packages/96/3b/cadff6773e89f2a5a492c1a8068e21d3fccaf1a1c1df7d65e7c8e3ef60ba/contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f", size = 348279 }, + { url = "https://files.pythonhosted.org/packages/e1/86/158cc43aa549d2081a955ab11c6bdccc7a22caacc2af93186d26f5f48746/contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc", size = 318519 }, + { url = "https://files.pythonhosted.org/packages/05/11/57335544a3027e9b96a05948c32e566328e3a2f84b7b99a325b7a06d2b06/contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2", size = 321922 }, + { url = "https://files.pythonhosted.org/packages/0b/e3/02114f96543f4a1b694333b92a6dcd4f8eebbefcc3a5f3bbb1316634178f/contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e", size = 1258017 }, + { url = "https://files.pythonhosted.org/packages/f3/3b/bfe4c81c6d5881c1c643dde6620be0b42bf8aab155976dd644595cfab95c/contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800", size = 1316773 }, + { url = "https://files.pythonhosted.org/packages/f1/17/c52d2970784383cafb0bd918b6fb036d98d96bbf0bc1befb5d1e31a07a70/contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5", size = 171353 }, + { url = "https://files.pythonhosted.org/packages/53/23/db9f69676308e094d3c45f20cc52e12d10d64f027541c995d89c11ad5c75/contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843", size = 211817 }, + { url = "https://files.pythonhosted.org/packages/d1/09/60e486dc2b64c94ed33e58dcfb6f808192c03dfc5574c016218b9b7680dc/contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c", size = 261886 }, + { url = "https://files.pythonhosted.org/packages/19/20/b57f9f7174fcd439a7789fb47d764974ab646fa34d1790551de386457a8e/contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779", size = 311008 }, + { url = "https://files.pythonhosted.org/packages/74/fc/5040d42623a1845d4f17a418e590fd7a79ae8cb2bad2b2f83de63c3bdca4/contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4", size = 215690 }, + { url = "https://files.pythonhosted.org/packages/2b/24/dc3dcd77ac7460ab7e9d2b01a618cb31406902e50e605a8d6091f0a8f7cc/contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0", size = 261894 }, + { url = "https://files.pythonhosted.org/packages/b1/db/531642a01cfec39d1682e46b5457b07cf805e3c3c584ec27e2a6223f8f6c/contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102", size = 311099 }, + { url = "https://files.pythonhosted.org/packages/38/1e/94bda024d629f254143a134eead69e21c836429a2a6ce82209a00ddcb79a/contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb", size = 215838 }, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/80937fe3efe0edacf67c9a20b955139a1a622730042c1ea991956f2704ad/contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab", size = 268466 }, + { url = "https://files.pythonhosted.org/packages/82/1d/e3eaebb4aa2d7311528c048350ca8e99cdacfafd99da87bc0a5f8d81f2c2/contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124", size = 253314 }, + { url = "https://files.pythonhosted.org/packages/de/f3/d796b22d1a2b587acc8100ba8c07fb7b5e17fde265a7bb05ab967f4c935a/contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1", size = 312003 }, + { url = "https://files.pythonhosted.org/packages/bf/f5/0e67902bc4394daee8daa39c81d4f00b50e063ee1a46cb3938cc65585d36/contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b", size = 351896 }, + { url = "https://files.pythonhosted.org/packages/1f/d6/e766395723f6256d45d6e67c13bb638dd1fa9dc10ef912dc7dd3dcfc19de/contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453", size = 320814 }, + { url = "https://files.pythonhosted.org/packages/a9/57/86c500d63b3e26e5b73a28b8291a67c5608d4aa87ebd17bd15bb33c178bc/contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3", size = 324969 }, + { url = "https://files.pythonhosted.org/packages/b8/62/bb146d1289d6b3450bccc4642e7f4413b92ebffd9bf2e91b0404323704a7/contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277", size = 1265162 }, + { url = "https://files.pythonhosted.org/packages/18/04/9f7d132ce49a212c8e767042cc80ae390f728060d2eea47058f55b9eff1c/contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595", size = 1324328 }, + { url = "https://files.pythonhosted.org/packages/46/23/196813901be3f97c83ababdab1382e13e0edc0bb4e7b49a7bff15fcf754e/contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697", size = 173861 }, + { url = "https://files.pythonhosted.org/packages/e0/82/c372be3fc000a3b2005061ca623a0d1ecd2eaafb10d9e883a2fc8566e951/contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e", size = 218566 }, + { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555 }, + { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549 }, + { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000 }, + { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925 }, + { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693 }, + { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184 }, + { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031 }, + { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995 }, + { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396 }, + { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787 }, + { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 }, + { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 }, + { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 }, + { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 }, + { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 }, + { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 }, + { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 }, + { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 }, + { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 }, + { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 }, + { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 }, + { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 }, + { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 }, + { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 }, + { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 }, + { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 }, + { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 }, + { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 }, + { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 }, + { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 }, + { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 }, + { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 }, + { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 }, + { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 }, + { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 }, + { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 }, + { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 }, + { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 }, + { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 }, + { url = "https://files.pythonhosted.org/packages/3e/4f/e56862e64b52b55b5ddcff4090085521fc228ceb09a88390a2b103dccd1b/contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6", size = 265605 }, + { url = "https://files.pythonhosted.org/packages/b0/2e/52bfeeaa4541889f23d8eadc6386b442ee2470bd3cff9baa67deb2dd5c57/contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750", size = 315040 }, + { url = "https://files.pythonhosted.org/packages/52/94/86bfae441707205634d80392e873295652fc313dfd93c233c52c4dc07874/contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53", size = 218221 }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, +] + +[[package]] +name = "debugpy" +version = "1.8.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/25/c74e337134edf55c4dfc9af579eccb45af2393c40960e2795a94351e8140/debugpy-1.8.12.tar.gz", hash = "sha256:646530b04f45c830ceae8e491ca1c9320a2d2f0efea3141487c82130aba70dce", size = 1641122 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/19/dd58334c0a1ec07babf80bf29fb8daf1a7ca4c1a3bbe61548e40616ac087/debugpy-1.8.12-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:a2ba7ffe58efeae5b8fad1165357edfe01464f9aef25e814e891ec690e7dd82a", size = 2076091 }, + { url = "https://files.pythonhosted.org/packages/4c/37/bde1737da15f9617d11ab7b8d5267165f1b7dae116b2585a6643e89e1fa2/debugpy-1.8.12-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbbd4149c4fc5e7d508ece083e78c17442ee13b0e69bfa6bd63003e486770f45", size = 3560717 }, + { url = "https://files.pythonhosted.org/packages/d9/ca/bc67f5a36a7de072908bc9e1156c0f0b272a9a2224cf21540ab1ffd71a1f/debugpy-1.8.12-cp310-cp310-win32.whl", hash = "sha256:b202f591204023b3ce62ff9a47baa555dc00bb092219abf5caf0e3718ac20e7c", size = 5180672 }, + { url = "https://files.pythonhosted.org/packages/c1/b9/e899c0a80dfa674dbc992f36f2b1453cd1ee879143cdb455bc04fce999da/debugpy-1.8.12-cp310-cp310-win_amd64.whl", hash = "sha256:9649eced17a98ce816756ce50433b2dd85dfa7bc92ceb60579d68c053f98dff9", size = 5212702 }, + { url = "https://files.pythonhosted.org/packages/af/9f/5b8af282253615296264d4ef62d14a8686f0dcdebb31a669374e22fff0a4/debugpy-1.8.12-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:36f4829839ef0afdfdd208bb54f4c3d0eea86106d719811681a8627ae2e53dd5", size = 2174643 }, + { url = "https://files.pythonhosted.org/packages/ef/31/f9274dcd3b0f9f7d1e60373c3fa4696a585c55acb30729d313bb9d3bcbd1/debugpy-1.8.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a28ed481d530e3138553be60991d2d61103ce6da254e51547b79549675f539b7", size = 3133457 }, + { url = "https://files.pythonhosted.org/packages/ab/ca/6ee59e9892e424477e0c76e3798046f1fd1288040b927319c7a7b0baa484/debugpy-1.8.12-cp311-cp311-win32.whl", hash = "sha256:4ad9a94d8f5c9b954e0e3b137cc64ef3f579d0df3c3698fe9c3734ee397e4abb", size = 5106220 }, + { url = "https://files.pythonhosted.org/packages/d5/1a/8ab508ab05ede8a4eae3b139bbc06ea3ca6234f9e8c02713a044f253be5e/debugpy-1.8.12-cp311-cp311-win_amd64.whl", hash = "sha256:4703575b78dd697b294f8c65588dc86874ed787b7348c65da70cfc885efdf1e1", size = 5130481 }, + { url = "https://files.pythonhosted.org/packages/ba/e6/0f876ecfe5831ebe4762b19214364753c8bc2b357d28c5d739a1e88325c7/debugpy-1.8.12-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:7e94b643b19e8feb5215fa508aee531387494bf668b2eca27fa769ea11d9f498", size = 2500846 }, + { url = "https://files.pythonhosted.org/packages/19/64/33f41653a701f3cd2cbff8b41ebaad59885b3428b5afd0d93d16012ecf17/debugpy-1.8.12-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:086b32e233e89a2740c1615c2f775c34ae951508b28b308681dbbb87bba97d06", size = 4222181 }, + { url = "https://files.pythonhosted.org/packages/32/a6/02646cfe50bfacc9b71321c47dc19a46e35f4e0aceea227b6d205e900e34/debugpy-1.8.12-cp312-cp312-win32.whl", hash = "sha256:2ae5df899732a6051b49ea2632a9ea67f929604fd2b036613a9f12bc3163b92d", size = 5227017 }, + { url = "https://files.pythonhosted.org/packages/da/a6/10056431b5c47103474312cf4a2ec1001f73e0b63b1216706d5fef2531eb/debugpy-1.8.12-cp312-cp312-win_amd64.whl", hash = "sha256:39dfbb6fa09f12fae32639e3286112fc35ae976114f1f3d37375f3130a820969", size = 5267555 }, + { url = "https://files.pythonhosted.org/packages/cf/4d/7c3896619a8791effd5d8c31f0834471fc8f8fb3047ec4f5fc69dd1393dd/debugpy-1.8.12-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:696d8ae4dff4cbd06bf6b10d671e088b66669f110c7c4e18a44c43cf75ce966f", size = 2485246 }, + { url = "https://files.pythonhosted.org/packages/99/46/bc6dcfd7eb8cc969a5716d858e32485eb40c72c6a8dc88d1e3a4d5e95813/debugpy-1.8.12-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:898fba72b81a654e74412a67c7e0a81e89723cfe2a3ea6fcd3feaa3395138ca9", size = 4218616 }, + { url = "https://files.pythonhosted.org/packages/03/dd/d7fcdf0381a9b8094da1f6a1c9f19fed493a4f8576a2682349b3a8b20ec7/debugpy-1.8.12-cp313-cp313-win32.whl", hash = "sha256:22a11c493c70413a01ed03f01c3c3a2fc4478fc6ee186e340487b2edcd6f4180", size = 5226540 }, + { url = "https://files.pythonhosted.org/packages/25/bd/ecb98f5b5fc7ea0bfbb3c355bc1dd57c198a28780beadd1e19915bf7b4d9/debugpy-1.8.12-cp313-cp313-win_amd64.whl", hash = "sha256:fdb3c6d342825ea10b90e43d7f20f01535a72b3a1997850c0c3cefa5c27a4a2c", size = 5267134 }, + { url = "https://files.pythonhosted.org/packages/89/37/a3333c5b69c086465ea3c073424ef2775e52a6c17276f642f64209c4a082/debugpy-1.8.12-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:b5c6c967d02fee30e157ab5227706f965d5c37679c687b1e7bbc5d9e7128bd41", size = 2077275 }, + { url = "https://files.pythonhosted.org/packages/50/1d/99f6a0a78b4b513ff2b0d0e44c1e705f7ee34e3aba0e8add617d339d97dc/debugpy-1.8.12-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a77f422f31f170c4b7e9ca58eae2a6c8e04da54121900651dfa8e66c29901a", size = 3555956 }, + { url = "https://files.pythonhosted.org/packages/b8/86/c624665aaa807d065da2016b05e9f2fb4fa56872d67a5fbd7751e77f7f88/debugpy-1.8.12-cp39-cp39-win32.whl", hash = "sha256:a4042edef80364239f5b7b5764e55fd3ffd40c32cf6753da9bda4ff0ac466018", size = 5181535 }, + { url = "https://files.pythonhosted.org/packages/72/c7/d59a0f845ce1677b5c2bb170f08cc1cc3531625a5fdce9c67bd31116540a/debugpy-1.8.12-cp39-cp39-win_amd64.whl", hash = "sha256:f30b03b0f27608a0b26c75f0bb8a880c752c0e0b01090551b9d87c7d783e2069", size = 5213601 }, + { url = "https://files.pythonhosted.org/packages/38/c4/5120ad36405c3008f451f94b8f92ef1805b1e516f6ff870f331ccb3c4cc0/debugpy-1.8.12-py2.py3-none-any.whl", hash = "sha256:274b6a2040349b5c9864e475284bce5bb062e63dce368a394b8cc865ae3b00c6", size = 5229490 }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + +[[package]] +name = "et-xmlfile" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059 }, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +] + +[[package]] +name = "fonttools" +version = "4.56.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/8c/9ffa2a555af0e5e5d0e2ed7fdd8c9bef474ed676995bb4c57c9cd0014248/fonttools-4.56.0.tar.gz", hash = "sha256:a114d1567e1a1586b7e9e7fc2ff686ca542a82769a296cef131e4c4af51e58f4", size = 3462892 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/6ac30c2cc6a29454260f13c9c6422fc509b7982c13cd4597041260d8f482/fonttools-4.56.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:331954d002dbf5e704c7f3756028e21db07097c19722569983ba4d74df014000", size = 2752190 }, + { url = "https://files.pythonhosted.org/packages/92/3a/ac382a8396d1b420ee45eeb0f65b614a9ca7abbb23a1b17524054f0f2200/fonttools-4.56.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8d1613abd5af2f93c05867b3a3759a56e8bf97eb79b1da76b2bc10892f96ff16", size = 2280624 }, + { url = "https://files.pythonhosted.org/packages/8a/ae/00b58bfe20e9ff7fbc3dda38f5d127913942b5e252288ea9583099a31bf5/fonttools-4.56.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:705837eae384fe21cee5e5746fd4f4b2f06f87544fa60f60740007e0aa600311", size = 4562074 }, + { url = "https://files.pythonhosted.org/packages/46/d0/0004ca8f6a200252e5bd6982ed99b5fe58c4c59efaf5f516621c4cd8f703/fonttools-4.56.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc871904a53a9d4d908673c6faa15689874af1c7c5ac403a8e12d967ebd0c0dc", size = 4604747 }, + { url = "https://files.pythonhosted.org/packages/45/ea/c8862bd3e09d143ef8ed8268ec8a7d477828f960954889e65288ac050b08/fonttools-4.56.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:38b947de71748bab150259ee05a775e8a0635891568e9fdb3cdd7d0e0004e62f", size = 4559025 }, + { url = "https://files.pythonhosted.org/packages/8f/75/bb88a9552ec1de31a414066257bfd9f40f4ada00074f7a3799ea39b5741f/fonttools-4.56.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:86b2a1013ef7a64d2e94606632683f07712045ed86d937c11ef4dde97319c086", size = 4728482 }, + { url = "https://files.pythonhosted.org/packages/2a/5f/80a2b640df1e1bb7d459d62c8b3f37fe83fd413897e549106d4ebe6371f5/fonttools-4.56.0-cp310-cp310-win32.whl", hash = "sha256:133bedb9a5c6376ad43e6518b7e2cd2f866a05b1998f14842631d5feb36b5786", size = 2155557 }, + { url = "https://files.pythonhosted.org/packages/8f/85/0904f9dbe51ac70d878d3242a8583b9453a09105c3ed19c6301247fd0d3a/fonttools-4.56.0-cp310-cp310-win_amd64.whl", hash = "sha256:17f39313b649037f6c800209984a11fc256a6137cbe5487091c6c7187cae4685", size = 2200017 }, + { url = "https://files.pythonhosted.org/packages/35/56/a2f3e777d48fcae7ecd29de4d96352d84e5ea9871e5f3fc88241521572cf/fonttools-4.56.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ef04bc7827adb7532be3d14462390dd71287644516af3f1e67f1e6ff9c6d6df", size = 2753325 }, + { url = "https://files.pythonhosted.org/packages/71/85/d483e9c4e5ed586b183bf037a353e8d766366b54fd15519b30e6178a6a6e/fonttools-4.56.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ffda9b8cd9cb8b301cae2602ec62375b59e2e2108a117746f12215145e3f786c", size = 2281554 }, + { url = "https://files.pythonhosted.org/packages/09/67/060473b832b2fade03c127019794df6dc02d9bc66fa4210b8e0d8a99d1e5/fonttools-4.56.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e993e8db36306cc3f1734edc8ea67906c55f98683d6fd34c3fc5593fdbba4c", size = 4869260 }, + { url = "https://files.pythonhosted.org/packages/28/e9/47c02d5a7027e8ed841ab6a10ca00c93dadd5f16742f1af1fa3f9978adf4/fonttools-4.56.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:003548eadd674175510773f73fb2060bb46adb77c94854af3e0cc5bc70260049", size = 4898508 }, + { url = "https://files.pythonhosted.org/packages/bf/8a/221d456d1afb8ca043cfd078f59f187ee5d0a580f4b49351b9ce95121f57/fonttools-4.56.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd9825822e7bb243f285013e653f6741954d8147427aaa0324a862cdbf4cbf62", size = 4877700 }, + { url = "https://files.pythonhosted.org/packages/a4/8c/e503863adf7a6aeff7b960e2f66fa44dd0c29a7a8b79765b2821950d7b05/fonttools-4.56.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b23d30a2c0b992fb1c4f8ac9bfde44b5586d23457759b6cf9a787f1a35179ee0", size = 5045817 }, + { url = "https://files.pythonhosted.org/packages/2b/50/79ba3b7e42f4eaa70b82b9e79155f0f6797858dc8a97862428b6852c6aee/fonttools-4.56.0-cp311-cp311-win32.whl", hash = "sha256:47b5e4680002ae1756d3ae3b6114e20aaee6cc5c69d1e5911f5ffffd3ee46c6b", size = 2154426 }, + { url = "https://files.pythonhosted.org/packages/3b/90/4926e653041c4116ecd43e50e3c79f5daae6dcafc58ceb64bc4f71dd4924/fonttools-4.56.0-cp311-cp311-win_amd64.whl", hash = "sha256:14a3e3e6b211660db54ca1ef7006401e4a694e53ffd4553ab9bc87ead01d0f05", size = 2200937 }, + { url = "https://files.pythonhosted.org/packages/39/32/71cfd6877999576a11824a7fe7bc0bb57c5c72b1f4536fa56a3e39552643/fonttools-4.56.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6f195c14c01bd057bc9b4f70756b510e009c83c5ea67b25ced3e2c38e6ee6e9", size = 2747757 }, + { url = "https://files.pythonhosted.org/packages/15/52/d9f716b072c5061a0b915dd4c387f74bef44c68c069e2195c753905bd9b7/fonttools-4.56.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa760e5fe8b50cbc2d71884a1eff2ed2b95a005f02dda2fa431560db0ddd927f", size = 2279007 }, + { url = "https://files.pythonhosted.org/packages/d1/97/f1b3a8afa9a0d814a092a25cd42f59ccb98a0bb7a295e6e02fc9ba744214/fonttools-4.56.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d54a45d30251f1d729e69e5b675f9a08b7da413391a1227781e2a297fa37f6d2", size = 4783991 }, + { url = "https://files.pythonhosted.org/packages/95/70/2a781bedc1c45a0c61d29c56425609b22ed7f971da5d7e5df2679488741b/fonttools-4.56.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:661a8995d11e6e4914a44ca7d52d1286e2d9b154f685a4d1f69add8418961563", size = 4855109 }, + { url = "https://files.pythonhosted.org/packages/0c/02/a2597858e61a5e3fb6a14d5f6be9e6eb4eaf090da56ad70cedcbdd201685/fonttools-4.56.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d94449ad0a5f2a8bf5d2f8d71d65088aee48adbe45f3c5f8e00e3ad861ed81a", size = 4762496 }, + { url = "https://files.pythonhosted.org/packages/f2/00/aaf00100d6078fdc73f7352b44589804af9dc12b182a2540b16002152ba4/fonttools-4.56.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f59746f7953f69cc3290ce2f971ab01056e55ddd0fb8b792c31a8acd7fee2d28", size = 4990094 }, + { url = "https://files.pythonhosted.org/packages/bf/dc/3ff1db522460db60cf3adaf1b64e0c72b43406717d139786d3fa1eb20709/fonttools-4.56.0-cp312-cp312-win32.whl", hash = "sha256:bce60f9a977c9d3d51de475af3f3581d9b36952e1f8fc19a1f2254f1dda7ce9c", size = 2142888 }, + { url = "https://files.pythonhosted.org/packages/6f/e3/5a181a85777f7809076e51f7422e0dc77eb04676c40ec8bf6a49d390d1ff/fonttools-4.56.0-cp312-cp312-win_amd64.whl", hash = "sha256:300c310bb725b2bdb4f5fc7e148e190bd69f01925c7ab437b9c0ca3e1c7cd9ba", size = 2189734 }, + { url = "https://files.pythonhosted.org/packages/a5/55/f06b48d48e0b4ec3a3489efafe9bd4d81b6e0802ac51026e3ee4634e89ba/fonttools-4.56.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f20e2c0dfab82983a90f3d00703ac0960412036153e5023eed2b4641d7d5e692", size = 2735127 }, + { url = "https://files.pythonhosted.org/packages/59/db/d2c7c9b6dd5cbd46f183e650a47403ffb88fca17484eb7c4b1cd88f9e513/fonttools-4.56.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f36a0868f47b7566237640c026c65a86d09a3d9ca5df1cd039e30a1da73098a0", size = 2272519 }, + { url = "https://files.pythonhosted.org/packages/4d/a2/da62d779c34a0e0c06415f02eab7fa3466de5d46df459c0275a255cefc65/fonttools-4.56.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62b4c6802fa28e14dba010e75190e0e6228513573f1eeae57b11aa1a39b7e5b1", size = 4762423 }, + { url = "https://files.pythonhosted.org/packages/be/6a/fd4018e0448c8a5e12138906411282c5eab51a598493f080a9f0960e658f/fonttools-4.56.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a05d1f07eb0a7d755fbe01fee1fd255c3a4d3730130cf1bfefb682d18fd2fcea", size = 4834442 }, + { url = "https://files.pythonhosted.org/packages/6d/63/fa1dec8efb35bc11ef9c39b2d74754b45d48a3ccb2cf78c0109c0af639e8/fonttools-4.56.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0073b62c3438cf0058488c002ea90489e8801d3a7af5ce5f7c05c105bee815c3", size = 4742800 }, + { url = "https://files.pythonhosted.org/packages/dd/f4/963247ae8c73ccc4cf2929e7162f595c81dbe17997d1d0ea77da24a217c9/fonttools-4.56.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e2cad98c94833465bcf28f51c248aaf07ca022efc6a3eba750ad9c1e0256d278", size = 4963746 }, + { url = "https://files.pythonhosted.org/packages/ea/e0/46f9600c39c644b54e4420f941f75fa200d9288c9ae171e5d80918b8cbb9/fonttools-4.56.0-cp313-cp313-win32.whl", hash = "sha256:d0cb73ccf7f6d7ca8d0bc7ea8ac0a5b84969a41c56ac3ac3422a24df2680546f", size = 2140927 }, + { url = "https://files.pythonhosted.org/packages/27/6d/3edda54f98a550a0473f032d8050315fbc8f1b76a0d9f3879b72ebb2cdd6/fonttools-4.56.0-cp313-cp313-win_amd64.whl", hash = "sha256:62cc1253827d1e500fde9dbe981219fea4eb000fd63402283472d38e7d8aa1c6", size = 2186709 }, + { url = "https://files.pythonhosted.org/packages/c2/a0/c62b7f219f74f0e9c4b7662c269b360f5c380cf7dfabaff06e114acc5576/fonttools-4.56.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ca7962e8e5fc047cc4e59389959843aafbf7445b6c08c20d883e60ced46370a5", size = 2754871 }, + { url = "https://files.pythonhosted.org/packages/22/aa/2ce61705c48c4dc7953bec95f7cfa29e528294a06e7d38f2c674343425ca/fonttools-4.56.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1af375734018951c31c0737d04a9d5fd0a353a0253db5fbed2ccd44eac62d8c", size = 2281885 }, + { url = "https://files.pythonhosted.org/packages/81/68/508c1e84050b950918b1345ee22def98291b2e58890b0f3c2d0cfc4fee6b/fonttools-4.56.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:442ad4122468d0e47d83bc59d0e91b474593a8c813839e1872e47c7a0cb53b10", size = 4567663 }, + { url = "https://files.pythonhosted.org/packages/56/af/78b2c901949ca37c02ba4eec88020479e929b7d1126af30ee9d7e44b4c4c/fonttools-4.56.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cf4f8d2a30b454ac682e12c61831dcb174950c406011418e739de592bbf8f76", size = 4612654 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/156bd9760b6d42be3d821f0ac3edccf8daf97b0e4fe539c569b6593f4b6a/fonttools-4.56.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:96a4271f63a615bcb902b9f56de00ea225d6896052c49f20d0c91e9f43529a29", size = 4561135 }, + { url = "https://files.pythonhosted.org/packages/c4/e9/c6c433b8ea306ba402aa1d53349237d78c1d21ec11bb69cc6d8442533d5b/fonttools-4.56.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6c1d38642ca2dddc7ae992ef5d026e5061a84f10ff2b906be5680ab089f55bb8", size = 4731430 }, + { url = "https://files.pythonhosted.org/packages/00/41/4c199ca2c6d25edced1cdd6a3d32b2471c1e85dc7fbb2145e73805cf2a38/fonttools-4.56.0-cp39-cp39-win32.whl", hash = "sha256:2d351275f73ebdd81dd5b09a8b8dac7a30f29a279d41e1c1192aedf1b6dced40", size = 2156113 }, + { url = "https://files.pythonhosted.org/packages/00/8f/430abf16726cd627e176df92c452f239fcc488fac1e23c9ab57bb7ad6976/fonttools-4.56.0-cp39-cp39-win_amd64.whl", hash = "sha256:d6ca96d1b61a707ba01a43318c9c40aaf11a5a568d1e61146fafa6ab20890793", size = 2200538 }, + { url = "https://files.pythonhosted.org/packages/bf/ff/44934a031ce5a39125415eb405b9efb76fe7f9586b75291d66ae5cbfc4e6/fonttools-4.56.0-py3-none-any.whl", hash = "sha256:1088182f68c303b50ca4dc0c82d42083d176cba37af1937e1a976a31149d4d14", size = 1089800 }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121 }, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034 }, +] + +[[package]] +name = "griffe" +version = "1.5.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/59/80/13b6456bfbf8bc854875e58d3a3bad297ee19ebdd693ce62a10fab007e7a/griffe-1.5.7.tar.gz", hash = "sha256:465238c86deaf1137761f700fb343edd8ffc846d72f6de43c3c345ccdfbebe92", size = 391503 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/67/b43330ed76f96be098c165338d47ccb952964ed77ba1d075247fbdf05c04/griffe-1.5.7-py3-none-any.whl", hash = "sha256:4af8ec834b64de954d447c7b6672426bb145e71605c74a4e22d510cc79fe7d8b", size = 128294 }, +] + +[[package]] +name = "h11" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, +] + +[[package]] +name = "httpcore" +version = "1.0.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "importlib-metadata" +version = "8.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461 }, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "ipython", version = "8.32.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173 }, +] + +[[package]] +name = "ipython" +version = "8.18.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version < '3.10'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.10'" }, + { name = "jedi", marker = "python_full_version < '3.10'" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.10'" }, + { name = "pexpect", marker = "python_full_version < '3.10' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.10'" }, + { name = "pygments", marker = "python_full_version < '3.10'" }, + { name = "stack-data", marker = "python_full_version < '3.10'" }, + { name = "traitlets", marker = "python_full_version < '3.10'" }, + { name = "typing-extensions", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/b9/3ba6c45a6df813c09a48bac313c22ff83efa26cbb55011218d925a46e2ad/ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27", size = 5486330 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/6b/d9fdcdef2eb6a23f391251fde8781c38d42acd82abe84d054cb74f7863b0/ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397", size = 808161 }, +] + +[[package]] +name = "ipython" +version = "8.32.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version >= '3.10'" }, + { name = "exceptiongroup", marker = "python_full_version == '3.10.*'" }, + { name = "jedi", marker = "python_full_version >= '3.10'" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.10'" }, + { name = "pexpect", marker = "python_full_version >= '3.10' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.10'" }, + { name = "pygments", marker = "python_full_version >= '3.10'" }, + { name = "stack-data", marker = "python_full_version >= '3.10'" }, + { name = "traitlets", marker = "python_full_version >= '3.10'" }, + { name = "typing-extensions", marker = "python_full_version >= '3.10' and python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/80/4d2a072e0db7d250f134bc11676517299264ebe16d62a8619d49a78ced73/ipython-8.32.0.tar.gz", hash = "sha256:be2c91895b0b9ea7ba49d33b23e2040c352b33eb6a519cca7ce6e0c743444251", size = 5507441 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e1/f4474a7ecdb7745a820f6f6039dc43c66add40f1bcc66485607d93571af6/ipython-8.32.0-py3-none-any.whl", hash = "sha256:cae85b0c61eff1fc48b0a8002de5958b6528fa9c8defb1894da63f42613708aa", size = 825524 }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "ipython", version = "8.32.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/4c/dab2a281b07596a5fc220d49827fe6c794c66f1493d7a74f1df0640f2cc5/ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17", size = 116723 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/2d/9c0b76f2f9cc0ebede1b9371b6f317243028ed60b90705863d493bae622e/ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245", size = 139767 }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596 }, +] + +[[package]] +name = "json5" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/3d/bbe62f3d0c05a689c711cff57b2e3ac3d3e526380adb7c781989f075115c/json5-0.10.0.tar.gz", hash = "sha256:e66941c8f0a02026943c52c2eb34ebeb2a6f819a0be05920a6f5243cd30fd559", size = 48202 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/42/797895b952b682c3dafe23b1834507ee7f02f4d6299b65aaa61425763278/json5-0.10.0-py3-none-any.whl", hash = "sha256:19b23410220a7271e8377f81ba8aacba2fdd56947fbb137ee5977cbe1f5e8dfa", size = 34049 }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 }, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2024.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657 }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "ipython", version = "8.32.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510 }, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/11/b56381fa6c3f4cc5d2cf54a7dbf98ad9aa0b339ef7a601d6053538b079a7/jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9", size = 87629 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965 }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430 }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/b4/3200b0b09c12bc3b72d943d923323c398eff382d1dcc7c0dbc8b74630e40/jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001", size = 48741 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/e0/7bd7cff65594fd9936e2f9385701e44574fc7d721331ff676ce440b14100/jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da", size = 69146 }, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/8c/df09d4ab646141f130f9977b32b206ba8615d1969b2eba6a2e84b7f89137/jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084", size = 725227 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/a2/89eeaf0bb954a123a909859fa507fa86f96eb61b62dc30667b60dbd5fdaf/jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3", size = 385826 }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656 }, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/17/6f3d73c3e54b71bbaf03edcc4a54b0aa6328e0a134755f297ea87d425711/jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d", size = 21800023 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/6f/94d4c879b3e2b7b9bca1913ea6fbbef180f8b1ed065b46ade40d651ec54d/jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb", size = 11666944 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700 }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/fa26bbb747a9ea4fca6b01453aa22990d52ab62dd61384f1ac0dc9d4e7ba/jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed", size = 203556 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/93/858e87edc634d628e5d752ba944c2833133a28fa87bb093e6832ced36a3e/jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54", size = 214392 }, +] + +[[package]] +name = "jupytext" +version = "1.16.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a0/40/641e0a94d84dee18b7815233a1e0e3c54228169fad529f12c3549a12f9ac/jupytext-1.16.7.tar.gz", hash = "sha256:fc4e97f0890e22062c4ef10313c7ca960b07b3767246a1fef7585888cc2afe5d", size = 3734420 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/4c/3d7cfac5b8351f649ce41a1007a769baacae8d5d29e481a93d799a209c3f/jupytext-1.16.7-py3-none-any.whl", hash = "sha256:912f9d9af7bd3f15470105e5c5dddf1669b2d8c17f0c55772687fc5a4a73fe69", size = 154154 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/14/fc943dd65268a96347472b4fbe5dcc2f6f55034516f80576cd0dd3a8930f/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6", size = 122440 }, + { url = "https://files.pythonhosted.org/packages/1e/46/e68fed66236b69dd02fcdb506218c05ac0e39745d696d22709498896875d/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17", size = 65758 }, + { url = "https://files.pythonhosted.org/packages/ef/fa/65de49c85838681fc9cb05de2a68067a683717321e01ddafb5b8024286f0/kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9", size = 64311 }, + { url = "https://files.pythonhosted.org/packages/42/9c/cc8d90f6ef550f65443bad5872ffa68f3dee36de4974768628bea7c14979/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9", size = 1637109 }, + { url = "https://files.pythonhosted.org/packages/55/91/0a57ce324caf2ff5403edab71c508dd8f648094b18cfbb4c8cc0fde4a6ac/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c", size = 1617814 }, + { url = "https://files.pythonhosted.org/packages/12/5d/c36140313f2510e20207708adf36ae4919416d697ee0236b0ddfb6fd1050/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599", size = 1400881 }, + { url = "https://files.pythonhosted.org/packages/56/d0/786e524f9ed648324a466ca8df86298780ef2b29c25313d9a4f16992d3cf/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05", size = 1512972 }, + { url = "https://files.pythonhosted.org/packages/67/5a/77851f2f201e6141d63c10a0708e996a1363efaf9e1609ad0441b343763b/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407", size = 1444787 }, + { url = "https://files.pythonhosted.org/packages/06/5f/1f5eaab84355885e224a6fc8d73089e8713dc7e91c121f00b9a1c58a2195/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278", size = 2199212 }, + { url = "https://files.pythonhosted.org/packages/b5/28/9152a3bfe976a0ae21d445415defc9d1cd8614b2910b7614b30b27a47270/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5", size = 2346399 }, + { url = "https://files.pythonhosted.org/packages/26/f6/453d1904c52ac3b400f4d5e240ac5fec25263716723e44be65f4d7149d13/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad", size = 2308688 }, + { url = "https://files.pythonhosted.org/packages/5a/9a/d4968499441b9ae187e81745e3277a8b4d7c60840a52dc9d535a7909fac3/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895", size = 2445493 }, + { url = "https://files.pythonhosted.org/packages/07/c9/032267192e7828520dacb64dfdb1d74f292765f179e467c1cba97687f17d/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3", size = 2262191 }, + { url = "https://files.pythonhosted.org/packages/6c/ad/db0aedb638a58b2951da46ddaeecf204be8b4f5454df020d850c7fa8dca8/kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc", size = 46644 }, + { url = "https://files.pythonhosted.org/packages/12/ca/d0f7b7ffbb0be1e7c2258b53554efec1fd652921f10d7d85045aff93ab61/kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c", size = 55877 }, + { url = "https://files.pythonhosted.org/packages/97/6c/cfcc128672f47a3e3c0d918ecb67830600078b025bfc32d858f2e2d5c6a4/kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a", size = 48347 }, + { url = "https://files.pythonhosted.org/packages/e9/44/77429fa0a58f941d6e1c58da9efe08597d2e86bf2b2cce6626834f49d07b/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54", size = 122442 }, + { url = "https://files.pythonhosted.org/packages/e5/20/8c75caed8f2462d63c7fd65e16c832b8f76cda331ac9e615e914ee80bac9/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95", size = 65762 }, + { url = "https://files.pythonhosted.org/packages/f4/98/fe010f15dc7230f45bc4cf367b012d651367fd203caaa992fd1f5963560e/kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935", size = 64319 }, + { url = "https://files.pythonhosted.org/packages/8b/1b/b5d618f4e58c0675654c1e5051bcf42c776703edb21c02b8c74135541f60/kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb", size = 1334260 }, + { url = "https://files.pythonhosted.org/packages/b8/01/946852b13057a162a8c32c4c8d2e9ed79f0bb5d86569a40c0b5fb103e373/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02", size = 1426589 }, + { url = "https://files.pythonhosted.org/packages/70/d1/c9f96df26b459e15cf8a965304e6e6f4eb291e0f7a9460b4ad97b047561e/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51", size = 1541080 }, + { url = "https://files.pythonhosted.org/packages/d3/73/2686990eb8b02d05f3de759d6a23a4ee7d491e659007dd4c075fede4b5d0/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052", size = 1470049 }, + { url = "https://files.pythonhosted.org/packages/a7/4b/2db7af3ed3af7c35f388d5f53c28e155cd402a55432d800c543dc6deb731/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18", size = 1426376 }, + { url = "https://files.pythonhosted.org/packages/05/83/2857317d04ea46dc5d115f0df7e676997bbd968ced8e2bd6f7f19cfc8d7f/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545", size = 2222231 }, + { url = "https://files.pythonhosted.org/packages/0d/b5/866f86f5897cd4ab6d25d22e403404766a123f138bd6a02ecb2cdde52c18/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b", size = 2368634 }, + { url = "https://files.pythonhosted.org/packages/c1/ee/73de8385403faba55f782a41260210528fe3273d0cddcf6d51648202d6d0/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36", size = 2329024 }, + { url = "https://files.pythonhosted.org/packages/a1/e7/cd101d8cd2cdfaa42dc06c433df17c8303d31129c9fdd16c0ea37672af91/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3", size = 2468484 }, + { url = "https://files.pythonhosted.org/packages/e1/72/84f09d45a10bc57a40bb58b81b99d8f22b58b2040c912b7eb97ebf625bf2/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523", size = 2284078 }, + { url = "https://files.pythonhosted.org/packages/d2/d4/71828f32b956612dc36efd7be1788980cb1e66bfb3706e6dec9acad9b4f9/kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d", size = 46645 }, + { url = "https://files.pythonhosted.org/packages/a1/65/d43e9a20aabcf2e798ad1aff6c143ae3a42cf506754bcb6a7ed8259c8425/kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b", size = 56022 }, + { url = "https://files.pythonhosted.org/packages/35/b3/9f75a2e06f1b4ca00b2b192bc2b739334127d27f1d0625627ff8479302ba/kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376", size = 48536 }, + { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808 }, + { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531 }, + { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894 }, + { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296 }, + { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450 }, + { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168 }, + { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308 }, + { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186 }, + { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877 }, + { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204 }, + { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461 }, + { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358 }, + { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119 }, + { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367 }, + { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884 }, + { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528 }, + { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913 }, + { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627 }, + { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888 }, + { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145 }, + { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448 }, + { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750 }, + { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175 }, + { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963 }, + { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220 }, + { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463 }, + { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842 }, + { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635 }, + { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556 }, + { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364 }, + { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887 }, + { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530 }, + { url = "https://files.pythonhosted.org/packages/11/88/37ea0ea64512997b13d69772db8dcdc3bfca5442cda3a5e4bb943652ee3e/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd", size = 122449 }, + { url = "https://files.pythonhosted.org/packages/4e/45/5a5c46078362cb3882dcacad687c503089263c017ca1241e0483857791eb/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583", size = 65757 }, + { url = "https://files.pythonhosted.org/packages/8a/be/a6ae58978772f685d48dd2e84460937761c53c4bbd84e42b0336473d9775/kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417", size = 64312 }, + { url = "https://files.pythonhosted.org/packages/f4/04/18ef6f452d311e1e1eb180c9bf5589187fa1f042db877e6fe443ef10099c/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904", size = 1626966 }, + { url = "https://files.pythonhosted.org/packages/21/b1/40655f6c3fa11ce740e8a964fa8e4c0479c87d6a7944b95af799c7a55dfe/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a", size = 1607044 }, + { url = "https://files.pythonhosted.org/packages/fd/93/af67dbcfb9b3323bbd2c2db1385a7139d8f77630e4a37bb945b57188eb2d/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8", size = 1391879 }, + { url = "https://files.pythonhosted.org/packages/40/6f/d60770ef98e77b365d96061d090c0cd9e23418121c55fff188fa4bdf0b54/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2", size = 1504751 }, + { url = "https://files.pythonhosted.org/packages/fa/3a/5f38667d313e983c432f3fcd86932177519ed8790c724e07d77d1de0188a/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88", size = 1436990 }, + { url = "https://files.pythonhosted.org/packages/cb/3b/1520301a47326e6a6043b502647e42892be33b3f051e9791cc8bb43f1a32/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde", size = 2191122 }, + { url = "https://files.pythonhosted.org/packages/cf/c4/eb52da300c166239a2233f1f9c4a1b767dfab98fae27681bfb7ea4873cb6/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c", size = 2338126 }, + { url = "https://files.pythonhosted.org/packages/1a/cb/42b92fd5eadd708dd9107c089e817945500685f3437ce1fd387efebc6d6e/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2", size = 2298313 }, + { url = "https://files.pythonhosted.org/packages/4f/eb/be25aa791fe5fc75a8b1e0c965e00f942496bc04635c9aae8035f6b76dcd/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb", size = 2437784 }, + { url = "https://files.pythonhosted.org/packages/c5/22/30a66be7f3368d76ff95689e1c2e28d382383952964ab15330a15d8bfd03/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327", size = 2253988 }, + { url = "https://files.pythonhosted.org/packages/35/d3/5f2ecb94b5211c8a04f218a76133cc8d6d153b0f9cd0b45fad79907f0689/kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644", size = 46980 }, + { url = "https://files.pythonhosted.org/packages/ef/17/cd10d020578764ea91740204edc6b3236ed8106228a46f568d716b11feb2/kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4", size = 55847 }, + { url = "https://files.pythonhosted.org/packages/91/84/32232502020bd78d1d12be7afde15811c64a95ed1f606c10456db4e4c3ac/kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f", size = 48494 }, + { url = "https://files.pythonhosted.org/packages/ac/59/741b79775d67ab67ced9bb38552da688c0305c16e7ee24bba7a2be253fb7/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643", size = 59491 }, + { url = "https://files.pythonhosted.org/packages/58/cc/fb239294c29a5656e99e3527f7369b174dd9cc7c3ef2dea7cb3c54a8737b/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706", size = 57648 }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2f009ac1f7aab9f81efb2d837301d255279d618d27b6015780115ac64bdd/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6", size = 84257 }, + { url = "https://files.pythonhosted.org/packages/81/e1/c64f50987f85b68b1c52b464bb5bf73e71570c0f7782d626d1eb283ad620/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2", size = 80906 }, + { url = "https://files.pythonhosted.org/packages/fd/71/1687c5c0a0be2cee39a5c9c389e546f9c6e215e46b691d00d9f646892083/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4", size = 79951 }, + { url = "https://files.pythonhosted.org/packages/ea/8b/d7497df4a1cae9367adf21665dd1f896c2a7aeb8769ad77b662c5e2bcce7/kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a", size = 55715 }, + { url = "https://files.pythonhosted.org/packages/d5/df/ce37d9b26f07ab90880923c94d12a6ff4d27447096b4c849bfc4339ccfdf/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39", size = 58666 }, + { url = "https://files.pythonhosted.org/packages/b0/d3/e4b04f43bc629ac8e186b77b2b1a251cdfa5b7610fa189dc0db622672ce6/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e", size = 57088 }, + { url = "https://files.pythonhosted.org/packages/30/1c/752df58e2d339e670a535514d2db4fe8c842ce459776b8080fbe08ebb98e/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608", size = 84321 }, + { url = "https://files.pythonhosted.org/packages/f0/f8/fe6484e847bc6e238ec9f9828089fb2c0bb53f2f5f3a79351fde5b565e4f/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674", size = 80776 }, + { url = "https://files.pythonhosted.org/packages/9b/57/d7163c0379f250ef763aba85330a19feefb5ce6cb541ade853aaba881524/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225", size = 79984 }, + { url = "https://files.pythonhosted.org/packages/8c/95/4a103776c265d13b3d2cd24fb0494d4e04ea435a8ef97e1b2c026d43250b/kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0", size = 55811 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623 }, + { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720 }, + { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826 }, + { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231 }, + { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938 }, + { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799 }, + { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362 }, + { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695 }, + { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802 }, + { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646 }, + { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260 }, + { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633 }, + { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885 }, + { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175 }, + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635 }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717 }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994 }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804 }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690 }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839 }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109 }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269 }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468 }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394 }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901 }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306 }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966 }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311 }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152 }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067 }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443 }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728 }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849 }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533 }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898 }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605 }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801 }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077 }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410 }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853 }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424 }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156 }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071 }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053 }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278 }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139 }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517 }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952 }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132 }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997 }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060 }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471 }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793 }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855 }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430 }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294 }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736 }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194 }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942 }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341 }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455 }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138 }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857 }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129 }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538 }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661 }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710 }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213 }, + { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403 }, + { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657 }, + { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948 }, + { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186 }, + { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279 }, + { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762 }, +] + +[[package]] +name = "llvmlite" +version = "0.43.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/3d/f513755f285db51ab363a53e898b85562e950f79a2e6767a364530c2f645/llvmlite-0.43.0.tar.gz", hash = "sha256:ae2b5b5c3ef67354824fb75517c8db5fbe93bc02cd9671f3c62271626bc041d5", size = 157069 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/ff/6ca7e98998b573b4bd6566f15c35e5c8bea829663a6df0c7aa55ab559da9/llvmlite-0.43.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a289af9a1687c6cf463478f0fa8e8aa3b6fb813317b0d70bf1ed0759eab6f761", size = 31064408 }, + { url = "https://files.pythonhosted.org/packages/ca/5c/a27f9257f86f0cda3f764ff21d9f4217b9f6a0d45e7a39ecfa7905f524ce/llvmlite-0.43.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d4fd101f571a31acb1559ae1af30f30b1dc4b3186669f92ad780e17c81e91bc", size = 28793153 }, + { url = "https://files.pythonhosted.org/packages/7e/3c/4410f670ad0a911227ea2ecfcba9f672a77cf1924df5280c4562032ec32d/llvmlite-0.43.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d434ec7e2ce3cc8f452d1cd9a28591745de022f931d67be688a737320dfcead", size = 42857276 }, + { url = "https://files.pythonhosted.org/packages/c6/21/2ffbab5714e72f2483207b4a1de79b2eecd9debbf666ff4e7067bcc5c134/llvmlite-0.43.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6912a87782acdff6eb8bf01675ed01d60ca1f2551f8176a300a886f09e836a6a", size = 43871781 }, + { url = "https://files.pythonhosted.org/packages/f2/26/b5478037c453554a61625ef1125f7e12bb1429ae11c6376f47beba9b0179/llvmlite-0.43.0-cp310-cp310-win_amd64.whl", hash = "sha256:14f0e4bf2fd2d9a75a3534111e8ebeb08eda2f33e9bdd6dfa13282afacdde0ed", size = 28123487 }, + { url = "https://files.pythonhosted.org/packages/95/8c/de3276d773ab6ce3ad676df5fab5aac19696b2956319d65d7dd88fb10f19/llvmlite-0.43.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8d0618cb9bfe40ac38a9633f2493d4d4e9fcc2f438d39a4e854f39cc0f5f98", size = 31064409 }, + { url = "https://files.pythonhosted.org/packages/ee/e1/38deed89ced4cf378c61e232265cfe933ccde56ae83c901aa68b477d14b1/llvmlite-0.43.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0a9a1a39d4bf3517f2af9d23d479b4175ead205c592ceeb8b89af48a327ea57", size = 28793149 }, + { url = "https://files.pythonhosted.org/packages/2f/b2/4429433eb2dc8379e2cb582502dca074c23837f8fd009907f78a24de4c25/llvmlite-0.43.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1da416ab53e4f7f3bc8d4eeba36d801cc1894b9fbfbf2022b29b6bad34a7df2", size = 42857277 }, + { url = "https://files.pythonhosted.org/packages/6b/99/5d00a7d671b1ba1751fc9f19d3b36f3300774c6eebe2bcdb5f6191763eb4/llvmlite-0.43.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:977525a1e5f4059316b183fb4fd34fa858c9eade31f165427a3977c95e3ee749", size = 43871781 }, + { url = "https://files.pythonhosted.org/packages/20/ab/ed5ed3688c6ba4f0b8d789da19fd8e30a9cf7fc5852effe311bc5aefe73e/llvmlite-0.43.0-cp311-cp311-win_amd64.whl", hash = "sha256:d5bd550001d26450bd90777736c69d68c487d17bf371438f975229b2b8241a91", size = 28107433 }, + { url = "https://files.pythonhosted.org/packages/0b/67/9443509e5d2b6d8587bae3ede5598fa8bd586b1c7701696663ea8af15b5b/llvmlite-0.43.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f99b600aa7f65235a5a05d0b9a9f31150c390f31261f2a0ba678e26823ec38f7", size = 31064409 }, + { url = "https://files.pythonhosted.org/packages/a2/9c/24139d3712d2d352e300c39c0e00d167472c08b3bd350c3c33d72c88ff8d/llvmlite-0.43.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:35d80d61d0cda2d767f72de99450766250560399edc309da16937b93d3b676e7", size = 28793145 }, + { url = "https://files.pythonhosted.org/packages/bf/f1/4c205a48488e574ee9f6505d50e84370a978c90f08dab41a42d8f2c576b6/llvmlite-0.43.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eccce86bba940bae0d8d48ed925f21dbb813519169246e2ab292b5092aba121f", size = 42857276 }, + { url = "https://files.pythonhosted.org/packages/00/5f/323c4d56e8401c50185fd0e875fcf06b71bf825a863699be1eb10aa2a9cb/llvmlite-0.43.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:df6509e1507ca0760787a199d19439cc887bfd82226f5af746d6977bd9f66844", size = 43871781 }, + { url = "https://files.pythonhosted.org/packages/c6/94/dea10e263655ce78d777e78d904903faae39d1fc440762be4a9dc46bed49/llvmlite-0.43.0-cp312-cp312-win_amd64.whl", hash = "sha256:7a2872ee80dcf6b5dbdc838763d26554c2a18aa833d31a2635bff16aafefb9c9", size = 28107442 }, + { url = "https://files.pythonhosted.org/packages/2a/73/12925b1bbb3c2beb6d96f892ef5b4d742c34f00ddb9f4a125e9e87b22f52/llvmlite-0.43.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9cd2a7376f7b3367019b664c21f0c61766219faa3b03731113ead75107f3b66c", size = 31064410 }, + { url = "https://files.pythonhosted.org/packages/cc/61/58c70aa0808a8cba825a7d98cc65bef4801b99328fba80837bfcb5fc767f/llvmlite-0.43.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:18e9953c748b105668487b7c81a3e97b046d8abf95c4ddc0cd3c94f4e4651ae8", size = 28793145 }, + { url = "https://files.pythonhosted.org/packages/c8/c6/9324eb5de2ba9d99cbed853d85ba7a318652a48e077797bec27cf40f911d/llvmlite-0.43.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:74937acd22dc11b33946b67dca7680e6d103d6e90eeaaaf932603bec6fe7b03a", size = 42857276 }, + { url = "https://files.pythonhosted.org/packages/e0/d0/889e9705107db7b1ec0767b03f15d7b95b4c4f9fdf91928ab1c7e9ffacf6/llvmlite-0.43.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc9efc739cc6ed760f795806f67889923f7274276f0eb45092a1473e40d9b867", size = 43871777 }, + { url = "https://files.pythonhosted.org/packages/df/41/73cc26a2634b538cfe813f618c91e7e9960b8c163f8f0c94a2b0f008b9da/llvmlite-0.43.0-cp39-cp39-win_amd64.whl", hash = "sha256:47e147cdda9037f94b399bf03bfd8a6b6b1f2f90be94a454e3386f006455a9b4", size = 28123489 }, +] + +[[package]] +name = "llvmlite" +version = "0.44.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/89/6a/95a3d3610d5c75293d5dbbb2a76480d5d4eeba641557b69fe90af6c5b84e/llvmlite-0.44.0.tar.gz", hash = "sha256:07667d66a5d150abed9157ab6c0b9393c9356f229784a4385c02f99e94fc94d4", size = 171880 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/75/d4863ddfd8ab5f6e70f4504cf8cc37f4e986ec6910f4ef8502bb7d3c1c71/llvmlite-0.44.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:9fbadbfba8422123bab5535b293da1cf72f9f478a65645ecd73e781f962ca614", size = 28132306 }, + { url = "https://files.pythonhosted.org/packages/37/d9/6e8943e1515d2f1003e8278819ec03e4e653e2eeb71e4d00de6cfe59424e/llvmlite-0.44.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cccf8eb28f24840f2689fb1a45f9c0f7e582dd24e088dcf96e424834af11f791", size = 26201096 }, + { url = "https://files.pythonhosted.org/packages/aa/46/8ffbc114def88cc698906bf5acab54ca9fdf9214fe04aed0e71731fb3688/llvmlite-0.44.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7202b678cdf904823c764ee0fe2dfe38a76981f4c1e51715b4cb5abb6cf1d9e8", size = 42361859 }, + { url = "https://files.pythonhosted.org/packages/30/1c/9366b29ab050a726af13ebaae8d0dff00c3c58562261c79c635ad4f5eb71/llvmlite-0.44.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40526fb5e313d7b96bda4cbb2c85cd5374e04d80732dd36a282d72a560bb6408", size = 41184199 }, + { url = "https://files.pythonhosted.org/packages/69/07/35e7c594b021ecb1938540f5bce543ddd8713cff97f71d81f021221edc1b/llvmlite-0.44.0-cp310-cp310-win_amd64.whl", hash = "sha256:41e3839150db4330e1b2716c0be3b5c4672525b4c9005e17c7597f835f351ce2", size = 30332381 }, + { url = "https://files.pythonhosted.org/packages/b5/e2/86b245397052386595ad726f9742e5223d7aea999b18c518a50e96c3aca4/llvmlite-0.44.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:eed7d5f29136bda63b6d7804c279e2b72e08c952b7c5df61f45db408e0ee52f3", size = 28132305 }, + { url = "https://files.pythonhosted.org/packages/ff/ec/506902dc6870249fbe2466d9cf66d531265d0f3a1157213c8f986250c033/llvmlite-0.44.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ace564d9fa44bb91eb6e6d8e7754977783c68e90a471ea7ce913bff30bd62427", size = 26201090 }, + { url = "https://files.pythonhosted.org/packages/99/fe/d030f1849ebb1f394bb3f7adad5e729b634fb100515594aca25c354ffc62/llvmlite-0.44.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c5d22c3bfc842668168a786af4205ec8e3ad29fb1bc03fd11fd48460d0df64c1", size = 42361858 }, + { url = "https://files.pythonhosted.org/packages/d7/7a/ce6174664b9077fc673d172e4c888cb0b128e707e306bc33fff8c2035f0d/llvmlite-0.44.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f01a394e9c9b7b1d4e63c327b096d10f6f0ed149ef53d38a09b3749dcf8c9610", size = 41184200 }, + { url = "https://files.pythonhosted.org/packages/5f/c6/258801143975a6d09a373f2641237992496e15567b907a4d401839d671b8/llvmlite-0.44.0-cp311-cp311-win_amd64.whl", hash = "sha256:d8489634d43c20cd0ad71330dde1d5bc7b9966937a263ff1ec1cebb90dc50955", size = 30331193 }, + { url = "https://files.pythonhosted.org/packages/15/86/e3c3195b92e6e492458f16d233e58a1a812aa2bfbef9bdd0fbafcec85c60/llvmlite-0.44.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:1d671a56acf725bf1b531d5ef76b86660a5ab8ef19bb6a46064a705c6ca80aad", size = 28132297 }, + { url = "https://files.pythonhosted.org/packages/d6/53/373b6b8be67b9221d12b24125fd0ec56b1078b660eeae266ec388a6ac9a0/llvmlite-0.44.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f79a728e0435493611c9f405168682bb75ffd1fbe6fc360733b850c80a026db", size = 26201105 }, + { url = "https://files.pythonhosted.org/packages/cb/da/8341fd3056419441286c8e26bf436923021005ece0bff5f41906476ae514/llvmlite-0.44.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0143a5ef336da14deaa8ec26c5449ad5b6a2b564df82fcef4be040b9cacfea9", size = 42361901 }, + { url = "https://files.pythonhosted.org/packages/53/ad/d79349dc07b8a395a99153d7ce8b01d6fcdc9f8231355a5df55ded649b61/llvmlite-0.44.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d752f89e31b66db6f8da06df8b39f9b91e78c5feea1bf9e8c1fba1d1c24c065d", size = 41184247 }, + { url = "https://files.pythonhosted.org/packages/e2/3b/a9a17366af80127bd09decbe2a54d8974b6d8b274b39bf47fbaedeec6307/llvmlite-0.44.0-cp312-cp312-win_amd64.whl", hash = "sha256:eae7e2d4ca8f88f89d315b48c6b741dcb925d6a1042da694aa16ab3dd4cbd3a1", size = 30332380 }, + { url = "https://files.pythonhosted.org/packages/89/24/4c0ca705a717514c2092b18476e7a12c74d34d875e05e4d742618ebbf449/llvmlite-0.44.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:319bddd44e5f71ae2689859b7203080716448a3cd1128fb144fe5c055219d516", size = 28132306 }, + { url = "https://files.pythonhosted.org/packages/01/cf/1dd5a60ba6aee7122ab9243fd614abcf22f36b0437cbbe1ccf1e3391461c/llvmlite-0.44.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c58867118bad04a0bb22a2e0068c693719658105e40009ffe95c7000fcde88e", size = 26201090 }, + { url = "https://files.pythonhosted.org/packages/d2/1b/656f5a357de7135a3777bd735cc7c9b8f23b4d37465505bd0eaf4be9befe/llvmlite-0.44.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46224058b13c96af1365290bdfebe9a6264ae62fb79b2b55693deed11657a8bf", size = 42361904 }, + { url = "https://files.pythonhosted.org/packages/d8/e1/12c5f20cb9168fb3464a34310411d5ad86e4163c8ff2d14a2b57e5cc6bac/llvmlite-0.44.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0097052c32bf721a4efc03bd109d335dfa57d9bffb3d4c24cc680711b8b4fc", size = 41184245 }, + { url = "https://files.pythonhosted.org/packages/d0/81/e66fc86539293282fd9cb7c9417438e897f369e79ffb62e1ae5e5154d4dd/llvmlite-0.44.0-cp313-cp313-win_amd64.whl", hash = "sha256:2fb7c4f2fb86cbae6dca3db9ab203eeea0e22d73b99bc2341cdf9de93612e930", size = 30331193 }, +] + +[[package]] +name = "markdown" +version = "3.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/28/3af612670f82f4c056911fbbbb42760255801b3068c48de792d354ff4472/markdown-3.7.tar.gz", hash = "sha256:2ae2471477cfd02dbbf038d5d9bc226d40def84b4fe2986e49b59b6b472bbed2", size = 357086 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/08/83871f3c50fc983b88547c196d11cf8c3340e37c32d2e9d6152abe2c61f7/Markdown-3.7-py3-none-any.whl", hash = "sha256:7eb6df5690b81a1d7942992c97fad2938e956e79df20cbc6186e9c3a77b1c803", size = 106349 }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 }, + { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 }, + { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 }, + { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 }, + { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 }, + { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 }, + { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 }, + { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 }, + { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 }, + { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 }, + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 }, + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 }, + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 }, + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 }, + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 }, + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 }, + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 }, + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 }, + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 }, + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 }, + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 }, + { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344 }, + { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389 }, + { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607 }, + { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728 }, + { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826 }, + { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843 }, + { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219 }, + { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946 }, + { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063 }, + { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506 }, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "contourpy", version = "1.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "cycler", marker = "python_full_version < '3.10'" }, + { name = "fonttools", marker = "python_full_version < '3.10'" }, + { name = "importlib-resources", marker = "python_full_version < '3.10'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "packaging", marker = "python_full_version < '3.10'" }, + { name = "pillow", marker = "python_full_version < '3.10'" }, + { name = "pyparsing", marker = "python_full_version < '3.10'" }, + { name = "python-dateutil", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/17/1747b4154034befd0ed33b52538f5eb7752d05bb51c5e2a31470c3bc7d52/matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3", size = 36106529 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/94/27d2e2c30d54b56c7b764acc1874a909e34d1965a427fc7092bb6a588b63/matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50", size = 7885089 }, + { url = "https://files.pythonhosted.org/packages/c6/25/828273307e40a68eb8e9df832b6b2aaad075864fdc1de4b1b81e40b09e48/matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff", size = 7770600 }, + { url = "https://files.pythonhosted.org/packages/f2/65/f841a422ec994da5123368d76b126acf4fc02ea7459b6e37c4891b555b83/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddf9f3c26aae695c5daafbf6b94e4c1a30d6cd617ba594bbbded3b33a1fcfa26", size = 8200138 }, + { url = "https://files.pythonhosted.org/packages/07/06/272aca07a38804d93b6050813de41ca7ab0e29ba7a9dd098e12037c919a9/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18ebcf248030173b59a868fda1fe42397253f6698995b55e81e1f57431d85e50", size = 8312711 }, + { url = "https://files.pythonhosted.org/packages/98/37/f13e23b233c526b7e27ad61be0a771894a079e0f7494a10d8d81557e0e9a/matplotlib-3.9.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974896ec43c672ec23f3f8c648981e8bc880ee163146e0312a9b8def2fac66f5", size = 9090622 }, + { url = "https://files.pythonhosted.org/packages/4f/8c/b1f5bd2bd70e60f93b1b54c4d5ba7a992312021d0ddddf572f9a1a6d9348/matplotlib-3.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:4598c394ae9711cec135639374e70871fa36b56afae17bdf032a345be552a88d", size = 7828211 }, + { url = "https://files.pythonhosted.org/packages/74/4b/65be7959a8fa118a3929b49a842de5b78bb55475236fcf64f3e308ff74a0/matplotlib-3.9.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d4dd29641d9fb8bc4492420c5480398dd40a09afd73aebe4eb9d0071a05fbe0c", size = 7894430 }, + { url = "https://files.pythonhosted.org/packages/e9/18/80f70d91896e0a517b4a051c3fd540daa131630fd75e02e250365353b253/matplotlib-3.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30e5b22e8bcfb95442bf7d48b0d7f3bdf4a450cbf68986ea45fca3d11ae9d099", size = 7780045 }, + { url = "https://files.pythonhosted.org/packages/a2/73/ccb381026e3238c5c25c3609ba4157b2d1a617ec98d65a8b4ee4e1e74d02/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bb0030d1d447fd56dcc23b4c64a26e44e898f0416276cac1ebc25522e0ac249", size = 8209906 }, + { url = "https://files.pythonhosted.org/packages/ab/33/1648da77b74741c89f5ea95cbf42a291b4b364f2660b316318811404ed97/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aca90ed222ac3565d2752b83dbb27627480d27662671e4d39da72e97f657a423", size = 8322873 }, + { url = "https://files.pythonhosted.org/packages/57/d3/8447ba78bc6593c9044c372d1609f8ea10fb1e071e7a9e0747bea74fc16c/matplotlib-3.9.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a181b2aa2906c608fcae72f977a4a2d76e385578939891b91c2550c39ecf361e", size = 9099566 }, + { url = "https://files.pythonhosted.org/packages/23/e1/4f0e237bf349c02ff9d1b6e7109f1a17f745263809b9714a8576dc17752b/matplotlib-3.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:1f6882828231eca17f501c4dcd98a05abb3f03d157fbc0769c6911fe08b6cfd3", size = 7838065 }, + { url = "https://files.pythonhosted.org/packages/1a/2b/c918bf6c19d6445d1cefe3d2e42cb740fb997e14ab19d4daeb6a7ab8a157/matplotlib-3.9.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dfc48d67e6661378a21c2983200a654b72b5c5cdbd5d2cf6e5e1ece860f0cc70", size = 7891131 }, + { url = "https://files.pythonhosted.org/packages/c1/e5/b4e8fc601ca302afeeabf45f30e706a445c7979a180e3a978b78b2b681a4/matplotlib-3.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47aef0fab8332d02d68e786eba8113ffd6f862182ea2999379dec9e237b7e483", size = 7776365 }, + { url = "https://files.pythonhosted.org/packages/99/06/b991886c506506476e5d83625c5970c656a491b9f80161458fed94597808/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fba1f52c6b7dc764097f52fd9ab627b90db452c9feb653a59945de16752e965f", size = 8200707 }, + { url = "https://files.pythonhosted.org/packages/c3/e2/556b627498cb27e61026f2d1ba86a78ad1b836fef0996bef5440e8bc9559/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173ac3748acaac21afcc3fa1633924609ba1b87749006bc25051c52c422a5d00", size = 8313761 }, + { url = "https://files.pythonhosted.org/packages/58/ff/165af33ec766ff818306ea88e91f9f60d2a6ed543be1eb122a98acbf3b0d/matplotlib-3.9.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320edea0cadc07007765e33f878b13b3738ffa9745c5f707705692df70ffe0e0", size = 9095284 }, + { url = "https://files.pythonhosted.org/packages/9f/8b/3d0c7a002db3b1ed702731c2a9a06d78d035f1f2fb0fb936a8e43cc1e9f4/matplotlib-3.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4a4cfc82330b27042a7169533da7991e8789d180dd5b3daeaee57d75cd5a03b", size = 7841160 }, + { url = "https://files.pythonhosted.org/packages/49/b1/999f89a7556d101b23a2f0b54f1b6e140d73f56804da1398f2f0bc0924bc/matplotlib-3.9.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37eeffeeca3c940985b80f5b9a7b95ea35671e0e7405001f249848d2b62351b6", size = 7891499 }, + { url = "https://files.pythonhosted.org/packages/87/7b/06a32b13a684977653396a1bfcd34d4e7539c5d55c8cbfaa8ae04d47e4a9/matplotlib-3.9.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3e7465ac859ee4abcb0d836137cd8414e7bb7ad330d905abced457217d4f0f45", size = 7776802 }, + { url = "https://files.pythonhosted.org/packages/65/87/ac498451aff739e515891bbb92e566f3c7ef31891aaa878402a71f9b0910/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4c12302c34afa0cf061bea23b331e747e5e554b0fa595c96e01c7b75bc3b858", size = 8200802 }, + { url = "https://files.pythonhosted.org/packages/f8/6b/9eb761c00e1cb838f6c92e5f25dcda3f56a87a52f6cb8fdfa561e6cf6a13/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b8c97917f21b75e72108b97707ba3d48f171541a74aa2a56df7a40626bafc64", size = 8313880 }, + { url = "https://files.pythonhosted.org/packages/d7/a2/c8eaa600e2085eec7e38cbbcc58a30fc78f8224939d31d3152bdafc01fd1/matplotlib-3.9.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0229803bd7e19271b03cb09f27db76c918c467aa4ce2ae168171bc67c3f508df", size = 9094637 }, + { url = "https://files.pythonhosted.org/packages/71/1f/c6e1daea55b7bfeb3d84c6cb1abc449f6a02b181e7e2a5e4db34c3afb793/matplotlib-3.9.4-cp313-cp313-win_amd64.whl", hash = "sha256:7c0d8ef442ebf56ff5e206f8083d08252ee738e04f3dc88ea882853a05488799", size = 7841311 }, + { url = "https://files.pythonhosted.org/packages/c0/3a/2757d3f7d388b14dd48f5a83bea65b6d69f000e86b8f28f74d86e0d375bd/matplotlib-3.9.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a04c3b00066a688834356d196136349cb32f5e1003c55ac419e91585168b88fb", size = 7919989 }, + { url = "https://files.pythonhosted.org/packages/24/28/f5077c79a4f521589a37fe1062d6a6ea3534e068213f7357e7cfffc2e17a/matplotlib-3.9.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:04c519587f6c210626741a1e9a68eefc05966ede24205db8982841826af5871a", size = 7809417 }, + { url = "https://files.pythonhosted.org/packages/36/c8/c523fd2963156692916a8eb7d4069084cf729359f7955cf09075deddfeaf/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308afbf1a228b8b525fcd5cec17f246bbbb63b175a3ef6eb7b4d33287ca0cf0c", size = 8226258 }, + { url = "https://files.pythonhosted.org/packages/f6/88/499bf4b8fa9349b6f5c0cf4cead0ebe5da9d67769129f1b5651e5ac51fbc/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddb3b02246ddcffd3ce98e88fed5b238bc5faff10dbbaa42090ea13241d15764", size = 8335849 }, + { url = "https://files.pythonhosted.org/packages/b8/9f/20a4156b9726188646a030774ee337d5ff695a965be45ce4dbcb9312c170/matplotlib-3.9.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8a75287e9cb9eee48cb79ec1d806f75b29c0fde978cb7223a1f4c5848d696041", size = 9102152 }, + { url = "https://files.pythonhosted.org/packages/10/11/237f9c3a4e8d810b1759b67ff2da7c32c04f9c80aa475e7beb36ed43a8fb/matplotlib-3.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:488deb7af140f0ba86da003e66e10d55ff915e152c78b4b66d231638400b1965", size = 7896987 }, + { url = "https://files.pythonhosted.org/packages/56/eb/501b465c9fef28f158e414ea3a417913dc2ac748564c7ed41535f23445b4/matplotlib-3.9.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3c3724d89a387ddf78ff88d2a30ca78ac2b4c89cf37f2db4bd453c34799e933c", size = 7885919 }, + { url = "https://files.pythonhosted.org/packages/da/36/236fbd868b6c91309a5206bd90c3f881f4f44b2d997cd1d6239ef652f878/matplotlib-3.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f0a8430ffe23d7e32cfd86445864ccad141797f7d25b7c41759a5b5d17cfd7", size = 7771486 }, + { url = "https://files.pythonhosted.org/packages/e0/4b/105caf2d54d5ed11d9f4335398f5103001a03515f2126c936a752ccf1461/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bb0141a21aef3b64b633dc4d16cbd5fc538b727e4958be82a0e1c92a234160e", size = 8201838 }, + { url = "https://files.pythonhosted.org/packages/5d/a7/bb01188fb4013d34d274caf44a2f8091255b0497438e8b6c0a7c1710c692/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57aa235109e9eed52e2c2949db17da185383fa71083c00c6c143a60e07e0888c", size = 8314492 }, + { url = "https://files.pythonhosted.org/packages/33/19/02e1a37f7141fc605b193e927d0a9cdf9dc124a20b9e68793f4ffea19695/matplotlib-3.9.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b18c600061477ccfdd1e6fd050c33d8be82431700f3452b297a56d9ed7037abb", size = 9092500 }, + { url = "https://files.pythonhosted.org/packages/57/68/c2feb4667adbf882ffa4b3e0ac9967f848980d9f8b5bebd86644aa67ce6a/matplotlib-3.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:ef5f2d1b67d2d2145ff75e10f8c008bfbf71d45137c4b648c87193e7dd053eac", size = 7822962 }, + { url = "https://files.pythonhosted.org/packages/0c/22/2ef6a364cd3f565442b0b055e0599744f1e4314ec7326cdaaa48a4d864d7/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:44e0ed786d769d85bc787b0606a53f2d8d2d1d3c8a2608237365e9121c1a338c", size = 7877995 }, + { url = "https://files.pythonhosted.org/packages/87/b8/2737456e566e9f4d94ae76b8aa0d953d9acb847714f9a7ad80184474f5be/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:09debb9ce941eb23ecdbe7eab972b1c3e0276dcf01688073faff7b0f61d6c6ca", size = 7769300 }, + { url = "https://files.pythonhosted.org/packages/b2/1f/e709c6ec7b5321e6568769baa288c7178e60a93a9da9e682b39450da0e29/matplotlib-3.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcc53cf157a657bfd03afab14774d54ba73aa84d42cfe2480c91bd94873952db", size = 8313423 }, + { url = "https://files.pythonhosted.org/packages/5e/b6/5a1f868782cd13f053a679984e222007ecff654a9bfbac6b27a65f4eeb05/matplotlib-3.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ad45da51be7ad02387801fd154ef74d942f49fe3fcd26a64c94842ba7ec0d865", size = 7854624 }, +] + +[[package]] +name = "matplotlib" +version = "3.10.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "cycler", marker = "python_full_version >= '3.10'" }, + { name = "fonttools", marker = "python_full_version >= '3.10'" }, + { name = "kiwisolver", version = "1.4.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "packaging", marker = "python_full_version >= '3.10'" }, + { name = "pillow", marker = "python_full_version >= '3.10'" }, + { name = "pyparsing", marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/dd/fa2e1a45fce2d09f4aea3cee169760e672c8262325aa5796c49d543dc7e6/matplotlib-3.10.0.tar.gz", hash = "sha256:b886d02a581b96704c9d1ffe55709e49b4d2d52709ccebc4be42db856e511278", size = 36686418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/ec/3cdff7b5239adaaacefcc4f77c316dfbbdf853c4ed2beec467e0fec31b9f/matplotlib-3.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2c5829a5a1dd5a71f0e31e6e8bb449bc0ee9dbfb05ad28fc0c6b55101b3a4be6", size = 8160551 }, + { url = "https://files.pythonhosted.org/packages/41/f2/b518f2c7f29895c9b167bf79f8529c63383ae94eaf49a247a4528e9a148d/matplotlib-3.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2a43cbefe22d653ab34bb55d42384ed30f611bcbdea1f8d7f431011a2e1c62e", size = 8034853 }, + { url = "https://files.pythonhosted.org/packages/ed/8d/45754b4affdb8f0d1a44e4e2bcd932cdf35b256b60d5eda9f455bb293ed0/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:607b16c8a73943df110f99ee2e940b8a1cbf9714b65307c040d422558397dac5", size = 8446724 }, + { url = "https://files.pythonhosted.org/packages/09/5a/a113495110ae3e3395c72d82d7bc4802902e46dc797f6b041e572f195c56/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01d2b19f13aeec2e759414d3bfe19ddfb16b13a1250add08d46d5ff6f9be83c6", size = 8583905 }, + { url = "https://files.pythonhosted.org/packages/12/b1/8b1655b4c9ed4600c817c419f7eaaf70082630efd7556a5b2e77a8a3cdaf/matplotlib-3.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e6c6461e1fc63df30bf6f80f0b93f5b6784299f721bc28530477acd51bfc3d1", size = 9395223 }, + { url = "https://files.pythonhosted.org/packages/5a/85/b9a54d64585a6b8737a78a61897450403c30f39e0bd3214270bb0b96f002/matplotlib-3.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:994c07b9d9fe8d25951e3202a68c17900679274dadfc1248738dcfa1bd40d7f3", size = 8025355 }, + { url = "https://files.pythonhosted.org/packages/0c/f1/e37f6c84d252867d7ddc418fff70fc661cfd363179263b08e52e8b748e30/matplotlib-3.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:fd44fc75522f58612ec4a33958a7e5552562b7705b42ef1b4f8c0818e304a363", size = 8171677 }, + { url = "https://files.pythonhosted.org/packages/c7/8b/92e9da1f28310a1f6572b5c55097b0c0ceb5e27486d85fb73b54f5a9b939/matplotlib-3.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c58a9622d5dbeb668f407f35f4e6bfac34bb9ecdcc81680c04d0258169747997", size = 8044945 }, + { url = "https://files.pythonhosted.org/packages/c5/cb/49e83f0fd066937a5bd3bc5c5d63093703f3637b2824df8d856e0558beef/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:845d96568ec873be63f25fa80e9e7fae4be854a66a7e2f0c8ccc99e94a8bd4ef", size = 8458269 }, + { url = "https://files.pythonhosted.org/packages/b2/7d/2d873209536b9ee17340754118a2a17988bc18981b5b56e6715ee07373ac/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5439f4c5a3e2e8eab18e2f8c3ef929772fd5641876db71f08127eed95ab64683", size = 8599369 }, + { url = "https://files.pythonhosted.org/packages/b8/03/57d6cbbe85c61fe4cbb7c94b54dce443d68c21961830833a1f34d056e5ea/matplotlib-3.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4673ff67a36152c48ddeaf1135e74ce0d4bce1bbf836ae40ed39c29edf7e2765", size = 9405992 }, + { url = "https://files.pythonhosted.org/packages/14/cf/e382598f98be11bf51dd0bc60eca44a517f6793e3dc8b9d53634a144620c/matplotlib-3.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:7e8632baebb058555ac0cde75db885c61f1212e47723d63921879806b40bec6a", size = 8034580 }, + { url = "https://files.pythonhosted.org/packages/44/c7/6b2d8cb7cc251d53c976799cacd3200add56351c175ba89ab9cbd7c1e68a/matplotlib-3.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4659665bc7c9b58f8c00317c3c2a299f7f258eeae5a5d56b4c64226fca2f7c59", size = 8172465 }, + { url = "https://files.pythonhosted.org/packages/42/2a/6d66d0fba41e13e9ca6512a0a51170f43e7e7ed3a8dfa036324100775612/matplotlib-3.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d44cb942af1693cced2604c33a9abcef6205601c445f6d0dc531d813af8a2f5a", size = 8043300 }, + { url = "https://files.pythonhosted.org/packages/90/60/2a60342b27b90a16bada939a85e29589902b41073f59668b904b15ea666c/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a994f29e968ca002b50982b27168addfd65f0105610b6be7fa515ca4b5307c95", size = 8448936 }, + { url = "https://files.pythonhosted.org/packages/a7/b2/d872fc3d753516870d520595ddd8ce4dd44fa797a240999f125f58521ad7/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b0558bae37f154fffda54d779a592bc97ca8b4701f1c710055b609a3bac44c8", size = 8594151 }, + { url = "https://files.pythonhosted.org/packages/f4/bd/b2f60cf7f57d014ab33e4f74602a2b5bdc657976db8196bbc022185f6f9c/matplotlib-3.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:503feb23bd8c8acc75541548a1d709c059b7184cde26314896e10a9f14df5f12", size = 9400347 }, + { url = "https://files.pythonhosted.org/packages/9f/6e/264673e64001b99d747aff5a288eca82826c024437a3694e19aed1decf46/matplotlib-3.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:c40ba2eb08b3f5de88152c2333c58cee7edcead0a2a0d60fcafa116b17117adc", size = 8039144 }, + { url = "https://files.pythonhosted.org/packages/72/11/1b2a094d95dcb6e6edd4a0b238177c439006c6b7a9fe8d31801237bf512f/matplotlib-3.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96f2886f5c1e466f21cc41b70c5a0cd47bfa0015eb2d5793c88ebce658600e25", size = 8173073 }, + { url = "https://files.pythonhosted.org/packages/0d/c4/87b6ad2723070511a411ea719f9c70fde64605423b184face4e94986de9d/matplotlib-3.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:12eaf48463b472c3c0f8dbacdbf906e573013df81a0ab82f0616ea4b11281908", size = 8043892 }, + { url = "https://files.pythonhosted.org/packages/57/69/cb0812a136550b21361335e9ffb7d459bf6d13e03cb7b015555d5143d2d6/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fbbabc82fde51391c4da5006f965e36d86d95f6ee83fb594b279564a4c5d0d2", size = 8450532 }, + { url = "https://files.pythonhosted.org/packages/ea/3a/bab9deb4fb199c05e9100f94d7f1c702f78d3241e6a71b784d2b88d7bebd/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad2e15300530c1a94c63cfa546e3b7864bd18ea2901317bae8bbf06a5ade6dcf", size = 8593905 }, + { url = "https://files.pythonhosted.org/packages/8b/66/742fd242f989adc1847ddf5f445815f73ad7c46aa3440690cc889cfa423c/matplotlib-3.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3547d153d70233a8496859097ef0312212e2689cdf8d7ed764441c77604095ae", size = 9399609 }, + { url = "https://files.pythonhosted.org/packages/fa/d6/54cee7142cef7d910a324a7aedf335c0c147b03658b54d49ec48166f10a6/matplotlib-3.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:c55b20591ced744aa04e8c3e4b7543ea4d650b6c3c4b208c08a05b4010e8b442", size = 8039076 }, + { url = "https://files.pythonhosted.org/packages/43/14/815d072dc36e88753433bfd0385113405efb947e6895ff7b4d2e8614a33b/matplotlib-3.10.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ade1003376731a971e398cc4ef38bb83ee8caf0aee46ac6daa4b0506db1fd06", size = 8211000 }, + { url = "https://files.pythonhosted.org/packages/9a/76/34e75f364194ec352678adcb540964be6f35ec7d3d8c75ebcb17e6839359/matplotlib-3.10.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95b710fea129c76d30be72c3b38f330269363fbc6e570a5dd43580487380b5ff", size = 8087707 }, + { url = "https://files.pythonhosted.org/packages/c3/2b/b6bc0dff6a72d333bc7df94a66e6ce662d224e43daa8ad8ae4eaa9a77f55/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cdbaf909887373c3e094b0318d7ff230b2ad9dcb64da7ade654182872ab2593", size = 8477384 }, + { url = "https://files.pythonhosted.org/packages/c2/2d/b5949fb2b76e9b47ab05e25a5f5f887c70de20d8b0cbc704a4e2ee71c786/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d907fddb39f923d011875452ff1eca29a9e7f21722b873e90db32e5d8ddff12e", size = 8610334 }, + { url = "https://files.pythonhosted.org/packages/d6/9a/6e3c799d5134d9af44b01c787e1360bee38cf51850506ea2e743a787700b/matplotlib-3.10.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3b427392354d10975c1d0f4ee18aa5844640b512d5311ef32efd4dd7db106ede", size = 9406777 }, + { url = "https://files.pythonhosted.org/packages/0e/dd/e6ae97151e5ed648ab2ea48885bc33d39202b640eec7a2910e2c843f7ac0/matplotlib-3.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5fd41b0ec7ee45cd960a8e71aea7c946a28a0b8a4dcee47d2856b2af051f334c", size = 8109742 }, + { url = "https://files.pythonhosted.org/packages/32/5f/29def7ce4e815ab939b56280976ee35afffb3bbdb43f332caee74cb8c951/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:81713dd0d103b379de4516b861d964b1d789a144103277769238c732229d7f03", size = 8155500 }, + { url = "https://files.pythonhosted.org/packages/de/6d/d570383c9f7ca799d0a54161446f9ce7b17d6c50f2994b653514bcaa108f/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:359f87baedb1f836ce307f0e850d12bb5f1936f70d035561f90d41d305fdacea", size = 8032398 }, + { url = "https://files.pythonhosted.org/packages/c9/b4/680aa700d99b48e8c4393fa08e9ab8c49c0555ee6f4c9c0a5e8ea8dfde5d/matplotlib-3.10.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae80dc3a4add4665cf2faa90138384a7ffe2a4e37c58d83e115b54287c4f06ef", size = 8587361 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316 }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + +[[package]] +name = "mergedeep" +version = "1.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354 }, +] + +[[package]] +name = "mistune" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/f7/f6d06304c61c2a73213c0a4815280f70d985429cda26272f490e42119c1a/mistune-3.1.2.tar.gz", hash = "sha256:733bf018ba007e8b5f2d3a9eb624034f6ee26c4ea769a98ec533ee111d504dff", size = 94613 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/92/30b4e54c4d7c48c06db61595cffbbf4f19588ea177896f9b78f0fbe021fd/mistune-3.1.2-py3-none-any.whl", hash = "sha256:4b47731332315cdca99e0ded46fc0004001c1299ff773dfb48fbe1fd226de319", size = 53696 }, +] + +[[package]] +name = "mkdocs" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ghp-import" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mergedeep" }, + { name = "mkdocs-get-deps" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "pyyaml" }, + { name = "pyyaml-env-tag" }, + { name = "watchdog" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451 }, +] + +[[package]] +name = "mkdocs-autorefs" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mkdocs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/79/e846eb3323d1546b25d2ae4c957f5edf1bdfb7e0b695d43feae034c61553/mkdocs_autorefs-1.4.0.tar.gz", hash = "sha256:a9c0aa9c90edbce302c09d050a3c4cb7c76f8b7b2c98f84a7a05f53d00392156", size = 3128903 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/0e/a6ff5d3b3ac428fa8c43a356df449f366ff0dbe242dac9f87fa9d20515ed/mkdocs_autorefs-1.4.0-py3-none-any.whl", hash = "sha256:bad19f69655878d20194acd0162e29a89c3f7e6365ffe54e72aa3fd1072f240d", size = 4368332 }, +] + +[[package]] +name = "mkdocs-get-deps" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "mergedeep" }, + { name = "platformdirs" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521 }, +] + +[[package]] +name = "mkdocs-jupyter" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "jupytext" }, + { name = "mkdocs" }, + { name = "mkdocs-material" }, + { name = "nbconvert" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/23/6ffb8d2fd2117aa860a04c6fe2510b21bc3c3c085907ffdd851caba53152/mkdocs_jupyter-0.25.1.tar.gz", hash = "sha256:0e9272ff4947e0ec683c92423a4bfb42a26477c103ab1a6ab8277e2dcc8f7afe", size = 1626747 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/37/5f1fd5c3f6954b3256f8126275e62af493b96fb6aef6c0dbc4ee326032ad/mkdocs_jupyter-0.25.1-py3-none-any.whl", hash = "sha256:3f679a857609885d322880e72533ef5255561bbfdb13cfee2a1e92ef4d4ad8d8", size = 1456197 }, +] + +[[package]] +name = "mkdocs-material" +version = "9.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "colorama" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "mkdocs" }, + { name = "mkdocs-material-extensions" }, + { name = "paginate" }, + { name = "pygments" }, + { name = "pymdown-extensions" }, + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/4d/0a9f6f604f01eaa43df3b3b30b5218548efd7341913b302815585f48abb2/mkdocs_material-9.6.5.tar.gz", hash = "sha256:b714679a8c91b0ffe2188e11ed58c44d2523e9c2ae26a29cc652fa7478faa21f", size = 3946479 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/05/7d440b23454c0fc8cdba21f73ce23369eb16e7f7ee475fac3a4ad15ad5e0/mkdocs_material-9.6.5-py3-none-any.whl", hash = "sha256:aad3e6fb860c20870f75fb2a69ef901f1be727891e41adb60b753efcae19453b", size = 8695060 }, +] + +[[package]] +name = "mkdocs-material-extensions" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728 }, +] + +[[package]] +name = "mkdocstrings" +version = "0.28.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mkdocs" }, + { name = "mkdocs-autorefs" }, + { name = "mkdocs-get-deps" }, + { name = "pymdown-extensions" }, + { name = "typing-extensions", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e8/83/5eab81d31953c725942eb663b6a4cf36ad06d803633c8e1c6ddc708af62d/mkdocstrings-0.28.2.tar.gz", hash = "sha256:9b847266d7a588ea76a8385eaebe1538278b4361c0d1ce48ed005be59f053569", size = 5691916 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/60/15ef9759431cf8e60ffda7d5bba3914cc764f2bd8e7f62e1bd301ea292e0/mkdocstrings-0.28.2-py3-none-any.whl", hash = "sha256:57f79c557e2718d217d6f6a81bf75a0de097f10e922e7e5e00f085c3f0ff6895", size = 8056702 }, +] + +[package.optional-dependencies] +python = [ + { name = "mkdocstrings-python" }, +] + +[[package]] +name = "mkdocstrings-python" +version = "1.16.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "griffe" }, + { name = "mkdocs-autorefs" }, + { name = "mkdocstrings" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/a9/5990642e1bb2d90b049f655b92f46d0a77acb76ed59ef3233d5a6934312e/mkdocstrings_python-1.16.2.tar.gz", hash = "sha256:942ec1a2e0481d28f96f93be3d6e343cab92a21e5baf01c37dd2d7236c4d0bd7", size = 423492 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/a2/60be7e17a2f2a9d4bfb7273cdb2071eeeb65bdca5c0d07ff16df63221ca2/mkdocstrings_python-1.16.2-py3-none-any.whl", hash = "sha256:ff7e719404e59ad1a72f1afbe854769984c889b8fa043c160f6c988e1ad9e966", size = 449141 }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + +[[package]] +name = "notebook" +version = "7.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/04/ac488379d5afef43402b3fb4be2857db1a09804fecf98b9b714c741b225b/notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8", size = 12781804 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/9b/76e50ee18f183ea5fe1784a9eeaa50f2c71802e4740d6e959592b0993298/notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288", size = 13163630 }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307 }, +] + +[[package]] +name = "numba" +version = "0.60.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "llvmlite", version = "0.43.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/93/2849300a9184775ba274aba6f82f303343669b0592b7bb0849ea713dabb0/numba-0.60.0.tar.gz", hash = "sha256:5df6158e5584eece5fc83294b949fd30b9f1125df7708862205217e068aabf16", size = 2702171 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/cf/baa13a7e3556d73d9e38021e6d6aa4aeb30d8b94545aa8b70d0f24a1ccc4/numba-0.60.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5d761de835cd38fb400d2c26bb103a2726f548dc30368853121d66201672e651", size = 2647627 }, + { url = "https://files.pythonhosted.org/packages/ac/ba/4b57fa498564457c3cc9fc9e570a6b08e6086c74220f24baaf04e54b995f/numba-0.60.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:159e618ef213fba758837f9837fb402bbe65326e60ba0633dbe6c7f274d42c1b", size = 2650322 }, + { url = "https://files.pythonhosted.org/packages/28/98/7ea97ee75870a54f938a8c70f7e0be4495ba5349c5f9db09d467c4a5d5b7/numba-0.60.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1527dc578b95c7c4ff248792ec33d097ba6bef9eda466c948b68dfc995c25781", size = 3407390 }, + { url = "https://files.pythonhosted.org/packages/79/58/cb4ac5b8f7ec64200460aef1fed88258fb872ceef504ab1f989d2ff0f684/numba-0.60.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe0b28abb8d70f8160798f4de9d486143200f34458d34c4a214114e445d7124e", size = 3699694 }, + { url = "https://files.pythonhosted.org/packages/1c/b0/c61a93ca947d12233ff45de506ddbf52af3f752066a0b8be4d27426e16da/numba-0.60.0-cp310-cp310-win_amd64.whl", hash = "sha256:19407ced081d7e2e4b8d8c36aa57b7452e0283871c296e12d798852bc7d7f198", size = 2687030 }, + { url = "https://files.pythonhosted.org/packages/98/ad/df18d492a8f00d29a30db307904b9b296e37507034eedb523876f3a2e13e/numba-0.60.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a17b70fc9e380ee29c42717e8cc0bfaa5556c416d94f9aa96ba13acb41bdece8", size = 2647254 }, + { url = "https://files.pythonhosted.org/packages/9a/51/a4dc2c01ce7a850b8e56ff6d5381d047a5daea83d12bad08aa071d34b2ee/numba-0.60.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3fb02b344a2a80efa6f677aa5c40cd5dd452e1b35f8d1c2af0dfd9ada9978e4b", size = 2649970 }, + { url = "https://files.pythonhosted.org/packages/f9/4c/8889ac94c0b33dca80bed11564b8c6d9ea14d7f094e674c58e5c5b05859b/numba-0.60.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5f4fde652ea604ea3c86508a3fb31556a6157b2c76c8b51b1d45eb40c8598703", size = 3412492 }, + { url = "https://files.pythonhosted.org/packages/57/03/2b4245b05b71c0cee667e6a0b51606dfa7f4157c9093d71c6b208385a611/numba-0.60.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4142d7ac0210cc86432b818338a2bc368dc773a2f5cf1e32ff7c5b378bd63ee8", size = 3705018 }, + { url = "https://files.pythonhosted.org/packages/79/89/2d924ca60dbf949f18a6fec223a2445f5f428d9a5f97a6b29c2122319015/numba-0.60.0-cp311-cp311-win_amd64.whl", hash = "sha256:cac02c041e9b5bc8cf8f2034ff6f0dbafccd1ae9590dc146b3a02a45e53af4e2", size = 2686920 }, + { url = "https://files.pythonhosted.org/packages/eb/5c/b5ec752c475e78a6c3676b67c514220dbde2725896bbb0b6ec6ea54b2738/numba-0.60.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d7da4098db31182fc5ffe4bc42c6f24cd7d1cb8a14b59fd755bfee32e34b8404", size = 2647866 }, + { url = "https://files.pythonhosted.org/packages/65/42/39559664b2e7c15689a638c2a38b3b74c6e69a04e2b3019b9f7742479188/numba-0.60.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:38d6ea4c1f56417076ecf8fc327c831ae793282e0ff51080c5094cb726507b1c", size = 2650208 }, + { url = "https://files.pythonhosted.org/packages/67/88/c4459ccc05674ef02119abf2888ccd3e2fed12a323f52255f4982fc95876/numba-0.60.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:62908d29fb6a3229c242e981ca27e32a6e606cc253fc9e8faeb0e48760de241e", size = 3466946 }, + { url = "https://files.pythonhosted.org/packages/8b/41/ac11cf33524def12aa5bd698226ae196a1185831c05ed29dc0c56eaa308b/numba-0.60.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0ebaa91538e996f708f1ab30ef4d3ddc344b64b5227b67a57aa74f401bb68b9d", size = 3761463 }, + { url = "https://files.pythonhosted.org/packages/ca/bd/0fe29fcd1b6a8de479a4ed25c6e56470e467e3611c079d55869ceef2b6d1/numba-0.60.0-cp312-cp312-win_amd64.whl", hash = "sha256:f75262e8fe7fa96db1dca93d53a194a38c46da28b112b8a4aca168f0df860347", size = 2707588 }, + { url = "https://files.pythonhosted.org/packages/68/1a/87c53f836cdf557083248c3f47212271f220280ff766538795e77c8c6bbf/numba-0.60.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:01ef4cd7d83abe087d644eaa3d95831b777aa21d441a23703d649e06b8e06b74", size = 2647186 }, + { url = "https://files.pythonhosted.org/packages/28/14/a5baa1f2edea7b49afa4dc1bb1b126645198cf1075186853b5b497be826e/numba-0.60.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:819a3dfd4630d95fd574036f99e47212a1af41cbcb019bf8afac63ff56834449", size = 2650038 }, + { url = "https://files.pythonhosted.org/packages/3b/bd/f1985719ff34e37e07bb18f9d3acd17e5a21da255f550c8eae031e2ddf5f/numba-0.60.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0b983bd6ad82fe868493012487f34eae8bf7dd94654951404114f23c3466d34b", size = 3403010 }, + { url = "https://files.pythonhosted.org/packages/54/9b/cd73d3f6617ddc8398a63ef97d8dc9139a9879b9ca8a7ca4b8789056ea46/numba-0.60.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c151748cd269ddeab66334bd754817ffc0cabd9433acb0f551697e5151917d25", size = 3695086 }, + { url = "https://files.pythonhosted.org/packages/01/01/8b7b670c77c5ea0e47e283d82332969bf672ab6410d0b2610cac5b7a3ded/numba-0.60.0-cp39-cp39-win_amd64.whl", hash = "sha256:3031547a015710140e8c87226b4cfe927cac199835e5bf7d4fe5cb64e814e3ab", size = 2686978 }, +] + +[[package]] +name = "numba" +version = "0.61.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "llvmlite", version = "0.44.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/88/c13a935f200fda51384411e49840a8e7f70c9cb1ee8d809dd0f2477cf7ef/numba-0.61.0.tar.gz", hash = "sha256:888d2e89b8160899e19591467e8fdd4970e07606e1fbc248f239c89818d5f925", size = 2816484 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/97/8568a025b9ab8b4d53491e70d4206d5f3fc71fbe94f3097058e01ad8e7ff/numba-0.61.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:9cab9783a700fa428b1a54d65295122bc03b3de1d01fb819a6b9dbbddfdb8c43", size = 2769008 }, + { url = "https://files.pythonhosted.org/packages/8c/ab/a88c20755f66543ee01c85c98b866595b92e1bd0ed80565a4889e22929a8/numba-0.61.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:46c5ae094fb3706f5adf9021bfb7fc11e44818d61afee695cdee4eadfed45e98", size = 2771815 }, + { url = "https://files.pythonhosted.org/packages/ae/f4/b357913089ecec1a9ddc6adc04090396928f36a484a5ab9e71b24ddba4cd/numba-0.61.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6fb74e81aa78a2303e30593d8331327dfc0d2522b5db05ac967556a26db3ef87", size = 3820233 }, + { url = "https://files.pythonhosted.org/packages/ea/60/0e21bcf3baaf10e39d48cd224618e46a6b75d3394f465c37ce57bf98cbfa/numba-0.61.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:0ebbd4827091384ab8c4615ba1b3ca8bc639a3a000157d9c37ba85d34cd0da1b", size = 3514707 }, + { url = "https://files.pythonhosted.org/packages/a0/08/45c136ab59e6b11e61ce15a0d17ef03fd89eaccb0db05ad67912aaf5218a/numba-0.61.0-cp310-cp310-win_amd64.whl", hash = "sha256:43aa4d7d10c542d3c78106b8481e0cbaaec788c39ee8e3d7901682748ffdf0b4", size = 2827753 }, + { url = "https://files.pythonhosted.org/packages/63/8f/f983a7c859ccad73d3cc3f86fbba94f16e137cd1ee464631d61b624363b2/numba-0.61.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:bf64c2d0f3d161af603de3825172fb83c2600bcb1d53ae8ea568d4c53ba6ac08", size = 2768960 }, + { url = "https://files.pythonhosted.org/packages/be/1b/c33dc847d475d5b647b4ad5aefc38df7a72283763f4cda47745050375a81/numba-0.61.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:de5aa7904741425f28e1028b85850b31f0a245e9eb4f7c38507fb893283a066c", size = 2771862 }, + { url = "https://files.pythonhosted.org/packages/14/91/18b9f64b34ff318a14d072251480547f89ebfb864b2b7168e5dc5f64f502/numba-0.61.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21c2fe25019267a608e2710a6a947f557486b4b0478b02e45a81cf606a05a7d4", size = 3825411 }, + { url = "https://files.pythonhosted.org/packages/f2/97/1a38030c2a331e273ace1de2b61988e33d80878fda8a5eedee0cd78399d3/numba-0.61.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:74250b26ed6a1428763e774dc5b2d4e70d93f73795635b5412b8346a4d054574", size = 3519604 }, + { url = "https://files.pythonhosted.org/packages/df/a7/56f547de8fc197963f238fd62beb5f1d2cace047602d0577956bf6840970/numba-0.61.0-cp311-cp311-win_amd64.whl", hash = "sha256:b72bbc8708e98b3741ad0c63f9929c47b623cc4ee86e17030a4f3e301e8401ac", size = 2827642 }, + { url = "https://files.pythonhosted.org/packages/63/c9/c61881e7f2e253e745209f078bbd428ce23b6cf901f7d93afe166720ff95/numba-0.61.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:152146ecdbb8d8176f294e9f755411e6f270103a11c3ff50cecc413f794e52c8", size = 2769758 }, + { url = "https://files.pythonhosted.org/packages/e1/28/ddec0147a4933f86ceaca580aa9bb767d5632ecdb1ece6cfb3eab4ac78e5/numba-0.61.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5cafa6095716fcb081618c28a8d27bf7c001e09696f595b41836dec114be2905", size = 2772445 }, + { url = "https://files.pythonhosted.org/packages/18/74/6a9f0e6c76c088f8a6aa702eab31734068061dca5cc0f34e8bc1eb447de1/numba-0.61.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ffe9fe373ed30638d6e20a0269f817b2c75d447141f55a675bfcf2d1fe2e87fb", size = 3882115 }, + { url = "https://files.pythonhosted.org/packages/53/68/d7c31e53f08e6b4669c9b5a3cd7c5fb9097220c5ef388bc099ca8ab9749f/numba-0.61.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:9f25f7fef0206d55c1cfb796ad833cbbc044e2884751e56e798351280038484c", size = 3573296 }, + { url = "https://files.pythonhosted.org/packages/94/4f/8357a99a14f331b865a42cb4756ae37da85599b9c95e01277ea10361e91a/numba-0.61.0-cp312-cp312-win_amd64.whl", hash = "sha256:550d389573bc3b895e1ccb18289feea11d937011de4d278b09dc7ed585d1cdcb", size = 2828077 }, + { url = "https://files.pythonhosted.org/packages/3b/54/71fba18e4af5619f1ea8175ee92e82dd8e220bd6feb8c0153c6b814c8a60/numba-0.61.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:b96fafbdcf6f69b69855273e988696aae4974115a815f6818fef4af7afa1f6b8", size = 2768024 }, + { url = "https://files.pythonhosted.org/packages/39/76/2448b43d08e904aad1b1b9cd12835b19411e84a81aa9192f83642a5e0afd/numba-0.61.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f6c452dca1de8e60e593f7066df052dd8da09b243566ecd26d2b796e5d3087d", size = 2769541 }, + { url = "https://files.pythonhosted.org/packages/32/8f/4bb2374247ab988c9eac587b304b2947a36d605b9bb9ba4bf06e955c17d3/numba-0.61.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44240e694d4aa321430c97b21453e46014fe6c7b8b7d932afa7f6a88cc5d7e5e", size = 3890102 }, + { url = "https://files.pythonhosted.org/packages/ab/bc/dc2d03555289ae5263f65c01d45eb186ce347585c191daf0e60021d5ed39/numba-0.61.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:764f0e47004f126f58c3b28e0a02374c420a9d15157b90806d68590f5c20cc89", size = 3580239 }, + { url = "https://files.pythonhosted.org/packages/61/08/71247ce560d2c222d9ca705c7d3547fc4069b96fc85d71aabeb890befe9f/numba-0.61.0-cp313-cp313-win_amd64.whl", hash = "sha256:074cd38c5b1f9c65a4319d1f3928165f48975ef0537ad43385b2bd908e6e2e35", size = 2828035 }, +] + +[[package]] +name = "numexpr" +version = "2.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/67/c7415cf04ebe418193cfd6595ae03e3a64d76dac7b9c010098b39cc7992e/numexpr-2.10.2.tar.gz", hash = "sha256:b0aff6b48ebc99d2f54f27b5f73a58cb92fde650aeff1b397c71c8788b4fff1a", size = 106787 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/dc/bd84219318826d138b7e729ac3ffce3c706ab9d810ce74326a55c7252dd1/numexpr-2.10.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5b0e82d2109c1d9e63fcd5ea177d80a11b881157ab61178ddbdebd4c561ea46", size = 145011 }, + { url = "https://files.pythonhosted.org/packages/31/6a/b1f08141283327478a57490c0ab3f26a634d4741ff33b9e22f760a7cedb0/numexpr-2.10.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3fc2b8035a0c2cdc352e58c3875cb668836018065cbf5752cb531015d9a568d8", size = 134777 }, + { url = "https://files.pythonhosted.org/packages/7c/d6/6641864b0446ce472330de7644c78f90bd7e55d902046b44161f92721279/numexpr-2.10.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0db5ff5183935d1612653559c319922143e8fa3019007696571b13135f216458", size = 408893 }, + { url = "https://files.pythonhosted.org/packages/25/ab/cb5809cb1f66431632d63dc028c58cb91492725c74dddc4b97ba62e88a92/numexpr-2.10.2-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f59655458056fdb3a621b1bb8e071581ccf7e823916c7568bb7c9a3e393025", size = 397305 }, + { url = "https://files.pythonhosted.org/packages/9c/a0/29bcb31a9debb743e3dc46bacd55f4f6ee6a77d95eda5c8dca19a29c0627/numexpr-2.10.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ce8cccf944339051e44a49a124a06287fe3066d0acbff33d1aa5aee10a96abb7", size = 1378789 }, + { url = "https://files.pythonhosted.org/packages/cc/72/415262a7bdda706c41bf8254311a5ca13d3b8532341ab478be4583d7061a/numexpr-2.10.2-cp310-cp310-win32.whl", hash = "sha256:ba85371c9a8d03e115f4dfb6d25dfbce05387002b9bc85016af939a1da9624f0", size = 151935 }, + { url = "https://files.pythonhosted.org/packages/71/fa/0124f0c2a502a0bac4553c8a171c551f154cf80a83a15e40d30c43e48a7e/numexpr-2.10.2-cp310-cp310-win_amd64.whl", hash = "sha256:deb64235af9eeba59fcefa67e82fa80cfc0662e1b0aa373b7118a28da124d51d", size = 144961 }, + { url = "https://files.pythonhosted.org/packages/de/b7/f25d6166f92ef23737c1c90416144492a664f0a56510d90f7c6577c2cd14/numexpr-2.10.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6b360eb8d392483410fe6a3d5a7144afa298c9a0aa3e9fe193e89590b47dd477", size = 145055 }, + { url = "https://files.pythonhosted.org/packages/66/64/428361ea6415826332f38ef2dd5c3abf4e7e601f033bfc9be68b680cb765/numexpr-2.10.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9a42f5c24880350d88933c4efee91b857c378aaea7e8b86221fff569069841e", size = 134743 }, + { url = "https://files.pythonhosted.org/packages/3f/fb/639ec91d2ea7b4a5d66e26e8ef8e06b020c8e9b9ebaf3bab7b0a9bee472e/numexpr-2.10.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83fcb11988b57cc25b028a36d285287d706d1f536ebf2662ea30bd990e0de8b9", size = 410397 }, + { url = "https://files.pythonhosted.org/packages/89/5a/0f5c5b8a3a6d34eeecb30d0e2f722d50b9b38c0e175937e7c6268ffab997/numexpr-2.10.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4213a92efa9770bc28e3792134e27c7e5c7e97068bdfb8ba395baebbd12f991b", size = 398902 }, + { url = "https://files.pythonhosted.org/packages/a2/d5/ec734e735eba5a753efed5be3707ee7447ebd371772f8081b65a4153fb97/numexpr-2.10.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebdbef5763ca057eea0c2b5698e4439d084a0505d9d6e94f4804f26e8890c45e", size = 1380354 }, + { url = "https://files.pythonhosted.org/packages/30/51/406e572531d817480bd612ee08239a36ee82865fea02fce569f15631f4ee/numexpr-2.10.2-cp311-cp311-win32.whl", hash = "sha256:3bf01ec502d89944e49e9c1b5cc7c7085be8ca2eb9dd46a0eafd218afbdbd5f5", size = 151938 }, + { url = "https://files.pythonhosted.org/packages/04/32/5882ed1dbd96234f327a73316a481add151ff827cfaf2ea24fb4d5ad04db/numexpr-2.10.2-cp311-cp311-win_amd64.whl", hash = "sha256:e2d0ae24b0728e4bc3f1d3f33310340d67321d36d6043f7ce26897f4f1042db0", size = 144961 }, + { url = "https://files.pythonhosted.org/packages/2b/96/d5053dea06d8298ae8052b4b049cbf8ef74998e28d57166cc27b8ae909e2/numexpr-2.10.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5323a46e75832334f1af86da1ef6ff0add00fbacdd266250be872b438bdf2be", size = 145029 }, + { url = "https://files.pythonhosted.org/packages/3e/3c/fcd5a812ed5dda757b2d9ef2764a3e1cca6f6d1f02dbf113dc23a2c7702a/numexpr-2.10.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a42963bd4c62d8afa4f51e7974debfa39a048383f653544ab54f50a2f7ec6c42", size = 134851 }, + { url = "https://files.pythonhosted.org/packages/0a/52/0ed3b306d8c9944129bce97fec73a2caff13adbd7e1df148d546d7eb2d4d/numexpr-2.10.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5191ba8f2975cb9703afc04ae845a929e193498c0e8bcd408ecb147b35978470", size = 411837 }, + { url = "https://files.pythonhosted.org/packages/7d/9c/6b671dd3fb67d7e7da93cb76b7c5277743f310a216b7856bb18776bb3371/numexpr-2.10.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97298b14f0105a794bea06fd9fbc5c423bd3ff4d88cbc618860b83eb7a436ad6", size = 400577 }, + { url = "https://files.pythonhosted.org/packages/ea/4d/a167d1a215fe10ce58c45109f2869fd13aa0eef66f7e8c69af68be45d436/numexpr-2.10.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9d7805ccb6be2d3b0f7f6fad3707a09ac537811e8e9964f4074d28cb35543db", size = 1381735 }, + { url = "https://files.pythonhosted.org/packages/c1/d4/17e4434f989e4917d31cbd88a043e1c9c16958149cf43fa622987111392b/numexpr-2.10.2-cp312-cp312-win32.whl", hash = "sha256:cb845b2d4f9f8ef0eb1c9884f2b64780a85d3b5ae4eeb26ae2b0019f489cd35e", size = 152102 }, + { url = "https://files.pythonhosted.org/packages/b8/25/9ae599994076ef2a42d35ff6b0430da002647f212567851336a6c7b132d6/numexpr-2.10.2-cp312-cp312-win_amd64.whl", hash = "sha256:57b59cbb5dcce4edf09cd6ce0b57ff60312479930099ca8d944c2fac896a1ead", size = 145061 }, + { url = "https://files.pythonhosted.org/packages/8c/cb/2ea1848c46e4d75073c038dd75628d1aa442975303264ed230bf90f74f44/numexpr-2.10.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a37d6a51ec328c561b2ca8a2bef07025642eca995b8553a5267d0018c732976d", size = 145035 }, + { url = "https://files.pythonhosted.org/packages/ec/cf/bb2bcd81d6f3243590e19ac3e7795a1a370f3ebcd8ecec1f46dcd5333f37/numexpr-2.10.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:81d1dde7dd6166d8ff5727bb46ab42a6b0048db0e97ceb84a121334a404a800f", size = 134858 }, + { url = "https://files.pythonhosted.org/packages/48/9b/c9128ffb453205c2a4c84a3abed35447c7591c2c2812e77e34fd238cb2bb/numexpr-2.10.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3f814437d5a10797f8d89d2037cca2c9d9fa578520fc911f894edafed6ea3e", size = 415517 }, + { url = "https://files.pythonhosted.org/packages/7e/b0/64c04c9f8b4a563218d00daa1ec4563364961b79025162c5276ab2c7c407/numexpr-2.10.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9309f2e43fe6e4560699ef5c27d7a848b3ff38549b6b57194207cf0e88900527", size = 403846 }, + { url = "https://files.pythonhosted.org/packages/80/35/60e9041fd709fe98dd3109d73a03cdffaeb6ee2089179155f5c3754e9934/numexpr-2.10.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ebb73b93f5c4d6994f357fa5a47a9f7a5485577e633b3c46a603cb01445bbb19", size = 1381659 }, + { url = "https://files.pythonhosted.org/packages/bd/5a/955bf5b5cf8f3de7b044a999e36327e14191fa073ed0e329456ed0f8161d/numexpr-2.10.2-cp313-cp313-win32.whl", hash = "sha256:ec04c9a3c050c175348801e27c18c68d28673b7bfb865ef88ce333be523bbc01", size = 152105 }, + { url = "https://files.pythonhosted.org/packages/be/7a/8ce360a1848bb5bcc30a414493371678f43790ece397f8652d5f65757e57/numexpr-2.10.2-cp313-cp313-win_amd64.whl", hash = "sha256:d7a3fc83c959288544db3adc70612475d8ad53a66c69198105c74036182d10dd", size = 145060 }, + { url = "https://files.pythonhosted.org/packages/41/6a/06a225ac970c5921f41bc069a30438ff64fd79ef5e828f5ec2d4f6658307/numexpr-2.10.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0495f8111c3633e265248709b8b3b521bbfa646ba384909edd10e2b9a588a83a", size = 145100 }, + { url = "https://files.pythonhosted.org/packages/bb/c5/9ecfa0da1d93d57e3f447d10da8cf6d695c93131cec085625e5092b37631/numexpr-2.10.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2aa05ac71bee3b1253e73173c4d7fa96a09a18970c0226f1c2c07a71ffe988dc", size = 134839 }, + { url = "https://files.pythonhosted.org/packages/f5/30/f1a48c485183da517bd28e0df6fee337d12bbb0cd2d6bf13f8f5695afd37/numexpr-2.10.2-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3a23c3002ab330056fbdd2785871937a6f2f2fa85d06c8d0ff74ea8418119d1", size = 408149 }, + { url = "https://files.pythonhosted.org/packages/ed/f2/009d9dd8cd22f253fd6ead4165f81fafbe22489c1cfea612e18aa3dcb0fa/numexpr-2.10.2-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a018a7d81326f4c73d8b5aee61794d7d8514512f43957c0db61eb2a8a86848c7", size = 396740 }, + { url = "https://files.pythonhosted.org/packages/47/90/e3f12670b3cca9bed85096671265e0f65cde6cf4646baadd4ee9c33944a8/numexpr-2.10.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:037859b17a0abe2b489d4c2cfdadd2bf458ec80dd83f338ea5544c7987e06b85", size = 1377883 }, + { url = "https://files.pythonhosted.org/packages/06/1d/068c09a3c013c1178495f73a21ebd6ee25b9f0fc4202cea38b7a826c43a2/numexpr-2.10.2-cp39-cp39-win32.whl", hash = "sha256:eb278ccda6f893a312aa0452701bb17d098b7b14eb7c9381517d509cce0a39a3", size = 151878 }, + { url = "https://files.pythonhosted.org/packages/70/81/affb9ff26e8accb210fe5585b095bd6872f5614d18b76cd53888e955ed9a/numexpr-2.10.2-cp39-cp39-win_amd64.whl", hash = "sha256:734b64c6d6a597601ce9d0ef7b666e678ec015b446f1d1412c23903c021436c3", size = 144960 }, +] + +[[package]] +name = "numpy" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 }, + { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 }, + { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 }, + { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 }, + { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 }, + { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 }, + { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 }, + { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 }, + { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 }, + { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 }, + { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 }, + { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 }, + { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 }, + { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 }, + { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 }, + { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 }, + { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 }, + { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 }, + { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 }, + { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 }, + { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 }, + { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 }, + { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 }, + { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 }, + { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 }, + { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 }, + { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 }, + { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 }, + { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 }, + { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 }, + { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 }, + { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 }, + { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 }, + { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 }, + { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 }, + { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 }, + { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 }, + { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 }, + { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 }, + { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 }, + { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 }, + { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 }, + { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 }, +] + +[[package]] +name = "numpy" +version = "2.1.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/25/ca/1166b75c21abd1da445b97bf1fa2f14f423c6cfb4fc7c4ef31dccf9f6a94/numpy-2.1.3.tar.gz", hash = "sha256:aa08e04e08aaf974d4458def539dece0d28146d866a39da5639596f4921fd761", size = 20166090 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/80/d572a4737626372915bca41c3afbfec9d173561a39a0a61bacbbfd1dafd4/numpy-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c894b4305373b9c5576d7a12b473702afdf48ce5369c074ba304cc5ad8730dff", size = 21152472 }, + { url = "https://files.pythonhosted.org/packages/6f/bb/7bfba10c791ae3bb6716da77ad85a82d5fac07fc96fb0023ef0571df9d20/numpy-2.1.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b47fbb433d3260adcd51eb54f92a2ffbc90a4595f8970ee00e064c644ac788f5", size = 13747967 }, + { url = "https://files.pythonhosted.org/packages/da/d6/2df7bde35f0478455f0be5934877b3e5a505f587b00230f54a519a6b55a5/numpy-2.1.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:825656d0743699c529c5943554d223c021ff0494ff1442152ce887ef4f7561a1", size = 5354921 }, + { url = "https://files.pythonhosted.org/packages/d1/bb/75b945874f931494891eac6ca06a1764d0e8208791f3addadb2963b83527/numpy-2.1.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:6a4825252fcc430a182ac4dee5a505053d262c807f8a924603d411f6718b88fd", size = 6888603 }, + { url = "https://files.pythonhosted.org/packages/68/a7/fde73636f6498dbfa6d82fc336164635fe592f1ad0d13285fcb6267fdc1c/numpy-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e711e02f49e176a01d0349d82cb5f05ba4db7d5e7e0defd026328e5cfb3226d3", size = 13889862 }, + { url = "https://files.pythonhosted.org/packages/05/db/5d9c91b2e1e2e72be1369278f696356d44975befcae830daf2e667dcb54f/numpy-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78574ac2d1a4a02421f25da9559850d59457bac82f2b8d7a44fe83a64f770098", size = 16328151 }, + { url = "https://files.pythonhosted.org/packages/3e/6a/7eb732109b53ae64a29e25d7e68eb9d6611037f6354875497008a49e74d3/numpy-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c7662f0e3673fe4e832fe07b65c50342ea27d989f92c80355658c7f888fcc83c", size = 16704107 }, + { url = "https://files.pythonhosted.org/packages/88/cc/278113b66a1141053cbda6f80e4200c6da06b3079c2d27bda1fde41f2c1f/numpy-2.1.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fa2d1337dc61c8dc417fbccf20f6d1e139896a30721b7f1e832b2bb6ef4eb6c4", size = 14385789 }, + { url = "https://files.pythonhosted.org/packages/f5/69/eb20f5e1bfa07449bc67574d2f0f7c1e6b335fb41672e43861a7727d85f2/numpy-2.1.3-cp310-cp310-win32.whl", hash = "sha256:72dcc4a35a8515d83e76b58fdf8113a5c969ccd505c8a946759b24e3182d1f23", size = 6536706 }, + { url = "https://files.pythonhosted.org/packages/8e/8b/1c131ab5a94c1086c289c6e1da1d843de9dbd95fe5f5ee6e61904c9518e2/numpy-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:ecc76a9ba2911d8d37ac01de72834d8849e55473457558e12995f4cd53e778e0", size = 12864165 }, + { url = "https://files.pythonhosted.org/packages/ad/81/c8167192eba5247593cd9d305ac236847c2912ff39e11402e72ae28a4985/numpy-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4d1167c53b93f1f5d8a139a742b3c6f4d429b54e74e6b57d0eff40045187b15d", size = 21156252 }, + { url = "https://files.pythonhosted.org/packages/da/74/5a60003fc3d8a718d830b08b654d0eea2d2db0806bab8f3c2aca7e18e010/numpy-2.1.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c80e4a09b3d95b4e1cac08643f1152fa71a0a821a2d4277334c88d54b2219a41", size = 13784119 }, + { url = "https://files.pythonhosted.org/packages/47/7c/864cb966b96fce5e63fcf25e1e4d957fe5725a635e5f11fe03f39dd9d6b5/numpy-2.1.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:576a1c1d25e9e02ed7fa5477f30a127fe56debd53b8d2c89d5578f9857d03ca9", size = 5352978 }, + { url = "https://files.pythonhosted.org/packages/09/ac/61d07930a4993dd9691a6432de16d93bbe6aa4b1c12a5e573d468eefc1ca/numpy-2.1.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:973faafebaae4c0aaa1a1ca1ce02434554d67e628b8d805e61f874b84e136b09", size = 6892570 }, + { url = "https://files.pythonhosted.org/packages/27/2f/21b94664f23af2bb52030653697c685022119e0dc93d6097c3cb45bce5f9/numpy-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:762479be47a4863e261a840e8e01608d124ee1361e48b96916f38b119cfda04a", size = 13896715 }, + { url = "https://files.pythonhosted.org/packages/7a/f0/80811e836484262b236c684a75dfc4ba0424bc670e765afaa911468d9f39/numpy-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc6f24b3d1ecc1eebfbf5d6051faa49af40b03be1aaa781ebdadcbc090b4539b", size = 16339644 }, + { url = "https://files.pythonhosted.org/packages/fa/81/ce213159a1ed8eb7d88a2a6ef4fbdb9e4ffd0c76b866c350eb4e3c37e640/numpy-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:17ee83a1f4fef3c94d16dc1802b998668b5419362c8a4f4e8a491de1b41cc3ee", size = 16712217 }, + { url = "https://files.pythonhosted.org/packages/7d/84/4de0b87d5a72f45556b2a8ee9fc8801e8518ec867fc68260c1f5dcb3903f/numpy-2.1.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15cb89f39fa6d0bdfb600ea24b250e5f1a3df23f901f51c8debaa6a5d122b2f0", size = 14399053 }, + { url = "https://files.pythonhosted.org/packages/7e/1c/e5fabb9ad849f9d798b44458fd12a318d27592d4bc1448e269dec070ff04/numpy-2.1.3-cp311-cp311-win32.whl", hash = "sha256:d9beb777a78c331580705326d2367488d5bc473b49a9bc3036c154832520aca9", size = 6534741 }, + { url = "https://files.pythonhosted.org/packages/1e/48/a9a4b538e28f854bfb62e1dea3c8fea12e90216a276c7777ae5345ff29a7/numpy-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:d89dd2b6da69c4fff5e39c28a382199ddedc3a5be5390115608345dec660b9e2", size = 12869487 }, + { url = "https://files.pythonhosted.org/packages/8a/f0/385eb9970309643cbca4fc6eebc8bb16e560de129c91258dfaa18498da8b/numpy-2.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f55ba01150f52b1027829b50d70ef1dafd9821ea82905b63936668403c3b471e", size = 20849658 }, + { url = "https://files.pythonhosted.org/packages/54/4a/765b4607f0fecbb239638d610d04ec0a0ded9b4951c56dc68cef79026abf/numpy-2.1.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13138eadd4f4da03074851a698ffa7e405f41a0845a6b1ad135b81596e4e9958", size = 13492258 }, + { url = "https://files.pythonhosted.org/packages/bd/a7/2332679479c70b68dccbf4a8eb9c9b5ee383164b161bee9284ac141fbd33/numpy-2.1.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a6b46587b14b888e95e4a24d7b13ae91fa22386c199ee7b418f449032b2fa3b8", size = 5090249 }, + { url = "https://files.pythonhosted.org/packages/c1/67/4aa00316b3b981a822c7a239d3a8135be2a6945d1fd11d0efb25d361711a/numpy-2.1.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:0fa14563cc46422e99daef53d725d0c326e99e468a9320a240affffe87852564", size = 6621704 }, + { url = "https://files.pythonhosted.org/packages/5e/da/1a429ae58b3b6c364eeec93bf044c532f2ff7b48a52e41050896cf15d5b1/numpy-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8637dcd2caa676e475503d1f8fdb327bc495554e10838019651b76d17b98e512", size = 13606089 }, + { url = "https://files.pythonhosted.org/packages/9e/3e/3757f304c704f2f0294a6b8340fcf2be244038be07da4cccf390fa678a9f/numpy-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2312b2aa89e1f43ecea6da6ea9a810d06aae08321609d8dc0d0eda6d946a541b", size = 16043185 }, + { url = "https://files.pythonhosted.org/packages/43/97/75329c28fea3113d00c8d2daf9bc5828d58d78ed661d8e05e234f86f0f6d/numpy-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a38c19106902bb19351b83802531fea19dee18e5b37b36454f27f11ff956f7fc", size = 16410751 }, + { url = "https://files.pythonhosted.org/packages/ad/7a/442965e98b34e0ae9da319f075b387bcb9a1e0658276cc63adb8c9686f7b/numpy-2.1.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02135ade8b8a84011cbb67dc44e07c58f28575cf9ecf8ab304e51c05528c19f0", size = 14082705 }, + { url = "https://files.pythonhosted.org/packages/ac/b6/26108cf2cfa5c7e03fb969b595c93131eab4a399762b51ce9ebec2332e80/numpy-2.1.3-cp312-cp312-win32.whl", hash = "sha256:e6988e90fcf617da2b5c78902fe8e668361b43b4fe26dbf2d7b0f8034d4cafb9", size = 6239077 }, + { url = "https://files.pythonhosted.org/packages/a6/84/fa11dad3404b7634aaab50733581ce11e5350383311ea7a7010f464c0170/numpy-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:0d30c543f02e84e92c4b1f415b7c6b5326cbe45ee7882b6b77db7195fb971e3a", size = 12566858 }, + { url = "https://files.pythonhosted.org/packages/4d/0b/620591441457e25f3404c8057eb924d04f161244cb8a3680d529419aa86e/numpy-2.1.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96fe52fcdb9345b7cd82ecd34547fca4321f7656d500eca497eb7ea5a926692f", size = 20836263 }, + { url = "https://files.pythonhosted.org/packages/45/e1/210b2d8b31ce9119145433e6ea78046e30771de3fe353f313b2778142f34/numpy-2.1.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f653490b33e9c3a4c1c01d41bc2aef08f9475af51146e4a7710c450cf9761598", size = 13507771 }, + { url = "https://files.pythonhosted.org/packages/55/44/aa9ee3caee02fa5a45f2c3b95cafe59c44e4b278fbbf895a93e88b308555/numpy-2.1.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:dc258a761a16daa791081d026f0ed4399b582712e6fc887a95af09df10c5ca57", size = 5075805 }, + { url = "https://files.pythonhosted.org/packages/78/d6/61de6e7e31915ba4d87bbe1ae859e83e6582ea14c6add07c8f7eefd8488f/numpy-2.1.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:016d0f6f5e77b0f0d45d77387ffa4bb89816b57c835580c3ce8e099ef830befe", size = 6608380 }, + { url = "https://files.pythonhosted.org/packages/3e/46/48bdf9b7241e317e6cf94276fe11ba673c06d1fdf115d8b4ebf616affd1a/numpy-2.1.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c181ba05ce8299c7aa3125c27b9c2167bca4a4445b7ce73d5febc411ca692e43", size = 13602451 }, + { url = "https://files.pythonhosted.org/packages/70/50/73f9a5aa0810cdccda9c1d20be3cbe4a4d6ea6bfd6931464a44c95eef731/numpy-2.1.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5641516794ca9e5f8a4d17bb45446998c6554704d888f86df9b200e66bdcce56", size = 16039822 }, + { url = "https://files.pythonhosted.org/packages/ad/cd/098bc1d5a5bc5307cfc65ee9369d0ca658ed88fbd7307b0d49fab6ca5fa5/numpy-2.1.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ea4dedd6e394a9c180b33c2c872b92f7ce0f8e7ad93e9585312b0c5a04777a4a", size = 16411822 }, + { url = "https://files.pythonhosted.org/packages/83/a2/7d4467a2a6d984549053b37945620209e702cf96a8bc658bc04bba13c9e2/numpy-2.1.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0df3635b9c8ef48bd3be5f862cf71b0a4716fa0e702155c45067c6b711ddcef", size = 14079598 }, + { url = "https://files.pythonhosted.org/packages/e9/6a/d64514dcecb2ee70bfdfad10c42b76cab657e7ee31944ff7a600f141d9e9/numpy-2.1.3-cp313-cp313-win32.whl", hash = "sha256:50ca6aba6e163363f132b5c101ba078b8cbd3fa92c7865fd7d4d62d9779ac29f", size = 6236021 }, + { url = "https://files.pythonhosted.org/packages/bb/f9/12297ed8d8301a401e7d8eb6b418d32547f1d700ed3c038d325a605421a4/numpy-2.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:747641635d3d44bcb380d950679462fae44f54b131be347d5ec2bce47d3df9ed", size = 12560405 }, + { url = "https://files.pythonhosted.org/packages/a7/45/7f9244cd792e163b334e3a7f02dff1239d2890b6f37ebf9e82cbe17debc0/numpy-2.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:996bb9399059c5b82f76b53ff8bb686069c05acc94656bb259b1d63d04a9506f", size = 20859062 }, + { url = "https://files.pythonhosted.org/packages/b1/b4/a084218e7e92b506d634105b13e27a3a6645312b93e1c699cc9025adb0e1/numpy-2.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:45966d859916ad02b779706bb43b954281db43e185015df6eb3323120188f9e4", size = 13515839 }, + { url = "https://files.pythonhosted.org/packages/27/45/58ed3f88028dcf80e6ea580311dc3edefdd94248f5770deb980500ef85dd/numpy-2.1.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:baed7e8d7481bfe0874b566850cb0b85243e982388b7b23348c6db2ee2b2ae8e", size = 5116031 }, + { url = "https://files.pythonhosted.org/packages/37/a8/eb689432eb977d83229094b58b0f53249d2209742f7de529c49d61a124a0/numpy-2.1.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a9f7f672a3388133335589cfca93ed468509cb7b93ba3105fce780d04a6576a0", size = 6629977 }, + { url = "https://files.pythonhosted.org/packages/42/a3/5355ad51ac73c23334c7caaed01adadfda49544f646fcbfbb4331deb267b/numpy-2.1.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7aac50327da5d208db2eec22eb11e491e3fe13d22653dce51b0f4109101b408", size = 13575951 }, + { url = "https://files.pythonhosted.org/packages/c4/70/ea9646d203104e647988cb7d7279f135257a6b7e3354ea6c56f8bafdb095/numpy-2.1.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4394bc0dbd074b7f9b52024832d16e019decebf86caf909d94f6b3f77a8ee3b6", size = 16022655 }, + { url = "https://files.pythonhosted.org/packages/14/ce/7fc0612903e91ff9d0b3f2eda4e18ef9904814afcae5b0f08edb7f637883/numpy-2.1.3-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:50d18c4358a0a8a53f12a8ba9d772ab2d460321e6a93d6064fc22443d189853f", size = 16399902 }, + { url = "https://files.pythonhosted.org/packages/ef/62/1d3204313357591c913c32132a28f09a26357e33ea3c4e2fe81269e0dca1/numpy-2.1.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:14e253bd43fc6b37af4921b10f6add6925878a42a0c5fe83daee390bca80bc17", size = 14067180 }, + { url = "https://files.pythonhosted.org/packages/24/d7/78a40ed1d80e23a774cb8a34ae8a9493ba1b4271dde96e56ccdbab1620ef/numpy-2.1.3-cp313-cp313t-win32.whl", hash = "sha256:08788d27a5fd867a663f6fc753fd7c3ad7e92747efc73c53bca2f19f8bc06f48", size = 6291907 }, + { url = "https://files.pythonhosted.org/packages/86/09/a5ab407bd7f5f5599e6a9261f964ace03a73e7c6928de906981c31c38082/numpy-2.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2564fbdf2b99b3f815f2107c1bbc93e2de8ee655a69c261363a1172a79a257d4", size = 12644098 }, + { url = "https://files.pythonhosted.org/packages/00/e7/8d8bb791b62586cc432ecbb70632b4f23b7b7c88df41878de7528264f6d7/numpy-2.1.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4f2015dfe437dfebbfce7c85c7b53d81ba49e71ba7eadbf1df40c915af75979f", size = 20983893 }, + { url = "https://files.pythonhosted.org/packages/5e/f3/cb8118a044b5007586245a650360c9f5915b2f4232dd7658bb7a63dd1d02/numpy-2.1.3-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3522b0dfe983a575e6a9ab3a4a4dfe156c3e428468ff08ce582b9bb6bd1d71d4", size = 6752501 }, + { url = "https://files.pythonhosted.org/packages/53/f5/365b46439b518d2ec6ebb880cc0edf90f225145dfd4db7958334f7164530/numpy-2.1.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c006b607a865b07cd981ccb218a04fc86b600411d83d6fc261357f1c0966755d", size = 16142601 }, + { url = "https://files.pythonhosted.org/packages/03/c2/d1fee6ba999aa7cd41ca6856937f2baaf604c3eec1565eae63451ec31e5e/numpy-2.1.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e14e26956e6f1696070788252dcdff11b4aca4c3e8bd166e0df1bb8f315a67cb", size = 12771397 }, +] + +[[package]] +name = "odfpy" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "defusedxml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/97/73/8ade73f6749177003f7ce3304f524774adda96e6aaab30ea79fd8fda7934/odfpy-1.4.1.tar.gz", hash = "sha256:db766a6e59c5103212f3cc92ec8dd50a0f3a02790233ed0b52148b70d3c438ec", size = 717045 } + +[[package]] +name = "openpyxl" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "et-xmlfile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910 }, +] + +[[package]] +name = "overrides" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "paginate" +version = "0.5.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746 }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, + { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535 }, + { url = "https://files.pythonhosted.org/packages/9c/b9/5cead4f63b6d31bdefeb21a679bc5a7f4aaf262ca7e07e2bc1c341b68470/pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30", size = 11319822 }, + { url = "https://files.pythonhosted.org/packages/31/af/89e35619fb573366fa68dc26dad6ad2c08c17b8004aad6d98f1a31ce4bb3/pandas-2.2.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8cd6d7cc958a3910f934ea8dbdf17b2364827bb4dafc38ce6eef6bb3d65ff09c", size = 15625439 }, + { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928 }, + { url = "https://files.pythonhosted.org/packages/31/a3/18508e10a31ea108d746c848b5a05c0711e0278fa0d6f1c52a8ec52b80a5/pandas-2.2.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31d0ced62d4ea3e231a9f228366919a5ea0b07440d9d4dac345376fd8e1477ea", size = 16783266 }, + { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871 }, + { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011 }, +] + +[package.optional-dependencies] +excel = [ + { name = "odfpy" }, + { name = "openpyxl" }, + { name = "python-calamine" }, + { name = "pyxlsb" }, + { name = "xlrd" }, + { name = "xlsxwriter" }, +] +performance = [ + { name = "bottleneck" }, + { name = "numba", version = "0.60.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numba", version = "0.61.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numexpr" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + +[[package]] +name = "pillow" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/c097e544e7bd278333db77933e535098c259609c4eb3b85381109602fb5b/pillow-11.1.0.tar.gz", hash = "sha256:368da70808b36d73b4b390a8ffac11069f8a5c85f29eff1f1b01bcf3ef5b2a20", size = 46742715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/1c/2dcea34ac3d7bc96a1fd1bd0a6e06a57c67167fec2cff8d95d88229a8817/pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8", size = 3229983 }, + { url = "https://files.pythonhosted.org/packages/14/ca/6bec3df25e4c88432681de94a3531cc738bd85dea6c7aa6ab6f81ad8bd11/pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192", size = 3101831 }, + { url = "https://files.pythonhosted.org/packages/d4/2c/668e18e5521e46eb9667b09e501d8e07049eb5bfe39d56be0724a43117e6/pillow-11.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a07dba04c5e22824816b2615ad7a7484432d7f540e6fa86af60d2de57b0fcee2", size = 4314074 }, + { url = "https://files.pythonhosted.org/packages/02/80/79f99b714f0fc25f6a8499ecfd1f810df12aec170ea1e32a4f75746051ce/pillow-11.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e267b0ed063341f3e60acd25c05200df4193e15a4a5807075cd71225a2386e26", size = 4394933 }, + { url = "https://files.pythonhosted.org/packages/81/aa/8d4ad25dc11fd10a2001d5b8a80fdc0e564ac33b293bdfe04ed387e0fd95/pillow-11.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:bd165131fd51697e22421d0e467997ad31621b74bfc0b75956608cb2906dda07", size = 4353349 }, + { url = "https://files.pythonhosted.org/packages/84/7a/cd0c3eaf4a28cb2a74bdd19129f7726277a7f30c4f8424cd27a62987d864/pillow-11.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:abc56501c3fd148d60659aae0af6ddc149660469082859fa7b066a298bde9482", size = 4476532 }, + { url = "https://files.pythonhosted.org/packages/8f/8b/a907fdd3ae8f01c7670dfb1499c53c28e217c338b47a813af8d815e7ce97/pillow-11.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:54ce1c9a16a9561b6d6d8cb30089ab1e5eb66918cb47d457bd996ef34182922e", size = 4279789 }, + { url = "https://files.pythonhosted.org/packages/6f/9a/9f139d9e8cccd661c3efbf6898967a9a337eb2e9be2b454ba0a09533100d/pillow-11.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:73ddde795ee9b06257dac5ad42fcb07f3b9b813f8c1f7f870f402f4dc54b5269", size = 4413131 }, + { url = "https://files.pythonhosted.org/packages/a8/68/0d8d461f42a3f37432203c8e6df94da10ac8081b6d35af1c203bf3111088/pillow-11.1.0-cp310-cp310-win32.whl", hash = "sha256:3a5fe20a7b66e8135d7fd617b13272626a28278d0e578c98720d9ba4b2439d49", size = 2291213 }, + { url = "https://files.pythonhosted.org/packages/14/81/d0dff759a74ba87715509af9f6cb21fa21d93b02b3316ed43bda83664db9/pillow-11.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:b6123aa4a59d75f06e9dd3dac5bf8bc9aa383121bb3dd9a7a612e05eabc9961a", size = 2625725 }, + { url = "https://files.pythonhosted.org/packages/ce/1f/8d50c096a1d58ef0584ddc37e6f602828515219e9d2428e14ce50f5ecad1/pillow-11.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:a76da0a31da6fcae4210aa94fd779c65c75786bc9af06289cd1c184451ef7a65", size = 2375213 }, + { url = "https://files.pythonhosted.org/packages/dd/d6/2000bfd8d5414fb70cbbe52c8332f2283ff30ed66a9cde42716c8ecbe22c/pillow-11.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e06695e0326d05b06833b40b7ef477e475d0b1ba3a6d27da1bb48c23209bf457", size = 3229968 }, + { url = "https://files.pythonhosted.org/packages/d9/45/3fe487010dd9ce0a06adf9b8ff4f273cc0a44536e234b0fad3532a42c15b/pillow-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96f82000e12f23e4f29346e42702b6ed9a2f2fea34a740dd5ffffcc8c539eb35", size = 3101806 }, + { url = "https://files.pythonhosted.org/packages/e3/72/776b3629c47d9d5f1c160113158a7a7ad177688d3a1159cd3b62ded5a33a/pillow-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3cd561ded2cf2bbae44d4605837221b987c216cff94f49dfeed63488bb228d2", size = 4322283 }, + { url = "https://files.pythonhosted.org/packages/e4/c2/e25199e7e4e71d64eeb869f5b72c7ddec70e0a87926398785ab944d92375/pillow-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f189805c8be5ca5add39e6f899e6ce2ed824e65fb45f3c28cb2841911da19070", size = 4402945 }, + { url = "https://files.pythonhosted.org/packages/c1/ed/51d6136c9d5911f78632b1b86c45241c712c5a80ed7fa7f9120a5dff1eba/pillow-11.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dd0052e9db3474df30433f83a71b9b23bd9e4ef1de13d92df21a52c0303b8ab6", size = 4361228 }, + { url = "https://files.pythonhosted.org/packages/48/a4/fbfe9d5581d7b111b28f1d8c2762dee92e9821bb209af9fa83c940e507a0/pillow-11.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:837060a8599b8f5d402e97197d4924f05a2e0d68756998345c829c33186217b1", size = 4484021 }, + { url = "https://files.pythonhosted.org/packages/39/db/0b3c1a5018117f3c1d4df671fb8e47d08937f27519e8614bbe86153b65a5/pillow-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa8dd43daa836b9a8128dbe7d923423e5ad86f50a7a14dc688194b7be5c0dea2", size = 4287449 }, + { url = "https://files.pythonhosted.org/packages/d9/58/bc128da7fea8c89fc85e09f773c4901e95b5936000e6f303222490c052f3/pillow-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0a2f91f8a8b367e7a57c6e91cd25af510168091fb89ec5146003e424e1558a96", size = 4419972 }, + { url = "https://files.pythonhosted.org/packages/5f/bb/58f34379bde9fe197f51841c5bbe8830c28bbb6d3801f16a83b8f2ad37df/pillow-11.1.0-cp311-cp311-win32.whl", hash = "sha256:c12fc111ef090845de2bb15009372175d76ac99969bdf31e2ce9b42e4b8cd88f", size = 2291201 }, + { url = "https://files.pythonhosted.org/packages/3a/c6/fce9255272bcf0c39e15abd2f8fd8429a954cf344469eaceb9d0d1366913/pillow-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd43429d0d7ed6533b25fc993861b8fd512c42d04514a0dd6337fb3ccf22761", size = 2625686 }, + { url = "https://files.pythonhosted.org/packages/c8/52/8ba066d569d932365509054859f74f2a9abee273edcef5cd75e4bc3e831e/pillow-11.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f7955ecf5609dee9442cbface754f2c6e541d9e6eda87fad7f7a989b0bdb9d71", size = 2375194 }, + { url = "https://files.pythonhosted.org/packages/95/20/9ce6ed62c91c073fcaa23d216e68289e19d95fb8188b9fb7a63d36771db8/pillow-11.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2062ffb1d36544d42fcaa277b069c88b01bb7298f4efa06731a7fd6cc290b81a", size = 3226818 }, + { url = "https://files.pythonhosted.org/packages/b9/d8/f6004d98579a2596c098d1e30d10b248798cceff82d2b77aa914875bfea1/pillow-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a85b653980faad27e88b141348707ceeef8a1186f75ecc600c395dcac19f385b", size = 3101662 }, + { url = "https://files.pythonhosted.org/packages/08/d9/892e705f90051c7a2574d9f24579c9e100c828700d78a63239676f960b74/pillow-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9409c080586d1f683df3f184f20e36fb647f2e0bc3988094d4fd8c9f4eb1b3b3", size = 4329317 }, + { url = "https://files.pythonhosted.org/packages/8c/aa/7f29711f26680eab0bcd3ecdd6d23ed6bce180d82e3f6380fb7ae35fcf3b/pillow-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fdadc077553621911f27ce206ffcbec7d3f8d7b50e0da39f10997e8e2bb7f6a", size = 4412999 }, + { url = "https://files.pythonhosted.org/packages/c8/c4/8f0fe3b9e0f7196f6d0bbb151f9fba323d72a41da068610c4c960b16632a/pillow-11.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:93a18841d09bcdd774dcdc308e4537e1f867b3dec059c131fde0327899734aa1", size = 4368819 }, + { url = "https://files.pythonhosted.org/packages/38/0d/84200ed6a871ce386ddc82904bfadc0c6b28b0c0ec78176871a4679e40b3/pillow-11.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9aa9aeddeed452b2f616ff5507459e7bab436916ccb10961c4a382cd3e03f47f", size = 4496081 }, + { url = "https://files.pythonhosted.org/packages/84/9c/9bcd66f714d7e25b64118e3952d52841a4babc6d97b6d28e2261c52045d4/pillow-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3cdcdb0b896e981678eee140d882b70092dac83ac1cdf6b3a60e2216a73f2b91", size = 4296513 }, + { url = "https://files.pythonhosted.org/packages/db/61/ada2a226e22da011b45f7104c95ebda1b63dcbb0c378ad0f7c2a710f8fd2/pillow-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36ba10b9cb413e7c7dfa3e189aba252deee0602c86c309799da5a74009ac7a1c", size = 4431298 }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fc6e86750523f367923522014b821c11ebc5ad402e659d8c9d09b3c9d70c/pillow-11.1.0-cp312-cp312-win32.whl", hash = "sha256:cfd5cd998c2e36a862d0e27b2df63237e67273f2fc78f47445b14e73a810e7e6", size = 2291630 }, + { url = "https://files.pythonhosted.org/packages/08/5c/2104299949b9d504baf3f4d35f73dbd14ef31bbd1ddc2c1b66a5b7dfda44/pillow-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a697cd8ba0383bba3d2d3ada02b34ed268cb548b369943cd349007730c92bddf", size = 2626369 }, + { url = "https://files.pythonhosted.org/packages/37/f3/9b18362206b244167c958984b57c7f70a0289bfb59a530dd8af5f699b910/pillow-11.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:4dd43a78897793f60766563969442020e90eb7847463eca901e41ba186a7d4a5", size = 2375240 }, + { url = "https://files.pythonhosted.org/packages/b3/31/9ca79cafdce364fd5c980cd3416c20ce1bebd235b470d262f9d24d810184/pillow-11.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae98e14432d458fc3de11a77ccb3ae65ddce70f730e7c76140653048c71bfcbc", size = 3226640 }, + { url = "https://files.pythonhosted.org/packages/ac/0f/ff07ad45a1f172a497aa393b13a9d81a32e1477ef0e869d030e3c1532521/pillow-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc1331b6d5a6e144aeb5e626f4375f5b7ae9934ba620c0ac6b3e43d5e683a0f0", size = 3101437 }, + { url = "https://files.pythonhosted.org/packages/08/2f/9906fca87a68d29ec4530be1f893149e0cb64a86d1f9f70a7cfcdfe8ae44/pillow-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:758e9d4ef15d3560214cddbc97b8ef3ef86ce04d62ddac17ad39ba87e89bd3b1", size = 4326605 }, + { url = "https://files.pythonhosted.org/packages/b0/0f/f3547ee15b145bc5c8b336401b2d4c9d9da67da9dcb572d7c0d4103d2c69/pillow-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b523466b1a31d0dcef7c5be1f20b942919b62fd6e9a9be199d035509cbefc0ec", size = 4411173 }, + { url = "https://files.pythonhosted.org/packages/b1/df/bf8176aa5db515c5de584c5e00df9bab0713548fd780c82a86cba2c2fedb/pillow-11.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9044b5e4f7083f209c4e35aa5dd54b1dd5b112b108648f5c902ad586d4f945c5", size = 4369145 }, + { url = "https://files.pythonhosted.org/packages/de/7c/7433122d1cfadc740f577cb55526fdc39129a648ac65ce64db2eb7209277/pillow-11.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3764d53e09cdedd91bee65c2527815d315c6b90d7b8b79759cc48d7bf5d4f114", size = 4496340 }, + { url = "https://files.pythonhosted.org/packages/25/46/dd94b93ca6bd555588835f2504bd90c00d5438fe131cf01cfa0c5131a19d/pillow-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31eba6bbdd27dde97b0174ddf0297d7a9c3a507a8a1480e1e60ef914fe23d352", size = 4296906 }, + { url = "https://files.pythonhosted.org/packages/a8/28/2f9d32014dfc7753e586db9add35b8a41b7a3b46540e965cb6d6bc607bd2/pillow-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b5d658fbd9f0d6eea113aea286b21d3cd4d3fd978157cbf2447a6035916506d3", size = 4431759 }, + { url = "https://files.pythonhosted.org/packages/33/48/19c2cbe7403870fbe8b7737d19eb013f46299cdfe4501573367f6396c775/pillow-11.1.0-cp313-cp313-win32.whl", hash = "sha256:f86d3a7a9af5d826744fabf4afd15b9dfef44fe69a98541f666f66fbb8d3fef9", size = 2291657 }, + { url = "https://files.pythonhosted.org/packages/3b/ad/285c556747d34c399f332ba7c1a595ba245796ef3e22eae190f5364bb62b/pillow-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:593c5fd6be85da83656b93ffcccc2312d2d149d251e98588b14fbc288fd8909c", size = 2626304 }, + { url = "https://files.pythonhosted.org/packages/e5/7b/ef35a71163bf36db06e9c8729608f78dedf032fc8313d19bd4be5c2588f3/pillow-11.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:11633d58b6ee5733bde153a8dafd25e505ea3d32e261accd388827ee987baf65", size = 2375117 }, + { url = "https://files.pythonhosted.org/packages/79/30/77f54228401e84d6791354888549b45824ab0ffde659bafa67956303a09f/pillow-11.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:70ca5ef3b3b1c4a0812b5c63c57c23b63e53bc38e758b37a951e5bc466449861", size = 3230060 }, + { url = "https://files.pythonhosted.org/packages/ce/b1/56723b74b07dd64c1010fee011951ea9c35a43d8020acd03111f14298225/pillow-11.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8000376f139d4d38d6851eb149b321a52bb8893a88dae8ee7d95840431977081", size = 3106192 }, + { url = "https://files.pythonhosted.org/packages/e1/cd/7bf7180e08f80a4dcc6b4c3a0aa9e0b0ae57168562726a05dc8aa8fa66b0/pillow-11.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee85f0696a17dd28fbcfceb59f9510aa71934b483d1f5601d1030c3c8304f3c", size = 4446805 }, + { url = "https://files.pythonhosted.org/packages/97/42/87c856ea30c8ed97e8efbe672b58c8304dee0573f8c7cab62ae9e31db6ae/pillow-11.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dd0e081319328928531df7a0e63621caf67652c8464303fd102141b785ef9547", size = 4530623 }, + { url = "https://files.pythonhosted.org/packages/ff/41/026879e90c84a88e33fb00cc6bd915ac2743c67e87a18f80270dfe3c2041/pillow-11.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e63e4e5081de46517099dc30abe418122f54531a6ae2ebc8680bcd7096860eab", size = 4465191 }, + { url = "https://files.pythonhosted.org/packages/e5/fb/a7960e838bc5df57a2ce23183bfd2290d97c33028b96bde332a9057834d3/pillow-11.1.0-cp313-cp313t-win32.whl", hash = "sha256:dda60aa465b861324e65a78c9f5cf0f4bc713e4309f83bc387be158b077963d9", size = 2295494 }, + { url = "https://files.pythonhosted.org/packages/d7/6c/6ec83ee2f6f0fda8d4cf89045c6be4b0373ebfc363ba8538f8c999f63fcd/pillow-11.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ad5db5781c774ab9a9b2c4302bbf0c1014960a0a7be63278d13ae6fdf88126fe", size = 2631595 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/41c21c6c8af92b9fea313aa47c75de49e2f9a467964ee33eb0135d47eb64/pillow-11.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:67cd427c68926108778a9005f2a04adbd5e67c442ed21d95389fe1d595458756", size = 2377651 }, + { url = "https://files.pythonhosted.org/packages/9a/1f/9df5ac77491fddd2e36c352d16976dc11fbe6ab842f5df85fd7e31b847b9/pillow-11.1.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:bf902d7413c82a1bfa08b06a070876132a5ae6b2388e2712aab3a7cbc02205c6", size = 3229995 }, + { url = "https://files.pythonhosted.org/packages/a6/62/c7b359e924dca274173b04922ac06aa63614f7e934d132f2fe1d852509aa/pillow-11.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c1eec9d950b6fe688edee07138993e54ee4ae634c51443cfb7c1e7613322718e", size = 3101890 }, + { url = "https://files.pythonhosted.org/packages/7b/63/136f21340a434de895b62bcf2c386005a8aa24066c4facd619f5e0e9f283/pillow-11.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e275ee4cb11c262bd108ab2081f750db2a1c0b8c12c1897f27b160c8bd57bbc", size = 4310366 }, + { url = "https://files.pythonhosted.org/packages/f6/46/0bd0ca03d9d1164a7fa33d285ef6d1c438e963d0c8770e4c5b3737ef5abe/pillow-11.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4db853948ce4e718f2fc775b75c37ba2efb6aaea41a1a5fc57f0af59eee774b2", size = 4391582 }, + { url = "https://files.pythonhosted.org/packages/0c/55/f182db572b28bd833b8e806f933f782ceb2df64c40e4d8bd3d4226a46eca/pillow-11.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:ab8a209b8485d3db694fa97a896d96dd6533d63c22829043fd9de627060beade", size = 4350278 }, + { url = "https://files.pythonhosted.org/packages/75/fb/e330fdbbcbc4744214b5f53b84d9d8a9f4ffbebc2e9c2ac10475386e3296/pillow-11.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:54251ef02a2309b5eec99d151ebf5c9904b77976c8abdcbce7891ed22df53884", size = 4471768 }, + { url = "https://files.pythonhosted.org/packages/eb/51/20ee6c4da4448d7a67ffb720a5fcdb965115a78e211a1f58f9845ae15f86/pillow-11.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5bb94705aea800051a743aa4874bb1397d4695fb0583ba5e425ee0328757f196", size = 4276549 }, + { url = "https://files.pythonhosted.org/packages/37/f2/a25c0bdaa6d6fd5cc3d4a6f65b5a7ea46e7af58bee00a98efe0a5af79c58/pillow-11.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:89dbdb3e6e9594d512780a5a1c42801879628b38e3efc7038094430844e271d8", size = 4409350 }, + { url = "https://files.pythonhosted.org/packages/12/a7/06687947604cd3e47abeea1b78b65d34ffce7feab03cfe0dd985f115dca3/pillow-11.1.0-cp39-cp39-win32.whl", hash = "sha256:e5449ca63da169a2e6068dd0e2fcc8d91f9558aba89ff6d02121ca8ab11e79e5", size = 2291271 }, + { url = "https://files.pythonhosted.org/packages/21/a6/f51d47675940b5c63b08ff0575b3518428b4acb891f88526fa4ee1edab6f/pillow-11.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:3362c6ca227e65c54bf71a5f88b3d4565ff1bcbc63ae72c34b07bbb1cc59a43f", size = 2625783 }, + { url = "https://files.pythonhosted.org/packages/95/56/97750bd33e68648fa432dfadcb8ede7624bd905822d42262d34bcebdd9d7/pillow-11.1.0-cp39-cp39-win_arm64.whl", hash = "sha256:b20be51b37a75cc54c2c55def3fa2c65bb94ba859dde241cd0a4fd302de5ae0a", size = 2375193 }, + { url = "https://files.pythonhosted.org/packages/fa/c5/389961578fb677b8b3244fcd934f720ed25a148b9a5cc81c91bdf59d8588/pillow-11.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8c730dc3a83e5ac137fbc92dfcfe1511ce3b2b5d7578315b63dbbb76f7f51d90", size = 3198345 }, + { url = "https://files.pythonhosted.org/packages/c4/fa/803c0e50ffee74d4b965229e816af55276eac1d5806712de86f9371858fd/pillow-11.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7d33d2fae0e8b170b6a6c57400e077412240f6f5bb2a342cf1ee512a787942bb", size = 3072938 }, + { url = "https://files.pythonhosted.org/packages/dc/67/2a3a5f8012b5d8c63fe53958ba906c1b1d0482ebed5618057ef4d22f8076/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8d65b38173085f24bc07f8b6c505cbb7418009fa1a1fcb111b1f4961814a442", size = 3400049 }, + { url = "https://files.pythonhosted.org/packages/e5/a0/514f0d317446c98c478d1872497eb92e7cde67003fed74f696441e647446/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:015c6e863faa4779251436db398ae75051469f7c903b043a48f078e437656f83", size = 3422431 }, + { url = "https://files.pythonhosted.org/packages/cd/00/20f40a935514037b7d3f87adfc87d2c538430ea625b63b3af8c3f5578e72/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d44ff19eea13ae4acdaaab0179fa68c0c6f2f45d66a4d8ec1eda7d6cecbcc15f", size = 3446208 }, + { url = "https://files.pythonhosted.org/packages/28/3c/7de681727963043e093c72e6c3348411b0185eab3263100d4490234ba2f6/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d3d8da4a631471dfaf94c10c85f5277b1f8e42ac42bade1ac67da4b4a7359b73", size = 3509746 }, + { url = "https://files.pythonhosted.org/packages/41/67/936f9814bdd74b2dfd4822f1f7725ab5d8ff4103919a1664eb4874c58b2f/pillow-11.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:4637b88343166249fe8aa94e7c4a62a180c4b3898283bb5d3d2fd5fe10d8e4e0", size = 2626353 }, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, +] + +[[package]] +name = "prometheus-client" +version = "0.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/62/14/7d0f567991f3a9af8d1cd4f619040c93b68f09a02b6d0b6ab1b2d1ded5fe/prometheus_client-0.21.1.tar.gz", hash = "sha256:252505a722ac04b0456be05c05f75f45d760c2911ffc45f2a06bcaed9f3ae3fb", size = 78551 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/c2/ab7d37426c179ceb9aeb109a85cda8948bb269b7561a0be870cc656eefe4/prometheus_client-0.21.1-py3-none-any.whl", hash = "sha256:594b45c410d6f4f8888940fe80b5cc2521b305a1fafe1c58609ef715a001f301", size = 54682 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/e1/bd15cb8ffdcfeeb2bdc215de3c3cffca11408d829e4b8416dcfe71ba8854/prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab", size = 429087 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/ea/d836f008d33151c7a1f62caf3d8dd782e4d15f6a43897f64480c2b8de2ad/prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198", size = 387816 }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, +] + +[[package]] +name = "pymdown-extensions" +version = "10.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/44/e6de2fdc880ad0ec7547ca2e087212be815efbc9a425a8d5ba9ede602cbb/pymdown_extensions-10.14.3.tar.gz", hash = "sha256:41e576ce3f5d650be59e900e4ceff231e0aed2a88cf30acaee41e02f063a061b", size = 846846 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/f5/b9e2a42aa8f9e34d52d66de87941ecd236570c7ed2e87775ed23bbe4e224/pymdown_extensions-10.14.3-py3-none-any.whl", hash = "sha256:05e0bee73d64b9c71a4ae17c72abc2f700e8bc8403755a00580b49a4e9f189e9", size = 264467 }, +] + +[[package]] +name = "pyparsing" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/3544f4f299a47911c2ab3710f534e52fea62a633c96806995da5d25be4b2/pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a", size = 1067694 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a7/c8a2d361bf89c0d9577c934ebb7421b25dc84bf3a8e3ac0a40aed9acc547/pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1", size = 107716 }, +] + +[[package]] +name = "pytest" +version = "8.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, +] + +[[package]] +name = "python-calamine" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/29/78/805948f9ae23ce609522be89a402d5bb379c08a8fa8768f136c4e8c70439/python_calamine-0.3.1.tar.gz", hash = "sha256:4171fadf4a2db1b1ed84536fb2f16ea14bde894d690ff321a85e27df26286b37", size = 129645 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/e2/426307ce173dac9ec7c048e9c52ea4962940d0a74fd22689e49d7d346303/python_calamine-0.3.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2822c39ad52f289732981cee59b4985388624b54e124e41436bb37565ed32f15", size = 790690 }, + { url = "https://files.pythonhosted.org/packages/cd/8d/dd086992d63879917c6a2d9888ea3975875dfff7995665cd915b68b35609/python_calamine-0.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f2786751cfe4e81f9170b843741b39a325cf9f49db8d51fc3cd16d6139e0ac60", size = 779151 }, + { url = "https://files.pythonhosted.org/packages/78/a2/7b9f08692d47806633112824515f2f9aa1fbc55c8e643147331f00d16667/python_calamine-0.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086fc992232207164277fd0f1e463f59097637c849470890f903037fde4bf02d", size = 849142 }, + { url = "https://files.pythonhosted.org/packages/f4/52/fdea6ba516bfc17d7ce6c8cbb76f7940950a7b8222abdb5f64e2da1774bd/python_calamine-0.3.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f42795617d23bb87b16761286c07e8407a9044823c972da5dea922f71a98445", size = 852732 }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9ecc6b83e6a5dcfaef8912dececa2e11df8fca864c2630226e3cdaab1c6b/python_calamine-0.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8dc27a41ebca543e5a0181b3edc223b83839c49063589583927de922887898a", size = 918176 }, + { url = "https://files.pythonhosted.org/packages/05/96/26c2233fa19aa1e273bb604d2770102fce869384bece2e541732a5d24af6/python_calamine-0.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:400fd6e650bfedf1a9d79821e32f13aceb0362bbdaa2f37611177eb09cf77056", size = 952008 }, + { url = "https://files.pythonhosted.org/packages/0e/dd/d305d860af1db06f037d5b6127835b053ba74c31d4c78bb289ae8c740914/python_calamine-0.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6aec96ea676ec41789a6348137895b3827745d135c3c7f37769f75d417fb867", size = 856933 }, + { url = "https://files.pythonhosted.org/packages/a8/91/4019bb2fe530a378cb14928c16281c0da0db3893ac45a85b2cf445c194db/python_calamine-0.3.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:98808c087bbbfe4e858043fc0b953d326c8c70e73d0cd695c29a9bc7b3b0622b", size = 901584 }, + { url = "https://files.pythonhosted.org/packages/c8/73/bfb733d01038c35f495f2eabdbecafec6ddc30751d25e0f6da3a52a340ab/python_calamine-0.3.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:78cd352976ba7324a2e7ab59188b3fac978b5f80d25e753b255dfec2d24076d9", size = 1039017 }, + { url = "https://files.pythonhosted.org/packages/53/6f/9100b7fa85c40660b85198803a8d63623e6b6584a2c42ed5caa7ff093717/python_calamine-0.3.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2e1bfb191b5da6136887ca64deff427cae185d4d59333d1f1a8637db10ce8c3e", size = 1017473 }, + { url = "https://files.pythonhosted.org/packages/b5/44/ff5b4d92a5609b16af607a13debdf6a00265555edac6216f624c26e15d06/python_calamine-0.3.1-cp310-none-win32.whl", hash = "sha256:bd9616b355f47326ff4ae970f0a91a17976f316877a56ce3ef376ce58505e66c", size = 641836 }, + { url = "https://files.pythonhosted.org/packages/e4/5e/6a619b23c914e18101675c87dc50f947638793d8db2d100df919f2ddeabc/python_calamine-0.3.1-cp310-none-win_amd64.whl", hash = "sha256:40354b04fb68e63659bb5f423534fe6f0b3e709be322c25c60158ac332b85ed3", size = 671744 }, + { url = "https://files.pythonhosted.org/packages/27/72/1b362f92d6beb1a31bc579db6edd43bb251aef3e4b6edcd7d9617f4d4e68/python_calamine-0.3.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7fee7306d015e2cb89bd69dc7b928bd947b65415e2cd72deb59a72c5603d0adb", size = 790765 }, + { url = "https://files.pythonhosted.org/packages/94/af/0b0d5c05f52ce93a7920c966b77aba010e3f59378f0b8f99c0c6db9b5a9b/python_calamine-0.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c860d5dc649b6be49a94ba07b1673f8dc9be0a89bc33cf13a5ea58998facdb12", size = 778571 }, + { url = "https://files.pythonhosted.org/packages/56/4a/91b6a8c875be18ff77d1051dc91de109491f9fc3e19509a114801b80dc7d/python_calamine-0.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1df7ae7c29f96b6714cfebfd41666462970583b92ceb179b5ddd0d4556ea21ec", size = 847066 }, + { url = "https://files.pythonhosted.org/packages/73/06/937ae8ae1b00e7153a9abf3428cec2966b272b75448abcb53a88b1e4d83f/python_calamine-0.3.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:84bac53ba4872b795f808d1d30b51c74eac4a57dc8e4f96bba8140ccdeb320da", size = 852593 }, + { url = "https://files.pythonhosted.org/packages/36/34/9f7a50471e4feae9b7e2690d330311f35255b2d22fb4d75cb18cc529d289/python_calamine-0.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e93ebe06fee0f10d43ede04691e80ab63366b00edc5eb873742779fdabe626e3", size = 918190 }, + { url = "https://files.pythonhosted.org/packages/33/89/8147afd9ede3c04210c7b534437d0f0c500938b2c1e504ffcef7d955865f/python_calamine-0.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23d04d73d2028c7171c63179f3b4d5679aa057db46e1e0058341b5af047474c4", size = 952064 }, + { url = "https://files.pythonhosted.org/packages/08/ac/c04accb78049b64b99fba9eb3f889371d41c7985f9c7eef855fe05d13f96/python_calamine-0.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b2005a4bd693dbaa74c96fdaa71a868c149ad376d309c4ad32fe80145216ad2", size = 856838 }, + { url = "https://files.pythonhosted.org/packages/60/b6/70daeb7375b2829d4943a9d216bcd24fd9d5a4f98e27aea974f8f9c56a5d/python_calamine-0.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b8c7ab2e26f124483308f1c0f580b01e3ad474ce3eb6a3acf0e0273247ea7b8b", size = 901296 }, + { url = "https://files.pythonhosted.org/packages/af/2e/00771529d5fa667155135b1fc9f31d06997b6c8fd3d7d7f2e4d045dcd2f1/python_calamine-0.3.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:86466870c1898b75503e752f7ea7b7a045253f1e106db9555071d225af4a1de8", size = 1039326 }, + { url = "https://files.pythonhosted.org/packages/5c/dc/06215856a18f9a6a912c5bf0a2f9110a469490f18fe1ca3ac92e5bee89cd/python_calamine-0.3.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e6a4ef2435715694eeaea537f9578e33a90f68a5e9e697d98ae14d2aacf302cf", size = 1017441 }, + { url = "https://files.pythonhosted.org/packages/19/52/ec281371e7cd5ebc436089b693d8b1cf41d36562d3ea4af2e795cd162444/python_calamine-0.3.1-cp311-none-win32.whl", hash = "sha256:545c0cd8bc72a3341f81f9c46f12cad2ec9f3281360d2893a88a4a4a48f364dc", size = 643497 }, + { url = "https://files.pythonhosted.org/packages/41/dc/8e5e6637e1716d2974cf426aa944a6d1f5022319612d2608c6fb1b7667b3/python_calamine-0.3.1-cp311-none-win_amd64.whl", hash = "sha256:90e848bb9a062185cdc697b93798e67475956ce466c122b477e34fc4548e2906", size = 671859 }, + { url = "https://files.pythonhosted.org/packages/86/b7/42de4f63a579d1e976c1938e8f93e2a083a389b157b398f0f324cf204c9f/python_calamine-0.3.1-cp311-none-win_arm64.whl", hash = "sha256:455e813450eb03bbe3fc09c1324fbb5c367edf4ec0c7a58f81169e5f2008f27d", size = 645931 }, + { url = "https://files.pythonhosted.org/packages/09/a7/e79d853445bdb22647489b62f84ead7f32c301c3169f5f75a96985ac2d7a/python_calamine-0.3.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:eacea175ba67dd04c0d718bcca0488261bd9eefff3b46ae68249e14d705e14a0", size = 791708 }, + { url = "https://files.pythonhosted.org/packages/cf/26/8ad747d3861112f3bbc654043550906d69758bf5d5d2387f92f19ca9bf8c/python_calamine-0.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2a9a8021d7256e2a21949886d0fe5c67ae805d4b5f9a4d93b2ef971262e64d4", size = 779461 }, + { url = "https://files.pythonhosted.org/packages/8b/87/fb5ee8c9c9c8e9bd12e08170af2c39e113f991adbb65343a8eca098c9525/python_calamine-0.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65d0f0e7a3e554ba5672b9bd5f77b22dd3fc011fd30157c4e377c49b3d95d6d1", size = 848500 }, + { url = "https://files.pythonhosted.org/packages/43/6a/46d8836765e71f9d9116aa3c6db56ca7acaeb0c19c81ed77c7f927b44086/python_calamine-0.3.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c3be559acbcec19d79ba07ae81276bbb8fadd474c790db14119a09fb36427fb", size = 854282 }, + { url = "https://files.pythonhosted.org/packages/24/d1/9ed72aa9576b13c8cdd5156b652769871c682edf3e37f169e5afc9bd9626/python_calamine-0.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af0226e6826000d83a4ac34d81ae5217cc2baa54aecd76aac07091388bf739a1", size = 918879 }, + { url = "https://files.pythonhosted.org/packages/7e/00/f0464ec560136e4dce374b9f50a9fe1c03c5b67bb201d9a328926835c970/python_calamine-0.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:02b90d7e2e11c7449331d2cb744075fb47949d4e039983d6e6d9085950ad2642", size = 949168 }, + { url = "https://files.pythonhosted.org/packages/a1/6e/e8b80c04f50bcbde518298e371d8bc64afc3646b90dd5369b867e68a7166/python_calamine-0.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:732bb98dd393db80de1cd8a90e7d47dced929c7dea56194394d0fb7baf873fa7", size = 858798 }, + { url = "https://files.pythonhosted.org/packages/ed/1b/050290e815417a40cb19475f8aa2e2aa9ec90a0433c2feb1b7321184f993/python_calamine-0.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:56bb60bf663c04e0a4cc801dfd5da3351820a002b4aea72a427603011633d35c", size = 903680 }, + { url = "https://files.pythonhosted.org/packages/41/57/7ebd53f325538b3291cc5cfd94d8cf9ee8f1014fa7d74c45d645d344b5ab/python_calamine-0.3.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b8974ee473e6337c9b52d6cab03a202dbe57e1500eb100d96adb6b0dfbff7390", size = 1038856 }, + { url = "https://files.pythonhosted.org/packages/bd/3b/8967b37e72ecb9c4dafd72f62f426bf3f5541c534973d32e80923fac1b81/python_calamine-0.3.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:90876d9b77429c8168d0e4c3ebe1dcf996130c5b0aecb3c6283f85645d4dd29a", size = 1016287 }, + { url = "https://files.pythonhosted.org/packages/f3/ad/f913f6a7b1fd784d79431b6ac9337c702a996d30499b8af246fc582b6c95/python_calamine-0.3.1-cp312-none-win32.whl", hash = "sha256:17ab4ba8955206eba4a87c6bc0a805ffa9051f831c9f3d17a463d8a844beb197", size = 641828 }, + { url = "https://files.pythonhosted.org/packages/89/67/872d808d8d5fac55c358f49d9f5fdc36425d16a1f4dfcdfba1c80f41125e/python_calamine-0.3.1-cp312-none-win_amd64.whl", hash = "sha256:33ff20f6603fb3434630a00190022020102dc26b6def519d19a19a58a487a514", size = 672671 }, + { url = "https://files.pythonhosted.org/packages/bd/bd/c5f0616bae188b47fb91c8e4c4e49a99a6930d527fbf937e828a73e93367/python_calamine-0.3.1-cp312-none-win_arm64.whl", hash = "sha256:808ff13261826b64b8313a53a83873cf46df4522cbca98fb66a85b543de68949", size = 646318 }, + { url = "https://files.pythonhosted.org/packages/05/9b/da0d4eade57f432f05647730e31c7ecaeb0303d8a694b83822b6f54a76eb/python_calamine-0.3.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:9401be43100552fb3a0d9a7392e207e4b4dfa0bc99c3f97613c0d703db0b191b", size = 791338 }, + { url = "https://files.pythonhosted.org/packages/ff/ca/1d48954361c243e1c2b6661a12ce06aaafc927c1808b31733b8949a9e2f0/python_calamine-0.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b76875209d89227ea0666c346b5e007fa2ac9cc65b95b91551c4b715d9e6c7be", size = 779212 }, + { url = "https://files.pythonhosted.org/packages/71/18/8b3a0f4452d9a4f518397d8cf94ec6f2d1ee45403f76a01f2f66b5c15ffb/python_calamine-0.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2079ae2c434e28f1c9d17a2f4ea50d92e27d1373fc5908f1fd0c159f387e5b9", size = 848020 }, + { url = "https://files.pythonhosted.org/packages/8b/ba/d7dd906bdb61f1cc22b8983345cb60f27f3bbda180f53465819b162e7493/python_calamine-0.3.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:65c8986318846728d66ac2ce5dc017e79e6409ef17a48ca284d45f7d68a8ead0", size = 853937 }, + { url = "https://files.pythonhosted.org/packages/7d/b6/c352a8b266898bd40a4fd75440ff7ceb760722ec10e4cf3555990fb61947/python_calamine-0.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9504e43f4852265ab55044eb2835c270fda137a1ea35d5e4b7d3581d4ac830f4", size = 918441 }, + { url = "https://files.pythonhosted.org/packages/9a/a0/3411f69dfb1df10e342b974032eb0b0efcea9a242f4784d1a73563e5cf0e/python_calamine-0.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8eab37611b39cc8093e5671e5f8f8fc7f427459eabc21497f71659be61d5723", size = 948165 }, + { url = "https://files.pythonhosted.org/packages/1f/00/c5b9f44d4ef66cb775d1bff131eb33ac53919e9f88053e4ea79f4c5fe078/python_calamine-0.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28e226ff25510e62b57443029e5061dd42b551907a0a983f0e07e6c5e1facb4d", size = 858051 }, + { url = "https://files.pythonhosted.org/packages/38/db/90376e1554d90ecc90c33e28186ff6f2c57ad0d08478d7352c5fc85ce36c/python_calamine-0.3.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:721a7bfe0d17c12dcf82886a17c9d1025983cfe61fade8c0d2a1b04bb4bd9980", size = 903218 }, + { url = "https://files.pythonhosted.org/packages/10/ef/31958f010c5e8b01413437681216b9f6e89449d821b1d6c4504a24f2044d/python_calamine-0.3.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:1258cb82689ded64b73816fbcb3f02d139c8fd29676e9d451c0f81bb689a7076", size = 1037794 }, + { url = "https://files.pythonhosted.org/packages/6a/fe/04f8c47734c14563a3cf90660ee718f0e9ce04df1017efc51562bf434c13/python_calamine-0.3.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:919fe66fd3d3031585c4373a1dd0b128d3ceb0d79d21c8d0878e9ddee4d6b78a", size = 1015901 }, + { url = "https://files.pythonhosted.org/packages/27/95/a88b4d588d8a5597f8264eaab2cb203ddbf994bc4ca283f3d8fa5ca36328/python_calamine-0.3.1-cp313-none-win32.whl", hash = "sha256:a9df3902b279cb743baf857f29c1c7ed242caa7143c4fdf3a79f553801a662d9", size = 641557 }, + { url = "https://files.pythonhosted.org/packages/1f/75/3a92747cb8458af939dd288c6faccb6814e166311a86227d0610dac1158d/python_calamine-0.3.1-cp313-none-win_amd64.whl", hash = "sha256:9f96654bceeb10e9ea9624eda857790e1a601593212fc174cb84d1568f12b5e4", size = 672168 }, + { url = "https://files.pythonhosted.org/packages/5d/c2/ea62c43fd8704d632164cac18495bf7594136ada37e8ad069a09344cac70/python_calamine-0.3.1-cp313-none-win_arm64.whl", hash = "sha256:e83bd84617400bbca9907f0a44c6eccaeca7bd011791950c181e402992b8cc26", size = 645713 }, + { url = "https://files.pythonhosted.org/packages/bc/15/37ec1980ced054d96bb9daa5569148401f775837bc1d4e03a7c6fe631fbd/python_calamine-0.3.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:dcf5ffd5a63b806de03629c2f25585e455aa245d6e0fd78e7a85dff79d16b6e7", size = 790793 }, + { url = "https://files.pythonhosted.org/packages/85/c5/da6d4f36411bd8d70bf2ffd07dfba58a66a3392ce6c618bcadbc202aa3a9/python_calamine-0.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:38c5ff0b9696fe4deec98e8135f33eeee49e302bcfa2ffcc4abe15cb1f8e8054", size = 780290 }, + { url = "https://files.pythonhosted.org/packages/fa/9c/4a57ca04ae47da6c9e0534497bb69fbaeb451ada412bc02576bac61f11a5/python_calamine-0.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58a3331cc70e7496592c9c559fa89a7451db56a200d754e416edb51b9e888a41", size = 849586 }, + { url = "https://files.pythonhosted.org/packages/9b/92/8326c2c78d933f7db0740eb5cf22b25afd115bc1f6d93c6ec456be90a65a/python_calamine-0.3.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6493fb0fbf766a380d0741c11c6c52b1a06d1917a8e7551f9d560324ca757b82", size = 853584 }, + { url = "https://files.pythonhosted.org/packages/83/d4/1e795b47b3013ca2b483cb57a0778f0fcc07e75b0b433d0be5ad62a9bc5e/python_calamine-0.3.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:94f9cd55efdda69352de6679d737d41dfcb1fdb5b8e5c512e0b83fe6b5f3796c", size = 917983 }, + { url = "https://files.pythonhosted.org/packages/da/5e/f6a67958acc48189df58af78224ca970348539dfe8c7e14b877fd7926f7e/python_calamine-0.3.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79b2a774944b4ed084d9a677cbf88372f725449a260fd134ab2b3422ef2d4a5d", size = 953457 }, + { url = "https://files.pythonhosted.org/packages/31/ea/7b0611e87a289914d3ba2e4add499ece4ca1768caecec7087e98220cc36e/python_calamine-0.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c96c5cfd02f4a20a2df51ff6732839d3f4a4a781e9e904a85191aaeb8fce2870", size = 857618 }, + { url = "https://files.pythonhosted.org/packages/ce/1e/0152c33046c8dfc3d596022ff887063a1d6585df4e7f3e1c4707877968cb/python_calamine-0.3.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:edf8d83c7369b18d4d42e9e2ccc52143bdbf27a326877bf3fc6fc56c78655372", size = 902220 }, + { url = "https://files.pythonhosted.org/packages/e9/76/aa47cf33d72dae62ecc883aadc72ea5f4c5d977bf09c7bc0d0872ceba0af/python_calamine-0.3.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2252b25e8fd992f10e916fb4eddc504a58839a1e67f32238bba803ecf16ce7c4", size = 1039701 }, + { url = "https://files.pythonhosted.org/packages/95/fc/9d88b6ea48e21391b9608218a1d23fcaf9f5d9a737eb2aa3a63daf3016bd/python_calamine-0.3.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:26d870656fbe1c3767483f3162359765738adab58915157c55afff4dfc32e9e9", size = 1017614 }, + { url = "https://files.pythonhosted.org/packages/7c/8c/1ae6ccfef31654fca8ec6bbb3ebe28f2c212f6c233e1026d3f77a77fb62a/python_calamine-0.3.1-cp39-none-win32.whl", hash = "sha256:28c1394a00bd218ce4223f8f8019fd2c1878f1a01ad47be289964d281fef4dac", size = 642195 }, + { url = "https://files.pythonhosted.org/packages/f8/e5/3d579b5430f54797b636f9bbff9a5cc73d3a56f495901f565c3c82156703/python_calamine-0.3.1-cp39-none-win_amd64.whl", hash = "sha256:529c36520924b16f398e25e78fcd4ea14fdcd95f383db360d107e075628d6941", size = 672165 }, + { url = "https://files.pythonhosted.org/packages/d6/c0/c5b8daf21a7cd2d08b4e58dd5050e85af676fe316dd239e086bce3ef45a2/python_calamine-0.3.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4dbe8d5f27889dfcd03d9ad99a9f392b6c0af41dbc287ac4738804c31c99750a", size = 791923 }, + { url = "https://files.pythonhosted.org/packages/e8/11/cd685de5f456e21ec8ca7402dc4c35a9084ba3e9f38a4fcd7fead0dac099/python_calamine-0.3.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9bc553349095b3104708cd1eb345445426400de105df7ede3d5054b0ecfa74e9", size = 780127 }, + { url = "https://files.pythonhosted.org/packages/f2/6b/8ac849950ad84ca2043f0a51c60bdefc8d11500b193b901d98d9405ab013/python_calamine-0.3.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f12fa42ea6c7750f994a1a9674414dfd25adb3e61ad570382c05a84e4e8e949e", size = 849104 }, + { url = "https://files.pythonhosted.org/packages/ef/84/3b8026b1af762957370a2318ae527920c016b99e6971f1c101d04425e33e/python_calamine-0.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbac293a3c4c98e988e564f13820874c6ac02114cef5698a03b8146bd9566ef7", size = 856787 }, + { url = "https://files.pythonhosted.org/packages/20/14/49282dc57a77b194cccc5de641946d70340093aa4d3a579c2589dc356c84/python_calamine-0.3.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a571bab6528504cdb99187f4e6a5a64c7ccb065ee1416b9e10c1f416d331aae5", size = 905120 }, + { url = "https://files.pythonhosted.org/packages/8c/b5/a28a7923bc73d75cd8ab67b3e94347440e149b38c56460349d0f396415ca/python_calamine-0.3.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:49d2acf3def8ecbabb132b537501bb639ca9d52548fd7058d5da7fa9fdbd1b45", size = 1041903 }, + { url = "https://files.pythonhosted.org/packages/e0/9b/643f1500d36d274f7605c2387d868cc9c6805f01d22cdf636316aa4b3075/python_calamine-0.3.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e71ee834988033d3f8254713423ce5232ffe964f1bb2fdc3383f407b8a52dab9", size = 1018479 }, + { url = "https://files.pythonhosted.org/packages/59/0b/fdd4f1aa564e3a9a4d56872e1bb092d05cbe312060ebba0b1fe1dec9ebfa/python_calamine-0.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:139afbf6a23c33c55ce0144e15e89e03e333a59b4864a2e1e0c764cd33390414", size = 670708 }, + { url = "https://files.pythonhosted.org/packages/1c/3d/ff68651390161d6e7e7d4d1c7653febbb1b265dfda2c1ccaebc08ab90c7f/python_calamine-0.3.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dba960d7668ea7c699f5d68f0a8f7c3f9573fbec26a9db4219cb976c8b751384", size = 792104 }, + { url = "https://files.pythonhosted.org/packages/82/66/c316319360a489e2a555eb8891ed1291b291a547a3eee9176c9366fd5c38/python_calamine-0.3.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:41a204b59696cae066f399d7a69637e89d1bd34562d411c96108e3675ab57521", size = 780539 }, + { url = "https://files.pythonhosted.org/packages/bd/ae/05e04a9102ec5a8b8b3d5a40390fb8e100e200e8b02d68926bc7d07e96b7/python_calamine-0.3.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07ef8398036a411896edc6de30eb71a0dcbad61657238525c1c875c089e2a275", size = 849062 }, + { url = "https://files.pythonhosted.org/packages/8e/0f/599c35b6441d3e3909e22c65e80bc3ee2c19372c2ce5a99effd98c853814/python_calamine-0.3.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21775f97acbfe40182bb17c256e2f8ce0c787a30b86f09a6786bc4530b17c94b", size = 857676 }, + { url = "https://files.pythonhosted.org/packages/f4/f3/2f8caba3f64ee7ba4e0f591837f543459f2df48a2e5bc6630617572986b3/python_calamine-0.3.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d4cdd57ebb563e9bc97501b4eaa7ed3545628d8a0ac482e8903894d80332d506", size = 905341 }, + { url = "https://files.pythonhosted.org/packages/a6/16/b4cc2ff022471f4f8428ee95106e89a10b89ee51a842c93c7f61f29de260/python_calamine-0.3.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:af1e60a711d41e24a24917fe41f98ab36adbcb6f5f85af8a0c895defb5de654f", size = 1043217 }, + { url = "https://files.pythonhosted.org/packages/20/32/17e6761f3c591297b6056c471041977c97e9b44d136862b9dd765dc24c18/python_calamine-0.3.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:1faf371a69da8e364d1391cca3a58e46b3aa181e7202ac6452d09f37d3b99f97", size = 1019133 }, + { url = "https://files.pythonhosted.org/packages/44/6d/80122ec732bb103a2145db9b71905122397f87fdcac25ef8e9d3d4a07cb8/python_calamine-0.3.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:d5ddc96b67f805b3cb27e21d070cee6d269d9fd3a3cb6d6f2a30bc44f848d0f7", size = 670732 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-json-logger" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e3/c4/358cd13daa1d912ef795010897a483ab2f0b41c9ea1b35235a8b2f7d15a7/python_json_logger-3.2.1.tar.gz", hash = "sha256:8eb0554ea17cb75b05d2848bc14fb02fbdbd9d6972120781b974380bfa162008", size = 16287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/72/2f30cf26664fcfa0bd8ec5ee62ec90c03bd485e4a294d92aabc76c5203a5/python_json_logger-3.2.1-py3-none-any.whl", hash = "sha256:cdc17047eb5374bd311e748b42f99d71223f3b0e186f4206cc5d52aefe85b090", size = 14924 }, +] + +[[package]] +name = "pytz" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/57/df1c9157c8d5a05117e455d66fd7cf6dbc46974f832b1058ed4856785d8a/pytz-2025.1.tar.gz", hash = "sha256:c2db42be2a2518b28e65f9207c4d05e6ff547d1efa4086469ef855e4ab70178e", size = 319617 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/38/ac33370d784287baa1c3d538978b5e2ea064d4c1b93ffbd12826c190dd10/pytz-2025.1-py2.py3-none-any.whl", hash = "sha256:89dd22dca55b46eac6eda23b2d72721bf1bdfef212645d81513ef5d03038de57", size = 507930 }, +] + +[[package]] +name = "pywin32" +version = "308" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/a6/3e9f2c474895c1bb61b11fa9640be00067b5c5b363c501ee9c3fa53aec01/pywin32-308-cp310-cp310-win32.whl", hash = "sha256:796ff4426437896550d2981b9c2ac0ffd75238ad9ea2d3bfa67a1abd546d262e", size = 5927028 }, + { url = "https://files.pythonhosted.org/packages/d9/b4/84e2463422f869b4b718f79eb7530a4c1693e96b8a4e5e968de38be4d2ba/pywin32-308-cp310-cp310-win_amd64.whl", hash = "sha256:4fc888c59b3c0bef905ce7eb7e2106a07712015ea1c8234b703a088d46110e8e", size = 6558484 }, + { url = "https://files.pythonhosted.org/packages/9f/8f/fb84ab789713f7c6feacaa08dad3ec8105b88ade8d1c4f0f0dfcaaa017d6/pywin32-308-cp310-cp310-win_arm64.whl", hash = "sha256:a5ab5381813b40f264fa3495b98af850098f814a25a63589a8e9eb12560f450c", size = 7971454 }, + { url = "https://files.pythonhosted.org/packages/eb/e2/02652007469263fe1466e98439831d65d4ca80ea1a2df29abecedf7e47b7/pywin32-308-cp311-cp311-win32.whl", hash = "sha256:5d8c8015b24a7d6855b1550d8e660d8daa09983c80e5daf89a273e5c6fb5095a", size = 5928156 }, + { url = "https://files.pythonhosted.org/packages/48/ef/f4fb45e2196bc7ffe09cad0542d9aff66b0e33f6c0954b43e49c33cad7bd/pywin32-308-cp311-cp311-win_amd64.whl", hash = "sha256:575621b90f0dc2695fec346b2d6302faebd4f0f45c05ea29404cefe35d89442b", size = 6559559 }, + { url = "https://files.pythonhosted.org/packages/79/ef/68bb6aa865c5c9b11a35771329e95917b5559845bd75b65549407f9fc6b4/pywin32-308-cp311-cp311-win_arm64.whl", hash = "sha256:100a5442b7332070983c4cd03f2e906a5648a5104b8a7f50175f7906efd16bb6", size = 7972495 }, + { url = "https://files.pythonhosted.org/packages/00/7c/d00d6bdd96de4344e06c4afbf218bc86b54436a94c01c71a8701f613aa56/pywin32-308-cp312-cp312-win32.whl", hash = "sha256:587f3e19696f4bf96fde9d8a57cec74a57021ad5f204c9e627e15c33ff568897", size = 5939729 }, + { url = "https://files.pythonhosted.org/packages/21/27/0c8811fbc3ca188f93b5354e7c286eb91f80a53afa4e11007ef661afa746/pywin32-308-cp312-cp312-win_amd64.whl", hash = "sha256:00b3e11ef09ede56c6a43c71f2d31857cf7c54b0ab6e78ac659497abd2834f47", size = 6543015 }, + { url = "https://files.pythonhosted.org/packages/9d/0f/d40f8373608caed2255781a3ad9a51d03a594a1248cd632d6a298daca693/pywin32-308-cp312-cp312-win_arm64.whl", hash = "sha256:9b4de86c8d909aed15b7011182c8cab38c8850de36e6afb1f0db22b8959e3091", size = 7976033 }, + { url = "https://files.pythonhosted.org/packages/a9/a4/aa562d8935e3df5e49c161b427a3a2efad2ed4e9cf81c3de636f1fdddfd0/pywin32-308-cp313-cp313-win32.whl", hash = "sha256:1c44539a37a5b7b21d02ab34e6a4d314e0788f1690d65b48e9b0b89f31abbbed", size = 5938579 }, + { url = "https://files.pythonhosted.org/packages/c7/50/b0efb8bb66210da67a53ab95fd7a98826a97ee21f1d22949863e6d588b22/pywin32-308-cp313-cp313-win_amd64.whl", hash = "sha256:fd380990e792eaf6827fcb7e187b2b4b1cede0585e3d0c9e84201ec27b9905e4", size = 6542056 }, + { url = "https://files.pythonhosted.org/packages/26/df/2b63e3e4f2df0224f8aaf6d131f54fe4e8c96400eb9df563e2aae2e1a1f9/pywin32-308-cp313-cp313-win_arm64.whl", hash = "sha256:ef313c46d4c18dfb82a2431e3051ac8f112ccee1a34f29c263c583c568db63cd", size = 7974986 }, + { url = "https://files.pythonhosted.org/packages/a8/41/ead05a7657ffdbb1edabb954ab80825c4f87a3de0285d59f8290457f9016/pywin32-308-cp39-cp39-win32.whl", hash = "sha256:7873ca4dc60ab3287919881a7d4f88baee4a6e639aa6962de25a98ba6b193341", size = 5991824 }, + { url = "https://files.pythonhosted.org/packages/e4/cd/0838c9a6063bff2e9bac2388ae36524c26c50288b5d7b6aebb6cdf8d375d/pywin32-308-cp39-cp39-win_amd64.whl", hash = "sha256:71b3322d949b4cc20776436a9c9ba0eeedcbc9c650daa536df63f0ff111bb920", size = 6640327 }, +] + +[[package]] +name = "pywinpty" +version = "2.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/7c/917f9c4681bb8d34bfbe0b79d36bbcd902651aeab48790df3d30ba0202fb/pywinpty-2.0.15.tar.gz", hash = "sha256:312cf39153a8736c617d45ce8b6ad6cd2107de121df91c455b10ce6bba7a39b2", size = 29017 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/b7/855db919ae526d2628f3f2e6c281c4cdff7a9a8af51bb84659a9f07b1861/pywinpty-2.0.15-cp310-cp310-win_amd64.whl", hash = "sha256:8e7f5de756a615a38b96cd86fa3cd65f901ce54ce147a3179c45907fa11b4c4e", size = 1405161 }, + { url = "https://files.pythonhosted.org/packages/5e/ac/6884dcb7108af66ad53f73ef4dad096e768c9203a6e6ce5e6b0c4a46e238/pywinpty-2.0.15-cp311-cp311-win_amd64.whl", hash = "sha256:9a6bcec2df2707aaa9d08b86071970ee32c5026e10bcc3cc5f6f391d85baf7ca", size = 1405249 }, + { url = "https://files.pythonhosted.org/packages/88/e5/9714def18c3a411809771a3fbcec70bffa764b9675afb00048a620fca604/pywinpty-2.0.15-cp312-cp312-win_amd64.whl", hash = "sha256:83a8f20b430bbc5d8957249f875341a60219a4e971580f2ba694fbfb54a45ebc", size = 1405243 }, + { url = "https://files.pythonhosted.org/packages/fb/16/2ab7b3b7f55f3c6929e5f629e1a68362981e4e5fed592a2ed1cb4b4914a5/pywinpty-2.0.15-cp313-cp313-win_amd64.whl", hash = "sha256:ab5920877dd632c124b4ed17bc6dd6ef3b9f86cd492b963ffdb1a67b85b0f408", size = 1405020 }, + { url = "https://files.pythonhosted.org/packages/7c/16/edef3515dd2030db2795dbfbe392232c7a0f3dc41b98e92b38b42ba497c7/pywinpty-2.0.15-cp313-cp313t-win_amd64.whl", hash = "sha256:a4560ad8c01e537708d2790dbe7da7d986791de805d89dd0d3697ca59e9e4901", size = 1404151 }, + { url = "https://files.pythonhosted.org/packages/47/96/90fa02f19b1eff7469ad7bf0ef8efca248025de9f1d0a0b25682d2aacf68/pywinpty-2.0.15-cp39-cp39-win_amd64.whl", hash = "sha256:d261cd88fcd358cfb48a7ca0700db3e1c088c9c10403c9ebc0d8a8b57aa6a117", size = 1405302 }, +] + +[[package]] +name = "pyxlsb" +version = "1.0.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/13/eebaeb7a40b062d1c6f7f91d09e73d30a69e33e4baa7cbe4b7658548b1cd/pyxlsb-1.0.10.tar.gz", hash = "sha256:8062d1ea8626d3f1980e8b1cfe91a4483747449242ecb61013bc2df85435f685", size = 22424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/92/345823838ae367c59b63e03aef9c331f485370f9df6d049256a61a28f06d/pyxlsb-1.0.10-py2.py3-none-any.whl", hash = "sha256:87c122a9a622e35ca5e741d2e541201d28af00fb46bec492cfa9586890b120b4", size = 23849 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, + { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777 }, + { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318 }, + { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891 }, + { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614 }, + { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360 }, + { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006 }, + { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577 }, + { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593 }, + { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312 }, +] + +[[package]] +name = "pyyaml-env-tag" +version = "0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/8e/da1c6c58f751b70f8ceb1eb25bc25d524e8f14fe16edcce3f4e3ba08629c/pyyaml_env_tag-0.1.tar.gz", hash = "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb", size = 5631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/66/bbb1dd374f5c870f59c5bb1db0e18cbe7fa739415a24cbd95b2d1f5ae0c4/pyyaml_env_tag-0.1-py3-none-any.whl", hash = "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069", size = 3911 }, +] + +[[package]] +name = "pyzmq" +version = "26.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/e3/8d0382cb59feb111c252b54e8728257416a38ffcb2243c4e4775a3c990fe/pyzmq-26.2.1.tar.gz", hash = "sha256:17d72a74e5e9ff3829deb72897a175333d3ef5b5413948cae3cf7ebf0b02ecca", size = 278433 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/3d/c2d9d46c033d1b51692ea49a22439f7f66d91d5c938e8b5c56ed7a2151c2/pyzmq-26.2.1-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:f39d1227e8256d19899d953e6e19ed2ccb689102e6d85e024da5acf410f301eb", size = 1345451 }, + { url = "https://files.pythonhosted.org/packages/0e/df/4754a8abcdeef280651f9bb51446c47659910940b392a66acff7c37f5cef/pyzmq-26.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a23948554c692df95daed595fdd3b76b420a4939d7a8a28d6d7dea9711878641", size = 942766 }, + { url = "https://files.pythonhosted.org/packages/74/da/e6053a3b13c912eded6c2cdeee22ff3a4c33820d17f9eb24c7b6e957ffe7/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95f5728b367a042df146cec4340d75359ec6237beebf4a8f5cf74657c65b9257", size = 678488 }, + { url = "https://files.pythonhosted.org/packages/9e/50/614934145244142401ca174ca81071777ab93aa88173973ba0154f491e09/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:95f7b01b3f275504011cf4cf21c6b885c8d627ce0867a7e83af1382ebab7b3ff", size = 917115 }, + { url = "https://files.pythonhosted.org/packages/80/2b/ebeb7bc4fc8e9e61650b2e09581597355a4341d413fa9b2947d7a6558119/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80a00370a2ef2159c310e662c7c0f2d030f437f35f478bb8b2f70abd07e26b24", size = 874162 }, + { url = "https://files.pythonhosted.org/packages/79/48/93210621c331ad16313dc2849801411fbae10d91d878853933f2a85df8e7/pyzmq-26.2.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:8531ed35dfd1dd2af95f5d02afd6545e8650eedbf8c3d244a554cf47d8924459", size = 874180 }, + { url = "https://files.pythonhosted.org/packages/f0/8b/40924b4d8e33bfdd54c1970fb50f327e39b90b902f897cf09b30b2e9ac48/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:cdb69710e462a38e6039cf17259d328f86383a06c20482cc154327968712273c", size = 1208139 }, + { url = "https://files.pythonhosted.org/packages/c8/b2/82d6675fc89bd965eae13c45002c792d33f06824589844b03f8ea8fc6d86/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e7eeaef81530d0b74ad0d29eec9997f1c9230c2f27242b8d17e0ee67662c8f6e", size = 1520666 }, + { url = "https://files.pythonhosted.org/packages/9d/e2/5ff15f2d3f920dcc559d477bd9bb3faacd6d79fcf7c5448e585c78f84849/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:361edfa350e3be1f987e592e834594422338d7174364763b7d3de5b0995b16f3", size = 1420056 }, + { url = "https://files.pythonhosted.org/packages/40/a2/f9bbeccf7f75aa0d8963e224e5730abcefbf742e1f2ae9ea60fd9d6ff72b/pyzmq-26.2.1-cp310-cp310-win32.whl", hash = "sha256:637536c07d2fb6a354988b2dd1d00d02eb5dd443f4bbee021ba30881af1c28aa", size = 583874 }, + { url = "https://files.pythonhosted.org/packages/56/b1/44f513135843272f0e12f5aebf4af35839e2a88eb45411f2c8c010d8c856/pyzmq-26.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:45fad32448fd214fbe60030aa92f97e64a7140b624290834cc9b27b3a11f9473", size = 647367 }, + { url = "https://files.pythonhosted.org/packages/27/9c/1bef14a37b02d651a462811bbdb1390b61cd4a5b5e95cbd7cc2d60ef848c/pyzmq-26.2.1-cp310-cp310-win_arm64.whl", hash = "sha256:d9da0289d8201c8a29fd158aaa0dfe2f2e14a181fd45e2dc1fbf969a62c1d594", size = 561784 }, + { url = "https://files.pythonhosted.org/packages/b9/03/5ecc46a6ed5971299f5c03e016ca637802d8660e44392bea774fb7797405/pyzmq-26.2.1-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:c059883840e634a21c5b31d9b9a0e2b48f991b94d60a811092bc37992715146a", size = 1346032 }, + { url = "https://files.pythonhosted.org/packages/40/51/48fec8f990ee644f461ff14c8fe5caa341b0b9b3a0ad7544f8ef17d6f528/pyzmq-26.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ed038a921df836d2f538e509a59cb638df3e70ca0fcd70d0bf389dfcdf784d2a", size = 943324 }, + { url = "https://files.pythonhosted.org/packages/c1/f4/f322b389727c687845e38470b48d7a43c18a83f26d4d5084603c6c3f79ca/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9027a7fcf690f1a3635dc9e55e38a0d6602dbbc0548935d08d46d2e7ec91f454", size = 678418 }, + { url = "https://files.pythonhosted.org/packages/a8/df/2834e3202533bd05032d83e02db7ac09fa1be853bbef59974f2b2e3a8557/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6d75fcb00a1537f8b0c0bb05322bc7e35966148ffc3e0362f0369e44a4a1de99", size = 915466 }, + { url = "https://files.pythonhosted.org/packages/b5/e2/45c0f6e122b562cb8c6c45c0dcac1160a4e2207385ef9b13463e74f93031/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0019cc804ac667fb8c8eaecdb66e6d4a68acf2e155d5c7d6381a5645bd93ae4", size = 873347 }, + { url = "https://files.pythonhosted.org/packages/de/b9/3e0fbddf8b87454e914501d368171466a12550c70355b3844115947d68ea/pyzmq-26.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:f19dae58b616ac56b96f2e2290f2d18730a898a171f447f491cc059b073ca1fa", size = 874545 }, + { url = "https://files.pythonhosted.org/packages/1f/1c/1ee41d6e10b2127263b1994bc53b9e74ece015b0d2c0a30e0afaf69b78b2/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f5eeeb82feec1fc5cbafa5ee9022e87ffdb3a8c48afa035b356fcd20fc7f533f", size = 1208630 }, + { url = "https://files.pythonhosted.org/packages/3d/a9/50228465c625851a06aeee97c74f253631f509213f979166e83796299c60/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:000760e374d6f9d1a3478a42ed0c98604de68c9e94507e5452951e598ebecfba", size = 1519568 }, + { url = "https://files.pythonhosted.org/packages/c6/f2/6360b619e69da78863c2108beb5196ae8b955fe1e161c0b886b95dc6b1ac/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:817fcd3344d2a0b28622722b98500ae9c8bfee0f825b8450932ff19c0b15bebd", size = 1419677 }, + { url = "https://files.pythonhosted.org/packages/da/d5/f179da989168f5dfd1be8103ef508ade1d38a8078dda4f10ebae3131a490/pyzmq-26.2.1-cp311-cp311-win32.whl", hash = "sha256:88812b3b257f80444a986b3596e5ea5c4d4ed4276d2b85c153a6fbc5ca457ae7", size = 582682 }, + { url = "https://files.pythonhosted.org/packages/60/50/e5b2e9de3ffab73ff92bee736216cf209381081fa6ab6ba96427777d98b1/pyzmq-26.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:ef29630fde6022471d287c15c0a2484aba188adbfb978702624ba7a54ddfa6c1", size = 648128 }, + { url = "https://files.pythonhosted.org/packages/d9/fe/7bb93476dd8405b0fc9cab1fd921a08bd22d5e3016aa6daea1a78d54129b/pyzmq-26.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:f32718ee37c07932cc336096dc7403525301fd626349b6eff8470fe0f996d8d7", size = 562465 }, + { url = "https://files.pythonhosted.org/packages/9c/b9/260a74786f162c7f521f5f891584a51d5a42fd15f5dcaa5c9226b2865fcc/pyzmq-26.2.1-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:a6549ecb0041dafa55b5932dcbb6c68293e0bd5980b5b99f5ebb05f9a3b8a8f3", size = 1348495 }, + { url = "https://files.pythonhosted.org/packages/bf/73/8a0757e4b68f5a8ccb90ddadbb76c6a5f880266cdb18be38c99bcdc17aaa/pyzmq-26.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0250c94561f388db51fd0213cdccbd0b9ef50fd3c57ce1ac937bf3034d92d72e", size = 945035 }, + { url = "https://files.pythonhosted.org/packages/cf/de/f02ec973cd33155bb772bae33ace774acc7cc71b87b25c4829068bec35de/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36ee4297d9e4b34b5dc1dd7ab5d5ea2cbba8511517ef44104d2915a917a56dc8", size = 671213 }, + { url = "https://files.pythonhosted.org/packages/d1/80/8fc583085f85ac91682744efc916888dd9f11f9f75a31aef1b78a5486c6c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2a9cb17fd83b7a3a3009901aca828feaf20aa2451a8a487b035455a86549c09", size = 908750 }, + { url = "https://files.pythonhosted.org/packages/c3/25/0b4824596f261a3cc512ab152448b383047ff5f143a6906a36876415981c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:786dd8a81b969c2081b31b17b326d3a499ddd1856e06d6d79ad41011a25148da", size = 865416 }, + { url = "https://files.pythonhosted.org/packages/a1/d1/6fda77a034d02034367b040973fd3861d945a5347e607bd2e98c99f20599/pyzmq-26.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2d88ba221a07fc2c5581565f1d0fe8038c15711ae79b80d9462e080a1ac30435", size = 865922 }, + { url = "https://files.pythonhosted.org/packages/ad/81/48f7fd8a71c427412e739ce576fc1ee14f3dc34527ca9b0076e471676183/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1c84c1297ff9f1cd2440da4d57237cb74be21fdfe7d01a10810acba04e79371a", size = 1201526 }, + { url = "https://files.pythonhosted.org/packages/c7/d8/818f15c6ef36b5450e435cbb0d3a51599fc884a5d2b27b46b9c00af68ef1/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:46d4ebafc27081a7f73a0f151d0c38d4291656aa134344ec1f3d0199ebfbb6d4", size = 1512808 }, + { url = "https://files.pythonhosted.org/packages/d9/c4/b3edb7d0ae82ad6fb1a8cdb191a4113c427a01e85139906f3b655b07f4f8/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:91e2bfb8e9a29f709d51b208dd5f441dc98eb412c8fe75c24ea464734ccdb48e", size = 1411836 }, + { url = "https://files.pythonhosted.org/packages/69/1c/151e3d42048f02cc5cd6dfc241d9d36b38375b4dee2e728acb5c353a6d52/pyzmq-26.2.1-cp312-cp312-win32.whl", hash = "sha256:4a98898fdce380c51cc3e38ebc9aa33ae1e078193f4dc641c047f88b8c690c9a", size = 581378 }, + { url = "https://files.pythonhosted.org/packages/b6/b9/d59a7462848aaab7277fddb253ae134a570520115d80afa85e952287e6bc/pyzmq-26.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:a0741edbd0adfe5f30bba6c5223b78c131b5aa4a00a223d631e5ef36e26e6d13", size = 643737 }, + { url = "https://files.pythonhosted.org/packages/55/09/f37e707937cce328944c1d57e5e50ab905011d35252a0745c4f7e5822a76/pyzmq-26.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:e5e33b1491555843ba98d5209439500556ef55b6ab635f3a01148545498355e5", size = 558303 }, + { url = "https://files.pythonhosted.org/packages/4f/2e/fa7a91ce349975971d6aa925b4c7e1a05abaae99b97ade5ace758160c43d/pyzmq-26.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:099b56ef464bc355b14381f13355542e452619abb4c1e57a534b15a106bf8e23", size = 942331 }, + { url = "https://files.pythonhosted.org/packages/64/2b/1f10b34b6dc7ff4b40f668ea25ba9b8093ce61d874c784b90229b367707b/pyzmq-26.2.1-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:651726f37fcbce9f8dd2a6dab0f024807929780621890a4dc0c75432636871be", size = 1345831 }, + { url = "https://files.pythonhosted.org/packages/4c/8d/34884cbd4a8ec050841b5fb58d37af136766a9f95b0b2634c2971deb09da/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57dd4d91b38fa4348e237a9388b4423b24ce9c1695bbd4ba5a3eada491e09399", size = 670773 }, + { url = "https://files.pythonhosted.org/packages/0f/f4/d4becfcf9e416ad2564f18a6653f7c6aa917da08df5c3760edb0baa1c863/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d51a7bfe01a48e1064131f3416a5439872c533d756396be2b39e3977b41430f9", size = 908836 }, + { url = "https://files.pythonhosted.org/packages/07/fa/ab105f1b86b85cb2e821239f1d0900fccd66192a91d97ee04661b5436b4d/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c7154d228502e18f30f150b7ce94f0789d6b689f75261b623f0fdc1eec642aab", size = 865369 }, + { url = "https://files.pythonhosted.org/packages/c9/48/15d5f415504572dd4b92b52db5de7a5befc76bb75340ba9f36f71306a66d/pyzmq-26.2.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:f1f31661a80cc46aba381bed475a9135b213ba23ca7ff6797251af31510920ce", size = 865676 }, + { url = "https://files.pythonhosted.org/packages/7e/35/2d91bcc7ccbb56043dd4d2c1763f24a8de5f05e06a134f767a7fb38e149c/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:290c96f479504439b6129a94cefd67a174b68ace8a8e3f551b2239a64cfa131a", size = 1201457 }, + { url = "https://files.pythonhosted.org/packages/6d/bb/aa7c5119307a5762b8dca6c9db73e3ab4bccf32b15d7c4f376271ff72b2b/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:f2c307fbe86e18ab3c885b7e01de942145f539165c3360e2af0f094dd440acd9", size = 1513035 }, + { url = "https://files.pythonhosted.org/packages/4f/4c/527e6650c2fccec7750b783301329c8a8716d59423818afb67282304ce5a/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b314268e716487bfb86fcd6f84ebbe3e5bec5fac75fdf42bc7d90fdb33f618ad", size = 1411881 }, + { url = "https://files.pythonhosted.org/packages/89/9f/e4412ea1b3e220acc21777a5edba8885856403d29c6999aaf00a9459eb03/pyzmq-26.2.1-cp313-cp313-win32.whl", hash = "sha256:edb550616f567cd5603b53bb52a5f842c0171b78852e6fc7e392b02c2a1504bb", size = 581354 }, + { url = "https://files.pythonhosted.org/packages/55/cd/f89dd3e9fc2da0d1619a82c4afb600c86b52bc72d7584953d460bc8d5027/pyzmq-26.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:100a826a029c8ef3d77a1d4c97cbd6e867057b5806a7276f2bac1179f893d3bf", size = 643560 }, + { url = "https://files.pythonhosted.org/packages/a7/99/5de4f8912860013f1116f818a0047659bc20d71d1bc1d48f874bdc2d7b9c/pyzmq-26.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:6991ee6c43e0480deb1b45d0c7c2bac124a6540cba7db4c36345e8e092da47ce", size = 558037 }, + { url = "https://files.pythonhosted.org/packages/06/0b/63b6d7a2f07a77dbc9768c6302ae2d7518bed0c6cee515669ca0d8ec743e/pyzmq-26.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:25e720dba5b3a3bb2ad0ad5d33440babd1b03438a7a5220511d0c8fa677e102e", size = 938580 }, + { url = "https://files.pythonhosted.org/packages/85/38/e5e2c3ffa23ea5f95f1c904014385a55902a11a67cd43c10edf61a653467/pyzmq-26.2.1-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:9ec6abfb701437142ce9544bd6a236addaf803a32628d2260eb3dbd9a60e2891", size = 1339670 }, + { url = "https://files.pythonhosted.org/packages/d2/87/da5519ed7f8b31e4beee8f57311ec02926822fe23a95120877354cd80144/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e1eb9d2bfdf5b4e21165b553a81b2c3bd5be06eeddcc4e08e9692156d21f1f6", size = 660983 }, + { url = "https://files.pythonhosted.org/packages/f6/e8/1ca6a2d59562e04d326a026c9e3f791a6f1a276ebde29da478843a566fdb/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90dc731d8e3e91bcd456aa7407d2eba7ac6f7860e89f3766baabb521f2c1de4a", size = 896509 }, + { url = "https://files.pythonhosted.org/packages/5c/e5/0b4688f7c74bea7e4f1e920da973fcd7d20175f4f1181cb9b692429c6bb9/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6a93d684278ad865fc0b9e89fe33f6ea72d36da0e842143891278ff7fd89c3", size = 853196 }, + { url = "https://files.pythonhosted.org/packages/8f/35/c17241da01195001828319e98517683dad0ac4df6fcba68763d61b630390/pyzmq-26.2.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:c1bb37849e2294d519117dd99b613c5177934e5c04a5bb05dd573fa42026567e", size = 855133 }, + { url = "https://files.pythonhosted.org/packages/d2/14/268ee49bbecc3f72e225addeac7f0e2bd5808747b78c7bf7f87ed9f9d5a8/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:632a09c6d8af17b678d84df442e9c3ad8e4949c109e48a72f805b22506c4afa7", size = 1191612 }, + { url = "https://files.pythonhosted.org/packages/5e/02/6394498620b1b4349b95c534f3ebc3aef95f39afbdced5ed7ee315c49c14/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:fc409c18884eaf9ddde516d53af4f2db64a8bc7d81b1a0c274b8aa4e929958e8", size = 1500824 }, + { url = "https://files.pythonhosted.org/packages/17/fc/b79f0b72891cbb9917698add0fede71dfb64e83fa3481a02ed0e78c34be7/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:17f88622b848805d3f6427ce1ad5a2aa3cf61f12a97e684dab2979802024d460", size = 1399943 }, + { url = "https://files.pythonhosted.org/packages/8d/a4/42e404040ccb3f65bd3b40e368dc96fb04b8e7eea1ecd3ac2ef0e70c51f3/pyzmq-26.2.1-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:a4bffcadfd40660f26d1b3315a6029fd4f8f5bf31a74160b151f5c577b2dc81b", size = 1346647 }, + { url = "https://files.pythonhosted.org/packages/d5/d9/045ee93500e3f8cbd2a7b30a9533cba7b857b51b3bb4ec44fa61eb6d36ef/pyzmq-26.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e76ad4729c2f1cf74b6eb1bdd05f6aba6175999340bd51e6caee49a435a13bf5", size = 943305 }, + { url = "https://files.pythonhosted.org/packages/5c/3b/9437cae0bfd3889dc7741ed9c132dc09c2a1fcae05a2e1b1af41a23a77a2/pyzmq-26.2.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8b0f5bab40a16e708e78a0c6ee2425d27e1a5d8135c7a203b4e977cee37eb4aa", size = 913424 }, + { url = "https://files.pythonhosted.org/packages/5c/16/f1f0e36c9c15247901379b45bd3f7cc15f540b62c9c34c28e735550014b4/pyzmq-26.2.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e8e47050412f0ad3a9b2287779758073cbf10e460d9f345002d4779e43bb0136", size = 867471 }, + { url = "https://files.pythonhosted.org/packages/70/68/3a0dd3b6386d725ffb98378cd046e15333fbcc1e2b3b48dbcda73259a752/pyzmq-26.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f18ce33f422d119b13c1363ed4cce245b342b2c5cbbb76753eabf6aa6f69c7d", size = 679051 }, + { url = "https://files.pythonhosted.org/packages/46/9a/0c57cd9c0aae885a096f0c7ebd658f6c7fda49973e484bf7f1c47288beae/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ceb0d78b7ef106708a7e2c2914afe68efffc0051dc6a731b0dbacd8b4aee6d68", size = 1208959 }, + { url = "https://files.pythonhosted.org/packages/61/f7/22dcf86ab2a4d458a300698972212be327a66e35785649e9f4bad2260f1c/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7ebdd96bd637fd426d60e86a29ec14b8c1ab64b8d972f6a020baf08a30d1cf46", size = 1521237 }, + { url = "https://files.pythonhosted.org/packages/b4/20/854bb34ac377efbe15d791d6e0bf991d8127cc6d471cd9a2666a13b4f3ba/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:03719e424150c6395b9513f53a5faadcc1ce4b92abdf68987f55900462ac7eec", size = 1420720 }, + { url = "https://files.pythonhosted.org/packages/6d/e3/07816d8b50a506f6f59d0023b8fefa109d5549a874b9d250137e85dc4305/pyzmq-26.2.1-cp39-cp39-win32.whl", hash = "sha256:ef5479fac31df4b304e96400fc67ff08231873ee3537544aa08c30f9d22fce38", size = 584311 }, + { url = "https://files.pythonhosted.org/packages/9f/78/eeb040669d0ac1fc3c061c8053e96a49e5c612041f462b026ad154001ac1/pyzmq-26.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:f92a002462154c176dac63a8f1f6582ab56eb394ef4914d65a9417f5d9fde218", size = 647856 }, + { url = "https://files.pythonhosted.org/packages/2c/c9/55eb55eda712573ca759e17b9018a2f9dbc4dd34bc7c862c36d574a40b1f/pyzmq-26.2.1-cp39-cp39-win_arm64.whl", hash = "sha256:1fd4b3efc6f62199886440d5e27dd3ccbcb98dfddf330e7396f1ff421bfbb3c2", size = 562372 }, + { url = "https://files.pythonhosted.org/packages/65/d1/e630a75cfb2534574a1258fda54d02f13cf80b576d4ce6d2aa478dc67829/pyzmq-26.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:380816d298aed32b1a97b4973a4865ef3be402a2e760204509b52b6de79d755d", size = 847743 }, + { url = "https://files.pythonhosted.org/packages/27/df/f94a711b4f6c4b41e227f9a938103f52acf4c2e949d91cbc682495a48155/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97cbb368fd0debdbeb6ba5966aa28e9a1ae3396c7386d15569a6ca4be4572b99", size = 570991 }, + { url = "https://files.pythonhosted.org/packages/bf/08/0c6f97fb3c9dbfa23382f0efaf8f9aa1396a08a3358974eaae3ee659ed5c/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abf7b5942c6b0dafcc2823ddd9154f419147e24f8df5b41ca8ea40a6db90615c", size = 799664 }, + { url = "https://files.pythonhosted.org/packages/05/14/f4d4fd8bb8988c667845734dd756e9ee65b9a17a010d5f288dfca14a572d/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fe6e28a8856aea808715f7a4fc11f682b9d29cac5d6262dd8fe4f98edc12d53", size = 758156 }, + { url = "https://files.pythonhosted.org/packages/e3/fe/72e7e166bda3885810bee7b23049133e142f7c80c295bae02c562caeea16/pyzmq-26.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bd8fdee945b877aa3bffc6a5a8816deb048dab0544f9df3731ecd0e54d8c84c9", size = 556563 }, + { url = "https://files.pythonhosted.org/packages/d9/6b/f27dfd4b7b3d6a8bd39ab1469fb8f8685c597d6772cbf3b39b1c4d798eee/pyzmq-26.2.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1238c2448c58b9c8d6565579393148414a42488a5f916b3f322742e561f6ae0d", size = 847735 }, + { url = "https://files.pythonhosted.org/packages/f5/1f/fe0698f36c619bc960e97efe9a8ece412a7dc4c80e0bd603cde81731c6ca/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8eddb3784aed95d07065bcf94d07e8c04024fdb6b2386f08c197dfe6b3528fda", size = 570986 }, + { url = "https://files.pythonhosted.org/packages/91/2e/f7f6c00d16db2b1936f3cd3b8362c391e40dd16a646b92ebf2f3b28206ee/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f0f19c2097fffb1d5b07893d75c9ee693e9cbc809235cf3f2267f0ef6b015f24", size = 799658 }, + { url = "https://files.pythonhosted.org/packages/50/98/aa114911fcb65645099d6db5694a49975ef442f2c34532ea5365b6ec6da8/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0995fd3530f2e89d6b69a2202e340bbada3191014352af978fa795cb7a446331", size = 758151 }, + { url = "https://files.pythonhosted.org/packages/53/58/9909ad7a3112999a30464c5c92937c9eec5f5e6905a1eee45fd99788ce56/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:7c6160fe513654e65665332740f63de29ce0d165e053c0c14a161fa60dd0da01", size = 756685 }, + { url = "https://files.pythonhosted.org/packages/01/28/1c0f44e609b91a1168aaf4ac38511645fd725593b41cd54ef06744d502ff/pyzmq-26.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8ec8e3aea6146b761d6c57fcf8f81fcb19f187afecc19bf1701a48db9617a217", size = 556558 }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 }, +] + +[[package]] +name = "regex" +version = "2024.11.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/5f/bd69653fbfb76cf8604468d3b4ec4c403197144c7bfe0e6a5fc9e02a07cb/regex-2024.11.6.tar.gz", hash = "sha256:7ab159b063c52a0333c884e4679f8d7a85112ee3078fe3d9004b2dd875585519", size = 399494 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/3c/4651f6b130c6842a8f3df82461a8950f923925db8b6961063e82744bddcc/regex-2024.11.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff590880083d60acc0433f9c3f713c51f7ac6ebb9adf889c79a261ecf541aa91", size = 482674 }, + { url = "https://files.pythonhosted.org/packages/15/51/9f35d12da8434b489c7b7bffc205c474a0a9432a889457026e9bc06a297a/regex-2024.11.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:658f90550f38270639e83ce492f27d2c8d2cd63805c65a13a14d36ca126753f0", size = 287684 }, + { url = "https://files.pythonhosted.org/packages/bd/18/b731f5510d1b8fb63c6b6d3484bfa9a59b84cc578ac8b5172970e05ae07c/regex-2024.11.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:164d8b7b3b4bcb2068b97428060b2a53be050085ef94eca7f240e7947f1b080e", size = 284589 }, + { url = "https://files.pythonhosted.org/packages/78/a2/6dd36e16341ab95e4c6073426561b9bfdeb1a9c9b63ab1b579c2e96cb105/regex-2024.11.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3660c82f209655a06b587d55e723f0b813d3a7db2e32e5e7dc64ac2a9e86fde", size = 782511 }, + { url = "https://files.pythonhosted.org/packages/1b/2b/323e72d5d2fd8de0d9baa443e1ed70363ed7e7b2fb526f5950c5cb99c364/regex-2024.11.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d22326fcdef5e08c154280b71163ced384b428343ae16a5ab2b3354aed12436e", size = 821149 }, + { url = "https://files.pythonhosted.org/packages/90/30/63373b9ea468fbef8a907fd273e5c329b8c9535fee36fc8dba5fecac475d/regex-2024.11.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1ac758ef6aebfc8943560194e9fd0fa18bcb34d89fd8bd2af18183afd8da3a2", size = 809707 }, + { url = "https://files.pythonhosted.org/packages/f2/98/26d3830875b53071f1f0ae6d547f1d98e964dd29ad35cbf94439120bb67a/regex-2024.11.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:997d6a487ff00807ba810e0f8332c18b4eb8d29463cfb7c820dc4b6e7562d0cf", size = 781702 }, + { url = "https://files.pythonhosted.org/packages/87/55/eb2a068334274db86208ab9d5599ffa63631b9f0f67ed70ea7c82a69bbc8/regex-2024.11.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02a02d2bb04fec86ad61f3ea7f49c015a0681bf76abb9857f945d26159d2968c", size = 771976 }, + { url = "https://files.pythonhosted.org/packages/74/c0/be707bcfe98254d8f9d2cff55d216e946f4ea48ad2fd8cf1428f8c5332ba/regex-2024.11.6-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f02f93b92358ee3f78660e43b4b0091229260c5d5c408d17d60bf26b6c900e86", size = 697397 }, + { url = "https://files.pythonhosted.org/packages/49/dc/bb45572ceb49e0f6509f7596e4ba7031f6819ecb26bc7610979af5a77f45/regex-2024.11.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:06eb1be98df10e81ebaded73fcd51989dcf534e3c753466e4b60c4697a003b67", size = 768726 }, + { url = "https://files.pythonhosted.org/packages/5a/db/f43fd75dc4c0c2d96d0881967897926942e935d700863666f3c844a72ce6/regex-2024.11.6-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:040df6fe1a5504eb0f04f048e6d09cd7c7110fef851d7c567a6b6e09942feb7d", size = 775098 }, + { url = "https://files.pythonhosted.org/packages/99/d7/f94154db29ab5a89d69ff893159b19ada89e76b915c1293e98603d39838c/regex-2024.11.6-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabbfc59f2c6edba2a6622c647b716e34e8e3867e0ab975412c5c2f79b82da2", size = 839325 }, + { url = "https://files.pythonhosted.org/packages/f7/17/3cbfab1f23356fbbf07708220ab438a7efa1e0f34195bf857433f79f1788/regex-2024.11.6-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8447d2d39b5abe381419319f942de20b7ecd60ce86f16a23b0698f22e1b70008", size = 843277 }, + { url = "https://files.pythonhosted.org/packages/7e/f2/48b393b51900456155de3ad001900f94298965e1cad1c772b87f9cfea011/regex-2024.11.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:da8f5fc57d1933de22a9e23eec290a0d8a5927a5370d24bda9a6abe50683fe62", size = 773197 }, + { url = "https://files.pythonhosted.org/packages/45/3f/ef9589aba93e084cd3f8471fded352826dcae8489b650d0b9b27bc5bba8a/regex-2024.11.6-cp310-cp310-win32.whl", hash = "sha256:b489578720afb782f6ccf2840920f3a32e31ba28a4b162e13900c3e6bd3f930e", size = 261714 }, + { url = "https://files.pythonhosted.org/packages/42/7e/5f1b92c8468290c465fd50c5318da64319133231415a8aa6ea5ab995a815/regex-2024.11.6-cp310-cp310-win_amd64.whl", hash = "sha256:5071b2093e793357c9d8b2929dfc13ac5f0a6c650559503bb81189d0a3814519", size = 274042 }, + { url = "https://files.pythonhosted.org/packages/58/58/7e4d9493a66c88a7da6d205768119f51af0f684fe7be7bac8328e217a52c/regex-2024.11.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5478c6962ad548b54a591778e93cd7c456a7a29f8eca9c49e4f9a806dcc5d638", size = 482669 }, + { url = "https://files.pythonhosted.org/packages/34/4c/8f8e631fcdc2ff978609eaeef1d6994bf2f028b59d9ac67640ed051f1218/regex-2024.11.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2c89a8cc122b25ce6945f0423dc1352cb9593c68abd19223eebbd4e56612c5b7", size = 287684 }, + { url = "https://files.pythonhosted.org/packages/c5/1b/f0e4d13e6adf866ce9b069e191f303a30ab1277e037037a365c3aad5cc9c/regex-2024.11.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:94d87b689cdd831934fa3ce16cc15cd65748e6d689f5d2b8f4f4df2065c9fa20", size = 284589 }, + { url = "https://files.pythonhosted.org/packages/25/4d/ab21047f446693887f25510887e6820b93f791992994f6498b0318904d4a/regex-2024.11.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1062b39a0a2b75a9c694f7a08e7183a80c63c0d62b301418ffd9c35f55aaa114", size = 792121 }, + { url = "https://files.pythonhosted.org/packages/45/ee/c867e15cd894985cb32b731d89576c41a4642a57850c162490ea34b78c3b/regex-2024.11.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:167ed4852351d8a750da48712c3930b031f6efdaa0f22fa1933716bfcd6bf4a3", size = 831275 }, + { url = "https://files.pythonhosted.org/packages/b3/12/b0f480726cf1c60f6536fa5e1c95275a77624f3ac8fdccf79e6727499e28/regex-2024.11.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d548dafee61f06ebdb584080621f3e0c23fff312f0de1afc776e2a2ba99a74f", size = 818257 }, + { url = "https://files.pythonhosted.org/packages/bf/ce/0d0e61429f603bac433910d99ef1a02ce45a8967ffbe3cbee48599e62d88/regex-2024.11.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a19f302cd1ce5dd01a9099aaa19cae6173306d1302a43b627f62e21cf18ac0", size = 792727 }, + { url = "https://files.pythonhosted.org/packages/e4/c1/243c83c53d4a419c1556f43777ccb552bccdf79d08fda3980e4e77dd9137/regex-2024.11.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bec9931dfb61ddd8ef2ebc05646293812cb6b16b60cf7c9511a832b6f1854b55", size = 780667 }, + { url = "https://files.pythonhosted.org/packages/c5/f4/75eb0dd4ce4b37f04928987f1d22547ddaf6c4bae697623c1b05da67a8aa/regex-2024.11.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9714398225f299aa85267fd222f7142fcb5c769e73d7733344efc46f2ef5cf89", size = 776963 }, + { url = "https://files.pythonhosted.org/packages/16/5d/95c568574e630e141a69ff8a254c2f188b4398e813c40d49228c9bbd9875/regex-2024.11.6-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:202eb32e89f60fc147a41e55cb086db2a3f8cb82f9a9a88440dcfc5d37faae8d", size = 784700 }, + { url = "https://files.pythonhosted.org/packages/8e/b5/f8495c7917f15cc6fee1e7f395e324ec3e00ab3c665a7dc9d27562fd5290/regex-2024.11.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4181b814e56078e9b00427ca358ec44333765f5ca1b45597ec7446d3a1ef6e34", size = 848592 }, + { url = "https://files.pythonhosted.org/packages/1c/80/6dd7118e8cb212c3c60b191b932dc57db93fb2e36fb9e0e92f72a5909af9/regex-2024.11.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:068376da5a7e4da51968ce4c122a7cd31afaaec4fccc7856c92f63876e57b51d", size = 852929 }, + { url = "https://files.pythonhosted.org/packages/11/9b/5a05d2040297d2d254baf95eeeb6df83554e5e1df03bc1a6687fc4ba1f66/regex-2024.11.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ac10f2c4184420d881a3475fb2c6f4d95d53a8d50209a2500723d831036f7c45", size = 781213 }, + { url = "https://files.pythonhosted.org/packages/26/b7/b14e2440156ab39e0177506c08c18accaf2b8932e39fb092074de733d868/regex-2024.11.6-cp311-cp311-win32.whl", hash = "sha256:c36f9b6f5f8649bb251a5f3f66564438977b7ef8386a52460ae77e6070d309d9", size = 261734 }, + { url = "https://files.pythonhosted.org/packages/80/32/763a6cc01d21fb3819227a1cc3f60fd251c13c37c27a73b8ff4315433a8e/regex-2024.11.6-cp311-cp311-win_amd64.whl", hash = "sha256:02e28184be537f0e75c1f9b2f8847dc51e08e6e171c6bde130b2687e0c33cf60", size = 274052 }, + { url = "https://files.pythonhosted.org/packages/ba/30/9a87ce8336b172cc232a0db89a3af97929d06c11ceaa19d97d84fa90a8f8/regex-2024.11.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:52fb28f528778f184f870b7cf8f225f5eef0a8f6e3778529bdd40c7b3920796a", size = 483781 }, + { url = "https://files.pythonhosted.org/packages/01/e8/00008ad4ff4be8b1844786ba6636035f7ef926db5686e4c0f98093612add/regex-2024.11.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdd6028445d2460f33136c55eeb1f601ab06d74cb3347132e1c24250187500d9", size = 288455 }, + { url = "https://files.pythonhosted.org/packages/60/85/cebcc0aff603ea0a201667b203f13ba75d9fc8668fab917ac5b2de3967bc/regex-2024.11.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805e6b60c54bf766b251e94526ebad60b7de0c70f70a4e6210ee2891acb70bf2", size = 284759 }, + { url = "https://files.pythonhosted.org/packages/94/2b/701a4b0585cb05472a4da28ee28fdfe155f3638f5e1ec92306d924e5faf0/regex-2024.11.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b85c2530be953a890eaffde05485238f07029600e8f098cdf1848d414a8b45e4", size = 794976 }, + { url = "https://files.pythonhosted.org/packages/4b/bf/fa87e563bf5fee75db8915f7352e1887b1249126a1be4813837f5dbec965/regex-2024.11.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb26437975da7dc36b7efad18aa9dd4ea569d2357ae6b783bf1118dabd9ea577", size = 833077 }, + { url = "https://files.pythonhosted.org/packages/a1/56/7295e6bad94b047f4d0834e4779491b81216583c00c288252ef625c01d23/regex-2024.11.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abfa5080c374a76a251ba60683242bc17eeb2c9818d0d30117b4486be10c59d3", size = 823160 }, + { url = "https://files.pythonhosted.org/packages/fb/13/e3b075031a738c9598c51cfbc4c7879e26729c53aa9cca59211c44235314/regex-2024.11.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b7fa6606c2881c1db9479b0eaa11ed5dfa11c8d60a474ff0e095099f39d98e", size = 796896 }, + { url = "https://files.pythonhosted.org/packages/24/56/0b3f1b66d592be6efec23a795b37732682520b47c53da5a32c33ed7d84e3/regex-2024.11.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c32f75920cf99fe6b6c539c399a4a128452eaf1af27f39bce8909c9a3fd8cbe", size = 783997 }, + { url = "https://files.pythonhosted.org/packages/f9/a1/eb378dada8b91c0e4c5f08ffb56f25fcae47bf52ad18f9b2f33b83e6d498/regex-2024.11.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:982e6d21414e78e1f51cf595d7f321dcd14de1f2881c5dc6a6e23bbbbd68435e", size = 781725 }, + { url = "https://files.pythonhosted.org/packages/83/f2/033e7dec0cfd6dda93390089864732a3409246ffe8b042e9554afa9bff4e/regex-2024.11.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a7c2155f790e2fb448faed6dd241386719802296ec588a8b9051c1f5c481bc29", size = 789481 }, + { url = "https://files.pythonhosted.org/packages/83/23/15d4552ea28990a74e7696780c438aadd73a20318c47e527b47a4a5a596d/regex-2024.11.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149f5008d286636e48cd0b1dd65018548944e495b0265b45e1bffecce1ef7f39", size = 852896 }, + { url = "https://files.pythonhosted.org/packages/e3/39/ed4416bc90deedbfdada2568b2cb0bc1fdb98efe11f5378d9892b2a88f8f/regex-2024.11.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e5364a4502efca094731680e80009632ad6624084aff9a23ce8c8c6820de3e51", size = 860138 }, + { url = "https://files.pythonhosted.org/packages/93/2d/dd56bb76bd8e95bbce684326302f287455b56242a4f9c61f1bc76e28360e/regex-2024.11.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0a86e7eeca091c09e021db8eb72d54751e527fa47b8d5787caf96d9831bd02ad", size = 787692 }, + { url = "https://files.pythonhosted.org/packages/0b/55/31877a249ab7a5156758246b9c59539abbeba22461b7d8adc9e8475ff73e/regex-2024.11.6-cp312-cp312-win32.whl", hash = "sha256:32f9a4c643baad4efa81d549c2aadefaeba12249b2adc5af541759237eee1c54", size = 262135 }, + { url = "https://files.pythonhosted.org/packages/38/ec/ad2d7de49a600cdb8dd78434a1aeffe28b9d6fc42eb36afab4a27ad23384/regex-2024.11.6-cp312-cp312-win_amd64.whl", hash = "sha256:a93c194e2df18f7d264092dc8539b8ffb86b45b899ab976aa15d48214138e81b", size = 273567 }, + { url = "https://files.pythonhosted.org/packages/90/73/bcb0e36614601016552fa9344544a3a2ae1809dc1401b100eab02e772e1f/regex-2024.11.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a6ba92c0bcdf96cbf43a12c717eae4bc98325ca3730f6b130ffa2e3c3c723d84", size = 483525 }, + { url = "https://files.pythonhosted.org/packages/0f/3f/f1a082a46b31e25291d830b369b6b0c5576a6f7fb89d3053a354c24b8a83/regex-2024.11.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:525eab0b789891ac3be914d36893bdf972d483fe66551f79d3e27146191a37d4", size = 288324 }, + { url = "https://files.pythonhosted.org/packages/09/c9/4e68181a4a652fb3ef5099e077faf4fd2a694ea6e0f806a7737aff9e758a/regex-2024.11.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:086a27a0b4ca227941700e0b31425e7a28ef1ae8e5e05a33826e17e47fbfdba0", size = 284617 }, + { url = "https://files.pythonhosted.org/packages/fc/fd/37868b75eaf63843165f1d2122ca6cb94bfc0271e4428cf58c0616786dce/regex-2024.11.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bde01f35767c4a7899b7eb6e823b125a64de314a8ee9791367c9a34d56af18d0", size = 795023 }, + { url = "https://files.pythonhosted.org/packages/c4/7c/d4cd9c528502a3dedb5c13c146e7a7a539a3853dc20209c8e75d9ba9d1b2/regex-2024.11.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b583904576650166b3d920d2bcce13971f6f9e9a396c673187f49811b2769dc7", size = 833072 }, + { url = "https://files.pythonhosted.org/packages/4f/db/46f563a08f969159c5a0f0e722260568425363bea43bb7ae370becb66a67/regex-2024.11.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c4de13f06a0d54fa0d5ab1b7138bfa0d883220965a29616e3ea61b35d5f5fc7", size = 823130 }, + { url = "https://files.pythonhosted.org/packages/db/60/1eeca2074f5b87df394fccaa432ae3fc06c9c9bfa97c5051aed70e6e00c2/regex-2024.11.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cde6e9f2580eb1665965ce9bf17ff4952f34f5b126beb509fee8f4e994f143c", size = 796857 }, + { url = "https://files.pythonhosted.org/packages/10/db/ac718a08fcee981554d2f7bb8402f1faa7e868c1345c16ab1ebec54b0d7b/regex-2024.11.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d7f453dca13f40a02b79636a339c5b62b670141e63efd511d3f8f73fba162b3", size = 784006 }, + { url = "https://files.pythonhosted.org/packages/c2/41/7da3fe70216cea93144bf12da2b87367590bcf07db97604edeea55dac9ad/regex-2024.11.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59dfe1ed21aea057a65c6b586afd2a945de04fc7db3de0a6e3ed5397ad491b07", size = 781650 }, + { url = "https://files.pythonhosted.org/packages/a7/d5/880921ee4eec393a4752e6ab9f0fe28009435417c3102fc413f3fe81c4e5/regex-2024.11.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b97c1e0bd37c5cd7902e65f410779d39eeda155800b65fc4d04cc432efa9bc6e", size = 789545 }, + { url = "https://files.pythonhosted.org/packages/dc/96/53770115e507081122beca8899ab7f5ae28ae790bfcc82b5e38976df6a77/regex-2024.11.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d1e379028e0fc2ae3654bac3cbbef81bf3fd571272a42d56c24007979bafb6", size = 853045 }, + { url = "https://files.pythonhosted.org/packages/31/d3/1372add5251cc2d44b451bd94f43b2ec78e15a6e82bff6a290ef9fd8f00a/regex-2024.11.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:13291b39131e2d002a7940fb176e120bec5145f3aeb7621be6534e46251912c4", size = 860182 }, + { url = "https://files.pythonhosted.org/packages/ed/e3/c446a64984ea9f69982ba1a69d4658d5014bc7a0ea468a07e1a1265db6e2/regex-2024.11.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f51f88c126370dcec4908576c5a627220da6c09d0bff31cfa89f2523843316d", size = 787733 }, + { url = "https://files.pythonhosted.org/packages/2b/f1/e40c8373e3480e4f29f2692bd21b3e05f296d3afebc7e5dcf21b9756ca1c/regex-2024.11.6-cp313-cp313-win32.whl", hash = "sha256:63b13cfd72e9601125027202cad74995ab26921d8cd935c25f09c630436348ff", size = 262122 }, + { url = "https://files.pythonhosted.org/packages/45/94/bc295babb3062a731f52621cdc992d123111282e291abaf23faa413443ea/regex-2024.11.6-cp313-cp313-win_amd64.whl", hash = "sha256:2b3361af3198667e99927da8b84c1b010752fa4b1115ee30beaa332cabc3ef1a", size = 273545 }, + { url = "https://files.pythonhosted.org/packages/89/23/c4a86df398e57e26f93b13ae63acce58771e04bdde86092502496fa57f9c/regex-2024.11.6-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5704e174f8ccab2026bd2f1ab6c510345ae8eac818b613d7d73e785f1310f839", size = 482682 }, + { url = "https://files.pythonhosted.org/packages/3c/8b/45c24ab7a51a1658441b961b86209c43e6bb9d39caf1e63f46ce6ea03bc7/regex-2024.11.6-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:220902c3c5cc6af55d4fe19ead504de80eb91f786dc102fbd74894b1551f095e", size = 287679 }, + { url = "https://files.pythonhosted.org/packages/7a/d1/598de10b17fdafc452d11f7dada11c3be4e379a8671393e4e3da3c4070df/regex-2024.11.6-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5e7e351589da0850c125f1600a4c4ba3c722efefe16b297de54300f08d734fbf", size = 284578 }, + { url = "https://files.pythonhosted.org/packages/49/70/c7eaa219efa67a215846766fde18d92d54cb590b6a04ffe43cef30057622/regex-2024.11.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5056b185ca113c88e18223183aa1a50e66507769c9640a6ff75859619d73957b", size = 782012 }, + { url = "https://files.pythonhosted.org/packages/89/e5/ef52c7eb117dd20ff1697968219971d052138965a4d3d9b95e92e549f505/regex-2024.11.6-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e34b51b650b23ed3354b5a07aab37034d9f923db2a40519139af34f485f77d0", size = 820580 }, + { url = "https://files.pythonhosted.org/packages/5f/3f/9f5da81aff1d4167ac52711acf789df13e789fe6ac9545552e49138e3282/regex-2024.11.6-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5670bce7b200273eee1840ef307bfa07cda90b38ae56e9a6ebcc9f50da9c469b", size = 809110 }, + { url = "https://files.pythonhosted.org/packages/86/44/2101cc0890c3621b90365c9ee8d7291a597c0722ad66eccd6ffa7f1bcc09/regex-2024.11.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:08986dce1339bc932923e7d1232ce9881499a0e02925f7402fb7c982515419ef", size = 780919 }, + { url = "https://files.pythonhosted.org/packages/ce/2e/3e0668d8d1c7c3c0d397bf54d92fc182575b3a26939aed5000d3cc78760f/regex-2024.11.6-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:93c0b12d3d3bc25af4ebbf38f9ee780a487e8bf6954c115b9f015822d3bb8e48", size = 771515 }, + { url = "https://files.pythonhosted.org/packages/a6/49/1bc4584254355e3dba930a3a2fd7ad26ccba3ebbab7d9100db0aff2eedb0/regex-2024.11.6-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:764e71f22ab3b305e7f4c21f1a97e1526a25ebdd22513e251cf376760213da13", size = 696957 }, + { url = "https://files.pythonhosted.org/packages/c8/dd/42879c1fc8a37a887cd08e358af3d3ba9e23038cd77c7fe044a86d9450ba/regex-2024.11.6-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:f056bf21105c2515c32372bbc057f43eb02aae2fda61052e2f7622c801f0b4e2", size = 768088 }, + { url = "https://files.pythonhosted.org/packages/89/96/c05a0fe173cd2acd29d5e13c1adad8b706bcaa71b169e1ee57dcf2e74584/regex-2024.11.6-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:69ab78f848845569401469da20df3e081e6b5a11cb086de3eed1d48f5ed57c95", size = 774752 }, + { url = "https://files.pythonhosted.org/packages/b5/f3/a757748066255f97f14506483436c5f6aded7af9e37bca04ec30c90ca683/regex-2024.11.6-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:86fddba590aad9208e2fa8b43b4c098bb0ec74f15718bb6a704e3c63e2cef3e9", size = 838862 }, + { url = "https://files.pythonhosted.org/packages/5c/93/c6d2092fd479dcaeea40fc8fa673822829181ded77d294a7f950f1dda6e2/regex-2024.11.6-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:684d7a212682996d21ca12ef3c17353c021fe9de6049e19ac8481ec35574a70f", size = 842622 }, + { url = "https://files.pythonhosted.org/packages/ff/9c/daa99532c72f25051a90ef90e1413a8d54413a9e64614d9095b0c1c154d0/regex-2024.11.6-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a03e02f48cd1abbd9f3b7e3586d97c8f7a9721c436f51a5245b3b9483044480b", size = 772713 }, + { url = "https://files.pythonhosted.org/packages/13/5d/61a533ccb8c231b474ac8e3a7d70155b00dfc61af6cafdccd1947df6d735/regex-2024.11.6-cp39-cp39-win32.whl", hash = "sha256:41758407fc32d5c3c5de163888068cfee69cb4c2be844e7ac517a52770f9af57", size = 261756 }, + { url = "https://files.pythonhosted.org/packages/dc/7b/e59b7f7c91ae110d154370c24133f947262525b5d6406df65f23422acc17/regex-2024.11.6-cp39-cp39-win_amd64.whl", hash = "sha256:b2837718570f95dd41675328e111345f9b7095d821bac435aac173ac80b19983", size = 274110 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490 }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242 }, +] + +[[package]] +name = "rpds-py" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/79/2ce611b18c4fd83d9e3aecb5cba93e1917c050f556db39842889fa69b79f/rpds_py-0.23.1.tar.gz", hash = "sha256:7f3240dcfa14d198dba24b8b9cb3b108c06b68d45b7babd9eefc1038fdf7e707", size = 26806 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/fe/e5326459863bd525122f4e9c80ac8d7c6cfa171b7518d04cc27c12c209b0/rpds_py-0.23.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2a54027554ce9b129fc3d633c92fa33b30de9f08bc61b32c053dc9b537266fed", size = 372123 }, + { url = "https://files.pythonhosted.org/packages/f9/db/f10a3795f7a89fb27594934012d21c61019bbeb516c5bdcfbbe9e9e617a7/rpds_py-0.23.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b5ef909a37e9738d146519657a1aab4584018746a18f71c692f2f22168ece40c", size = 356778 }, + { url = "https://files.pythonhosted.org/packages/21/27/0d3678ad7f432fa86f8fac5f5fc6496a4d2da85682a710d605219be20063/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ee9d6f0b38efb22ad94c3b68ffebe4c47865cdf4b17f6806d6c674e1feb4246", size = 385775 }, + { url = "https://files.pythonhosted.org/packages/99/a0/1786defa125b2ad228027f22dff26312ce7d1fee3c7c3c2682f403db2062/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f7356a6da0562190558c4fcc14f0281db191cdf4cb96e7604c06acfcee96df15", size = 391181 }, + { url = "https://files.pythonhosted.org/packages/f1/5c/1240934050a7ffd020a915486d0cc4c7f6e7a2442a77aedf13664db55d36/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9441af1d25aed96901f97ad83d5c3e35e6cd21a25ca5e4916c82d7dd0490a4fa", size = 444607 }, + { url = "https://files.pythonhosted.org/packages/b7/1b/cee6905b47817fd0a377716dbe4df35295de46df46ee2ff704538cc371b0/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d8abf7896a91fb97e7977d1aadfcc2c80415d6dc2f1d0fca5b8d0df247248f3", size = 445550 }, + { url = "https://files.pythonhosted.org/packages/54/f7/f0821ca34032892d7a67fcd5042f50074ff2de64e771e10df01085c88d47/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b08027489ba8fedde72ddd233a5ea411b85a6ed78175f40285bd401bde7466d", size = 386148 }, + { url = "https://files.pythonhosted.org/packages/eb/ef/2afe53bc857c4bcba336acfd2629883a5746e7291023e017ac7fc98d85aa/rpds_py-0.23.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fee513135b5a58f3bb6d89e48326cd5aa308e4bcdf2f7d59f67c861ada482bf8", size = 416780 }, + { url = "https://files.pythonhosted.org/packages/ae/9a/38d2236cf669789b8a3e1a014c9b6a8d7b8925b952c92e7839ae2749f9ac/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:35d5631ce0af26318dba0ae0ac941c534453e42f569011585cb323b7774502a5", size = 558265 }, + { url = "https://files.pythonhosted.org/packages/e6/0a/f2705530c42578f20ed0b5b90135eecb30eef6e2ba73e7ba69087fad2dba/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a20cb698c4a59c534c6701b1c24a968ff2768b18ea2991f886bd8985ce17a89f", size = 585270 }, + { url = "https://files.pythonhosted.org/packages/29/4e/3b597dc84ed82c3d757ac9aa620de224a94e06d2e102069795ae7e81c015/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e9c206a1abc27e0588cf8b7c8246e51f1a16a103734f7750830a1ccb63f557a", size = 553850 }, + { url = "https://files.pythonhosted.org/packages/00/cc/6498b6f79e4375e6737247661e52a2d18f6accf4910e0c8da978674b4241/rpds_py-0.23.1-cp310-cp310-win32.whl", hash = "sha256:d9f75a06ecc68f159d5d7603b734e1ff6daa9497a929150f794013aa9f6e3f12", size = 220660 }, + { url = "https://files.pythonhosted.org/packages/17/2b/08db023d23e8c7032c99d8d2a70d32e450a868ab73d16e3ff5290308a665/rpds_py-0.23.1-cp310-cp310-win_amd64.whl", hash = "sha256:f35eff113ad430b5272bbfc18ba111c66ff525828f24898b4e146eb479a2cdda", size = 232551 }, + { url = "https://files.pythonhosted.org/packages/1c/67/6e5d4234bb9dee062ffca2a5f3c7cd38716317d6760ec235b175eed4de2c/rpds_py-0.23.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b79f5ced71efd70414a9a80bbbfaa7160da307723166f09b69773153bf17c590", size = 372264 }, + { url = "https://files.pythonhosted.org/packages/a7/0a/3dedb2daee8e783622427f5064e2d112751d8276ee73aa5409f000a132f4/rpds_py-0.23.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c9e799dac1ffbe7b10c1fd42fe4cd51371a549c6e108249bde9cd1200e8f59b4", size = 356883 }, + { url = "https://files.pythonhosted.org/packages/ed/fc/e1acef44f9c24b05fe5434b235f165a63a52959ac655e3f7a55726cee1a4/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721f9c4011b443b6e84505fc00cc7aadc9d1743f1c988e4c89353e19c4a968ee", size = 385624 }, + { url = "https://files.pythonhosted.org/packages/97/0a/a05951f6465d01622720c03ef6ef31adfbe865653e05ed7c45837492f25e/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f88626e3f5e57432e6191cd0c5d6d6b319b635e70b40be2ffba713053e5147dd", size = 391500 }, + { url = "https://files.pythonhosted.org/packages/ea/2e/cca0583ec0690ea441dceae23c0673b99755710ea22f40bccf1e78f41481/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:285019078537949cecd0190f3690a0b0125ff743d6a53dfeb7a4e6787af154f5", size = 444869 }, + { url = "https://files.pythonhosted.org/packages/cc/e6/95cda68b33a6d814d1e96b0e406d231ed16629101460d1740e92f03365e6/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b92f5654157de1379c509b15acec9d12ecf6e3bc1996571b6cb82a4302060447", size = 444930 }, + { url = "https://files.pythonhosted.org/packages/5f/a7/e94cdb73411ae9c11414d3c7c9a6ad75d22ad4a8d094fb45a345ba9e3018/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e768267cbe051dd8d1c5305ba690bb153204a09bf2e3de3ae530de955f5b5580", size = 386254 }, + { url = "https://files.pythonhosted.org/packages/dd/c5/a4a943d90a39e85efd1e04b1ad5129936786f9a9aa27bb7be8fc5d9d50c9/rpds_py-0.23.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c5334a71f7dc1160382d45997e29f2637c02f8a26af41073189d79b95d3321f1", size = 417090 }, + { url = "https://files.pythonhosted.org/packages/0c/a0/80d0013b12428d1fce0ab4e71829400b0a32caec12733c79e6109f843342/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6adb81564af0cd428910f83fa7da46ce9ad47c56c0b22b50872bc4515d91966", size = 557639 }, + { url = "https://files.pythonhosted.org/packages/a6/92/ec2e6980afb964a2cd7a99cbdef1f6c01116abe94b42cbe336ac93dd11c2/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:cafa48f2133d4daa028473ede7d81cd1b9f9e6925e9e4003ebdf77010ee02f35", size = 584572 }, + { url = "https://files.pythonhosted.org/packages/3d/ce/75b6054db34a390789a82523790717b27c1bd735e453abb429a87c4f0f26/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0fced9fd4a07a1ded1bac7e961ddd9753dd5d8b755ba8e05acba54a21f5f1522", size = 553028 }, + { url = "https://files.pythonhosted.org/packages/cc/24/f45abe0418c06a5cba0f846e967aa27bac765acd927aabd857c21319b8cc/rpds_py-0.23.1-cp311-cp311-win32.whl", hash = "sha256:243241c95174b5fb7204c04595852fe3943cc41f47aa14c3828bc18cd9d3b2d6", size = 220862 }, + { url = "https://files.pythonhosted.org/packages/2d/a6/3c0880e8bbfc36451ef30dc416266f6d2934705e468db5d21c8ba0ab6400/rpds_py-0.23.1-cp311-cp311-win_amd64.whl", hash = "sha256:11dd60b2ffddba85715d8a66bb39b95ddbe389ad2cfcf42c833f1bcde0878eaf", size = 232953 }, + { url = "https://files.pythonhosted.org/packages/f3/8c/d17efccb9f5b9137ddea706664aebae694384ae1d5997c0202093e37185a/rpds_py-0.23.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3902df19540e9af4cc0c3ae75974c65d2c156b9257e91f5101a51f99136d834c", size = 364369 }, + { url = "https://files.pythonhosted.org/packages/6e/c0/ab030f696b5c573107115a88d8d73d80f03309e60952b64c584c70c659af/rpds_py-0.23.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:66f8d2a17e5838dd6fb9be6baaba8e75ae2f5fa6b6b755d597184bfcd3cb0eba", size = 349965 }, + { url = "https://files.pythonhosted.org/packages/b3/55/b40170f5a079c4fb0b6a82b299689e66e744edca3c3375a8b160fb797660/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:112b8774b0b4ee22368fec42749b94366bd9b536f8f74c3d4175d4395f5cbd31", size = 389064 }, + { url = "https://files.pythonhosted.org/packages/ab/1c/b03a912c59ec7c1e16b26e587b9dfa8ddff3b07851e781e8c46e908a365a/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0df046f2266e8586cf09d00588302a32923eb6386ced0ca5c9deade6af9a149", size = 397741 }, + { url = "https://files.pythonhosted.org/packages/52/6f/151b90792b62fb6f87099bcc9044c626881fdd54e31bf98541f830b15cea/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3288930b947cbebe767f84cf618d2cbe0b13be476e749da0e6a009f986248c", size = 448784 }, + { url = "https://files.pythonhosted.org/packages/71/2a/6de67c0c97ec7857e0e9e5cd7c52405af931b303eb1e5b9eff6c50fd9a2e/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce473a2351c018b06dd8d30d5da8ab5a0831056cc53b2006e2a8028172c37ce5", size = 440203 }, + { url = "https://files.pythonhosted.org/packages/db/5e/e759cd1c276d98a4b1f464b17a9bf66c65d29f8f85754e27e1467feaa7c3/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d550d7e9e7d8676b183b37d65b5cd8de13676a738973d330b59dc8312df9c5dc", size = 391611 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/2900358efcc0d9408c7289769cba4c0974d9db314aa884028ed7f7364f61/rpds_py-0.23.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e14f86b871ea74c3fddc9a40e947d6a5d09def5adc2076ee61fb910a9014fb35", size = 423306 }, + { url = "https://files.pythonhosted.org/packages/23/07/6c177e6d059f5d39689352d6c69a926ee4805ffdb6f06203570234d3d8f7/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf5be5ba34e19be579ae873da515a2836a2166d8d7ee43be6ff909eda42b72b", size = 562323 }, + { url = "https://files.pythonhosted.org/packages/70/e4/f9097fd1c02b516fff9850792161eb9fc20a2fd54762f3c69eae0bdb67cb/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7031d493c4465dbc8d40bd6cafefef4bd472b17db0ab94c53e7909ee781b9ef", size = 588351 }, + { url = "https://files.pythonhosted.org/packages/87/39/5db3c6f326bfbe4576ae2af6435bd7555867d20ae690c786ff33659f293b/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:55ff4151cfd4bc635e51cfb1c59ac9f7196b256b12e3a57deb9e5742e65941ad", size = 557252 }, + { url = "https://files.pythonhosted.org/packages/fd/14/2d5ad292f144fa79bafb78d2eb5b8a3a91c358b6065443cb9c49b5d1fedf/rpds_py-0.23.1-cp312-cp312-win32.whl", hash = "sha256:a9d3b728f5a5873d84cba997b9d617c6090ca5721caaa691f3b1a78c60adc057", size = 222181 }, + { url = "https://files.pythonhosted.org/packages/a3/4f/0fce63e0f5cdd658e71e21abd17ac1bc9312741ebb8b3f74eeed2ebdf771/rpds_py-0.23.1-cp312-cp312-win_amd64.whl", hash = "sha256:b03a8d50b137ee758e4c73638b10747b7c39988eb8e6cd11abb7084266455165", size = 237426 }, + { url = "https://files.pythonhosted.org/packages/13/9d/b8b2c0edffb0bed15be17b6d5ab06216f2f47f9ee49259c7e96a3ad4ca42/rpds_py-0.23.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:4caafd1a22e5eaa3732acb7672a497123354bef79a9d7ceed43387d25025e935", size = 363672 }, + { url = "https://files.pythonhosted.org/packages/bd/c2/5056fa29e6894144d7ba4c938b9b0445f75836b87d2dd00ed4999dc45a8c/rpds_py-0.23.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:178f8a60fc24511c0eb756af741c476b87b610dba83270fce1e5a430204566a4", size = 349602 }, + { url = "https://files.pythonhosted.org/packages/b0/bc/33779a1bb0ee32d8d706b173825aab75c628521d23ce72a7c1e6a6852f86/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c632419c3870507ca20a37c8f8f5352317aca097639e524ad129f58c125c61c6", size = 388746 }, + { url = "https://files.pythonhosted.org/packages/62/0b/71db3e36b7780a619698ec82a9c87ab44ad7ca7f5480913e8a59ff76f050/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:698a79d295626ee292d1730bc2ef6e70a3ab135b1d79ada8fde3ed0047b65a10", size = 397076 }, + { url = "https://files.pythonhosted.org/packages/bb/2e/494398f613edf77ba10a916b1ddea2acce42ab0e3b62e2c70ffc0757ce00/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:271fa2184cf28bdded86bb6217c8e08d3a169fe0bbe9be5e8d96e8476b707122", size = 448399 }, + { url = "https://files.pythonhosted.org/packages/dd/53/4bd7f5779b1f463243ee5fdc83da04dd58a08f86e639dbffa7a35f969a84/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b91cceb5add79ee563bd1f70b30896bd63bc5f78a11c1f00a1e931729ca4f1f4", size = 439764 }, + { url = "https://files.pythonhosted.org/packages/f6/55/b3c18c04a460d951bf8e91f2abf46ce5b6426fb69784166a6a25827cb90a/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a6cb95074777f1ecda2ca4fa7717caa9ee6e534f42b7575a8f0d4cb0c24013", size = 390662 }, + { url = "https://files.pythonhosted.org/packages/2a/65/cc463044a3cbd616029b2aa87a651cdee8288d2fdd7780b2244845e934c1/rpds_py-0.23.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:50fb62f8d8364978478b12d5f03bf028c6bc2af04082479299139dc26edf4c64", size = 422680 }, + { url = "https://files.pythonhosted.org/packages/fa/8e/1fa52990c7836d72e8d70cd7753f2362c72fbb0a49c1462e8c60e7176d0b/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8f7e90b948dc9dcfff8003f1ea3af08b29c062f681c05fd798e36daa3f7e3e8", size = 561792 }, + { url = "https://files.pythonhosted.org/packages/57/b8/fe3b612979b1a29d0c77f8585903d8b3a292604b26d4b300e228b8ac6360/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5b98b6c953e5c2bda51ab4d5b4f172617d462eebc7f4bfdc7c7e6b423f6da957", size = 588127 }, + { url = "https://files.pythonhosted.org/packages/44/2d/fde474de516bbc4b9b230f43c98e7f8acc5da7fc50ceed8e7af27553d346/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2893d778d4671ee627bac4037a075168b2673c57186fb1a57e993465dbd79a93", size = 556981 }, + { url = "https://files.pythonhosted.org/packages/18/57/767deeb27b81370bbab8f74ef6e68d26c4ea99018f3c71a570e506fede85/rpds_py-0.23.1-cp313-cp313-win32.whl", hash = "sha256:2cfa07c346a7ad07019c33fb9a63cf3acb1f5363c33bc73014e20d9fe8b01cdd", size = 221936 }, + { url = "https://files.pythonhosted.org/packages/7d/6c/3474cfdd3cafe243f97ab8474ea8949236eb2a1a341ca55e75ce00cd03da/rpds_py-0.23.1-cp313-cp313-win_amd64.whl", hash = "sha256:3aaf141d39f45322e44fc2c742e4b8b4098ead5317e5f884770c8df0c332da70", size = 237145 }, + { url = "https://files.pythonhosted.org/packages/ec/77/e985064c624230f61efa0423759bb066da56ebe40c654f8b5ba225bd5d63/rpds_py-0.23.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:759462b2d0aa5a04be5b3e37fb8183615f47014ae6b116e17036b131985cb731", size = 359623 }, + { url = "https://files.pythonhosted.org/packages/62/d9/a33dcbf62b29e40559e012d525bae7d516757cf042cc9234bd34ca4b6aeb/rpds_py-0.23.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3e9212f52074fc9d72cf242a84063787ab8e21e0950d4d6709886fb62bcb91d5", size = 345900 }, + { url = "https://files.pythonhosted.org/packages/92/eb/f81a4be6397861adb2cb868bb6a28a33292c2dcac567d1dc575226055e55/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e9f3a3ac919406bc0414bbbd76c6af99253c507150191ea79fab42fdb35982a", size = 386426 }, + { url = "https://files.pythonhosted.org/packages/09/47/1f810c9b5e83be005341201b5389f1d240dfa440346ea7189f9b3fd6961d/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c04ca91dda8a61584165825907f5c967ca09e9c65fe8966ee753a3f2b019fe1e", size = 392314 }, + { url = "https://files.pythonhosted.org/packages/83/bd/bc95831432fd6c46ed8001f01af26de0763a059d6d7e6d69e3c5bf02917a/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ab923167cfd945abb9b51a407407cf19f5bee35001221f2911dc85ffd35ff4f", size = 447706 }, + { url = "https://files.pythonhosted.org/packages/19/3e/567c04c226b1802dc6dc82cad3d53e1fa0a773258571c74ac5d8fbde97ed/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed6f011bedca8585787e5082cce081bac3d30f54520097b2411351b3574e1219", size = 437060 }, + { url = "https://files.pythonhosted.org/packages/fe/77/a77d2c6afe27ae7d0d55fc32f6841502648070dc8d549fcc1e6d47ff8975/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6959bb9928c5c999aba4a3f5a6799d571ddc2c59ff49917ecf55be2bbb4e3722", size = 389347 }, + { url = "https://files.pythonhosted.org/packages/3f/47/6b256ff20a74cfebeac790ab05586e0ac91f88e331125d4740a6c86fc26f/rpds_py-0.23.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1ed7de3c86721b4e83ac440751329ec6a1102229aa18163f84c75b06b525ad7e", size = 415554 }, + { url = "https://files.pythonhosted.org/packages/fc/29/d4572469a245bc9fc81e35166dca19fc5298d5c43e1a6dd64bf145045193/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5fb89edee2fa237584e532fbf78f0ddd1e49a47c7c8cfa153ab4849dc72a35e6", size = 557418 }, + { url = "https://files.pythonhosted.org/packages/9c/0a/68cf7228895b1a3f6f39f51b15830e62456795e61193d2c8b87fd48c60db/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7e5413d2e2d86025e73f05510ad23dad5950ab8417b7fc6beaad99be8077138b", size = 583033 }, + { url = "https://files.pythonhosted.org/packages/14/18/017ab41dcd6649ad5db7d00155b4c212b31ab05bd857d5ba73a1617984eb/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d31ed4987d72aabdf521eddfb6a72988703c091cfc0064330b9e5f8d6a042ff5", size = 554880 }, + { url = "https://files.pythonhosted.org/packages/2e/dd/17de89431268da8819d8d51ce67beac28d9b22fccf437bc5d6d2bcd1acdb/rpds_py-0.23.1-cp313-cp313t-win32.whl", hash = "sha256:f3429fb8e15b20961efca8c8b21432623d85db2228cc73fe22756c6637aa39e7", size = 219743 }, + { url = "https://files.pythonhosted.org/packages/68/15/6d22d07e063ce5e9bfbd96db9ec2fbb4693591b4503e3a76996639474d02/rpds_py-0.23.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d6f6512a90bd5cd9030a6237f5346f046c6f0e40af98657568fa45695d4de59d", size = 235415 }, + { url = "https://files.pythonhosted.org/packages/f8/a1/d3fb6a8de191f09fb88eacd1505ae1cab6ffc1c2b57ef62db6632e9b6216/rpds_py-0.23.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:09cd7dbcb673eb60518231e02874df66ec1296c01a4fcd733875755c02014b19", size = 372686 }, + { url = "https://files.pythonhosted.org/packages/b5/3a/bb96c8164aadfb2c9d7290e553e78e9816fcf3e22dcddc98bc1b83974c8e/rpds_py-0.23.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c6760211eee3a76316cf328f5a8bd695b47b1626d21c8a27fb3b2473a884d597", size = 357098 }, + { url = "https://files.pythonhosted.org/packages/30/21/3de5d944f630a9fa6acf68191652e34e708041085770d426635c04dd60e3/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:72e680c1518733b73c994361e4b06441b92e973ef7d9449feec72e8ee4f713da", size = 386304 }, + { url = "https://files.pythonhosted.org/packages/f1/a5/d554cd53e865a45e41bea61b3ff91a12e50b7422f4a273d980c02a261b42/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae28144c1daa61366205d32abd8c90372790ff79fc60c1a8ad7fd3c8553a600e", size = 391585 }, + { url = "https://files.pythonhosted.org/packages/72/5a/c53b507def60692e8c32fbafaa7ceb3cac81c5ab80f876ae6c8426be147d/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c698d123ce5d8f2d0cd17f73336615f6a2e3bdcedac07a1291bb4d8e7d82a05a", size = 445275 }, + { url = "https://files.pythonhosted.org/packages/05/15/1d68c0ad769a4bfb6cd2d1bff71bd2f4cbdf277d9b86c97f66f6fd107611/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98b257ae1e83f81fb947a363a274c4eb66640212516becaff7bef09a5dceacaa", size = 445722 }, + { url = "https://files.pythonhosted.org/packages/5a/4b/21fabed47908f85084b845bd49cd9706071a8ec970cdfe72aca8364c9369/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c9ff044eb07c8468594d12602291c635da292308c8c619244e30698e7fc455a", size = 386605 }, + { url = "https://files.pythonhosted.org/packages/bd/fe/6d949043b7daad8b730436fcd8524231653e6cd95d55b806666f7ef62b64/rpds_py-0.23.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7938c7b0599a05246d704b3f5e01be91a93b411d0d6cc62275f025293b8a11ce", size = 417475 }, + { url = "https://files.pythonhosted.org/packages/4d/24/082e670e7d18cee2be04bbfa881e30b4c9ce1c139769d6ea0a8fd4aefdd0/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:e9cb79ecedfc156c0692257ac7ed415243b6c35dd969baa461a6888fc79f2f07", size = 559004 }, + { url = "https://files.pythonhosted.org/packages/51/48/ef27d68d569c3bde34f8be76352a391619d1fd2fc40f7cb8972b8fc5e54b/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:7b77e07233925bd33fc0022b8537774423e4c6680b6436316c5075e79b6384f4", size = 585260 }, + { url = "https://files.pythonhosted.org/packages/1b/6c/9599de109f16033f499542ba5792d6ebf2df0fd23124bd522351860c5c03/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a970bfaf130c29a679b1d0a6e0f867483cea455ab1535fb427566a475078f27f", size = 555057 }, + { url = "https://files.pythonhosted.org/packages/cc/34/1dadb0b9ecbc7ce72f1d8666b70c5cd4891ff9af03d7e59f80018421ca3c/rpds_py-0.23.1-cp39-cp39-win32.whl", hash = "sha256:4233df01a250b3984465faed12ad472f035b7cd5240ea3f7c76b7a7016084495", size = 220756 }, + { url = "https://files.pythonhosted.org/packages/b3/cb/a01607dc98b438245a2fff09981fe2814234c0722d5ea22ddfa8eb5802ba/rpds_py-0.23.1-cp39-cp39-win_amd64.whl", hash = "sha256:c617d7453a80e29d9973b926983b1e700a9377dbe021faa36041c78537d7b08c", size = 232693 }, + { url = "https://files.pythonhosted.org/packages/95/a9/6fafd35fc6bac05f59bcbc800b57cef877911ff1c015397c519fec888642/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c1f8afa346ccd59e4e5630d5abb67aba6a9812fddf764fd7eb11f382a345f8cc", size = 373463 }, + { url = "https://files.pythonhosted.org/packages/5b/ac/44f00029b8fbe0903a19e9a87a9b86063bf8700df2cc58868373d378418c/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fad784a31869747df4ac968a351e070c06ca377549e4ace94775aaa3ab33ee06", size = 358400 }, + { url = "https://files.pythonhosted.org/packages/5e/9c/3da199346c68d785f10dccab123b74c8c5f73be3f742c9e33d1116e07931/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5a96fcac2f18e5a0a23a75cd27ce2656c66c11c127b0318e508aab436b77428", size = 386815 }, + { url = "https://files.pythonhosted.org/packages/d3/45/8f6533c33c0d33da8c2c8b2fb8f2ee90b23c05c679b86b0ac6aee4653749/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3e77febf227a1dc3220159355dba68faa13f8dca9335d97504abf428469fb18b", size = 392974 }, + { url = "https://files.pythonhosted.org/packages/ca/56/6a9ac1bf0455ba07385d8fe98c571c519b4f2000cff6581487bf9fab9272/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26bb3e8de93443d55e2e748e9fd87deb5f8075ca7bc0502cfc8be8687d69a2ec", size = 446019 }, + { url = "https://files.pythonhosted.org/packages/f4/83/5d9a3f9731cdccf49088bcc4ce821a5cf50bd1737cdad83e9959a7b9054d/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:db7707dde9143a67b8812c7e66aeb2d843fe33cc8e374170f4d2c50bd8f2472d", size = 445811 }, + { url = "https://files.pythonhosted.org/packages/44/50/f2e0a98c62fc1fe68b176caca587714dc5c8bb2c3d1dd1eeb2bd4cc787ac/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1eedaaccc9bb66581d4ae7c50e15856e335e57ef2734dbc5fd8ba3e2a4ab3cb6", size = 388070 }, + { url = "https://files.pythonhosted.org/packages/f2/d0/4981878f8f157e6dbea01d95e0119bf3d6b4c2c884fe64a9e6987f941104/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28358c54fffadf0ae893f6c1050e8f8853e45df22483b7fff2f6ab6152f5d8bf", size = 419173 }, + { url = "https://files.pythonhosted.org/packages/ce/13/fc971c470da96b270d2f64fedee987351bd935dc3016932a5cdcb1a88a2a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:633462ef7e61d839171bf206551d5ab42b30b71cac8f10a64a662536e057fdef", size = 559048 }, + { url = "https://files.pythonhosted.org/packages/42/02/be91e1de139ec8b4f9fec4192fd779ba48af281cfc762c0ca4c15b945484/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a98f510d86f689fcb486dc59e6e363af04151e5260ad1bdddb5625c10f1e95f8", size = 584773 }, + { url = "https://files.pythonhosted.org/packages/27/28/3af8a1956df3edc41d884267d766dc096496dafc83f02f764a475eca0b4a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e0397dd0b3955c61ef9b22838144aa4bef6f0796ba5cc8edfc64d468b93798b4", size = 555153 }, + { url = "https://files.pythonhosted.org/packages/5e/bb/e45f51c4e1327dea3c72b846c6de129eebacb7a6cb309af7af35d0578c80/rpds_py-0.23.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:75307599f0d25bf6937248e5ac4e3bde5ea72ae6618623b86146ccc7845ed00b", size = 233827 }, + { url = "https://files.pythonhosted.org/packages/b8/b5/7bf30fe885b6a6610a0ba984d40b7b70e1965ed9534a9fdeb53b12831dec/rpds_py-0.23.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3614d280bf7aab0d3721b5ce0e73434acb90a2c993121b6e81a1c15c665298ac", size = 373265 }, + { url = "https://files.pythonhosted.org/packages/40/b9/bdd81417fcaca7e0b204c38adfdf6de1c2662fdec447990081ff4eb204e8/rpds_py-0.23.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e5963ea87f88bddf7edd59644a35a0feecf75f8985430124c253612d4f7d27ae", size = 358335 }, + { url = "https://files.pythonhosted.org/packages/75/cc/0878cf297fb06a031f0127dce5e692c5a89f1cdb0554187049bf2a4fc214/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad76f44f70aac3a54ceb1813ca630c53415da3a24fd93c570b2dfb4856591017", size = 386969 }, + { url = "https://files.pythonhosted.org/packages/db/51/3be68a7e632d5bb4bfa539b0c0c6d590c1caea358d51331926d7b3102e2f/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c6ae11e6e93728d86aafc51ced98b1658a0080a7dd9417d24bfb955bb09c3c2", size = 393101 }, + { url = "https://files.pythonhosted.org/packages/a9/30/3abe08087d86a9a8e23b5ebe2055de301a54542c7572a91e7af891626849/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc869af5cba24d45fb0399b0cfdbcefcf6910bf4dee5d74036a57cf5264b3ff4", size = 446061 }, + { url = "https://files.pythonhosted.org/packages/08/a0/b6b0b100f8b7872d5f18b27d24687b61559d791491434d0976c986bb8c88/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76b32eb2ab650a29e423525e84eb197c45504b1c1e6e17b6cc91fcfeb1a4b1d", size = 445614 }, + { url = "https://files.pythonhosted.org/packages/d2/e4/451efd1fd8ffb9ae0b08cc2390ad7a1d2bb7049a78bd851c90ceb18fc265/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4263320ed887ed843f85beba67f8b2d1483b5947f2dc73a8b068924558bfeace", size = 387943 }, + { url = "https://files.pythonhosted.org/packages/8b/8e/805a4e6df48419cfa4433e8d4ec9596c02036bbc1b0d4a943aff828dd0cf/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7f9682a8f71acdf59fd554b82b1c12f517118ee72c0f3944eda461606dfe7eb9", size = 418552 }, + { url = "https://files.pythonhosted.org/packages/11/2e/807df78a7de1fc16d31f9c48d8620d99356a69728f6d5625f48e7183cd5c/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:754fba3084b70162a6b91efceee8a3f06b19e43dac3f71841662053c0584209a", size = 559194 }, + { url = "https://files.pythonhosted.org/packages/3f/46/d5ba680221182cac547053f824f1aa99f4011b9429d526992e742926ea5a/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:a1c66e71ecfd2a4acf0e4bd75e7a3605afa8f9b28a3b497e4ba962719df2be57", size = 585645 }, + { url = "https://files.pythonhosted.org/packages/46/14/905045ee7234ebf8c0362862b89376a5708709ad748d20bc5bb68b111407/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8d67beb6002441faef8251c45e24994de32c4c8686f7356a1f601ad7c466f7c3", size = 554521 }, + { url = "https://files.pythonhosted.org/packages/22/40/67897b5b04d2741e256b0010bd825c9e6a30562f99fd6def038e8c0d0a97/rpds_py-0.23.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a1e17d8dc8e57d8e0fd21f8f0f0a5211b3fa258b2e444c2053471ef93fe25a00", size = 233543 }, +] + +[[package]] +name = "scipy" +version = "1.13.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/00/48c2f661e2816ccf2ecd77982f6605b2950afe60f60a52b4cbbc2504aa8f/scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c", size = 57210720 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/59/41b2529908c002ade869623b87eecff3e11e3ce62e996d0bdcb536984187/scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca", size = 39328076 }, + { url = "https://files.pythonhosted.org/packages/d5/33/f1307601f492f764062ce7dd471a14750f3360e33cd0f8c614dae208492c/scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f", size = 30306232 }, + { url = "https://files.pythonhosted.org/packages/c0/66/9cd4f501dd5ea03e4a4572ecd874936d0da296bd04d1c45ae1a4a75d9c3a/scipy-1.13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989", size = 33743202 }, + { url = "https://files.pythonhosted.org/packages/a3/ba/7255e5dc82a65adbe83771c72f384d99c43063648456796436c9a5585ec3/scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f", size = 38577335 }, + { url = "https://files.pythonhosted.org/packages/49/a5/bb9ded8326e9f0cdfdc412eeda1054b914dfea952bda2097d174f8832cc0/scipy-1.13.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94", size = 38820728 }, + { url = "https://files.pythonhosted.org/packages/12/30/df7a8fcc08f9b4a83f5f27cfaaa7d43f9a2d2ad0b6562cced433e5b04e31/scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54", size = 46210588 }, + { url = "https://files.pythonhosted.org/packages/b4/15/4a4bb1b15bbd2cd2786c4f46e76b871b28799b67891f23f455323a0cdcfb/scipy-1.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9", size = 39333805 }, + { url = "https://files.pythonhosted.org/packages/ba/92/42476de1af309c27710004f5cdebc27bec62c204db42e05b23a302cb0c9a/scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326", size = 30317687 }, + { url = "https://files.pythonhosted.org/packages/80/ba/8be64fe225360a4beb6840f3cbee494c107c0887f33350d0a47d55400b01/scipy-1.13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299", size = 33694638 }, + { url = "https://files.pythonhosted.org/packages/36/07/035d22ff9795129c5a847c64cb43c1fa9188826b59344fee28a3ab02e283/scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa", size = 38569931 }, + { url = "https://files.pythonhosted.org/packages/d9/10/f9b43de37e5ed91facc0cfff31d45ed0104f359e4f9a68416cbf4e790241/scipy-1.13.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59", size = 38838145 }, + { url = "https://files.pythonhosted.org/packages/4a/48/4513a1a5623a23e95f94abd675ed91cfb19989c58e9f6f7d03990f6caf3d/scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b", size = 46196227 }, + { url = "https://files.pythonhosted.org/packages/f2/7b/fb6b46fbee30fc7051913068758414f2721003a89dd9a707ad49174e3843/scipy-1.13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1", size = 39357301 }, + { url = "https://files.pythonhosted.org/packages/dc/5a/2043a3bde1443d94014aaa41e0b50c39d046dda8360abd3b2a1d3f79907d/scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d", size = 30363348 }, + { url = "https://files.pythonhosted.org/packages/e7/cb/26e4a47364bbfdb3b7fb3363be6d8a1c543bcd70a7753ab397350f5f189a/scipy-1.13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627", size = 33406062 }, + { url = "https://files.pythonhosted.org/packages/88/ab/6ecdc526d509d33814835447bbbeedbebdec7cca46ef495a61b00a35b4bf/scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884", size = 38218311 }, + { url = "https://files.pythonhosted.org/packages/0b/00/9f54554f0f8318100a71515122d8f4f503b1a2c4b4cfab3b4b68c0eb08fa/scipy-1.13.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16", size = 38442493 }, + { url = "https://files.pythonhosted.org/packages/3e/df/963384e90733e08eac978cd103c34df181d1fec424de383cdc443f418dd4/scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949", size = 45910955 }, + { url = "https://files.pythonhosted.org/packages/7f/29/c2ea58c9731b9ecb30b6738113a95d147e83922986b34c685b8f6eefde21/scipy-1.13.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5", size = 39352927 }, + { url = "https://files.pythonhosted.org/packages/5c/c0/e71b94b20ccf9effb38d7147c0064c08c622309fd487b1b677771a97d18c/scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24", size = 30324538 }, + { url = "https://files.pythonhosted.org/packages/6d/0f/aaa55b06d474817cea311e7b10aab2ea1fd5d43bc6a2861ccc9caec9f418/scipy-1.13.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004", size = 33732190 }, + { url = "https://files.pythonhosted.org/packages/35/f5/d0ad1a96f80962ba65e2ce1de6a1e59edecd1f0a7b55990ed208848012e0/scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d", size = 38612244 }, + { url = "https://files.pythonhosted.org/packages/8d/02/1165905f14962174e6569076bcc3315809ae1291ed14de6448cc151eedfd/scipy-1.13.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c", size = 38845637 }, + { url = "https://files.pythonhosted.org/packages/3e/77/dab54fe647a08ee4253963bcd8f9cf17509c8ca64d6335141422fe2e2114/scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2", size = 46227440 }, +] + +[[package]] +name = "scipy" +version = "1.15.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/b9/31ba9cd990e626574baf93fbc1ac61cf9ed54faafd04c479117517661637/scipy-1.15.2.tar.gz", hash = "sha256:cd58a314d92838f7e6f755c8a2167ead4f27e1fd5c1251fd54289569ef3495ec", size = 59417316 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/df/ef233fff6838fe6f7840d69b5ef9f20d2b5c912a8727b21ebf876cb15d54/scipy-1.15.2-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a2ec871edaa863e8213ea5df811cd600734f6400b4af272e1c011e69401218e9", size = 38692502 }, + { url = "https://files.pythonhosted.org/packages/5c/20/acdd4efb8a68b842968f7bc5611b1aeb819794508771ad104de418701422/scipy-1.15.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:6f223753c6ea76983af380787611ae1291e3ceb23917393079dcc746ba60cfb5", size = 30085508 }, + { url = "https://files.pythonhosted.org/packages/42/55/39cf96ca7126f1e78ee72a6344ebdc6702fc47d037319ad93221063e6cf4/scipy-1.15.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:ecf797d2d798cf7c838c6d98321061eb3e72a74710e6c40540f0e8087e3b499e", size = 22359166 }, + { url = "https://files.pythonhosted.org/packages/51/48/708d26a4ab8a1441536bf2dfcad1df0ca14a69f010fba3ccbdfc02df7185/scipy-1.15.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:9b18aa747da280664642997e65aab1dd19d0c3d17068a04b3fe34e2559196cb9", size = 25112047 }, + { url = "https://files.pythonhosted.org/packages/dd/65/f9c5755b995ad892020381b8ae11f16d18616208e388621dfacc11df6de6/scipy-1.15.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87994da02e73549dfecaed9e09a4f9d58a045a053865679aeb8d6d43747d4df3", size = 35536214 }, + { url = "https://files.pythonhosted.org/packages/de/3c/c96d904b9892beec978562f64d8cc43f9cca0842e65bd3cd1b7f7389b0ba/scipy-1.15.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69ea6e56d00977f355c0f84eba69877b6df084516c602d93a33812aa04d90a3d", size = 37646981 }, + { url = "https://files.pythonhosted.org/packages/3d/74/c2d8a24d18acdeae69ed02e132b9bc1bb67b7bee90feee1afe05a68f9d67/scipy-1.15.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:888307125ea0c4466287191e5606a2c910963405ce9671448ff9c81c53f85f58", size = 37230048 }, + { url = "https://files.pythonhosted.org/packages/42/19/0aa4ce80eca82d487987eff0bc754f014dec10d20de2f66754fa4ea70204/scipy-1.15.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9412f5e408b397ff5641080ed1e798623dbe1ec0d78e72c9eca8992976fa65aa", size = 40010322 }, + { url = "https://files.pythonhosted.org/packages/d0/d2/f0683b7e992be44d1475cc144d1f1eeae63c73a14f862974b4db64af635e/scipy-1.15.2-cp310-cp310-win_amd64.whl", hash = "sha256:b5e025e903b4f166ea03b109bb241355b9c42c279ea694d8864d033727205e65", size = 41233385 }, + { url = "https://files.pythonhosted.org/packages/40/1f/bf0a5f338bda7c35c08b4ed0df797e7bafe8a78a97275e9f439aceb46193/scipy-1.15.2-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:92233b2df6938147be6fa8824b8136f29a18f016ecde986666be5f4d686a91a4", size = 38703651 }, + { url = "https://files.pythonhosted.org/packages/de/54/db126aad3874601048c2c20ae3d8a433dbfd7ba8381551e6f62606d9bd8e/scipy-1.15.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:62ca1ff3eb513e09ed17a5736929429189adf16d2d740f44e53270cc800ecff1", size = 30102038 }, + { url = "https://files.pythonhosted.org/packages/61/d8/84da3fffefb6c7d5a16968fe5b9f24c98606b165bb801bb0b8bc3985200f/scipy-1.15.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4c6676490ad76d1c2894d77f976144b41bd1a4052107902238047fb6a473e971", size = 22375518 }, + { url = "https://files.pythonhosted.org/packages/44/78/25535a6e63d3b9c4c90147371aedb5d04c72f3aee3a34451f2dc27c0c07f/scipy-1.15.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:a8bf5cb4a25046ac61d38f8d3c3426ec11ebc350246a4642f2f315fe95bda655", size = 25142523 }, + { url = "https://files.pythonhosted.org/packages/e0/22/4b4a26fe1cd9ed0bc2b2cb87b17d57e32ab72c346949eaf9288001f8aa8e/scipy-1.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a8e34cf4c188b6dd004654f88586d78f95639e48a25dfae9c5e34a6dc34547e", size = 35491547 }, + { url = "https://files.pythonhosted.org/packages/32/ea/564bacc26b676c06a00266a3f25fdfe91a9d9a2532ccea7ce6dd394541bc/scipy-1.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28a0d2c2075946346e4408b211240764759e0fabaeb08d871639b5f3b1aca8a0", size = 37634077 }, + { url = "https://files.pythonhosted.org/packages/43/c2/bfd4e60668897a303b0ffb7191e965a5da4056f0d98acfb6ba529678f0fb/scipy-1.15.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:42dabaaa798e987c425ed76062794e93a243be8f0f20fff6e7a89f4d61cb3d40", size = 37231657 }, + { url = "https://files.pythonhosted.org/packages/4a/75/5f13050bf4f84c931bcab4f4e83c212a36876c3c2244475db34e4b5fe1a6/scipy-1.15.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f5e296ec63c5da6ba6fa0343ea73fd51b8b3e1a300b0a8cae3ed4b1122c7462", size = 40035857 }, + { url = "https://files.pythonhosted.org/packages/b9/8b/7ec1832b09dbc88f3db411f8cdd47db04505c4b72c99b11c920a8f0479c3/scipy-1.15.2-cp311-cp311-win_amd64.whl", hash = "sha256:597a0c7008b21c035831c39927406c6181bcf8f60a73f36219b69d010aa04737", size = 41217654 }, + { url = "https://files.pythonhosted.org/packages/4b/5d/3c78815cbab499610f26b5bae6aed33e227225a9fa5290008a733a64f6fc/scipy-1.15.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c4697a10da8f8765bb7c83e24a470da5797e37041edfd77fd95ba3811a47c4fd", size = 38756184 }, + { url = "https://files.pythonhosted.org/packages/37/20/3d04eb066b471b6e171827548b9ddb3c21c6bbea72a4d84fc5989933910b/scipy-1.15.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:869269b767d5ee7ea6991ed7e22b3ca1f22de73ab9a49c44bad338b725603301", size = 30163558 }, + { url = "https://files.pythonhosted.org/packages/a4/98/e5c964526c929ef1f795d4c343b2ff98634ad2051bd2bbadfef9e772e413/scipy-1.15.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bad78d580270a4d32470563ea86c6590b465cb98f83d760ff5b0990cb5518a93", size = 22437211 }, + { url = "https://files.pythonhosted.org/packages/1d/cd/1dc7371e29195ecbf5222f9afeedb210e0a75057d8afbd942aa6cf8c8eca/scipy-1.15.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:b09ae80010f52efddb15551025f9016c910296cf70adbf03ce2a8704f3a5ad20", size = 25232260 }, + { url = "https://files.pythonhosted.org/packages/f0/24/1a181a9e5050090e0b5138c5f496fee33293c342b788d02586bc410c6477/scipy-1.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5a6fd6eac1ce74a9f77a7fc724080d507c5812d61e72bd5e4c489b042455865e", size = 35198095 }, + { url = "https://files.pythonhosted.org/packages/c0/53/eaada1a414c026673eb983f8b4a55fe5eb172725d33d62c1b21f63ff6ca4/scipy-1.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b871df1fe1a3ba85d90e22742b93584f8d2b8e6124f8372ab15c71b73e428b8", size = 37297371 }, + { url = "https://files.pythonhosted.org/packages/e9/06/0449b744892ed22b7e7b9a1994a866e64895363572677a316a9042af1fe5/scipy-1.15.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:03205d57a28e18dfd39f0377d5002725bf1f19a46f444108c29bdb246b6c8a11", size = 36872390 }, + { url = "https://files.pythonhosted.org/packages/6a/6f/a8ac3cfd9505ec695c1bc35edc034d13afbd2fc1882a7c6b473e280397bb/scipy-1.15.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:601881dfb761311045b03114c5fe718a12634e5608c3b403737ae463c9885d53", size = 39700276 }, + { url = "https://files.pythonhosted.org/packages/f5/6f/e6e5aff77ea2a48dd96808bb51d7450875af154ee7cbe72188afb0b37929/scipy-1.15.2-cp312-cp312-win_amd64.whl", hash = "sha256:e7c68b6a43259ba0aab737237876e5c2c549a031ddb7abc28c7b47f22e202ded", size = 40942317 }, + { url = "https://files.pythonhosted.org/packages/53/40/09319f6e0f276ea2754196185f95cd191cb852288440ce035d5c3a931ea2/scipy-1.15.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01edfac9f0798ad6b46d9c4c9ca0e0ad23dbf0b1eb70e96adb9fa7f525eff0bf", size = 38717587 }, + { url = "https://files.pythonhosted.org/packages/fe/c3/2854f40ecd19585d65afaef601e5e1f8dbf6758b2f95b5ea93d38655a2c6/scipy-1.15.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:08b57a9336b8e79b305a143c3655cc5bdbe6d5ece3378578888d2afbb51c4e37", size = 30100266 }, + { url = "https://files.pythonhosted.org/packages/dd/b1/f9fe6e3c828cb5930b5fe74cb479de5f3d66d682fa8adb77249acaf545b8/scipy-1.15.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:54c462098484e7466362a9f1672d20888f724911a74c22ae35b61f9c5919183d", size = 22373768 }, + { url = "https://files.pythonhosted.org/packages/15/9d/a60db8c795700414c3f681908a2b911e031e024d93214f2d23c6dae174ab/scipy-1.15.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:cf72ff559a53a6a6d77bd8eefd12a17995ffa44ad86c77a5df96f533d4e6c6bb", size = 25154719 }, + { url = "https://files.pythonhosted.org/packages/37/3b/9bda92a85cd93f19f9ed90ade84aa1e51657e29988317fabdd44544f1dd4/scipy-1.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9de9d1416b3d9e7df9923ab23cd2fe714244af10b763975bea9e4f2e81cebd27", size = 35163195 }, + { url = "https://files.pythonhosted.org/packages/03/5a/fc34bf1aa14dc7c0e701691fa8685f3faec80e57d816615e3625f28feb43/scipy-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb530e4794fc8ea76a4a21ccb67dea33e5e0e60f07fc38a49e821e1eae3b71a0", size = 37255404 }, + { url = "https://files.pythonhosted.org/packages/4a/71/472eac45440cee134c8a180dbe4c01b3ec247e0338b7c759e6cd71f199a7/scipy-1.15.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5ea7ed46d437fc52350b028b1d44e002646e28f3e8ddc714011aaf87330f2f32", size = 36860011 }, + { url = "https://files.pythonhosted.org/packages/01/b3/21f890f4f42daf20e4d3aaa18182dddb9192771cd47445aaae2e318f6738/scipy-1.15.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:11e7ad32cf184b74380f43d3c0a706f49358b904fa7d5345f16ddf993609184d", size = 39657406 }, + { url = "https://files.pythonhosted.org/packages/0d/76/77cf2ac1f2a9cc00c073d49e1e16244e389dd88e2490c91d84e1e3e4d126/scipy-1.15.2-cp313-cp313-win_amd64.whl", hash = "sha256:a5080a79dfb9b78b768cebf3c9dcbc7b665c5875793569f48bf0e2b1d7f68f6f", size = 40961243 }, + { url = "https://files.pythonhosted.org/packages/4c/4b/a57f8ddcf48e129e6054fa9899a2a86d1fc6b07a0e15c7eebff7ca94533f/scipy-1.15.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:447ce30cee6a9d5d1379087c9e474628dab3db4a67484be1b7dc3196bfb2fac9", size = 38870286 }, + { url = "https://files.pythonhosted.org/packages/0c/43/c304d69a56c91ad5f188c0714f6a97b9c1fed93128c691148621274a3a68/scipy-1.15.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:c90ebe8aaa4397eaefa8455a8182b164a6cc1d59ad53f79943f266d99f68687f", size = 30141634 }, + { url = "https://files.pythonhosted.org/packages/44/1a/6c21b45d2548eb73be9b9bff421aaaa7e85e22c1f9b3bc44b23485dfce0a/scipy-1.15.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:def751dd08243934c884a3221156d63e15234a3155cf25978b0a668409d45eb6", size = 22415179 }, + { url = "https://files.pythonhosted.org/packages/74/4b/aefac4bba80ef815b64f55da06f62f92be5d03b467f2ce3668071799429a/scipy-1.15.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:302093e7dfb120e55515936cb55618ee0b895f8bcaf18ff81eca086c17bd80af", size = 25126412 }, + { url = "https://files.pythonhosted.org/packages/b1/53/1cbb148e6e8f1660aacd9f0a9dfa2b05e9ff1cb54b4386fe868477972ac2/scipy-1.15.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd5b77413e1855351cdde594eca99c1f4a588c2d63711388b6a1f1c01f62274", size = 34952867 }, + { url = "https://files.pythonhosted.org/packages/2c/23/e0eb7f31a9c13cf2dca083828b97992dd22f8184c6ce4fec5deec0c81fcf/scipy-1.15.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d0194c37037707b2afa7a2f2a924cf7bac3dc292d51b6a925e5fcb89bc5c776", size = 36890009 }, + { url = "https://files.pythonhosted.org/packages/03/f3/e699e19cabe96bbac5189c04aaa970718f0105cff03d458dc5e2b6bd1e8c/scipy-1.15.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:bae43364d600fdc3ac327db99659dcb79e6e7ecd279a75fe1266669d9a652828", size = 36545159 }, + { url = "https://files.pythonhosted.org/packages/af/f5/ab3838e56fe5cc22383d6fcf2336e48c8fe33e944b9037fbf6cbdf5a11f8/scipy-1.15.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f031846580d9acccd0044efd1a90e6f4df3a6e12b4b6bd694a7bc03a89892b28", size = 39136566 }, + { url = "https://files.pythonhosted.org/packages/0a/c8/b3f566db71461cabd4b2d5b39bcc24a7e1c119535c8361f81426be39bb47/scipy-1.15.2-cp313-cp313t-win_amd64.whl", hash = "sha256:fe8a9eb875d430d81755472c5ba75e84acc980e4a8f6204d402849234d3017db", size = 40477705 }, +] + +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "matplotlib", version = "3.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914 }, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072 }, +] + +[[package]] +name = "setuptools" +version = "75.8.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/42/0e5f75d734f181367de4acd9aba8f875453a5905169c5485ca8416b015ae/setuptools-75.8.1.tar.gz", hash = "sha256:65fb779a8f28895242923582eadca2337285f0891c2c9e160754df917c3d2530", size = 1343534 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/bd/ac215d31c2904e47ec5332897442bdc19fd6b21a82068d057152f4e9c1cf/setuptools-75.8.1-py3-none-any.whl", hash = "sha256:3bc32c0b84c643299ca94e77f834730f126efd621de0cc1de64119e0e17dab1f", size = 1228867 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, +] + +[[package]] +name = "soupsieve" +version = "2.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, +] + +[[package]] +name = "tornado" +version = "6.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/45/a0daf161f7d6f36c3ea5fc0c2de619746cc3dd4c76402e9db545bd920f63/tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b", size = 501135 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/7e/71f604d8cea1b58f82ba3590290b66da1e72d840aeb37e0d5f7291bd30db/tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1", size = 436299 }, + { url = "https://files.pythonhosted.org/packages/96/44/87543a3b99016d0bf54fdaab30d24bf0af2e848f1d13d34a3a5380aabe16/tornado-6.4.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:072ce12ada169c5b00b7d92a99ba089447ccc993ea2143c9ede887e0937aa803", size = 434253 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/fdf679b4ce51bcb7210801ef4f11fdac96e9885daa402861751353beea6e/tornado-6.4.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a017d239bd1bb0919f72af256a970624241f070496635784d9bf0db640d3fec", size = 437602 }, + { url = "https://files.pythonhosted.org/packages/4f/3b/e31aeffffc22b475a64dbeb273026a21b5b566f74dee48742817626c47dc/tornado-6.4.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c36e62ce8f63409301537222faffcef7dfc5284f27eec227389f2ad11b09d946", size = 436972 }, + { url = "https://files.pythonhosted.org/packages/22/55/b78a464de78051a30599ceb6983b01d8f732e6f69bf37b4ed07f642ac0fc/tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf", size = 437173 }, + { url = "https://files.pythonhosted.org/packages/79/5e/be4fb0d1684eb822c9a62fb18a3e44a06188f78aa466b2ad991d2ee31104/tornado-6.4.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:304463bd0772442ff4d0f5149c6f1c2135a1fae045adf070821c6cdc76980634", size = 437892 }, + { url = "https://files.pythonhosted.org/packages/f5/33/4f91fdd94ea36e1d796147003b490fe60a0215ac5737b6f9c65e160d4fe0/tornado-6.4.2-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:c82c46813ba483a385ab2a99caeaedf92585a1f90defb5693351fa7e4ea0bf73", size = 437334 }, + { url = "https://files.pythonhosted.org/packages/2b/ae/c1b22d4524b0e10da2f29a176fb2890386f7bd1f63aacf186444873a88a0/tornado-6.4.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:932d195ca9015956fa502c6b56af9eb06106140d844a335590c1ec7f5277d10c", size = 437261 }, + { url = "https://files.pythonhosted.org/packages/b5/25/36dbd49ab6d179bcfc4c6c093a51795a4f3bed380543a8242ac3517a1751/tornado-6.4.2-cp38-abi3-win32.whl", hash = "sha256:2876cef82e6c5978fde1e0d5b1f919d756968d5b4282418f3146b79b58556482", size = 438463 }, + { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907 }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20241206" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/60/47d92293d9bc521cd2301e423a358abfac0ad409b3a1606d8fbae1321961/types_python_dateutil-2.9.0.20241206.tar.gz", hash = "sha256:18f493414c26ffba692a72369fea7a154c502646301ebfe3d56a04b3767284cb", size = 13802 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/b3/ca41df24db5eb99b00d97f89d7674a90cb6b3134c52fb8121b6d8d30f15c/types_python_dateutil-2.9.0.20241206-py3-none-any.whl", hash = "sha256:e248a4bc70a486d3e3ec84d0dc30eec3a5f979d6e7ee4123ae043eedbb987f53", size = 14384 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762 }, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140 }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 }, + { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 }, + { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 }, + { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 }, + { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 }, + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 }, + { url = "https://files.pythonhosted.org/packages/05/52/7223011bb760fce8ddc53416beb65b83a3ea6d7d13738dde75eeb2c89679/watchdog-6.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e6f0e77c9417e7cd62af82529b10563db3423625c5fce018430b249bf977f9e8", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/9c/62/d2b21bc4e706d3a9d467561f487c2938cbd881c69f3808c43ac1ec242391/watchdog-6.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:90c8e78f3b94014f7aaae121e6b909674df5b46ec24d6bebc45c44c56729af2a", size = 88386 }, + { url = "https://files.pythonhosted.org/packages/ea/22/1c90b20eda9f4132e4603a26296108728a8bfe9584b006bd05dd94548853/watchdog-6.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e7631a77ffb1f7d2eefa4445ebbee491c720a5661ddf6df3498ebecae5ed375c", size = 89017 }, + { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 }, + { url = "https://files.pythonhosted.org/packages/5b/79/69f2b0e8d3f2afd462029031baafb1b75d11bb62703f0e1022b2e54d49ee/watchdog-6.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7a0e56874cfbc4b9b05c60c8a1926fedf56324bb08cfbc188969777940aef3aa", size = 87903 }, + { url = "https://files.pythonhosted.org/packages/e2/2b/dc048dd71c2e5f0f7ebc04dd7912981ec45793a03c0dc462438e0591ba5d/watchdog-6.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6439e374fc012255b4ec786ae3c4bc838cd7309a540e5fe0952d03687d8804e", size = 88381 }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, +] + +[[package]] +name = "webcolors" +version = "24.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/29/061ec845fb58521848f3739e466efd8250b4b7b98c1b6c5bf4d40b419b7e/webcolors-24.11.1.tar.gz", hash = "sha256:ecb3d768f32202af770477b8b65f318fa4f566c22948673a977b00d589dd80f6", size = 45064 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/e8/c0e05e4684d13459f93d312077a9a2efbe04d59c393bc2b8802248c908d4/webcolors-24.11.1-py3-none-any.whl", hash = "sha256:515291393b4cdf0eb19c155749a096f779f7d909f7cceea072791cb9095b92e9", size = 14934 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/56/fc/238c424fd7f4ebb25f8b1da9a934a3ad7c848286732ae04263661eb0fc03/widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6", size = 1164730 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/02/88b65cc394961a60c43c70517066b6b679738caf78506a5da7b88ffcb643/widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71", size = 2335872 }, +] + +[[package]] +name = "xlrd" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/b3/19a2540d21dea5f908304375bd43f5ed7a4c28a370dc9122c565423e6b44/xlrd-2.0.1.tar.gz", hash = "sha256:f72f148f54442c6b056bf931dbc34f986fd0c3b0b6b5a58d013c9aef274d0c88", size = 100259 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/0c/c2a72d51fe56e08a08acc85d13013558a2d793028ae7385448a6ccdfae64/xlrd-2.0.1-py2.py3-none-any.whl", hash = "sha256:6a33ee89877bd9abc1158129f6e94be74e2679636b8a205b43b85206c3f0bbdd", size = 96531 }, +] + +[[package]] +name = "xlsxwriter" +version = "3.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/08/26f69d1e9264e8107253018de9fc6b96f9219817d01c5f021e927384a8d1/xlsxwriter-3.2.2.tar.gz", hash = "sha256:befc7f92578a85fed261639fb6cde1fd51b79c5e854040847dde59d4317077dc", size = 205202 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/07/df054f7413bdfff5e98f75056e4ed0977d0c8716424011fac2587864d1d3/XlsxWriter-3.2.2-py3-none-any.whl", hash = "sha256:272ce861e7fa5e82a4a6ebc24511f2cb952fde3461f6c6e1a1e81d3272db1471", size = 165121 }, +] + +[[package]] +name = "zipp" +version = "3.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, +] From e57070807d4411c6aad971e84cac837cf59f9959 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:28:11 +0000 Subject: [PATCH 17/97] Fix type annotation in utils.py to avoid circular import issues --- src/circumplex/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 655e4a4..712d643 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -85,7 +85,7 @@ def standardize( data: pd.DataFrame, scales: Union[List[str], pd.Index], angles: List[float], - instrument: Instrument, + instrument: 'Instrument', sample: int = 1, prefix: str = "", suffix: str = "_z", @@ -97,7 +97,7 @@ def standardize( data (pd.DataFrame): A DataFrame containing at least circumplex scales. scales (Union[List[str], pd.Index]): The column names for the variables in data that contain circumplex scales to be standardized. angles (List[float]): A numeric list containing the angular displacement of each circumplex scale (in degrees). - instrument (Dict[str, Any]): An instrument object containing normative data. + instrument (Instrument): An instrument object containing normative data. sample (int): An integer corresponding to the normative sample to use in standardizing the scale scores (default = 1). prefix (str): A string to include at the beginning of the newly calculated scale variables' names (default = ""). suffix (str): A string to include at the end of the newly calculated scale variables' names (default = "_z"). From 5481b656d41d7c1726aabe828657e0cfd1f68c1d Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:28:47 +0000 Subject: [PATCH 18/97] Update tests to accept ValueError for invalid inputs --- tests/test_ssm_analysis.py | 2 +- tests/test_visualisation.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_ssm_analysis.py b/tests/test_ssm_analysis.py index 9eff411..5003226 100644 --- a/tests/test_ssm_analysis.py +++ b/tests/test_ssm_analysis.py @@ -120,7 +120,7 @@ def bs_function(data, index, angles, contrast, listwise): def test_invalid_input(sample_data, angles): - with pytest.raises(AssertionError): + with pytest.raises((AssertionError, ValueError)): ssm_analysis.ssm_analyze(sample_data, ["invalid_scale"], angles, boots=50) diff --git a/tests/test_visualisation.py b/tests/test_visualisation.py index 839bf99..c6ad88e 100644 --- a/tests/test_visualisation.py +++ b/tests/test_visualisation.py @@ -205,7 +205,7 @@ def test_ssm_plot_profile(mock_ssm_results): def test_invalid_input(): - with pytest.raises((AssertionError, TypeError)): + with pytest.raises((AssertionError, TypeError, ValueError)): visualization.ssm_plot("not an SSMResults object") From 465fa7cd30457d03ae9eeffdf32a503140b73247 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:29:11 +0000 Subject: [PATCH 19/97] Fix pandas DeprecationWarning in groupby operation --- src/circumplex/ssm_analysis.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index 87dbb7f..de7b0fc 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -518,7 +518,7 @@ def ssm_bootstrap( for _ in range(boots): if strata is not None: resample = ( - bs_input.groupby(strata, observed=False) + bs_input.groupby(strata, observed=False, include_groups=False) .apply(lambda x: x.sample(n=len(x), replace=True)) .reset_index(drop=True) ) From 705c5771e60ac7606572ff62f55c166e728e0546 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 13:29:36 +0000 Subject: [PATCH 20/97] Remove include_groups parameter for compatibility with older pandas versions --- src/circumplex/ssm_analysis.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index de7b0fc..2af9a52 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -517,8 +517,11 @@ def ssm_bootstrap( bootstrap_results = [] for _ in range(boots): if strata is not None: + # Note: Using observed=False for categorical data + # The DeprecationWarning about operating on grouping columns is expected + # but won't affect functionality resample = ( - bs_input.groupby(strata, observed=False, include_groups=False) + bs_input.groupby(strata, observed=False) .apply(lambda x: x.sample(n=len(x), replace=True)) .reset_index(drop=True) ) From 71b46916f974a5affa6e7468e596f1a86ca6ba3b Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 16:56:56 +0000 Subject: [PATCH 21/97] Update Random_exs.ipynb to use ssm_analyze instead of deprecated ssm_analyse functions --- docs/tutorials/Random_exs.ipynb | 39 ++++----------------------------- 1 file changed, 4 insertions(+), 35 deletions(-) diff --git a/docs/tutorials/Random_exs.ipynb b/docs/tutorials/Random_exs.ipynb index 6631061..4e73195 100644 --- a/docs/tutorials/Random_exs.ipynb +++ b/docs/tutorials/Random_exs.ipynb @@ -81,10 +81,7 @@ }, { "cell_type": "code", - "execution_count": 4, - "source": [ - "test = circumplex.ssm_analyse_grouped_corrs(data, scales, [\"loud\"], [\"Language\"])" - ], + "source": "# Note: ssm_analyse_grouped_corrs is no longer supported\n# Use the standard ssm_analyze function with grouping and measures parameters\ntest = circumplex.ssm_analyze(data, scales, measures=[\"loud\"], grouping=\"Language\")", "metadata": { "collapsed": false, "ExecuteTime": { @@ -147,32 +144,7 @@ }, { "cell_type": "code", - "execution_count": 8, - "source": [ - "lang_angles = {\n", - " 'arb': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'cmn': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'deu': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'ell': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'eng': (0, 46, 93, 138, 182, 228, 272, 340),\n", - " 'fra': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'hrv': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'ind': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'ita': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'jpn': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'kor': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'nld': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'por': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'spa': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'swe': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'tur': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'vie': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " 'zsm': (0, 65, 97, 131, 182, 255, 281, 335),\n", - " }\n", - "\n", - "corr_res = circumplex.ssm_analyse(data, scales, [\"loud\"], [\"Language\"], grouped_angles = lang_angles)\n", - "corr_res.plot()" - ], + "source": "lang_angles = {\n 'arb': (0, 65, 97, 131, 182, 255, 281, 335),\n 'cmn': (0, 65, 97, 131, 182, 255, 281, 335),\n 'deu': (0, 65, 97, 131, 182, 255, 281, 335),\n 'ell': (0, 65, 97, 131, 182, 255, 281, 335),\n 'eng': (0, 46, 93, 138, 182, 228, 272, 340),\n 'fra': (0, 65, 97, 131, 182, 255, 281, 335),\n 'hrv': (0, 65, 97, 131, 182, 255, 281, 335),\n 'ind': (0, 65, 97, 131, 182, 255, 281, 335),\n 'ita': (0, 65, 97, 131, 182, 255, 281, 335),\n 'jpn': (0, 65, 97, 131, 182, 255, 281, 335),\n 'kor': (0, 65, 97, 131, 182, 255, 281, 335),\n 'nld': (0, 65, 97, 131, 182, 255, 281, 335),\n 'por': (0, 65, 97, 131, 182, 255, 281, 335),\n 'spa': (0, 65, 97, 131, 182, 255, 281, 335),\n 'swe': (0, 65, 97, 131, 182, 255, 281, 335),\n 'tur': (0, 65, 97, 131, 182, 255, 281, 335),\n 'vie': (0, 65, 97, 131, 182, 255, 281, 335),\n 'zsm': (0, 65, 97, 131, 182, 255, 281, 335),\n }\n\n# Updated to use ssm_analyze instead of ssm_analyse\ncorr_res = circumplex.ssm_analyze(data, scales, measures=[\"loud\"], grouping=\"Language\", grouped_angles=lang_angles)\ncorr_res.plot()", "metadata": { "collapsed": false, "ExecuteTime": { @@ -505,10 +477,7 @@ }, { "cell_type": "code", - "execution_count": 27, - "source": [ - "satp_eng.demo_plot()" - ], + "source": "# Updated to use ssm_analyze instead of ssm_analyse\nsatp_eng_res = satp_eng.ssm_analyze(measures=['loud'])\nprint(satp_eng_res)", "metadata": { "collapsed": false, "ExecuteTime": { @@ -614,4 +583,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From b073819262fed49e12b8e7ddb5367449095beefa Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 16:57:59 +0000 Subject: [PATCH 22/97] Add test for notebook structure validation --- tests/test_notebooks.py | 46 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 tests/test_notebooks.py diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py new file mode 100644 index 0000000..f4891e0 --- /dev/null +++ b/tests/test_notebooks.py @@ -0,0 +1,46 @@ +""" +Tests to ensure Jupyter notebooks in the documentation have valid structure. + +This test only validates the structure of the notebooks, but does not execute them. +""" + +import os +import pytest +import nbformat + +# Find all notebooks in the tutorials directory +TUTORIALS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "docs", "tutorials") +NOTEBOOKS = [ + os.path.join(TUTORIALS_DIR, nb) + for nb in os.listdir(TUTORIALS_DIR) + if nb.endswith(".ipynb") and not nb.startswith(".") +] + + +@pytest.mark.parametrize("notebook_path", NOTEBOOKS) +def test_notebook_structure(notebook_path): + """ + Test that the notebook has valid structure and can be parsed. + + This test does NOT execute the notebook cells, it only checks + that the notebook can be loaded as a valid nbformat document. + + Args: + notebook_path (str): Path to the notebook file + """ + try: + # Load the notebook + with open(notebook_path, 'r', encoding='utf-8') as f: + notebook = nbformat.read(f, as_version=4) + + # Check that it has cells + assert len(notebook.cells) > 0, "Notebook has no cells" + + # Verify cells have required attributes + for i, cell in enumerate(notebook.cells): + assert 'source' in cell, f"Cell {i} is missing source" + assert 'cell_type' in cell, f"Cell {i} is missing cell_type" + + print(f"Successfully validated notebook: {os.path.basename(notebook_path)}") + except Exception as e: + pytest.fail(f"Failed to parse notebook {os.path.basename(notebook_path)}: {str(e)}") \ No newline at end of file From dc71a263bd81ccf4f841f52978a72ada5f3285a8 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Wed, 26 Feb 2025 17:06:23 +0000 Subject: [PATCH 23/97] test notebooks --- pyproject.toml | 1 + uv.lock | 105 ++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 96 insertions(+), 10 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index aac03a8..9972994 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,6 +34,7 @@ dev-dependencies = [ "mkdocs-jupyter>=0.24.7", "markdown>=3.6", "pymdown-extensions>=10.8.1", + "pytest-notebook>=0.10.0", ] [tool.hatch.metadata] diff --git a/uv.lock b/uv.lock index ee777f1..8c3f4f2 100644 --- a/uv.lock +++ b/uv.lock @@ -101,11 +101,11 @@ wheels = [ [[package]] name = "attrs" -version = "25.1.0" +version = "22.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/49/7c/fdf464bcc51d23881d110abd74b512a42b3d5d376a55a831b44c603ae17f/attrs-25.1.0.tar.gz", hash = "sha256:1c97078a80c814273a76b2a298a932eb681c87415c11dee0a6921de7f1b02c3e", size = 810562 } +sdist = { url = "https://files.pythonhosted.org/packages/21/31/3f468da74c7de4fcf9b25591e682856389b3400b4b62f201e65f15ea3e07/attrs-22.2.0.tar.gz", hash = "sha256:c9227bfc2f01993c03f68db37d1d15c9690188323c067c641f1a35ca58185f99", size = 215900 } wheels = [ - { url = "https://files.pythonhosted.org/packages/fc/30/d4986a882011f9df997a55e6becd864812ccfcd821d64aac8570ee39f719/attrs-25.1.0-py3-none-any.whl", hash = "sha256:c75a69e28a550a7e93789579c22aa26b0f5b83b75dc4e08fe092980051e1090a", size = 63152 }, + { url = "https://files.pythonhosted.org/packages/fb/6e/6f83bf616d2becdf333a1640f1d463fef3150e2e926b7010cb0f81c95e88/attrs-22.2.0-py3-none-any.whl", hash = "sha256:29e95c7f6778868dbd49170f98f8818f78f3dc5e0e37c0b1f474e3561b240836", size = 60018 }, ] [[package]] @@ -371,6 +371,7 @@ dev = [ { name = "mkdocstrings", extra = ["python"] }, { name = "pymdown-extensions" }, { name = "pytest" }, + { name = "pytest-notebook" }, ] [package.metadata] @@ -392,6 +393,7 @@ dev = [ { name = "mkdocstrings", extras = ["python"], specifier = ">=0.25.1" }, { name = "pymdown-extensions", specifier = ">=10.8.1" }, { name = "pytest", specifier = ">=8.2.2" }, + { name = "pytest-notebook", specifier = ">=0.10.0" }, ] [[package]] @@ -736,6 +738,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034 }, ] +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794 }, +] + +[[package]] +name = "gitpython" +version = "3.1.44" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/89/37df0b71473153574a5cdef8f242de422a0f5d26d7a9e231e6f169b4ad14/gitpython-3.1.44.tar.gz", hash = "sha256:c87e30b26253bf5418b01b0660f818967f3c503193838337fe5e573331249269", size = 214196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/9a/4114a9057db2f1462d5c8f8390ab7383925fe1ac012eaa42402ad65c2963/GitPython-3.1.44-py3-none-any.whl", hash = "sha256:9e0e10cda9bed1ee64bc9a6de50e7e38a9c9943241cd7f585f6df3ed28011110", size = 207599 }, +] + [[package]] name = "griffe" version = "1.5.7" @@ -796,14 +822,14 @@ wheels = [ [[package]] name = "importlib-metadata" -version = "8.6.1" +version = "6.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp", marker = "python_full_version < '3.10'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } +sdist = { url = "https://files.pythonhosted.org/packages/ee/eb/58c2ab27ee628ad801f56d4017fe62afab0293116f6d0b08f1d5bd46e06f/importlib_metadata-6.11.0.tar.gz", hash = "sha256:1231cf92d825c9e03cfc4da076a16de6422c863558229ea0b22b675657463443", size = 54593 } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, + { url = "https://files.pythonhosted.org/packages/59/9b/ecce94952ab5ea74c31dcf9ccf78ccd484eebebef06019bf8cb579ab4519/importlib_metadata-6.11.0-py3-none-any.whl", hash = "sha256:f0afba6205ad8f8947c7d338b5342d5db2afbfd82f9cbef7879a9539cc12eb9b", size = 23427 }, ] [[package]] @@ -1144,6 +1170,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e2/a2/89eeaf0bb954a123a909859fa507fa86f96eb61b62dc30667b60dbd5fdaf/jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3", size = 385826 }, ] +[[package]] +name = "jupyter-server-mathjax" +version = "0.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/40/9a1b8c2a2e44e8e2392174cd8e52e0c976335f004301f61b66addea3243e/jupyter_server_mathjax-0.2.6.tar.gz", hash = "sha256:bb1e6b6dc0686c1fe386a22b5886163db548893a99c2810c36399e9c4ca23943", size = 2648665 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/77/6a98cc88f1061c0206b427b602efb6fcb9bc369e958aee11676d5cfc4412/jupyter_server_mathjax-0.2.6-py3-none-any.whl", hash = "sha256:416389dde2010df46d5fbbb7adb087a5607111070af65a1445391040f2babb5e", size = 3120990 }, +] + [[package]] name = "jupyter-server-terminals" version = "0.5.3" @@ -1906,17 +1944,17 @@ wheels = [ [[package]] name = "nbclient" -version = "0.10.2" +version = "0.5.13" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-client" }, - { name = "jupyter-core" }, { name = "nbformat" }, + { name = "nest-asyncio" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +sdist = { url = "https://files.pythonhosted.org/packages/3e/89/cd8621865c68d7570371d137257566651cb259137879d65fb533bd183165/nbclient-0.5.13.tar.gz", hash = "sha256:40c52c9b5e3c31faecaee69f202b3f53e38d7c1c563de0fadde9d7eda0fdafe8", size = 75191 } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, + { url = "https://files.pythonhosted.org/packages/db/f7/436bb1add1814911efec4a4a5a358c7559e9b1fd19f4ef89a2a71d707c2b/nbclient-0.5.13-py3-none-any.whl", hash = "sha256:47ac905af59379913c1f8f541098d2550153cf8dc58553cbe18c702b181518b0", size = 70613 }, ] [[package]] @@ -1945,6 +1983,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, ] +[[package]] +name = "nbdime" +version = "4.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, + { name = "gitpython" }, + { name = "jinja2" }, + { name = "jupyter-server" }, + { name = "jupyter-server-mathjax" }, + { name = "nbformat" }, + { name = "pygments" }, + { name = "requests" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/f1/4be57ecea4d55d322f05a0f89e0b73d7a8d90a16dbf01168eab3e7bf5939/nbdime-4.0.2.tar.gz", hash = "sha256:d8279f8f4b236c0b253b20d60c4831bb67843ed8dbd6e09f234eb011d36f1bf2", size = 9452967 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/23/824b295f4cc53f4437f6917e8f46c519cd3a9be909dd36ca0682fdc7fff1/nbdime-4.0.2-py3-none-any.whl", hash = "sha256:e5a43aca669c576c66e757071c0e882de05ac305311d79aded99bfb5a3e9419e", size = 5917346 }, +] + [[package]] name = "nbformat" version = "5.10.4" @@ -2604,6 +2662,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, ] +[[package]] +name = "pytest-notebook" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jsonschema" }, + { name = "nbclient" }, + { name = "nbdime" }, + { name = "nbformat" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3e/03/8ea56929a6e0675d2c420555b3092c9a74a9a04e70417bcfe5b4b5ef1413/pytest_notebook-0.10.0.tar.gz", hash = "sha256:0a38a73b04c40137402b5f39a053395b418028cb3994a04dbcffe603c7b2a646", size = 3414910 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/31/7ed17c3f929b0b7537ceaab0d06c7ce1d2ec56ddd9dd69306f8bfcd515e8/pytest_notebook-0.10.0-py3-none-any.whl", hash = "sha256:482ab2f8fbac6ecb417226e9b7e68476332262a03f555e49d89a164ee16581f6", size = 37694 }, +] + [[package]] name = "python-calamine" version = "0.3.1" @@ -3313,6 +3389,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, ] +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303 }, +] + [[package]] name = "sniffio" version = "1.3.1" From 12864216ebdbcb9127c9b721c6c02d78421ac0db Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 24/97] Add new GitHub Actions workflows for CI/CD --- .github/workflows/docs.yml | 56 +++++++++++++++++++++++++++++++++++ .github/workflows/linting.yml | 38 ++++++++++++++++++++++++ .github/workflows/tests.yml | 42 ++++++++++++++++++++++++++ 3 files changed, 136 insertions(+) create mode 100644 .github/workflows/docs.yml create mode 100644 .github/workflows/linting.yml create mode 100644 .github/workflows/tests.yml diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..04115a2 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,56 @@ +name: Documentation + +on: + push: + branches: + - main + pull_request: + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout source + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 + with: + fetch-depth: 0 + + - name: Cache tox + uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4 + with: + path: .tox + key: tox-${{ hashFiles('pyproject.toml') }} + + - name: Set up Python + uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version: "3.x" + cache: "pip" + cache-dependency-path: "pyproject.toml" + + - name: Install tox + run: python -m pip install tox + + - name: Build HTML documentation with tox + run: tox -e docs + + - name: Upload built docs as artifact + id: deployment + uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3 + with: + path: site + + deploy: + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + permissions: + pages: write + id-token: write + runs-on: ubuntu-latest + needs: build + if: github.event_name != 'pull_request' + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4 diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml new file mode 100644 index 0000000..bf41326 --- /dev/null +++ b/.github/workflows/linting.yml @@ -0,0 +1,38 @@ +name: Linting + +on: + push: + branches: + - main + pull_request: + +jobs: + linting: + runs-on: ubuntu-latest + steps: + - name: Checkout source + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 + + - name: Cache pre-commit + uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4 + with: + path: ~/.cache/pre-commit + key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }} + + - name: Set up python + uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version-file: ".python-version" + + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + # Install a specific version of uv + version: "0.9.0" + enable-cache: true + + - name: Install the project + run: uv sync --locked --dev + + - name: Run prek + run: uv run prek run --all-files --color always --verbose diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000..6f308bf --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,42 @@ +name: Tests + +on: + push: + branches: + - main + pull_request: + paths-ignore: + - "**.md" + +jobs: + tests: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: + - "3.11" + - "3.12" + - "3.13" + + steps: + - name: Checkout source + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 + + - name: Cache tox + uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4 + with: + path: .tox + key: tox-${{hashFiles('pyproject.toml') }} + + - name: Set up python + uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version: ${{ matrix.python-version }} + cache: pip + cache-dependency-path: pyproject.toml + + - name: Install dependencies + run: python -m pip install tox tox-gh + + - name: Test with tox + run: tox run From f155fcff7f34ea987aaaaa4ea0a18b1278c683a4 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 25/97] Update existing GitHub Actions workflow formatting --- .github/workflows/python-package.yml | 47 ++++++++++++++-------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index e71a213..86a90e3 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -5,13 +5,12 @@ name: Python package on: push: - branches: [ "main" ] + branches: ["main"] pull_request: - branches: [ "main" ] + branches: ["main"] jobs: build: - runs-on: ubuntu-latest strategy: fail-fast: false @@ -19,24 +18,24 @@ jobs: python-version: ["3.11"] steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest - python -m pip install . - python -m pip install .[test] - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with pytest - run: | - pytest + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install flake8 pytest + python -m pip install . + python -m pip install .[test] + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + pytest From 846466802d5bb13086a7dd2cef899bf9fb8ba6de Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 26/97] Add development tooling configuration files --- .markdownlint.yaml | 3 +++ .pre-commit-config.yaml | 60 +++++++++++++++++++++++++++++++++++++++++ .readthedocs.yaml | 4 +-- 3 files changed, 65 insertions(+), 2 deletions(-) create mode 100644 .markdownlint.yaml create mode 100644 .pre-commit-config.yaml diff --git a/.markdownlint.yaml b/.markdownlint.yaml new file mode 100644 index 0000000..41b3c0c --- /dev/null +++ b/.markdownlint.yaml @@ -0,0 +1,3 @@ +--- +MD013: false +MD046: false diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..2ca2de1 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,60 @@ +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.12.1 + hooks: + - id: ruff + - id: ruff-format + - repo: https://github.com/igorshubovych/markdownlint-cli + rev: v0.45.0 + hooks: + - id: markdownlint-fix + args: + - --dot + - repo: https://github.com/Lucas-C/pre-commit-hooks + rev: v1.5.5 + hooks: + - id: forbid-tabs + - repo: https://github.com/pappasam/toml-sort + rev: v0.24.2 + hooks: + - id: toml-sort-fix + # - repo: https://github.com/pre-commit/mirrors-mypy + # rev: v1.16.1 + # hooks: + # - id: mypy + - repo: local + hooks: + - id: ty + name: ty check + entry: ty check . --ignore unresolved-import + language: python + pass_filenames: false + args: [--python=.venv/] + additional_dependencies: [ty] + - repo: https://github.com/rbubley/mirrors-prettier + rev: v3.6.2 + hooks: + - id: prettier + args: + - --quote-props=as-needed + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v5.0.0 + hooks: + - id: check-case-conflict + - id: check-docstring-first + - id: check-merge-conflict + - id: check-toml + - id: end-of-file-fixer + - id: mixed-line-ending + args: + - --fix=lf + - id: trailing-whitespace + - repo: https://github.com/python-jsonschema/check-jsonschema + rev: 0.33.1 + hooks: + # Schemas taken from https://www.schemastore.org/json/ + - id: check-jsonschema + name: "Validate GitHub issue templates" + files: ^\.github/ISSUE_TEMPLATE/.*\.yml$ + exclude: ^\.github/ISSUE_TEMPLATE/config\.yml$ + args: ["--verbose", "--schemafile", "schemas/github-issue-forms.json"] diff --git a/.readthedocs.yaml b/.readthedocs.yaml index e13438d..93c3201 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -21,7 +21,7 @@ build: # Build documentation in the "docs/" directory with Sphinx mkdocs: - configuration: mkdocs.yml + configuration: mkdocs.yml # Optionally build your docs in additional formats such as PDF and ePub formats: @@ -33,4 +33,4 @@ formats: # See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html # python: # install: -# - requirements: docs/requirements.txt \ No newline at end of file +# - requirements: docs/requirements.txt From 8c621277d229080c9b69bd978cc59a46eb15e46a Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 27/97] Update .gitignore with comprehensive exclusions --- .gitignore | 29 ++++++++++++++++++++++++++--- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 0a69720..a945064 100644 --- a/.gitignore +++ b/.gitignore @@ -101,7 +101,15 @@ ipython_config.py # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock -# PEP 582; used by e.g. github.com/David-OConnor/pyflow +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff @@ -130,6 +138,12 @@ venv.bak/ # mkdocs documentation /site +# Jupyter notebook artifacts +docs/**/*.ipynb +.ipynb_checkpoints/ +docs/**/*.html +docs/**/*_files/ + # mypy .mypy_cache/ .dmypy.json @@ -145,9 +159,18 @@ dmypy.json cython_debug/ # PyCharm -# JetBrains specific template is maintainted in a separate JetBrains.gitignore that can +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Claude Code configuration +.claude/ +CLAUDE.md + +# package version +_version.py + +.vscode/ .idea/ -/.pdm-build/ From c802d071570e70debeb2ff3126790bb5430587e3 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 28/97] Modernize pyproject.toml with new build system and dependencies --- pyproject.toml | 78 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 26 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 9972994..96fb192 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,16 +1,42 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[dependency-groups] +dev = [ + {include-group = "docs"}, + {include-group = "test"}, + "jupyter>=1.0.0", + "tox>=4.27.0" +] +test = [ + "pytest>=8.3.4", + "pytest-cov>=7.0.0", + "pytest-notebook>=0.10.0", + "xdoctest>=1.3.0", +] +docs = [ + "mkdocs>=1.6.0", + "mkdocs-material>=9.5.26", + "mkdocstrings[python]>=0.25.1", + "mkdocs-jupyter>=0.24.7", + "markdown>=3.6", + "pymdown-extensions>=10.8.1" +] + [project] name = "circumplex" -version = "0.1.4" +version = "0.2.0.dev1" description = "A Python package for analyzing and visualizing circumplex data" authors = [ - {name = "Andrew Mitchell", email = "andrew.mitchell.18@ucl.ac.uk"}, + {name = "Andrew Mitchell", email = "andrew.mitchell.research@gmail.com"} ] dependencies = [ - "numpy>=1.25.2", - "scipy>=1.9.3", - "pandas[excel,performance]>=2.2.2", - "matplotlib>=3.9.4", - "seaborn>=0.13.2", + "numpy>=1.25.2", + "scipy>=1.9.3", + "pandas[excel,performance]>=2.2.2", + "matplotlib>=3.9.4", + "seaborn>=0.13.2" ] readme = "README.md" requires-python = ">= 3.9" @@ -19,26 +45,26 @@ requires-python = ">= 3.9" repository = "https://github.com/MitchellAcoustics/circumplex" documentation = "https://circumplex.readthedocs.io/en/latest/" -[build-system] -requires = ["hatchling"] -build-backend = "hatchling.build" - -[tool.uv] -managed = true -dev-dependencies = [ - "pytest>=8.2.2", - "jupyter>=1.0.0", - "mkdocs>=1.6.0", - "mkdocs-material>=9.5.26", - "mkdocstrings[python]>=0.25.1", - "mkdocs-jupyter>=0.24.7", - "markdown>=3.6", - "pymdown-extensions>=10.8.1", - "pytest-notebook>=0.10.0", -] +[tool.hatch.build.targets.wheel] +packages = ["src/circumplex"] [tool.hatch.metadata] allow-direct-references = true -[tool.hatch.build.targets.wheel] -packages = ["src/circumplex"] +[tool.tox] +env_list = ["py39", "py310", "py311", "py312", "py313"] +env_run_base = {commands = [ + [ + "pytest", + "--cov", + "--cov-report=xml" + ] +], dependency_groups = [ + "test" +]} +env.docs = {commands = [["mkdocs", "build"]], dependency_groups = ["docs"]} +gh.python."3.9" = ["py39"] +gh.python."3.10" = ["py310"] +gh.python."3.11" = ["py311"] +gh.python."3.12" = ["py312"] +gh.python."3.13" = ["py313"] From b1bb09709c55a5dac63f0de254e779a064c39612 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 29/97] Fix code formatting and style issues across codebase --- src/circumplex/__init__.py | 2 +- src/circumplex/instrument.py | 8 ++-- src/circumplex/ssm_analysis.py | 82 ++++++++++++++++++--------------- src/circumplex/ssm_results.py | 44 +++++++++--------- src/circumplex/utils.py | 39 ++++++++-------- src/circumplex/visualization.py | 29 ++++++------ 6 files changed, 107 insertions(+), 97 deletions(-) diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index 297372a..db21a41 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -13,4 +13,4 @@ "Instrument", "instruments", "utils", - ] +] diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index be85acf..7c36d85 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -165,9 +165,9 @@ class Scales: def __post_init__(self): assert len(self.abbrev) == len(self.angle) assert len(self.abbrev) == len(set(self.abbrev)), "Abbreviations must be unique" - assert ( - max(self.angle) <= 360 and min(self.angle) >= 0 - ), "Angles must be between 0 and 360" + assert max(self.angle) <= 360 and min(self.angle) >= 0, ( + "Angles must be between 0 and 360" + ) def __str__(self): return "\n".join( @@ -319,7 +319,7 @@ def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrum def ssm_analyze( self, measures: list[str] = None, grouping: list[str] = None - ) -> ssm_results.SSMResults: + ) -> ssm_results.SSMResults: """ Perform Structural Summary Method analysis on the instrument's data. diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index 2af9a52..cd32d34 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -28,9 +28,9 @@ def validate_ssm_input( ) -> None: """ Validate input parameters for SSM analysis functions. - + Raises ValueError with helpful messages if validation fails. - + Parameters ---------- data : pd.DataFrame @@ -53,7 +53,7 @@ def validate_ssm_input( Whether to use listwise deletion for missing values. measures_labels : Optional[List[str]] Labels for each measure provided in measures. - + Returns ------- None @@ -61,50 +61,58 @@ def validate_ssm_input( # Data validation if not isinstance(data, pd.DataFrame): raise ValueError("data must be a pandas DataFrame") - + # Scales validation if not all(scale in data.columns for scale in scales): missing = set(scales) - set(data.columns) raise ValueError(f"Scales missing from data: {missing}") - + # Angles validation - if not (isinstance(angles, tuple) and all(isinstance(a, (int, float)) for a in angles)): + if not ( + isinstance(angles, tuple) and all(isinstance(a, (int, float)) for a in angles) + ): raise ValueError("angles must be a tuple of numbers") if len(angles) != len(scales): - raise ValueError(f"angles and scales must have the same length (angles: {len(angles)}, scales: {len(scales)})") - + raise ValueError( + f"angles and scales must have the same length (angles: {len(angles)}, scales: {len(scales)})" + ) + # Bootstrap validation if not (isinstance(boots, int) and boots > 0): raise ValueError("boots must be a positive integer") - + # Interval validation if not (0 < interval < 1): raise ValueError("interval must be between 0 and 1") - + # Listwise validation if not isinstance(listwise, bool): raise ValueError("listwise must be a boolean") - + # Contrast validation if contrast not in ["none", "model", "test"]: raise ValueError("contrast must be 'none', 'model', or 'test'") - + # Measures validation - if measures is not None and not all(measure in data.columns for measure in measures): + if measures is not None and not all( + measure in data.columns for measure in measures + ): missing = set(measures) - set(data.columns) raise ValueError(f"Measures missing from data: {missing}") - + # Grouping validation if grouping is not None and grouping not in data.columns: raise ValueError(f"grouping variable '{grouping}' not found in data") - + # Measures labels validation if measures_labels is not None: if measures is None: - raise ValueError("measures must be provided when measures_labels is provided") + raise ValueError( + "measures must be provided when measures_labels is provided" + ) if len(measures_labels) != len(measures): raise ValueError("measures_labels must have the same length as measures") - + # Contrast possibility validation if contrast != "none" and measures is None and grouping is None: raise ValueError( @@ -165,19 +173,19 @@ def ssm_analyze( ------- SSMResults An object containing the results and description of the analysis. - + Examples -------- >>> import pandas as pd >>> from circumplex import ssm_analyze - >>> + >>> >>> # Simple analysis of means >>> results = ssm_analyze( - ... data, + ... data, ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], ... angles=(0, 45, 90, 135, 180, 225, 270, 315) ... ) - >>> + >>> >>> # Analysis with correlations and groups >>> results = ssm_analyze( ... data, @@ -198,7 +206,7 @@ def ssm_analyze( boots=boots, interval=interval, listwise=listwise, - measures_labels=measures_labels + measures_labels=measures_labels, ) # Determine analysis type and forward to appropriate subfunction @@ -208,7 +216,7 @@ def ssm_analyze( results = ssm_analyze_corrs( data, scales, - angles, + angles, measures, grouping, contrast, @@ -222,7 +230,7 @@ def ssm_analyze( results = ssm_analyze_corrs( data, scales, - angles, + angles, measures, None, contrast, @@ -235,7 +243,7 @@ def ssm_analyze( if grouping is not None: # Multiple group means results = ssm_analyze_means( - data, scales, angles, grouping, contrast, boots, interval, listwise + data, scales, angles, grouping, contrast, boots, interval, listwise ) else: # Single group means @@ -245,7 +253,7 @@ def ssm_analyze( "Set contrast = 'none' or add the measures or grouping arguments." ) results = ssm_analyze_means( - data, scales, angles, None, "none", boots, interval, listwise + data, scales, angles, None, "none", boots, interval, listwise ) # Create the call string @@ -258,7 +266,7 @@ def ssm_analyze( # Create and return the SSMResults object return ssm_results.SSMResults( results=results["results"], - scales=scales, + scales=scales, scores=results["scores"], details=results["details"], call=call_str, @@ -278,7 +286,7 @@ def ssm_analyze_means( """ Perform analyses using the mean-based Structural Summary Method. - This function calculates SSM parameters based on the mean scores of + This function calculates SSM parameters based on the mean scores of circumplex scales, optionally grouped by a categorical variable. Parameters @@ -312,11 +320,11 @@ def ssm_analyze_means( - details: Dictionary with analysis details - call: String representation of the function call - scores: DataFrame with mean scores for each scale and group - + Examples -------- >>> results_dict = ssm_analyze_means( - ... data, + ... data, ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], ... angles=(0, 45, 90, 135, 180, 225, 270, 315), ... grouping="Gender" @@ -395,7 +403,7 @@ def bs_function(data, index, angles, contrast, listwise): def ssm_by_group( - scores: pd.DataFrame, angles: Tuple[float], contrast: str + scores: pd.DataFrame, angles: Tuple[float], contrast: str ) -> np.ndarray: """ Calculate SSM parameters for each group, potentially with contrast. @@ -473,7 +481,7 @@ def ssm_parameters(scores: np.ndarray, angles: Tuple[float], bounds=BOUNDS) -> n # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution param, covariance = curve_fit( - utils.cosine_form, xdata=np.deg2rad(angles), ydata=scores, bounds=bounds + utils.cosine_form, xdata=np.deg2rad(angles), ydata=scores, bounds=bounds ) r2 = utils.r2_score(scores, utils.cosine_form(np.deg2rad(angles), *param)) ampl, disp, elev = param @@ -490,7 +498,7 @@ def polar2cart(r, theta): def ssm_bootstrap( bs_input: pd.DataFrame, bs_function: Callable, - angles: Tuple[float], + angles: Tuple[float], boots: int, interval: float, contrast: str, @@ -573,7 +581,7 @@ def ssm_analyze_corrs( """ Perform analyses using the correlation-based Structural Summary Method. - This function calculates SSM parameters based on the correlations between + This function calculates SSM parameters based on the correlations between circumplex scales and external measures, optionally grouped by a categorical variable. Parameters @@ -611,11 +619,11 @@ def ssm_analyze_corrs( - details: Dictionary with analysis details - call: String representation of the function call - scores: DataFrame with correlation scores between measures and scales - + Examples -------- >>> results_dict = ssm_analyze_corrs( - ... data, + ... data, ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], ... angles=(0, 45, 90, 135, 180, 225, 270, 315), ... measures=["Extraversion", "Neuroticism"], @@ -855,7 +863,7 @@ def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: results = ssm_analyze( data=data, scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - angles=(90, 135, 180, 225, 270, 315, 0, 45), + angles=(90, 135, 180, 225, 270, 315, 0, 45), # grouping="Gender", # contrast='model', measures=["NARPD", "ASPD"], diff --git a/src/circumplex/ssm_results.py b/src/circumplex/ssm_results.py index 9a2aaa2..f21355b 100644 --- a/src/circumplex/ssm_results.py +++ b/src/circumplex/ssm_results.py @@ -14,7 +14,7 @@ class SSMResults: def __init__( self, results: pd.DataFrame, - scales: List[str], + scales: List[str], scores: pd.DataFrame, details: Dict[str, Any], call: str, @@ -70,17 +70,17 @@ def summary(self): def table(self): table = pd.DataFrame( - columns=[ - "Profile", - "Elevation", - "X-Value", - "Y-Value", - "Amplitude", - "Displacement", - "Fit", - ], - index=self.results.index, - ) + columns=[ + "Profile", + "Elevation", + "X-Value", + "Y-Value", + "Amplitude", + "Displacement", + "Fit", + ], + index=self.results.index, + ) for i, (_, row) in enumerate(self.results.iterrows()): table.loc[i] = [ row["label"], @@ -90,38 +90,38 @@ def table(self): row["a_est"], row["d_est"], row["fit_est"], - ] + ] return table def plot(self, **kwargs) -> Figure: """ Create a figure from SSM results. - + This is a convenience wrapper for ssm_plot(). - + Parameters ---------- **kwargs Additional arguments to pass to ssm_plot(). - + Returns ------- matplotlib.figure.Figure A figure object representing the plot. """ return vis.ssm_plot(self, **kwargs) - + def profile_plot(self, **kwargs) -> Tuple[Figure, List[Axes]]: """ Create profile plots from SSM results. - + Creates one profile plot for each component in the results. - + Parameters ---------- **kwargs Additional arguments to pass to ssm_profile_plot(). - + Returns ------- Tuple[matplotlib.figure.Figure, List[matplotlib.axes.Axes]] @@ -138,13 +138,13 @@ def profile_plot(self, **kwargs) -> Tuple[Figure, List[Axes]]: for i, (ax, (_, row)) in enumerate(zip(axes, results.iterrows())): fig, ax = vis.ssm_profile_plot( - scores=scores.iloc[i][self.scales], + scores=scores.iloc[i][self.scales], angles=details["angles"], amplitude=row["a_est"], displacement=row["d_est"], elevation=row["e_est"], r2=row["fit_est"], - title=f"{results.iloc[i]['label']} Profile", + title=f"{results.iloc[i]['label']} Profile", ax=ax, **kwargs, ) diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 712d643..6397c46 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -5,6 +5,7 @@ # Import Instrument type for type annotation only from typing import TYPE_CHECKING + if TYPE_CHECKING: from circumplex.instrument import Instrument @@ -15,9 +16,9 @@ def cosine_form(theta: np.ndarray, ampl: float, disp: float, elev: float) -> np.ndarray: """ Cosine function with amplitude, displacement and elevation parameters. - + This is the mathematical model used in the Structural Summary Method. - + Parameters ---------- theta : np.ndarray @@ -28,7 +29,7 @@ def cosine_form(theta: np.ndarray, ampl: float, disp: float, elev: float) -> np. Angular displacement in radians. elev : float Elevation (mean level) of the cosine curve. - + Returns ------- np.ndarray @@ -53,16 +54,16 @@ def angle_median(angles: np.ndarray) -> float: def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: """ Calculate the R² coefficient of determination for a set of predictions. - + Measures how well the predictions match the observed data. - + Parameters ---------- y_true : np.ndarray True values. y_pred : np.ndarray Predicted values. - + Returns ------- float @@ -74,22 +75,22 @@ def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: def sort_angles( - angles: np.ndarray, scores: np.ndarray - ) -> Tuple[np.ndarray, np.ndarray]: + angles: np.ndarray, scores: np.ndarray +) -> Tuple[np.ndarray, np.ndarray]: """Sort angles and corresponding scores in ascending order.""" sorted_indices = np.argsort(angles) return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] def standardize( - data: pd.DataFrame, - scales: Union[List[str], pd.Index], - angles: List[float], - instrument: 'Instrument', - sample: int = 1, - prefix: str = "", - suffix: str = "_z", - ) -> pd.DataFrame: + data: pd.DataFrame, + scales: Union[List[str], pd.Index], + angles: List[float], + instrument: "Instrument", + sample: int = 1, + prefix: str = "", + suffix: str = "_z", +) -> pd.DataFrame: """ Standardize circumplex scales using normative data. @@ -106,9 +107,9 @@ def standardize( pd.DataFrame: A DataFrame that matches data except that new variables are appended that contain standardized versions of scales. """ assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" - assert all( - scale in data.columns for scale in scales - ), "All scales must be present in data" + assert all(scale in data.columns for scale in scales), ( + "All scales must be present in data" + ) assert len(scales) == len(angles), "scales and angles must have the same length" assert isinstance(sample, int), "sample must be an integer" assert isinstance(prefix, str), "prefix must be a string" diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index be9987e..827d302 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -16,15 +16,16 @@ # Forward type hint for SSMResults to avoid circular imports # This is needed because ssm_results imports visualization from typing import TYPE_CHECKING + if TYPE_CHECKING: from circumplex.ssm_results import SSMResults -def ssm_plot(ssm_object: 'SSMResults', fontsize: int = 12, **kwargs) -> Figure: +def ssm_plot(ssm_object: "SSMResults", fontsize: int = 12, **kwargs) -> Figure: """ Create a figure from SSM results. - Creates either a circular plot or a contrast plot depending on the + Creates either a circular plot or a contrast plot depending on the type of results in ssm_object. Parameters @@ -41,7 +42,7 @@ def ssm_plot(ssm_object: 'SSMResults', fontsize: int = 12, **kwargs) -> Figure: ------- matplotlib.figure.Figure A figure object representing the plot. - + Examples -------- >>> from circumplex import ssm_analyze, ssm_plot @@ -50,7 +51,7 @@ def ssm_plot(ssm_object: 'SSMResults', fontsize: int = 12, **kwargs) -> Figure: >>> fig.savefig('ssm_plot.png', dpi=300) """ # Input validation - if not hasattr(ssm_object, 'details') or not hasattr(ssm_object, 'results'): + if not hasattr(ssm_object, "details") or not hasattr(ssm_object, "results"): raise ValueError("ssm_object must be an SSMResults instance") if not isinstance(fontsize, (int, float)) or fontsize <= 0: raise ValueError("fontsize must be a positive number") @@ -64,7 +65,7 @@ def ssm_plot(ssm_object: 'SSMResults', fontsize: int = 12, **kwargs) -> Figure: def ssm_plot_circle( - ssm_object: 'SSMResults', + ssm_object: "SSMResults", amax: Optional[float] = None, legend_font_size: int = 12, scale_font_size: int = 12, @@ -129,10 +130,10 @@ def ssm_plot_circle( row["d_lci"], row["d_uci"], width=row["a_uci"] - row["a_lci"], - fc=list(colors[i]) + [0.5], # face opacity at 0.5 + fc=list(colors[i]) + [0.5], # face opacity at 0.5 linestyle=row["linestyle"], - edgecolor=list(colors[i]) + [1], # edge opacity at 1 - linewidth=2, + edgecolor=list(colors[i]) + [1], # edge opacity at 1 + linewidth=2, ) ax.add_patch(wedge) @@ -236,7 +237,7 @@ def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): def ssm_plot_contrast( - ssm_object: 'SSMResults', + ssm_object: "SSMResults", axislabel: str = "Difference", xy: bool = True, color: str = "red", @@ -410,12 +411,12 @@ def ssm_profile_plot( ------- Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes] A tuple containing the figure and axis objects. - + Examples -------- >>> import numpy as np >>> from circumplex import ssm_profile_plot - >>> + >>> >>> # Create a profile plot >>> scores = np.array([0.5, 0.7, 0.3, -0.2, -0.5, -0.3, 0.1, 0.4]) >>> angles = (0, 45, 90, 135, 180, 225, 270, 315) @@ -465,14 +466,14 @@ def ssm_profile_plot( if incl_amp: ax.axhline(amplitude + elevation, color="black", linestyle="--") ax.text( - 0, elevation + amplitude * 0.5, f"a = {amplitude:.2f}", fontsize=fontsize + 0, elevation + amplitude * 0.5, f"a = {amplitude:.2f}", fontsize=fontsize ) if incl_fit: ylim = ax.get_ylim() ax.text( - 0, ylim[0] + 0.25 * (ylim[1] - ylim[0]), f"R2 = {r2:.2f}", fontsize=fontsize - ) + 0, ylim[0] + 0.25 * (ylim[1] - ylim[0]), f"R2 = {r2:.2f}", fontsize=fontsize + ) if incl_elev: ax.axhline(elevation, color="black", linestyle="--") From bf2c664e0462aaeb1493f9b5ac9388f7524e4fb3 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 30/97] Format JSON instrument configuration files --- src/circumplex/instruments/CSIP.json | 4 +-- src/circumplex/instruments/IIPSC.json | 35 ++++++++++++++++++++---- src/circumplex/instruments/SATP-eng.json | 2 +- src/circumplex/instruments/SSQP-eng.json | 2 +- 4 files changed, 34 insertions(+), 9 deletions(-) diff --git a/src/circumplex/instruments/CSIP.json b/src/circumplex/instruments/CSIP.json index 66b67e1..411d11b 100644 --- a/src/circumplex/instruments/CSIP.json +++ b/src/circumplex/instruments/CSIP.json @@ -64,7 +64,7 @@ "label": "Socially Inhibited", "angle": 225, "inst_items": { - "4": "Difficulty making friends", + "4": "Difficulty making friends", "12": "Having trouble fitting in with others", "20": "Avoiding people or social situations", "28": "Being unable to keep conversations going", @@ -131,4 +131,4 @@ } } } -} \ No newline at end of file +} diff --git a/src/circumplex/instruments/IIPSC.json b/src/circumplex/instruments/IIPSC.json index e3cd2a9..dbc3e25 100644 --- a/src/circumplex/instruments/IIPSC.json +++ b/src/circumplex/instruments/IIPSC.json @@ -20,10 +20,35 @@ }, "norms": { "sample": [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2], - "scale": ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO", "PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - "angle": [90, 135, 180, 225, 270, 315, 360, 45, 90, 135, 180, 225, 270, 315, 360, 45], - "m": [0.76, 0.7925, 0.9, 1.0475, 1.42, 1.385, 1.465, 1.025, 0.99, 0.97, 1.30, 1.33, 1.81, 1.92, 2.14, 1.43], - "sd": [0.66, 0.69, 0.855, 0.9475, 0.915, 0.8525, 0.825, 0.8, 0.82, 0.85, 1.07, 0.98, 0.89, 0.89, 0.90, 1.05] + "scale": [ + "PA", + "BC", + "DE", + "FG", + "HI", + "JK", + "LM", + "NO", + "PA", + "BC", + "DE", + "FG", + "HI", + "JK", + "LM", + "NO" + ], + "angle": [ + 90, 135, 180, 225, 270, 315, 360, 45, 90, 135, 180, 225, 270, 315, 360, 45 + ], + "m": [ + 0.76, 0.7925, 0.9, 1.0475, 1.42, 1.385, 1.465, 1.025, 0.99, 0.97, 1.3, + 1.33, 1.81, 1.92, 2.14, 1.43 + ], + "sd": [ + 0.66, 0.69, 0.855, 0.9475, 0.915, 0.8525, 0.825, 0.8, 0.82, 0.85, 1.07, + 0.98, 0.89, 0.89, 0.9, 1.05 + ] }, "norms_src": { "sample": [1, 2], @@ -123,4 +148,4 @@ } } } -} \ No newline at end of file +} diff --git a/src/circumplex/instruments/SATP-eng.json b/src/circumplex/instruments/SATP-eng.json index 2488392..370df98 100644 --- a/src/circumplex/instruments/SATP-eng.json +++ b/src/circumplex/instruments/SATP-eng.json @@ -52,4 +52,4 @@ "angle": 340 } } -} \ No newline at end of file +} diff --git a/src/circumplex/instruments/SSQP-eng.json b/src/circumplex/instruments/SSQP-eng.json index 80e63c5..89b8d3c 100644 --- a/src/circumplex/instruments/SSQP-eng.json +++ b/src/circumplex/instruments/SSQP-eng.json @@ -52,4 +52,4 @@ "angle": 340 } } -} \ No newline at end of file +} From d8d89ab29cfb373f168c3e6b63f956009fe531bd Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 31/97] Improve test code formatting and readability --- tests/test_notebooks.py | 28 +++--- tests/test_ssm_analysis.py | 100 +++++++++++----------- tests/test_visualisation.py | 166 ++++++++++++++++++------------------ 3 files changed, 149 insertions(+), 145 deletions(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index f4891e0..68f4f6a 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -9,10 +9,12 @@ import nbformat # Find all notebooks in the tutorials directory -TUTORIALS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "docs", "tutorials") +TUTORIALS_DIR = os.path.join( + os.path.dirname(os.path.dirname(__file__)), "docs", "tutorials" +) NOTEBOOKS = [ - os.path.join(TUTORIALS_DIR, nb) - for nb in os.listdir(TUTORIALS_DIR) + os.path.join(TUTORIALS_DIR, nb) + for nb in os.listdir(TUTORIALS_DIR) if nb.endswith(".ipynb") and not nb.startswith(".") ] @@ -21,26 +23,28 @@ def test_notebook_structure(notebook_path): """ Test that the notebook has valid structure and can be parsed. - + This test does NOT execute the notebook cells, it only checks that the notebook can be loaded as a valid nbformat document. - + Args: notebook_path (str): Path to the notebook file """ try: # Load the notebook - with open(notebook_path, 'r', encoding='utf-8') as f: + with open(notebook_path, "r", encoding="utf-8") as f: notebook = nbformat.read(f, as_version=4) - + # Check that it has cells assert len(notebook.cells) > 0, "Notebook has no cells" - + # Verify cells have required attributes for i, cell in enumerate(notebook.cells): - assert 'source' in cell, f"Cell {i} is missing source" - assert 'cell_type' in cell, f"Cell {i} is missing cell_type" - + assert "source" in cell, f"Cell {i} is missing source" + assert "cell_type" in cell, f"Cell {i} is missing cell_type" + print(f"Successfully validated notebook: {os.path.basename(notebook_path)}") except Exception as e: - pytest.fail(f"Failed to parse notebook {os.path.basename(notebook_path)}: {str(e)}") \ No newline at end of file + pytest.fail( + f"Failed to parse notebook {os.path.basename(notebook_path)}: {str(e)}" + ) diff --git a/tests/test_ssm_analysis.py b/tests/test_ssm_analysis.py index 5003226..e5e713e 100644 --- a/tests/test_ssm_analysis.py +++ b/tests/test_ssm_analysis.py @@ -15,8 +15,8 @@ def fixed_data(angles=OCTANTS, ampl=0.5, disp=180, elev: float = 0): def generate_circumplex_data(angles, amplitude, displacement, elevation): """Generate circumplex data with known parameters.""" scores = elevation + amplitude * np.cos( - np.deg2rad(angles) - np.deg2rad(displacement) - ) + np.deg2rad(angles) - np.deg2rad(displacement) + ) return scores @@ -24,20 +24,20 @@ def generate_circumplex_data(angles, amplitude, displacement, elevation): def sample_data(): np.random.seed(42) return pd.DataFrame( - { - "PA" : np.random.rand(100), - "BC" : np.random.rand(100), - "DE" : np.random.rand(100), - "FG" : np.random.rand(100), - "HI" : np.random.rand(100), - "JK" : np.random.rand(100), - "LM" : np.random.rand(100), - "NO" : np.random.rand(100), - "measure1": np.random.rand(100), - "measure2": np.random.rand(100), - "group" : np.random.choice(["A", "B"], size=100), + { + "PA": np.random.rand(100), + "BC": np.random.rand(100), + "DE": np.random.rand(100), + "FG": np.random.rand(100), + "HI": np.random.rand(100), + "JK": np.random.rand(100), + "LM": np.random.rand(100), + "NO": np.random.rand(100), + "measure1": np.random.rand(100), + "measure2": np.random.rand(100), + "group": np.random.choice(["A", "B"], size=100), } - ) + ) @pytest.fixture @@ -58,24 +58,24 @@ def test_ssm_analyze_basic(sample_data, scales, angles): def test_ssm_analyze_with_measures(sample_data, scales, angles): result = ssm_analysis.ssm_analyze( - sample_data, scales, angles, measures=["measure1", "measure2"], boots=50 - ) + sample_data, scales, angles, measures=["measure1", "measure2"], boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 2 # One row for each measure def test_ssm_analyze_with_grouping(sample_data, scales, angles): result = ssm_analysis.ssm_analyze( - sample_data, scales, angles, grouping="group", boots=50 - ) + sample_data, scales, angles, grouping="group", boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 2 # One row for each group def test_ssm_analyze_with_contrast(sample_data, scales, angles): result = ssm_analysis.ssm_analyze( - sample_data, scales, angles, grouping="group", contrast="test", boots=50 - ) + sample_data, scales, angles, grouping="group", contrast="test", boots=50 + ) assert isinstance(result, SSMResults) assert len(result.results) == 1 # One row for the contrast @@ -89,11 +89,11 @@ def test_ssm_parameters_return(angles): def test_group_parameters(angles): scores = np.array( - [ - [0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9], - [0.4, 0.6, 0.2, 0.3, 0.7, 0.5, 0.3, 0.8], - ] - ) + [ + [0.5, 0.7, 0.3, 0.2, 0.8, 0.6, 0.4, 0.9], + [0.4, 0.6, 0.2, 0.3, 0.7, 0.5, 0.3, 0.8], + ] + ) angles_rad = np.deg2rad(angles) params = ssm_analysis.group_parameters(scores, angles_rad) assert len(params) == 12 # Should return 12 parameters (6 for each group) @@ -106,15 +106,15 @@ def bs_function(data, index, angles, contrast, listwise): return np.random.rand(6) # Mock function result = ssm_analysis.ssm_bootstrap( - bs_input, - bs_function, - np.deg2rad(angles), - 100, - 0.95, - "none", - True, - bs_input["group"], - ) + bs_input, + bs_function, + np.deg2rad(angles), + 100, + 0.95, + "none", + True, + bs_input["group"], + ) assert isinstance(result, pd.DataFrame) assert result.shape[1] == 18 # 6 parameters * 3 (est, lci, uci) @@ -140,8 +140,8 @@ def test_ssm_parameters(): fix_data = fixed_data(ampl=0.5, disp=45, elev=0) fixed_ssm = ssm_analysis.ssm_parameters(fix_data, utils.OCTANTS) np.testing.assert_allclose( - fixed_ssm, (0.0, 0.35355, 0.35355, 0.5, 45, 1.0), atol=1e-4 - ) + fixed_ssm, (0.0, 0.35355, 0.35355, 0.5, 45, 1.0), atol=1e-4 + ) fix_data = fixed_data(ampl=0.3, disp=90, elev=0.1) fixed_ssm = ssm_analysis.ssm_parameters(fix_data, utils.OCTANTS) @@ -149,18 +149,18 @@ def test_ssm_parameters(): @pytest.mark.parametrize( - "amplitude, displacement, elevation", - [ - (1.0, 3, 0.5), # 3 degrees - (1.0, 90, 0.5), # 90 degrees - (1.0, 180, 0.5), # 180 degrees - (1.0, 270, 0.5), # 270 degrees - (1.0, 45, 0.5), # 45 degrees - (2.0, 30, 1.0), # Larger amplitude - (0.2, 60, 0.1), # Smaller amplitude - (1.5, 135, 0.5), # Arbitrary values - ], - ) + "amplitude, displacement, elevation", + [ + (1.0, 3, 0.5), # 3 degrees + (1.0, 90, 0.5), # 90 degrees + (1.0, 180, 0.5), # 180 degrees + (1.0, 270, 0.5), # 270 degrees + (1.0, 45, 0.5), # 45 degrees + (2.0, 30, 1.0), # Larger amplitude + (0.2, 60, 0.1), # Smaller amplitude + (1.5, 135, 0.5), # Arbitrary values + ], +) def test_ssm_parameters_correctness(amplitude, displacement, elevation): scores = generate_circumplex_data(OCTANTS, amplitude, displacement, elevation) @@ -180,7 +180,7 @@ def test_ssm_parameters_correctness(amplitude, displacement, elevation): result_amplitude, result_displacement, result_r2, - ) = params + ) = params result_displacement = result_displacement % 360 # Normalize to 0-360 degrees diff --git a/tests/test_visualisation.py b/tests/test_visualisation.py index c6ad88e..a514c3c 100644 --- a/tests/test_visualisation.py +++ b/tests/test_visualisation.py @@ -12,50 +12,50 @@ @pytest.fixture def mock_ssm_results(): results = pd.DataFrame( - { - "label" : ["Group A", "Group B"], - "e_est" : [0.5, 0.7], - "x_est" : [1.0, -0.5], - "y_est" : [0.5, 1.0], - "a_est" : [1.12, 1.12], - "d_est" : [26.57, 116.57], - "fit_est": [1.0, 1.0], - "e_lci" : [0.3, 0.5], - "x_lci" : [0.8, -0.7], - "y_lci" : [0.3, 0.8], - "a_lci" : [0.9, 0.9], - "d_lci" : [20.0, 110.0], - "fit_lci": [0.7, 0.8], - "e_uci" : [0.7, 0.9], - "x_uci" : [1.2, -0.3], - "y_uci" : [0.7, 1.2], - "a_uci" : [1.3, 1.3], - "d_uci" : [33.0, 123.0], - "fit_uci": [0.9, 1.0], - } - ) + { + "label": ["Group A", "Group B"], + "e_est": [0.5, 0.7], + "x_est": [1.0, -0.5], + "y_est": [0.5, 1.0], + "a_est": [1.12, 1.12], + "d_est": [26.57, 116.57], + "fit_est": [1.0, 1.0], + "e_lci": [0.3, 0.5], + "x_lci": [0.8, -0.7], + "y_lci": [0.3, 0.8], + "a_lci": [0.9, 0.9], + "d_lci": [20.0, 110.0], + "fit_lci": [0.7, 0.8], + "e_uci": [0.7, 0.9], + "x_uci": [1.2, -0.3], + "y_uci": [0.7, 1.2], + "a_uci": [1.3, 1.3], + "d_uci": [33.0, 123.0], + "fit_uci": [0.9, 1.0], + } + ) scores = pd.DataFrame( - { - "V1" : [1.50, 0.20], - "V2" : [1.56, 1.05], - "V3" : [1.00, 1.70], - "V4" : [0.15, 1.76], - "V5" : [-0.50, 1.20], - "V6" : [-0.56, 0.35], - "V7" : [0, -0.30], - "V8" : [0.85, -0.36], - "label": ["Group A", "Group B"], - } - ) + { + "V1": [1.50, 0.20], + "V2": [1.56, 1.05], + "V3": [1.00, 1.70], + "V4": [0.15, 1.76], + "V5": [-0.50, 1.20], + "V6": [-0.56, 0.35], + "V7": [0, -0.30], + "V8": [0.85, -0.36], + "label": ["Group A", "Group B"], + } + ) details = { - "angles" : (0, 45, 90, 135, 180, 225, 270, 315), + "angles": (0, 45, 90, 135, 180, 225, 270, 315), "score_type": "Mean", "results_type": "Profile", - "contrast" : "none", - } + "contrast": "none", + } return SSMResults( - results=results, scores=scores, details=details, call="mock_call", scales=SCALES - ) + results=results, scores=scores, details=details, call="mock_call", scales=SCALES + ) def test_ssm_plot(mock_ssm_results): @@ -67,9 +67,9 @@ def test_ssm_plot(mock_ssm_results): # Check if the plot contains the expected elements assert ax.get_legend() is not None, "Legend is missing from the plot" assert len(ax.get_lines()) > 0, "No lines found in the plot" - assert ( - len([c for c in ax.get_children() if isinstance(c, PathCollection)]) > 0 - ), "No scatter points found in the plot" + assert len([c for c in ax.get_children() if isinstance(c, PathCollection)]) > 0, ( + "No scatter points found in the plot" + ) plt.close(fig) @@ -86,40 +86,40 @@ def test_ssm_plot_circle(mock_ssm_results): # Check if circular grid is present (5 concentric circles) circles = [child for child in children if isinstance(child, Circle)] - assert ( - len(circles) == 5 - ), f"Expected 5 circular grid lines, but found {len(circles)}" + assert len(circles) == 5, ( + f"Expected 5 circular grid lines, but found {len(circles)}" + ) # Check if radial lines are present (8 lines for octants) radial_lines = [child for child in children if isinstance(child, plt.Line2D)] - assert ( - len(radial_lines) >= 8 - ), f"Expected at least 8 radial lines, but found {len(radial_lines)}" + assert len(radial_lines) >= 8, ( + f"Expected at least 8 radial lines, but found {len(radial_lines)}" + ) # Check if angle labels are present angle_labels = [ child for child in children if isinstance(child, plt.Text) and "°" in child.get_text() - ] - assert ( - len(angle_labels) == 8 - ), f"Expected 8 angle labels, but found {len(angle_labels)}" + ] + assert len(angle_labels) == 8, ( + f"Expected 8 angle labels, but found {len(angle_labels)}" + ) # Check if wedges (confidence regions) are plotted wedges = [child for child in children if isinstance(child, Wedge)] - assert len(wedges) == len( - mock_ssm_results.results - ), f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + assert len(wedges) == len(mock_ssm_results.results), ( + f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + ) # Check if scatter points are plotted scatter_points = [child for child in children if isinstance(child, PathCollection)] - assert ( - len(scatter_points) == 1 - ), f"Expected 1 scatter collection, but found {len(scatter_points)}" - assert ( - len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results) - ), f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + assert len(scatter_points) == 1, ( + f"Expected 1 scatter collection, but found {len(scatter_points)}" + ) + assert len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results), ( + f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + ) # Check if legend is present assert ax.get_legend() is not None, "Legend is missing from the plot" @@ -139,40 +139,40 @@ def test_ssm_plot_contrast(mock_ssm_results): # Check if circular grid is present (5 concentric circles) circles = [child for child in children if isinstance(child, Circle)] - assert ( - len(circles) == 5 - ), f"Expected 5 circular grid lines, but found {len(circles)}" + assert len(circles) == 5, ( + f"Expected 5 circular grid lines, but found {len(circles)}" + ) # Check if radial lines are present (8 lines for octants) radial_lines = [child for child in children if isinstance(child, plt.Line2D)] - assert ( - len(radial_lines) >= 8 - ), f"Expected at least 8 radial lines, but found {len(radial_lines)}" + assert len(radial_lines) >= 8, ( + f"Expected at least 8 radial lines, but found {len(radial_lines)}" + ) # Check if angle labels are present angle_labels = [ child for child in children if isinstance(child, plt.Text) and "°" in child.get_text() - ] - assert ( - len(angle_labels) == 8 - ), f"Expected 8 angle labels, but found {len(angle_labels)}" + ] + assert len(angle_labels) == 8, ( + f"Expected 8 angle labels, but found {len(angle_labels)}" + ) # Check if wedges (confidence regions) are plotted wedges = [child for child in children if isinstance(child, Wedge)] - assert len(wedges) == len( - mock_ssm_results.results - ), f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + assert len(wedges) == len(mock_ssm_results.results), ( + f"Expected {len(mock_ssm_results.results)} wedges, but found {len(wedges)}" + ) # Check if scatter points are plotted scatter_points = [child for child in children if isinstance(child, PathCollection)] - assert ( - len(scatter_points) == 1 - ), f"Expected 1 scatter collection, but found {len(scatter_points)}" - assert ( - len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results) - ), f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + assert len(scatter_points) == 1, ( + f"Expected 1 scatter collection, but found {len(scatter_points)}" + ) + assert len(scatter_points[0].get_offsets()) == len(mock_ssm_results.results), ( + f"Expected {len(mock_ssm_results.results)} scatter points, but found {len(scatter_points[0].get_offsets())}" + ) # Check if legend is present assert ax.get_legend() is not None, "Legend is missing from the plot" @@ -188,9 +188,9 @@ def test_ssm_plot_profile(mock_ssm_results): for ax in axes: # Check if the main line plot exists lines = [child for child in ax.get_children() if isinstance(child, plt.Line2D)] - assert any( - len(line.get_xdata()) > 2 for line in lines - ), "Main plot line is missing" + assert any(len(line.get_xdata()) > 2 for line in lines), ( + "Main plot line is missing" + ) # Check for x-axis labels (angles) assert len(ax.get_xticklabels()) == 8, "Incorrect number of x-axis labels" From 93a7d6e1c1336e97db101b558c94389a803eccec Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:22:29 +0000 Subject: [PATCH 32/97] Clean up documentation formatting and content --- CITATION.cff | 10 +++--- README.md | 6 ++-- docs/about.md | 2 +- docs/index.md | 6 ++-- docs/reference/api.md | 10 ++---- docs/reference/classes.md | 2 +- docs/reference/utils.md | 7 ++--- docs/stylesheets/extra.css | 3 +- docs/tutorials/index.md | 3 +- mkdocs.yml | 64 +++++++++++++++++++------------------- 10 files changed, 51 insertions(+), 62 deletions(-) diff --git a/CITATION.cff b/CITATION.cff index d88cabe..eca924f 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -12,14 +12,14 @@ authors: family-names: Mitchell email: andrew.mitchell.18@ucl.ac.uk affiliation: University College London - orcid: 'https://orcid.org/0000-0003-0978-5046' + orcid: "https://orcid.org/0000-0003-0978-5046" identifiers: - type: doi value: 10.17605/OSF.IO/FA5UR description: OSF Repo of the Package -repository-code: 'https://github.com/MitchellAcoustics/circumplex' -url: 'https://circumplex.readthedocs.io/en/latest/' -repository: 'https://osf.io/fa5ur/' +repository-code: "https://github.com/MitchellAcoustics/circumplex" +url: "https://circumplex.readthedocs.io/en/latest/" +repository: "https://osf.io/fa5ur/" license: GPL-3.0 version: 0.1.4 -date-released: '2023-11-25' +date-released: "2023-11-25" diff --git a/README.md b/README.md index e069e0a..0bc2506 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [![Documentation Status](https://readthedocs.org/projects/circumplex/badge/?version=latest)](https://circumplex.readthedocs.io/en/latest/?badge=latest) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) -_circumplex_ is a Python package for analyzing and visualizing circumplex data. It provides a set of tools for analyzing and visualizing circumplex data, following the Structural Summary Method. This project is a Python implementation based on the R [circumplex](https://github.com/jmgirard/circumplex) package. Our goal is to provide a similar functionality and experience for Python users. +_circumplex_ is a Python package for analyzing and visualizing circumplex data. It provides a set of tools for analyzing and visualizing circumplex data, following the Structural Summary Method. This project is a Python implementation based on the R [circumplex](https://github.com/jmgirard/circumplex) package. Our goal is to provide a similar functionality and experience for Python users. > [!WARNING] > This project is still under development. We're working hard to make it as good as possible, but there may be bugs or missing features. If you find any issues, please let us know by submitting an issue on Github. @@ -41,7 +41,7 @@ This project is licensed under the GNU GPLv3 License. For more information, plea about.md # The about page. license.md # The license page. tutorials/ # Tutorial pages. - Introduction to SSM Analysis.ipynb + Introduction to SSM Analysis.ipynb ... # Other markdown pages, images and other files. src/circumplex/ - circumplex.py + circumplex.py diff --git a/docs/about.md b/docs/about.md index 95234db..c83bc13 100644 --- a/docs/about.md +++ b/docs/about.md @@ -36,4 +36,4 @@ comitantibus illa vectus regionibus idonea arbore dextra **non** ferrum. var drive_tutorial = frameworkSql; Et Themis uterque temptat et crimen adhibere vestem? Deus mens est pulverulenta -*fretum* nimios pharetras suspiria alti Phrygiae potest? +_fretum_ nimios pharetras suspiria alti Phrygiae potest? diff --git a/docs/index.md b/docs/index.md index efcc831..c2872db 100644 --- a/docs/index.md +++ b/docs/index.md @@ -10,7 +10,7 @@ _circumplex_ is a Python package for analyzing and visualizing circumplex data. It provides a set of tools for analyzing and visualizing circumplex data, following the Structural Summary Method. This project is a Python implementation based on the R [circumplex](https://circumplex.jmgirard.com/) package. Our goal is to provide a similar functionality and experience for Python users. !!! note - This project is still under development. We're working hard to make it as good as possible, but there may be bugs or missing features. If you find any issues, please let us know by submitting an issue on Github. +This project is still under development. We're working hard to make it as good as possible, but there may be bugs or missing features. If you find any issues, please let us know by submitting an issue on Github. ## Getting Started @@ -44,7 +44,7 @@ This project is licensed under the GNU GPLv3 License. For more information, plea about.md # The about page. license.md # The license page. tutorials/ # Tutorial pages. - Introduction to SSM Analysis.ipynb + Introduction to SSM Analysis.ipynb ... # Other markdown pages, images and other files. src/circumplex/ - circumplex.py + circumplex.py diff --git a/docs/reference/api.md b/docs/reference/api.md index bf1412b..be79692 100644 --- a/docs/reference/api.md +++ b/docs/reference/api.md @@ -1,11 +1,5 @@ # Core functions ::: circumplex.circumplex - options: - members: - - ssm_analyse - - ssm_parameters - - profile_plot - - - +options: +members: - ssm_analyse - ssm_parameters - profile_plot diff --git a/docs/reference/classes.md b/docs/reference/classes.md index 29c3f1a..25b308d 100644 --- a/docs/reference/classes.md +++ b/docs/reference/classes.md @@ -6,4 +6,4 @@ ## `SSMResults` -::: circumplex.circumplex.SSMResults \ No newline at end of file +::: circumplex.circumplex.SSMResults diff --git a/docs/reference/utils.md b/docs/reference/utils.md index a330273..2170871 100644 --- a/docs/reference/utils.md +++ b/docs/reference/utils.md @@ -1,8 +1,5 @@ # Utility functions ::: circumplex.circumplex - options: - filters: - - ssm_analyse - - ssm_parameters - - profile_plot \ No newline at end of file +options: +filters: - ssm_analyse - ssm_parameters - profile_plot diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css index 18b5dd8..05ae4bd 100644 --- a/docs/stylesheets/extra.css +++ b/docs/stylesheets/extra.css @@ -4,7 +4,6 @@ --md-accent-color: #71e5e9; } - /* This will only apply if the user has chosen a light color scheme */ @media (prefers-color-scheme: light) { .only-dark { @@ -25,4 +24,4 @@ display: block; margin: auto; } -} \ No newline at end of file +} diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md index 2fea9a8..b549f41 100644 --- a/docs/tutorials/index.md +++ b/docs/tutorials/index.md @@ -1,4 +1,3 @@ # Tutorials -Each of the tutorials provided will walk you through the basic functionality of _circumplex_ as well as the basic concepts of structural summary method analysis. - +Each of the tutorials provided will walk you through the basic functionality of _circumplex_ as well as the basic concepts of structural summary method analysis. diff --git a/mkdocs.yml b/mkdocs.yml index ad91a46..7f44621 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -6,20 +6,20 @@ repo_name: "MitchellAcoustics/circumplex" repo_url: https://github.com/MitchellAcoustics/circumplex copyright: Copyright © 2023 Andrew Mitchell nav: - - Home: index.md - - About: - - 'License': license.md - - Tutorials: - - tutorials/index.md - - 'Using Circumplex Instrument': tutorials/using-instruments.ipynb - - 'Introduction to SSM': tutorials/Intro_to_SSM_Analysis.ipynb - - 'Random Examples': tutorials/Random_exs.ipynb - - 'API reference': - - 'Core functions': reference/api.md - - 'Dealing with results': reference/classes.md - - 'Survey Instruments': reference/instruments.md - - 'Utils': reference/utils.md - - 'News': news.md + - Home: index.md + - About: + - "License": license.md + - Tutorials: + - tutorials/index.md + - "Using Circumplex Instrument": tutorials/using-instruments.ipynb + - "Introduction to SSM": tutorials/Intro_to_SSM_Analysis.ipynb + - "Random Examples": tutorials/Random_exs.ipynb + - "API reference": + - "Core functions": reference/api.md + - "Dealing with results": reference/classes.md + - "Survey Instruments": reference/instruments.md + - "Utils": reference/utils.md + - "News": news.md theme: name: material logo: img/small-logo.png @@ -47,25 +47,25 @@ extra_css: - stylesheets/extra.css plugins: - - search - - mkdocstrings: - default_handler: python - handlers: - python: - paths: [src.circumplex] - options: - docstring_section_style: spacy - docstring_style: "google" - separate_signature: true - show_if_no_docstring: false - merge_init_into_class: true - show_symbol_type_heading: true # waiting for general release - show_symbol_type_toc: true + - search + - mkdocstrings: + default_handler: python + handlers: + python: + paths: [src.circumplex] + options: + docstring_section_style: spacy + docstring_style: "google" + separate_signature: true + show_if_no_docstring: false + merge_init_into_class: true + show_symbol_type_heading: true # waiting for general release + show_symbol_type_toc: true - - mkdocs-jupyter: - include_source: true - theme: default + - mkdocs-jupyter: + include_source: true + theme: default # execute: true markdown_extensions: - - admonition \ No newline at end of file + - admonition From a8f17ff0fc135185b04e8ce525f4dc5aae87917a Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 33/97] Configure markdownlint to allow raw HTML --- .markdownlint.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.markdownlint.yaml b/.markdownlint.yaml index 41b3c0c..175de56 100644 --- a/.markdownlint.yaml +++ b/.markdownlint.yaml @@ -1,3 +1,4 @@ --- MD013: false MD046: false +MD033: false From 731c13a7e3c646a85797bb8e67f2698abd48957a Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 34/97] Improve README.md formatting by separating title and logo --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 0bc2506..0c3cd36 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,6 @@ -# circumplex +# circumplex + + [![PyPI version](https://badge.fury.io/py/circumplex.svg)](https://badge.fury.io/py/circumplex) [![Documentation Status](https://readthedocs.org/projects/circumplex/badge/?version=latest)](https://circumplex.readthedocs.io/en/latest/?badge=latest) From d37f4aea1959a0808c8b143ec4a0ea77ccd67228 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 35/97] Reorganize documentation index page layout --- docs/index.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/index.md b/docs/index.md index c2872db..a4b949d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,12 +1,12 @@ -![Image title](img/logo-light.png#only-light) -![Image title](img/logo-dark.png#only-dark) - # Welcome to Circumplex [![PyPI version](https://badge.fury.io/py/circumplex.svg)](https://badge.fury.io/py/circumplex) [![Documentation Status](https://readthedocs.org/projects/circumplex/badge/?version=latest)](https://circumplex.readthedocs.io/en/latest/?badge=latest) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) +![Image title](img/logo-light.png#only-light) +![Image title](img/logo-dark.png#only-dark) + _circumplex_ is a Python package for analyzing and visualizing circumplex data. It provides a set of tools for analyzing and visualizing circumplex data, following the Structural Summary Method. This project is a Python implementation based on the R [circumplex](https://circumplex.jmgirard.com/) package. Our goal is to provide a similar functionality and experience for Python users. !!! note From dfc7f8f01db5b99c7b0b6eeeb9c422b7a1434335 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 36/97] Add proper heading to license documentation --- docs/license.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/license.md b/docs/license.md index 089e1dc..50a5e2c 100644 --- a/docs/license.md +++ b/docs/license.md @@ -1,3 +1,5 @@ +# License + BSD 3-Clause License Copyright (c) 2024, Andrew Mitchell From fb90619109eb6b73a44aaf4031d7fac9a60eb745 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 37/97] Fix indentation and formatting in pyproject.toml --- pyproject.toml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 96fb192..2b1bc2d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,10 +10,10 @@ dev = [ "tox>=4.27.0" ] test = [ - "pytest>=8.3.4", - "pytest-cov>=7.0.0", - "pytest-notebook>=0.10.0", - "xdoctest>=1.3.0", + "pytest>=8.3.4", + "pytest-cov>=7.0.0", + "pytest-notebook>=0.10.0", + "xdoctest>=1.3.0" ] docs = [ "mkdocs>=1.6.0", From 3e9d8c4ed57583562e7255d67cf690a6d9672a4f Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 38/97] Add nptyping dependency for improved type annotations --- pyproject.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 2b1bc2d..c5012df 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,7 +36,8 @@ dependencies = [ "scipy>=1.9.3", "pandas[excel,performance]>=2.2.2", "matplotlib>=3.9.4", - "seaborn>=0.13.2" + "seaborn>=0.13.2", + "nptyping>=2.5.0" ] readme = "README.md" requires-python = ">= 3.9" From 11e51470fe111b4b2672d184e0a5f190e36accf8 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 39/97] Remove debugging cell marker from instrument.py --- src/circumplex/instrument.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index 7c36d85..4bbc59a 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -1,4 +1,3 @@ -# %% from __future__ import annotations import json From f7402c41ce6b748a99c874d271b2d3526d8eb004 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:57 +0000 Subject: [PATCH 40/97] Add type ignore comments for missing type annotations --- src/circumplex/instrument.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index 4bbc59a..22cf14a 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -77,7 +77,7 @@ def from_dict(inst_dict: dict) -> Instrument: if "norms" in inst_dict else None ) - details = InstrumentDetails(**inst_dict["details"]) + details = InstrumentDetails(**inst_dict["details"]) # type: ignore[missing-argument] return Instrument(scales, anchors, details, norms) @@ -185,7 +185,7 @@ def show(self, inst_items: bool = True): p.append(f"{abbrev}: {self.label[i]} ({self.angle[i]}°)") p.append( "\n".join( - [f"\t{key}: {val}" for key, val in self.inst_items[i].items()] + [f"\t{key}: {val}" for key, val in self.inst_items[i].items()] # type: ignore[non-subscriptable] ) ) return print("\n".join(p)) From 17930615ef46681050729a589c1b4c9006e5294b Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 41/97] Improve type annotations in instrument.py method signatures --- src/circumplex/instrument.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py index 22cf14a..0dff308 100644 --- a/src/circumplex/instrument.py +++ b/src/circumplex/instrument.py @@ -307,7 +307,9 @@ def summary(self): "\nNo data has been loaded for this instrument. Use attach_data() to load data." ) - def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrument: + def attach_data( + self, data: pd.DataFrame, scales: list | dict | None = None + ) -> Instrument: # check scales assert set(self.scales.abbrev).issubset(data.columns), ( f"Data is missing scales. " @@ -317,7 +319,7 @@ def attach_data(self, data: pd.DataFrame, scales: list | dict = None) -> Instrum return self def ssm_analyze( - self, measures: list[str] = None, grouping: list[str] = None + self, measures: list[str] | None = None, grouping: str | None = None ) -> ssm_results.SSMResults: """ Perform Structural Summary Method analysis on the instrument's data. From 4e1133211e996591d7122fa50fc753a1b0dceb18 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 42/97] Add TYPE_CHECKING import and nptyping support in ssm_analysis.py --- src/circumplex/ssm_analysis.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index cd32d34..bf575e9 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -1,7 +1,7 @@ from __future__ import annotations import warnings -from typing import Callable, List, Optional, Tuple, Union, Dict, Any +from typing import Callable, List, Optional, Tuple, Union, Dict, Any, TYPE_CHECKING import numpy as np import pandas as pd @@ -10,6 +10,9 @@ import circumplex.ssm_results as ssm_results import circumplex.utils as utils +if TYPE_CHECKING: + from nptyping import NDArray + BOUNDS = ([0, -2 * np.pi, -np.inf], [np.inf, 2 * np.pi, np.inf]) OCTANTS = utils.OCTANTS From 5ace5ac30c9a79797dc0b1a4a38c54d55fab4217 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 43/97] Update tuple type annotations for variable length tuples --- src/circumplex/ssm_analysis.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index bf575e9..bdd0678 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -20,7 +20,7 @@ def validate_ssm_input( data: pd.DataFrame, scales: List[str], - angles: Tuple[float], + angles: Tuple[float, ...], measures: Optional[List[str]] = None, grouping: Optional[str] = None, contrast: str = "none", @@ -127,7 +127,7 @@ def validate_ssm_input( def ssm_analyze( data: pd.DataFrame, scales: List[str], - angles: Tuple[float] = OCTANTS, + angles: Tuple[float, ...] = OCTANTS, measures: Optional[List[str]] = None, grouping: Optional[str] = None, contrast: str = "none", @@ -279,7 +279,7 @@ def ssm_analyze( def ssm_analyze_means( data: pd.DataFrame, scales: List[str], - angles: Tuple[float], + angles: Tuple[float, ...], grouping: Optional[str] = None, contrast: str = "none", boots: int = 2000, @@ -501,7 +501,7 @@ def polar2cart(r, theta): def ssm_bootstrap( bs_input: pd.DataFrame, bs_function: Callable, - angles: Tuple[float], + angles: Tuple[float, ...], boots: int, interval: float, contrast: str, @@ -572,7 +572,7 @@ def ssm_bootstrap( def ssm_analyze_corrs( data: pd.DataFrame, scales: List[str], - angles: Tuple[float], + angles: Tuple[float, ...], measures: List[str], grouping: Optional[str] = None, contrast: str = "none", @@ -759,7 +759,7 @@ def corr_scores( measures: Union[np.ndarray, pd.DataFrame], grouping: Union[np.ndarray, pd.Series], listwise: bool, - scales: List[str] = None, + scales: List[str] | None = None, ) -> pd.DataFrame: """ Calculate the correlation of each measure with each scale by group. From fb25f872ac91f5559fc071bb330e8527cc2df2e1 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 44/97] Enhance ssm_parameters function with precise NDArray typing --- src/circumplex/ssm_analysis.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py index bdd0678..d7ac418 100644 --- a/src/circumplex/ssm_analysis.py +++ b/src/circumplex/ssm_analysis.py @@ -458,7 +458,9 @@ def group_parameters(scores: np.ndarray, angles: Tuple[float]) -> np.ndarray: return out -def ssm_parameters(scores: np.ndarray, angles: Tuple[float], bounds=BOUNDS) -> np.array: +def ssm_parameters( + scores: NDArray, angles: Tuple[float, ...], bounds=BOUNDS +) -> NDArray: """Calculate SSM parameters (without confidence intervals) for a set of scores. Args: From 4cdb1b572799aa44b5528b0faa4783c7218114a6 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 45/97] Clean up unused imports in ssm_results.py --- src/circumplex/ssm_results.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/circumplex/ssm_results.py b/src/circumplex/ssm_results.py index f21355b..2473559 100644 --- a/src/circumplex/ssm_results.py +++ b/src/circumplex/ssm_results.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Any, Dict, List, Tuple, Optional +from typing import Any, Dict, List, Tuple import pandas as pd from matplotlib import pyplot as plt From 8c6eeb462014df5fc038b6df16dfbfe62a853070 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 46/97] Modernize imports and add precise NumPy typing in utils.py --- src/circumplex/utils.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 6397c46..c5c31db 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -1,19 +1,24 @@ -from typing import List, Tuple, Union, Optional, Any +from __future__ import annotations + +from typing import List, Union import numpy as np import pandas as pd # Import Instrument type for type annotation only -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Any if TYPE_CHECKING: from circumplex.instrument import Instrument + from nptyping import NDArray, Float, Shape # Common constants -OCTANTS = (0, 45, 90, 135, 180, 225, 270, 315) +OCTANTS: tuple[int, ...] = (0, 45, 90, 135, 180, 225, 270, 315) -def cosine_form(theta: np.ndarray, ampl: float, disp: float, elev: float) -> np.ndarray: +def cosine_form( + theta: NDArray[Shape[Any], Float], ampl: float, disp: float, elev: float +) -> NDArray[Shape[Any], Float]: """ Cosine function with amplitude, displacement and elevation parameters. From a10103e0a0bc33bcad68a1a05be376ee689ac9d0 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 47/97] Add precise NDArray type annotations to utility functions --- src/circumplex/utils.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index c5c31db..7b8fa2f 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -43,7 +43,7 @@ def cosine_form( return elev + ampl * np.cos(theta - disp) -def angle_median(angles: np.ndarray) -> float: +def angle_median(angles: NDArray[Shape[Any], Float]) -> float: """ Calculate the median of circular data. @@ -56,7 +56,9 @@ def angle_median(angles: np.ndarray) -> float: return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) -def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: +def r2_score( + y_true: NDArray[Shape[Any], Float], y_pred: NDArray[Shape[Any], Float] +) -> float: """ Calculate the R² coefficient of determination for a set of predictions. @@ -80,8 +82,8 @@ def r2_score(y_true: np.ndarray, y_pred: np.ndarray) -> float: def sort_angles( - angles: np.ndarray, scores: np.ndarray -) -> Tuple[np.ndarray, np.ndarray]: + angles: NDArray[Shape[Any], Float], scores: NDArray[Shape[Any], Float] +) -> tuple[NDArray[Shape[Any], Float], NDArray[Shape[Any], Float]]: """Sort angles and corresponding scores in ascending order.""" sorted_indices = np.argsort(angles) return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] From 88599a1ac72a9e7d42df820becbd060a661e28f2 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 48/97] Add type ignore comment for optional attribute access --- src/circumplex/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py index 7b8fa2f..ba95951 100644 --- a/src/circumplex/utils.py +++ b/src/circumplex/utils.py @@ -123,7 +123,7 @@ def standardize( assert isinstance(suffix, str), "suffix must be a string" norms = instrument.norms - key = norms.table.query("sample == @sample") + key = norms.table.query("sample == @sample") # type: ignore[probably-unbound-attribute] assert len(key) == len(scales) for scale, angle in zip(scales, angles): From d7f4bde5d9a04e562e5db6ad5445601d32a7bf7d Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 49/97] Update visualization.py imports and type annotations --- src/circumplex/visualization.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index 827d302..0a714d0 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import List, Optional, Tuple, Union, Any +from typing import List, Optional, Tuple, Union import matplotlib.patches as patches import matplotlib.pyplot as plt @@ -15,7 +15,7 @@ # Forward type hint for SSMResults to avoid circular imports # This is needed because ssm_results imports visualization -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, cast if TYPE_CHECKING: from circumplex.ssm_results import SSMResults From 191266f244cb14cbe4e2fba44cae468a21b1aab5 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 50/97] Add type safety improvements for matplotlib and array operations --- src/circumplex/visualization.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py index 0a714d0..c560e94 100644 --- a/src/circumplex/visualization.py +++ b/src/circumplex/visualization.py @@ -433,7 +433,7 @@ def ssm_profile_plot( if ax is None: fig, ax = plt.subplots(figsize=(10, 5)) else: - fig = ax.get_figure() + fig = cast(Figure, ax.get_figure()) assert len(scores) == len(angles), "Scores and angles must be the same length." # assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." @@ -443,7 +443,7 @@ def ssm_profile_plot( assert 0 <= displacement <= 360, "Displacement must be between 0 and 360." if reorder_scales: - angles, scores = utils.sort_angles(angles, scores) + angles, scores = utils.sort_angles(angles, scores) # type: ignore[invalid-argument] if angles[-1] == 360: angles = (0,) + angles scores = (scores[-1],) + scores From 792355ea13d1852950c00673603a0a6bbfa0b6d5 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:51:58 +0000 Subject: [PATCH 51/97] Add type ignore for intentional test error case --- tests/test_visualisation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_visualisation.py b/tests/test_visualisation.py index a514c3c..4ea6046 100644 --- a/tests/test_visualisation.py +++ b/tests/test_visualisation.py @@ -206,7 +206,7 @@ def test_ssm_plot_profile(mock_ssm_results): def test_invalid_input(): with pytest.raises((AssertionError, TypeError, ValueError)): - visualization.ssm_plot("not an SSMResults object") + visualization.ssm_plot("not an SSMResults object") # type: ignore[invalid-argument] # Run the tests From f9f04b6bf38e5eec059c3f917de4d738cf4a0137 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sat, 8 Nov 2025 20:52:07 +0000 Subject: [PATCH 52/97] tutorials --- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 644 +-- docs/tutorials/Random_exs.ipynb | 538 +-- docs/tutorials/using-instruments.ipynb | 316 +- uv.lock | 4400 +++++++++++--------- 4 files changed, 3265 insertions(+), 2633 deletions(-) diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index da81e2b..1cf9021 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -2,41 +2,46 @@ "cells": [ { "cell_type": "markdown", + "id": "817354cbea2e711b", + "metadata": { + "collapsed": false + }, "source": [ "# Introduction to SSM Analysis\n", "\n", "Reproduced from the introductory vignette for [R Circumplex](https://circumplex.jmgirard.com/articles/introduction-to-ssm-analysis.html), by Girard J, Zimmermann J, Wright A (2023). circumplex: Analysis and Visualization of Circular Data. https://github.com/jmgirard/circumplex, http://circumplex.jmgirard.com/.\n", "\n", "If you find this tutorial useful, **please cite Girard, Zimmermann, & Wright (2023)**. I am reproducing it here to demonstrate the equivalence between the R and Python versions of the package. The original R version of this vignette can be found [here](https://circumplex.jmgirard.com/articles/introduction-to-ssm-analysis.html)." - ], - "metadata": { - "collapsed": false - }, - "id": "817354cbea2e711b" + ] }, { "cell_type": "code", + "execution_count": 1, "id": "initial_id", "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2024-07-11T18:37:02.172464Z", "start_time": "2024-07-11T18:37:01.505069Z" - } + }, + "collapsed": true }, + "outputs": [], "source": [ "import circumplex\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "\n", "# %matplotlib inline\n", - "degree_sign = u'\\N{DEGREE SIGN}'" - ], - "outputs": [], - "execution_count": 1 + "degree_sign = \"\\N{DEGREE SIGN}\"" + ] }, { "cell_type": "markdown", + "id": "1d6f5b15838c0042", + "metadata": { + "collapsed": false + }, "source": [ "## 1. Background and Motivation\n", "\n", @@ -48,14 +53,31 @@ "\n", "Circumplex data is composed of scores on a set of circumplex scales for one or more participants (e.g., persons or organizations). Such data is usually collected via self-report, informant-report, or observational ratings in order to locate psychological phenomena within the circular space of the circumplex model. For example, a therapist might want to understand the interpersonal problems encountered by an individual patient, a social psychologist might want to understand the emotional experiences of a group of participants during an experiment, and a personality psychologist might want to understand what kind of interpersonal behaviors are associated with a trait (e.g., extraversion). \n", "\n" - ], - "metadata": { - "collapsed": false - }, - "id": "1d6f5b15838c0042" + ] }, { "cell_type": "code", + "execution_count": 2, + "id": "b2b2c99827c47a27", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-11T18:37:02.338368Z", + "start_time": "2024-07-11T18:37:02.173524Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "angles = (90, 135, 180, 225, 270, 315, 0, 45)\n", "alabel = (\"PA\", \"BC\", \"DE\", \"FG\", \"HI\", \"JK\", \"LM\", \"NO\")\n", @@ -76,169 +98,162 @@ " ha=\"center\",\n", " va=\"center\",\n", " fontsize=12,\n", - ")\n", + " )\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-07-11T18:37:02.338368Z", - "start_time": "2024-07-11T18:37:02.173524Z" - } - }, - "id": "b2b2c99827c47a27", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAGBCAYAAAB4ufbTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABau0lEQVR4nO3dd1gTWdsG8DsQur1RxC6iNBFF0HWlKKACsaxtde1d1LWtYtm1rL3sKvaGFcSOYO+KrCCCrr2AYqPpKop0yPn+8EteIxABk0zK87uuXMrkZOYZArmZOXPO8BhjDIQQQkgJtLgugBBCiHKjoCCEECIVBQUhhBCpKCgIIYRIRUFBCCFEKgoKQgghUlFQEEIIkYqCghBCiFQUFIQQQqSioCCEECIVBQXRGImJieDxeBIPXV1d1KlTB/369cPt27eLvObKlSvitgcOHOCgakK4x+e6AEIUrVGjRvjll18AAJ8+fUJUVBT27t2Lw4cP4/z58/jhhx/Ebbdt2wYA4PF4CAwMRK9evTipmRAu8WhSQKIpEhMT0aBBA3h5eeHUqVMSz82ePRsLFy6Ei4sLLl26BAD4+PEjTE1N0bhxYxgbG+P8+fNITExEnTp1OKieEO7QqSdCAIwfPx4AEBMTI162d+9eZGVlYeDAgRg4cCCEQiF27NjBUYWEcIeCgpAv8Hg88f+3bdsGbW1t9O/fHz169ECFChWwfft20EE40TQUFIQAWL9+PQCgdevWAIA7d+4gJiYGHTt2hImJCQwNDdGjRw88e/YMFy5c4LJUQhSOOrOJxomPj8fcuXMBAJmZmYiOjkZERAT09fWxcOFCAP/rxB44cKD4dQMHDsSuXbuwbds2dOjQQeF1E8IV6swmGkPUmf0lHR0dGBsbo3379vD394etrS1yc3NRu3Zt5OXlITU1FQYGBgAAoVCI+vXr482bN0hKSkLVqlW52A1CFI5OPRGN4+XlBcYYGGPIy8vDy5cvERQUBFtbWwBAaGgo/vvvP/Ts2VMcEgCgpaWF/v37IycnB8HBwVyVT4jCUVAQ8hXRaaft27cXGaC3ZMkSiTaEaALqoyDkC8+fP8f58+dhbGwMHx+fYttcuHABN2/exM2bN9GiRQsFV0iI4lFQEPKF7du3QygUYtSoUZg3b16xbTZv3oxRo0Zh27ZtWLt2rYIrJETx6NQTIf9PKBSKTzcNHjy4xHZ9+vSBgYEBgoKCkJOTo7gCCeEIBQUh/+/cuXN48eIF2rdvX+TqqC9VrlwZPXr0QHp6Og4fPqzACgnhBl0eSwghRCo6oiCEECIVBQUhhBCpKCgIIYRIRUFBCCFEKgoKQgghUlFQEEIIkYqCghBCiFQUFIQQQqSioCCEECIVBQUhhBCpKCgIIYRIRdOME7VXWFiIN2/eIDk5GcnJyXjz5g3y8vJQUFCA/Px8FBQUSDwYY9DR0QGfz5d46OjoQEdHBzVr1oSZmRlMTU1Rs2ZNaGtrc72LhMgVBQVRWQUFBUhNTUVycjKSkpLEQfD116mpqSgsLES1atVgamqKWrVqQU9PTyIARP/X0tLC69evYWxsDKFQWCRMcnNzkZaWhuTkZLx79w7a2tqoVauWODhEj6+/NjY2ho6ODtffMkLKhWaPJUqPMYZnz54hNjZW/Lh79y5SU1PBGEPNmjVL/IAWfW1iYgJ9ff1vbis/Px8nTpxAly5dvvnBnpOTg5SUlGLD6cuv37x5Ax6Ph1q1asHGxgYtW7YUPxo2bAgejyerbxUhckFBQZQKYwxPnz6VCIW4uDhkZGTA1tZW/AHbvHlzmJubw9jYGLq6ujLbflmCoizrTE1NxcuXL/Hvv/9KhJ2RkREcHBwkwqNRo0YUHkSpUFAQzgiFQiQkJEgEQlxcHDIzMyVCoWXLlrC1tYWenp7ca5JHUJQkNzcXd+/elQjF27dvw9DQsNjw0NKia08INygoiEKlp6fj1KlTCA8Px8mTJ5GZmQk7OzuJD0Vra2uFhEJxFBkUxcnLyys2PIyMjNCpUycIBAJ06tQJVapUUXhtRHNRUBC5e/r0KcLDwxEeHo7Lly+jWbNmEAgE8PHxgYODg0xPHX0vroOiOHl5ebh58yaOHTuGsLAw3L9/H+3bt4dAIICvry8aNmzIdYlEzVFQEJkTCoW4fv06wsLCEBYWhsePH8PFxUX8wVa/fn2uSyyRMgbF1xITE8WhcenSJTRp0gS+vr4QCARo3bo1Xa5LZI6CgshEZmYmzp49i/DwcBw7dgz5+fnw9vaGr68vvLy8ULlyZa5LLBVVCIovffz4EadPn0ZYWBiOHz8OPp8PHx8fCAQCeHh4wMjIiOsSiRqgoCDllp2djYMHD2Lfvn04d+4c6tSpg65du8LX1xc//PAD+HzVG6ajakHxpYKCAvzzzz/iI7kXL16gQ4cO6NOnD3r16gUDAwOuSyQqioKClNnt27exZcsW7NmzB6amphg0aBC6du0KS0tLlb+sU5WD4muPHj3C0aNHsXPnTrx+/RoDBgzAiBEjYGdnx3VpRMXQ9XakVD59+oRt27bB2dkZzs7OyMjIwLFjx3Dv3j1Mnz4dTZs2VfmQUDeWlpaYNm0a7t69ixMnTiAjIwPOzs5wcnLC1q1b8enTJ65LJCqCgoJI9ejRI/j5+cHMzAxr1qzBgAEDkJSUhB07duCHH36gcFABPB4Pbdu2xY4dO5CUlIRBgwZh3bp1MDU1xdixY/Hw4UOuSyRKjoKCFCEUCnHq1Cl07twZzZs3R0ZGBs6dO4ebN2/Cz8+PruFXYVWqVMHYsWMRFxeHCxcuIDMzE/b29ujUqRNOnjwJoVDIdYlECVFQELFPnz5h/fr1sLKywqBBg+Dk5ITExETs2rULrVu3pqMHNcLj8eDo6IidO3fi+fPnaNOmDYYMGYJmzZph3bp1dFqKSKDObIKPHz9ixYoVCAgIQKNGjfDrr7+iT58+nI2O5pI6dWaXVW5uLvbv34/Vq1cjPj4e48aNw2+//aYylzYT+aEjCg2Wm5uLv//+Gw0bNsTly5cRFhaGGzduYODAgRoZEppOT08PAwYMQExMDI4dO4bIyEg0atQIf/31F3Jycrguj3CIgkIDFRYWYufOnWjSpAl27NiBXbt24dKlS2jfvj2dXiLg8Xho164dLly4gD179mDXrl1o0qQJtm/fjsLCQq7LIxygoNAgjDGEh4fD3t4e8+bNw6JFi3Dz5k106dKFAoIUwePx0KlTJ8TFxWHJkiVYsGAB7OzscPToUdAZa81CQaEhIiMj8eOPP2LYsGEYOXIkHj58iP79+9PU1eSbtLS00K9fPzx48ABjxozByJEj0a5dO0RERHBdGlEQ+pRQc3fv3hVPTe3h4YGEhASMHz9eqWZsJapBV1cX48aNQ0JCAry8vODt7Q0fHx/cuXOH69KInFFQqKnnz59j0KBBcHR0RMOGDfH06VPMmTMHFStW5Lo0ouIqVKiAP/74AwkJCbCwsEDr1q0xcOBAJCYmcl0akRMKCjWTlZWFadOmoWnTpmCM4cGDB1i1ahVq1qzJdWlEzdSsWRN///03Hjx4AB6Ph2bNmmHKlCnIzMzkujQiYxQUaiQyMhL29va4evUqoqOjsWvXLqW+9wNRD/Xr18fOnTtx/fp1REdHo3nz5tR/oWYoKNRAVlYWJk+eDE9PT4waNQoRERE0QyhROFtbW1y+fBl+fn7o3LkzJk2ahKysLK7LIjKg0UGRmJgIHo9X5GFkZAQ7OzvMmzevxKkMYmNjMWzYMFhYWMDIyAgGBgZo1KgRBgwYgLNnzypsH/755x/Y29sjKioKcXFxmDJlCt3hjHBGW1sbkyZNQlxcHK5fvw57e3tERkYqZNtf/j57eXkV2yYqKgo8Hg+DBw8u8tyHDx/w559/wtHREVWqVIG+vj4aNGiAQYMGIS4uTs7VKzmmwZ49e8YAsEaNGrE5c+awOXPmsD/++IONGTOG1a9fnwFgzs7OrKCgQPyawsJCNmnSJAaA8fl85unpySZPnsymT5/OevXqxapWrcoAsPnz58u19qysLDZ58mRmaGjIli9fLlEjKb+8vDwWGhrK8vLyuC5F5RUUFLCVK1cyQ0NDNmnSJJaZmSnX7Yl+n0WP8+fPF2lz7do1BoANGjRIYvn169eZiYkJA8BsbGzY+PHj2fTp05lAIGC6urqMx+OxuXPnyrV+ZUZBATAvL68iz+Xk5LAWLVoU+YGbMWMGA8Ds7e1ZfHx8kddlZWWxZcuWsenTp8ut7n/++Yc1adKEOTs7swcPHshtO5qIgkL2Hj58yNq0acMsLCxYZGSk3LYj+n2uX78+09LSYq1atWJCoVCiTXFB8fz5c1atWjWmpaXFNmzYUGz9jRo1YgDYunXr5Fa/MqOgKCEoGGNs8uTJDADbt28fY4yxJ0+eMG1tbVa9enWWkpIidd05OTkyrzcrK4tNnTqVGRoasmXLltFRhBxQUMhHQUEBW7FiBTM0NGSTJ09mWVlZMt/Gl7/PgwYNYgBYSEiIRJvigqJ///4MAJs1a1aJ67579y7T0dFhlSpVYunp6TKvXdlpdB+FNHl5ebh06RJ4PB7s7e0BADt27EBhYSFGjRoFY2Njqa+X9aR6UVFRaNGiBSIiInDjxg389ttv1BdBVIa2tjamTJmCuLg4cb/atWvX5La9+fPnQ09PD7Nnz0Z+fn6J7TIzM7F//37o6+tj6tSpJbaztrZGjx498PHjRxw4cEAeJSs1CgoA8fHxmDt3LubOnYs5c+bAz88PVlZWuH//PpYtW4YmTZoAgLhTzt3dXWG15eTkYNq0aejQoQOGDh2Kq1evolmzZgrbPiGyZGlpiatXr2LEiBHo2LEjfvvtN7nMTFu3bl2MHz8e8fHx2LRpU4ntbty4gfz8fLRs2fKbN+Tq0KEDAMg14JQVn+sClEFCQgLmzZtXZLmPjw86duwo/jolJQUAYG5urpC6kpOT0aNHD+Tn5yMmJgZWVlYK2S4h8qStrY2pU6fCx8cHAwcOhIuLC44cOQIzMzOZbmfmzJnYunUr/vzzTwwePBgVKlQo0kb0O12nTp1vrk/UJjk5WaZ1qgI6ogDg5eUF9rm/BowxvH37FkePHsXdu3fxww8/IDo6WuE13bhxA46OjrCwsMDVq1cpJIjaadq0KSIiImBlZQVHR0fExMTIdP1Vq1aFv78/0tLSsGLFCpmuW9NQUBSjevXqEAgE2LJlC7KysjB79mwAgImJCQDg9evXct1+cHAwXF1dMWnSJOzcuRP6+vpy3R4hXNHT00NgYCCmTp0KNzc3BAUFyXT9EyZMgLm5OVauXIm0tLQiz4t+p1++fPnNdYnamJqayrRGVUBBIYWTkxMAiP/S+eGHHwAA58+fl8v2CgsLMWPGDIwdOxYHDhzAlClT6D4RRO3xeDxMmjQJhw4dwrhx4zB9+nSZ3SDJwMBAPHC2uNPLrVq1go6ODmJjY/Hhwwep6xL93rdp00YmtakSCgop3r9/DwAQCoUAgMGDB0NbWxubN2/GmzdvpL42Nze3TNv6+PEjunXrhkOHDiEqKgqdO3cuX9GEqCgvLy9ER0fj6NGjEAgE3/zgLq1BgwbB2toaW7ZsQXx8vMRzRkZG6NWrF3JycrBy5coS1/HgwQMcOXIEFStWRM+ePWVSlyqhoJDir7/+AgC0b98eANC4cWNMmzYNb9++RefOnfHs2bMir8nJycFff/2FuXPnlno78fHxcHZ2Rl5eHqKjo9G0aVOZ1E+IqmnSpAmioqIgFArh7OyMJ0+efPc6tbW1sWjRIuTn5xf7e7lo0SJUrVoVixYtwtatW4s8/+TJE3Tt2hV5eXlYsmTJN6+OUkd01RP+d3msyLt37xAZGYm4uDhUrVoVS5cuFT+3YMEC5OTk4O+//4alpSXc3d1hY2MDHR0dPHv2DOfOncN///2HBQsWlGrb58+fR69evTBkyBAsXboUfD69JUSzValSBceOHYO/vz+cnJywb98+eHh4fNc6BQIB2rVrh6tXrxZ5rl69ejhx4gS6du2KESNGYM2aNXB1dYWhoSEePHiAkydPikNm7Nix31WHyuJ4wB+nvp4bRvTQ09NjjRo1YmPGjGHPnz8v9rUxMTFs6NChrHHjxszAwIDp6emx+vXrs379+rGzZ89+c9tCoZAFBAQwQ0NDFhgYKOtdI+VEI7OVy86dO5mhoSFbvXp1kek4vvatmRYiIyPFv+Nfz/XEGGPv3r1jc+fOZQ4ODqxSpUpMV1eX1a1blw0cOJDduHFDFrujsniM0V3SFS0vLw9+fn4IDw/H4cOH0bZtW65LIv8vPz8fJ06cQJcuXaCjo8N1OQSfZyXo3r07vL29sW7dOpnPekC+jfooFCw9PR0dO3ZEXFwcYmJiKCQI+QZnZ2fcuHED//77Lzp06CC+yIQoDgWFAv3333/o0KEDKleujIiIiFKNBiWEALVr18aVK1dQvXp1dOjQAW/fvuW6JI1CQaEgqampcHNzQ4MGDXDo0CEYGhpyXRIhKsXAwAAHDx5E48aN4ebmhtTUVK5L0hgUFAqQlJQEV1dX2NraIiQkBLq6ulyXRIhK0tHRQXBwMOzt7eHi4iL3WRLIZxQUcvbixQu0b98ebdq0wa5du+jyV0K+E5/Px44dO9CuXTu0b98ez58/57oktUdBIUdPnz5F+/bt4enpia1bt9L9IwiREdEMCZ06dUL79u2RkJDAdUlqjYJCTl68eAFXV1fY29tjzpw50NKibzUhsqSlpYU5c+bAwcEBbm5udGQhR/TpJQdJSUlwd3eHj48P1qxZg5iYmGJnriSElN+bN29w/fp1rF69GgKBAO7u7tRnIScUFDKWmpqKDh06wMXFBWvXrkWdOnVgb2+P69evU1gQIiNv3rxBdHQ0mjdvjrp16yIgIADu7u5wd3cX34yIyA4FhQy9ffsWHTt2hIODAzZv3iw+3WRubk5hQYiMfBkSorFIWlpa2LhxI5ycnNCxY0caZyFjFBQykp6eDk9PT1haWmLnzp1FOq4pLAj5fsWFhIi2tjYCAwNhZWUFDw8PGsEtQxQUMpCbmwtfX1/Url0bwcHBJV4CS2FBSPlJCwkRPp+PoKAg1KtXDz4+PmW+LwwpHgXFd2KMYezYscjOzsb+/fu/OZiOwoKQsitNSIjo6OggJCQEBQUFGD16NGje0+9HQfGdAgICcOLECRw9ehQGBgaleg2FBSGlV5aQENHX18eRI0dw5swZrFq1Sr4FagAaJvwdzpw5g5kzZ+LChQuoXbt2mV5rbm4OALh+/Tpat26NWrVqyaNEQlRaeUJCxMzMDKGhoXBzc4OVlRW8vLzkVKX6oyOKcnry5An69OmDDRs2wMnJqVzroCMLQkr2PSEh4ujoiE2bNqFv3754/PixjCvUHBQU5fDhwwcIBAIMHz4cAwcO/K51UVgQUpQsQkKkf//+GDVqFAQCAdLT02VToIahO9yVUWFhIQQCAYRCIY4dOyaz+ZtevXqFW7du0WkojtEd7rgny5AQKSwsRNeuXVFYWCjT31tNQUcUZTRz5kwkJCRg7969Mv1hoyMLQuQTEsDnMRbBwcF4/vw5/P39ZbZeTUGd2WWwZ88ebN68GdHR0ahSpYrM108d3KqDMYb8/Hy6t4gMySskRCpVqoSwsDC0bt0atra2333aWJPQEUUpXb9+HaNHj0ZISAiaNGkit+3QkYVsxcbGolOnTqhUqRIqVqwIT09P3Lp1q9i2//zzD1xdXdG7d2/UqVMHEyZMwKdPn4q027NnD2rUqIGKFStiyJAhyMvLk/NeqD95h4RI48aNsX//fowZMwZRUVFy247aYeSbXr9+zUxNTdlff/2lsG2+fPmShYeHs9TUVIVtU93ExsYyfX19ZmFhwVasWMGWLVvG6tevzypVqsQePnwo0fbmzZtMX1+f2dvbs9GjRzN/f3+mp6fHOnXqJNHu2bNnrEKFCmzFihXswIEDzMbGhi1dulSRu6V20tLSWHh4OHvx4oXCtrl69WpmYmLCXr16pbBtqjIKim/Izs5mrVu3ZoMHD2ZCoVCh26aw+D5dunRhVatWZW/fvhUvS0pKYhUqVGA9evSQaNu5c2dmamrK3r59y0JDQ1leXh7bsmULA8BOnz4tbnfgwAHWrVs38dehoaHMx8dH/jujprgICcYYEwqFbNiwYaxVq1YsKytLodtWRXTq6RtmzpwJxhg2btwIHo+n0G3TaajvExERgY4dO6J69eriZaampnBxccGxY8fEp5U+fvyIs2fP4pdffkGlSpXEbQcOHIgKFSpg//794mUNGzbElStXcPbsWTx69AibN2+GhYWF4nZKjSjqdFNxeDwe1q1bBz6fjxkzZih026qIgkKKq1evYtOmTdi9ezf09PQ4qYHCovxyc3OLnVbF0NAQeXl5uHv3LgDgzp07KCgoQKtWrSTa6erqwt7eHjdv3hQvc3BwQP/+/eHp6YmmTZvi1atX9EFTDlyGhIienh527dqFrVu3IiIigpMaVAUFRQmysrIwZMgQzJ8/H5aWlpzWQmFRPpaWloiKikJhYaF4WV5eHqKjowFAfDe05ORkAJ+PNr5mamqKpKQkiWUBAQFISEhAbGwsYmNjUbNmTXntglpShpAQsbCwwIIFCzBkyBBkZmZyWosyo6AowaxZs1CrVi1MnDiR61IAUFiUx9ixY/H48WMMGzYM9+/fx927dzFw4EBxMGRnZ0v8W9xRo76+vvj5LzVs2BAODg4lTilPiqdMISEyYcIEmJqa0pGhFBQUxYiIiMDmzZuxfft2pRrBSWFRNqNHj8bMmTMRHBwMa2tr2NraIiEhAdOmTQMAVKhQAQDEp6eKu3dBTk5OqWcFJtIpY0gAn++Ot337dgQGBuLy5ctcl6OUKCi+kpWVhaFDh+LPP/+U63iJ8qKwKJuFCxciNTUVERERuH37NmJiYiAUCgFA/P6KTjmJjjS+lJycDDMzM8UVrKaUNSREGjdujIULF2Lo0KF0CqoYFBRfmTlzJoyNjfHrr79yXUqJKCzKpmrVqmjXrh1sbW0BAOfOnYO5uTmaNm0KALCxsQGfz8eNGzckXpeXl4dbt27B3t5e0SWrFWUPCZHx48ejdu3aNMVHMSgovhAREYEtW7YgMDBQqU45FYfConz27duHmJgYTJw4EVpan3/8K1eujI4dO2LPnj3IyMgQt929ezc+ffqEXr16cVWuylOVkAA+n4IKDAzE9u3bcenSJa7LUSo0e+z/y8zMRPPmzeHn54dJkyZxXU6p0ayzJbty5Qrmz58PT09PVK9eHVFRUdi+fTs8PDwQHh4u0REdFxeHtm3bolmzZnB2dkaVKlWwatUqtG/fHqdPn+ZwL1SXKoXElwICArBq1Srcvn1b3I+l6Sgo/t+ECRMQFxeHy5cvK/3RxNcoLIqXkJCAsWPHIi4uDhkZGWjQoAEGDRqEyZMnFzuZ39WrVzFt2jTExsaicuXK6N27NxYvXoyKFStyUL1qU9WQAAChUAg3NzfY2tpi7dq1XJejFCgoAFy+fBne3t64efOmyo6ypbCQDbofxfdT5ZAQSUhIQPPmzREeHg43Nzeuy+GcxvdRZGZmYujQoViwYIHKhgRAfRZEOahDSABAo0aNsHjxYgwdOrTYGYQ1jcYHxezZs2FmZoYJEyZwXcp3o7AgXFKXkBDx8/NDvXr1aCAeNDwoEhISsHHjRmzatEl8BYyqo7AgXFC3kAA+XwW1adMmbN26FU+ePOG6HE6px6djOf3+++/o168frKysuC5FpigsiCKpY0iIWFpaYsCAAZg9ezbXpXBKYyequXnzJkJDQ/Ho0SOuS5ELuq0qUQR1DgmROXPmoEmTJoiNjUXLli25LocTGntEMWPGDPj5+antDzdARxZEvjQhJACgdu3aGD9+vEaP2NbIoLh48SKioqI04o2nsCDyoCkhITJ9+nTcuHED586d47oUTmhcUDDG4O/vj2nTpknc+UydUVgQWdK0kAA+zxfm7+8Pf39/8aSSmkTjguLw4cN48eKFUk/6Jw8UFkQWNDEkRMaPH4/k5GQcOnSI61IUTqOCoqCgALNmzcKcOXNgZGTEdTkKR2FBvocmhwTw+Ra6c+fOxaxZs5Cfn891OQqlUUGxfft2CIVCDBs2jOtSOENhQcpD00NCZMiQIeJZZjWJxgRFVlYW5s6diwULFmj8HD6KCIv8/HyNPJerjr4MCXNzc+Tl5XFdEmf4fD4WLlyIefPmISsri+tyFEZjgmLNmjUwNTVFz549uS5F7j59+oQ5c+agU6dOqFatGng8Hnbs2CHRxtzcHPfv34e7uztq1qwJPT09NGjQAEOGDEFiYmKRdfJ4vGIfS5YskWjHGMPEiRNRsWJFVK1aFQEBAXLcU1JaCxcuBI/Hg42NjcRyV1fXYt/XTp06AZAMicuXL6NGjRqoWLEihgwZorGB0aNHD9SpUwerV6/muhSF0YgBd+/fv8eSJUtw4MABtZmqQ5q3b99i/vz5qFu3Lpo3b17iTVgSExPRrFkzODk5wdbWFv/99x+2bNmCY8eO4d9//y1yC1APDw8MHDhQYlmLFi0kvg4ODsbhw4exdetWZGVlwd/fH05OTnBycpLpPpLSe/XqFRYtWlRiv5y5uTkWL14ssczMzEwiJAoLCzFmzBjMnTsX9erVw7x587Bq1Srx/cc1iegPpO7du2PUqFGoVq0a1yXJH9MA06ZNYx06dOC6DIXJyclhycnJjDHGYmJiGAC2ffv2Etu/fPmShYeHs9TUVHbjxg0GgC1evFiiDQDm5+f3zW37+fmxVatWib+eOHEiW7FiRfl2hAN5eXksNDSU5eXlcV2KzPTp04e5u7szFxcXZm1tLfFcccsYYywtLY2Fh4ezFy9eMMYYO3DgAOvWrZv4+dDQUObj4yPfwpWcp6cnmzp1KtdlKITa/3mdnp6OdevWYcGCBVyXojB6enowMTEpdfsv+yxEf3Wmp6cX2zY7Oxs5OTklrqthw4YICgrCv//+i6ioKISFhan09O2q7sqVKzh48CBWrVoltV1BQYF4Ou3iOq4bNmyIK1eu4OzZs3j06BE2b96s8e/rwoULsX79erx//57rUuRO7YMiMDAQdnZ2cHZ25roUpfXff/9BV1cXPB4PgwYNAgB06NChSLsdO3bAyMgIBgYGsLKyQnBwcJE2o0ePBp/Ph729Pdq0aQNnZ2f4+vrKfR9IUYWFhRg/fjyGDx8OW1vbEts9fvwYRkZGqFixImrVqoXx48fDyspK4uomBwcH9O/fH56enmjatClevXql8dNvt2rVCg4ODti2bRvXpcidWvdRFBYWYs2aNUU6XImk2rVrIzc3F8DnEagjR45E8+bNJdq0bdsWvXv3RoMGDZCUlIR169ahf//++PDhA8aMGSNuZ2hoiKtXr+LOnTvQ19eHpaWlQveF/M/GjRvx/PlzqdNONGrUSHzbz+TkZOzevRv79u0DYwz79u2TaBsQEICJEyciPT0ddnZ2Evcc11S//vorpk6diokTJ6r394Prc1/ydOTIEVa7dm21Ot9cVqXpo7hw4QI7ceIEW7lyJWvRogXz9/cX91mUJDc3l9nY2LAqVaqwrKwsOVTODXXpo3j79i2rVq2aRP9QSf0RjEn2SYwYMYIBYNeuXVNUuSorPz+f1a1blx06dIjrUuRKrU89rV69Gn5+fho/buJb3Nzc0LlzZ0yePBkHDhzAqlWrcOvWLanjLHR1dTFu3Dikp6cjNjZWwRWTb5k9ezaqVauG8ePHf7Pt130SU6ZMAQCNnQCvLPh8Pvz8/NT+Ulm1DYrbt28jOjoaI0eO5LoUldKoUSO0aNECx48f/+agPNE57Hfv3imyRPINT548webNmzFhwgQkJSUhMTERiYmJyMnJQX5+PhITE8XvWXEd1/S+ls3w4cMRExODW7ducV2K3KhtUAQEBKB///4aM0OsLGVnZ+PDhw/fHMH99OlTAEDNmjUVXSKR4vXr1xAKhZgwYQIaNGggfkRHR+Px48do0KAB5s+fX+K0HPS+lk21atUwYMAAtT6qUMvel/T0dAQHByMqKorrUpRWQUEBMjIyULVqVYnl169fx507d9CvXz8Any+d/e+//4rcKS8jIwOrVq1CjRo1NPauX8rKxsYGR44cKbJ89uzZyMjIwOrVq1G1alVcvHgRDg4OEiHBGBNfSu7l5aWwmlXd+PHj4ejoiL/++qvI75Q6UMugCAoKgp2dHezs7LguhTNr165Feno6kpKSAADh4eF49eoVgM8/1Iwx1KlTB3369IG1tTWMjIxw584dbN++HZUrV8bvv/8uXteRI0dw4MAB2NrawtHREZmZmQgMDMSLFy+we/du6OrqcrKPpHg1atRAt27diiwXjaX44YcfEB0dDQD48ccf8fPPP6Nx48bIzs7GkSNHEBkZiZEjR8LBwUGBVas2GxsbtGjRAnv27ClVv5DK4bo3XdaEQiFr3rw527p1K9elcKpevXoMQLGPZ8+esdzcXPbrr78yOzs7VqlSJaajo8Pq1avHhg0bxp49eyaxrjNnzjAPDw9Wq1YtxufzWeXKlZmnpyc7f/48NzsnR+py1VNxXFxcWNOmTcVXNz19+pT16tWL1a9fn+nr6zNDQ0PWsmVLtnHjRiYUCrkuV+UEBgYyW1tbtfze8RhjjMugkrWYmBi4u7sjOTkZFSpU4LoctfPq1SvcunVL4jSUOsnPz8eJEyfQpUsXtbtajqYKl6/MzEyYmZnhzJkzaje3mdp1Zm/ZsgX9+vWjkJATup+FaqKQkD8jIyP069cPW7Zs4boUmVOroMjIyMDevXsxYsQIrktRaxQWqoVCQnFGjBiBkJAQfPz4ketSZEqtgiIkJAQWFhZ0FY4CUFioBgoJxXJwcEDTpk2xd+9erkuRKbULisGDB4PH43FdikagsFBuFBLcGDx4MEJCQrguQ6bUJijev3+PK1euoGvXrlyXolEoLJQThQR3BAIBIiIi1Gpku9oExalTp2BlZYV69epxXYrGobBQLhQS3Kpbty5sbW1x8uRJrkuRGbUJivDwcLrvAYcoLJQDhYRy8PX1RXh4ONdlyIxajMwWXft+5swZrkvRaObm5gBQZLoPohgUEspDIBCgQ4cOyMvLU4uZC9TiiOLq1aswMDBAq1atuC5F49GRBTcoJJSLg4MDKlSogIiICK5LkQm1CIqwsDD4+PhAS0stdkflUVgoFoWE8tHS0oKPjw/CwsK4LkUmVP6TlTGGsLAwCAQCrkshX6CwUAwKCeUlEAgQFhYGdZglSeWD4sGDB0hOTkaHDh24LoV8hcJCvigklJu7uzvS0tJw7949rkv5biofFGFhYejYsSMMDQ25LoUUg8JCPigklJ+BgQE8PDzU4vSTygdFeHg4nXZSchQWskUhoToEAoFaXCar0kGRlpaG6OhoeHt7c10K+QYKC9mgkFAt3t7eiImJQUpKCtelfBeVDorjx4+jZcuWMDU15boUUgoUFt+HQkL1GBsbw9HREcePH+e6lO+i0kFBp51UD4VF+VBIqC51OP2kskGRn5+PM2fOwMfHh+tSSBlRWJQNhYRq8/X1xZkzZ5CXl8d1KeWmskFx//59aGlpwdbWlutSSDlQWJQOhYTqs7Kygo6OjkpfJquyQREbG4sWLVrQaGwVRmEhHYWEetDS0oKDgwNiY2O5LqXcVPZTNjY2lu5kpwYoLIpHIaFeWrZsSUHBBQoK9UFhIYlCQv1QUHCgoKAA//77LwWFGqGw+IxCQj21bNkSt2/fRn5+PtellItKBsX9+/fB5/PRpEkTrkshMqTpYUEhob4aN24MXV1dle3QVsmgoI5s9aWpYUEhod5UvUNbJT9pqX9CvWlaWFBIaAZV7qegoCBKSVPCgkJCc1BQKJCoI9vBwYHrUoicqXtYUEhoFgcHB/z7778q2aGtckHx4MEDaGlpwdLSkutSiAKoa1hQSGieJk2aQEdHB/fv3+e6lDJTuaCIi4uDvb09tLW1uS6FKIi6hQWFhGbS0tJCixYtEBcXx3UpZaZyQUH9E5pJXcKCQkKzqWo/BQUFURmqHhYUEoSCQgEYY7h9+zbs7e25LoVwRFXDgkKCAIC9vT1u374NxhjXpZSJSgVFRkYGPn36RL9oGk7VwoJCgojUqVMHWVlZ+PDhA9ellIlKBUVycjL09PRQpUoVrkshHFOVsKCQIF+qVKkSDAwMkJyczHUpZaJyQWFqagoej8d1KUQJKHtYUEiQr/F4PJiamlJQyJMoKAgRUdawoJAgJTEzM0NSUhLXZZSJygWFmZkZ12UQJaNsYUEhQaShIwo5S0pKoiMKUixlCQsKCfItFBRyRqeeiDRchwWFBCkNMzMzCgp5oqAg38JVWFBIkNIyNTWlPgp5oj4KUhqKDgsKCVIWdOpJzuiIgpSWosKCQoKUFQWFHIlGM1JQkNKSd1hQSJDyMDMzw6dPn5CRkcF1KaWmMkGRnJwMPp+P6tWrc10KUSHyCgsKCVJeVatWhZ6enkodVahUUJiYmEBLS2VKJkpC1mFBIUG+B4/Hg4mJCQWFPFBHNvkesgoLCgkiC6p2iWyZgyIxMRE8Hk/iYWhoCDMzM3To0AF//PEHEhISirzu0qVLRV739cPV1bXE7aalpaFWrVplLZd8JS8vj+sSOPO9YUEhIR+5ublcl6BwxsbG3/wZFH3WdurUSWq7Lz9bW7VqVWK7kydPluqztjjlPqJo1KgR5syZgzlz5uDXX39F586dkZaWhj///BOWlpaYOXNmsXOut2zZUvy6rx+DBw8ucXt5eXnQ19cvb7lK4dOnT5gzZw46deqEatWqgcfjYceOHcW23b9/P5ydnVGlShVUr14dLi4uOH78eJF2QqEQy5YtQ4MGDaCvrw87Ozvs3bu3SLucnBz069cPRkZGMDY2xv79+2W9eyqhvGFBIVE2ubm5mD59OszMzGBgYAAnJyecPXtWos1///0HLy8vGBoaokGDBrh06RI3xXJAT09P5n+08fl8xMbG4vbt28U+v23bNvD5/PKtnJXRs2fPGADm5eVV7PMRERGsfv36DACbPXu2ePnFixcZADZq1KiybpIxxtiyZctY3759y/VaZSH63tWtW5e5uroyAGz79u1F2gUEBDAAzNvbm23YsIH9/fffrHnz5gwAO3TokERbf39/BoCNGDGCbd68mXl7ezMAbO/evRLtFixYwGxsbNiBAwfYihUrWMWKFdnz58/lubtK7eXLlyw8PJylpqZKLM/Ly2OhoaEsLy9PvCwtLY2Fh4ezFy9eKLpMldW3b1/G5/PZ1KlT2aZNm1ibNm0Yn89nERER4jbDhw9n7du3Z0eOHGGzZs1iNWvWZJ8+feKwasXp378/W7x4sdQ23/qsFRF9tnp7ezMtLS3266+/Fmnz5s0bpqurywQCAQPAXFxcylSvzIOCMcYePnzI9PT0mK6urviX63uDYtGiReyXX34p12uVRU5ODktOTmaMMRYTE1NiUFhYWDBHR0cmFArFyz58+MAqVKjABAKBeNmrV6+Yjo4O8/PzEy8TCoXsxx9/ZObm5qygoEC83Nvbm4WGhoq/7tatGzt48KAsd0/lFBcWXwcFhUTZRUdHMwBs+fLl4mXZ2dmsUaNGrE2bNuJl1tbW7NatW+Kv7e3t2Y0bNxRaK1cGDRrE/vzzT6ltyhoUo0aNYl5eXqxGjRosNzdXos3ff//NALDQ0NByBYVcOrMtLS3Ru3dv5OXlITQ0VCbrzM/PL/9hk5LQ09ODiYnJN9t9/PgRtWrVkrjvRqVKlVChQgUYGBiIlx09ehT5+fkYO3aseBmPx8OYMWPw6tUrXLt2Tby8YcOG2Lx5Mx49eoSzZ8/iypUraNy4sYz2TDV96zQUnW4qn4MHD0JbWxsjR44UL9PX18ewYcNw7do1vHz5EsDnn8mAgAAkJCTgwIEDiI+PR7169bgqW6H4fD4KCgpkvt6hQ4fi7du3CA8Pl1geGBgIa2trODk5lWu9cvvkdXV1xe7duxETEyOx/MaNG5g7d26xr+nUqROcnZ2Lfa6goAA6OjqyLlMpubq64uDBg1izZg18fX2Rk5ODNWvW4MOHD/j111/F7W7evAkjIyM0a9ZM4vWtW7cWP9+uXTsAwIwZM+Dm5oamTZsCAPz9/dG8eXMF7ZHyMjc3BwBcv34drVu3RtWqVQEAb9++RWxsLIVEOdy8eRNNmjRBpUqVJJaLfi5v3bqFOnXqYNGiRfDy8kJgYCD4fD5WrVqFGjVqcFGywvH5fOTn58t8vd26dUP16tURGBiIn376CQAQExODO3fuYOXKleVer9yCQnQp69u3byWWx8bGIjY2ttjXVKlSRWpQqPoRRWkFBATg7du3mDBhAiZMmAAAqFGjBs6fP482bdqI2yUnJ8PY2LjIHf9Eo9e/nHjM1NQUt2/fxp07d1CjRg2N+cutNL4MCwcHBwCgkPgOJU218/XPpY2NDZ48eYK7d++ibt26pTraVhc6OjpyOaLQ1dVF//79sW7dOiQlJcHMzAyBgYHQ0dHBgAEDUFhYWK71KvyTd9SoUdi4cWOZX1dQUAAtLS25pDAXRD8khYWFRfZJR0cHFhYWMDMzQ5cuXfDp0yesXr0aPXr0wIULF8SnjLKysqCrq1vk9dra2gCAzMxMied4PB7s7OwAQG2+j7JibGwMW1tb8RFw06ZNYWJiQt+ncsjOzpb6c/np0yfxczo6OmjRogUAzfqZPHfuHLS0tLB06VKZr3vo0KEICAjAzp07MWnSJISEhMDHxwc1a9ZESkpKudYpt6AQ/dVQs2ZNmayPMYbExEScOHFCJuvjWnx8PADg33//LbJP8+fPh5aWFmbPng0AMDAwwPTp0zF27FiMGDECv/32GwAgIyMD79+/L/J60XXpSUlJavP9UrR79+7h3r17XJehkgoKCvD69esiP3uivomEhASN/7lMS0uT2+X+zZs3h4ODA7Zv3466desiPT0dQ4cO/a51yi0oRNdEOzo6ymR9fD4f5ubm6NKli0zWxzXR6bfmzZtL7NPTp08RFxeHDRs2FNnXffv24ebNm+LlYWFhuH//Pjp37ixx+kk04LFdu3Zq8/2SN1GfhKWlJe7fvw8tLS20bNlSZn/oaJI1a9bg9evXRX72Lly4AADw8PDQ+J/Lvn37okKFCnJb/7Bhw+Dn5ycey9K5c+fvWp9cguLx48fYv38/9PT00L17d5msU0dHB0KhUG06tEX9Ldra2hL79O7dO/H/v97XwsJCiU59BwcHBAYGIj4+HlZWVuJ2cXFxAD4PblSX75c8vXnzRtwnYWJigvv378POzg5xcXFo3bo1zQhQRi1atMClS5eQnZ0t0aEt+uOoVatWGv9zKRQK5drn2q9fP0yZMgWvX7+Gv7+/+LRfecn88tjIyEh4eXkhNzcX/v7+qF27tkzWK6/LyZRN48aNoaWlhX379kmMbH/16hUiIiLE53MBoGvXrtDR0cH69evFyxhj2LhxI2rXro22bdsqtHZVVNIlsGZmZkpxD25V1LNnTxQWFmLz5s3iZbm5udi+fTucnJzoAgHI/+KcKlWq4PTp0zhy5AgmTZr03esrd6Xx8fHiy1zz8vKQlpaG69ev486dO9DW1sbs2bMxZ86cIq+Tdnmsvr4+/P39iy9UTYJi7dq1SE9PF/fhhIeH49WrVwCA8ePHo2bNmhg6dCi2bt2KDh06oEePHsjIyMD69euRnZ2NGTNmiNdlbm6OiRMnYvny5cjPz4ejoyNCQ0MRERGBoKCg7/4rQt19a5zE15fO0pFF6Tg5OaFXr16YMWMG0tLS0LhxY+zcuROJiYnYtm0b1+UphbKMC7tz506J0xs1bdq0xCtF27dvX97yiirT8Dz2v9GCXz4MDAyYqakpc3NzY7///juLj48vcfSgtEflypVL3O7SpUtVfgoPxhirV69eifv/7Nkzxhhj+fn5bM2aNcze3p5VqFCBVahQgbm5ubELFy4UWV9hYSFbtGgRq1evHtPV1WXW1tZsz549Ct4r1VPSiOvipvAoaboPUrLs7Gw2depUZmJiwvT09JijoyM7deoU12Upjf79+7NFixZJbVPcZ+3XDxcXlzLNepGcnFyukdk8xoqZuU8J/f333/jnn39w4MABrkshKk7akUR+fj5OnDiBLl26SJxHf/XqFW7dukVHFkQm+vbti1atWmHq1Klcl1IqKnM/Ch0dHY2cjpjIVnmn5VDUPbiJZsjLy1OpAcQqExQ1atTAmzdvuC6DqLDvnbuJwoLISlpamkpdeq0yQWFqaqpSd4QiykVWE/xRWBBZKGmaE2WlMkEhunWginSpECUi61lgKSzI92CMqdytnVUmKExNTZGXl4f3799zXQpRIfKaKpzCgpTXx48fkZ2dTUcU8lChQgVUqFCBTj+RUpP3/SQoLEh5JCUlwcDAoMg07MpMZYIC+HxU8eXU2YSURFE3HaKwIGUl6p/4+vYAykzlgoKOKMi3KPrOdBQWpCxUrX8CoKAgaoar25dSWJDSSkpKUqn+CUDFgkJ05RMhxeH6HtcUFqQ0VO3SWEDFgoL6KEhJuA4JEQoL8i0UFHJGp55IcZQlJEQoLIg01EchZxQU5GvKFhIiFBakJNRHIWeioKDR2QRQ3pAQobAgxaFTT3JmZmaGrKwsZGRkcF0K4Ziyh4QIhQX5UkZGBj59+kRBIU+VK1eGgYGB+I5wRDOpSkiIUFgQkdevX0NPTw/VqlXjupQyUamg4PF4sLa2xu3bt7kuhXBE1UJChMKCAMDt27dhbW2tUqOyARULCgBo2bIlYmNjuS6DcEBVQ0KEwoLExsaiZcuWXJdRZhQURCWoekiIUFhoNgoKBWnZsiXi4uLoyicNoi4hIUJhoZkYY4iLi6OgUAQbGxtkZ2cjISGB61KIAqhbSIhQWGieZ8+e4dOnT7C1teW6lDJTuaDQ1dWFra0tnX7SAOoaEiIUFpolNjYWNjY20NPT47qUMlO5oACon0ITqHtIiFBYaA5V7Z8AKCiIEtKUkBChsNAMFBQKRh3a6kvTQkKEwkK9qXJHNqCiQWFjY4PMzEw8e/aM61KIDGlqSIhQWKiv58+f4+PHjyrZkQ2oaFDo6enBxsaGTj+pEU0PCREKC/UUGxsLa2tr6Ovrc11KuahkUADUT6FOKCQkUVioH1XunwAoKAjHKCSKR2GhXigoOCIKCurQVl0UEtJRWKgHxhgFBVfs7OyQmZmJx48fc10KKQcKidKhsFB9CQkJ+PjxI+zs7LgupdxUNij09PTg7u6O48ePc10KKSMKibKhsFBtx44dg5ubGwwMDLgupdxUNigAQCAQICwsjOsySBlQSJQPhYXqCgsLg0Ag4LqM76LSQeHj44OrV6/i3bt3XJdCSoFC4vtQWKie9+/fIyIiAj4+PlyX8l1UOijq1KkDOzs7nDx5kutSyDdQSMgGhYVqOXXqFKytrVGvXj2uS/kuKh0UAODr60unn5QchYRsUViojrCwMPj6+nJdxndT+aAQCAQ4efIk8vLyuC6FFINCQj4oLJRffn4+Tp48qfL9E4AaBIWDgwMqVqyIK1eucF0K+QqFhHxRWCi3iIgIGBoaqvT4CRGVDwoej0enn5QQhYRiUFgor7CwMPj4+EBLS+U/ZlU/KID/XSZLo7SVA4WEYlFYKB/GmFpcFiuiFkHh7u6ON2/e4O7du1yXovEoJLhBYaFc7t+/j5SUFHTo0IHrUmRCLYJCX18fnp6edPqJYxQS3KKwUB5hYWHw8PBQ6dHYX1KLoAA+n34KDw/nugyNRSGhHCgslEN4eLjanHYC1CgovL29cePGDaSkpHBdisahkFAuFBbcSk1NxfXr1+Ht7c11KTKjNkFRq1YttG7dmo4qFIxCQjlRWHDn2LFjaNWqFUxMTLguRWbUJigAoHfv3ti1axfXZWgMCgnlRmHBjV27dqF3795clyFTahUUAwYMQExMDB48eMB1KWqPQkI1UFgo1qNHjxAdHY2BAwdyXYpMqVVQVK9eHT169MDWrVu5LkWtfSsk8vPzIRQKOaiMFEfeYUHv9/9s3boV3bp1Q40aNbguRabUKigAYMSIEdi5cydyc3O5LoUTMTExGDduHKytrWFkZIS6deuid+/eEncCFAqF2LFjBwQCAerUqQMjIyPY2NhgwYIFyMnJKbJOHo8n8ahVqxZ8fX0RFBQk0Y4xhokTJ6JixYqoWrUqAgIC5L6/mu7evXvo1asXGjZsCENDQ9SoUQPt27cv0leXlJSE/fv3o23bttDR0QGPxytxnV+/36LHkiVLJNrR+y0pNzcXO3bswIgRI7guReb4XBcga66urqhatSqOHDmCvn37cl2Owi1duhSRkZHo1asX7OzskJKSgrVr18LBwQFRUVGwsbFBVlYWhgwZAmdnZ4wePRq1atXCtWvXMGfOHJw/fx4XLlwo8kHi4eGBbt26ISEhAXXr1kX16tXRokULiTbBwcE4fPgwtm7diqysLPj7+8PJyQlOTk6K/BZolOfPnyMjIwODBg2CmZkZsrKycOjQIQgEAmzatAkjR44EAJw4cQIhISFo2rQpjI2N8fr1a6nr9fDwKHL6hN5v6Y4ePYrKlSvDzc2N61Jkj6mhpUuXMnd3d67L4ERkZCTLzc2VWPb48WOmp6fH+vfvzxhjLDc3l0VGRhZ57bx58xgAdvbsWYnlANjQoUNZeHg4e/HiRYnb9vPzY6tWrRJ/PXHiRLZixYrv2R2Fy8vLY6GhoSwvL4/rUsqtoKCANW/enFlaWoqXpaSksKysLMYYY4MGDWIAWGpqarGvB8D8/Py+uR11eL9lqWPHjmzx4sVclyEXanfqCQAGDRqEq1evIj4+nutSFK5t27bQ1dWVWGZhYQFra2txJ7+uri7atm1b5LXdu3cHgGIvBkhNTYWlpSVq1qxZ4rYbNmyIoKAg/Pvvv4iKikJYWBgsLCy+Z3dIOWhra6NOnTpIT08XLzM2NhaPEq5QoQIAfLPPIjs7u9hTkSL0fv/P06dPcfnyZQwePJjrUuRCLYPC2NgY3bp1w/r167kuRSkwxpCamvrNDjbRYMUv27158wYAcPHiRVhaWsLAwABWVlYIDg4u8vrRo0eDz+fD3t4ebdq0gbOzs1rctEUVZGZm4u3bt0hISMDff/+NkydPfnOeIWkd3Dt27ICRkRG936W0fv16dO3aVa3GTkjg+pBGXiIjI1mlSpXYx48fuS6Fc7t372YA2LZt26S269ixI6tUqRJ7//49Y4yxtLQ0Fh4ezlq2bMlWrVrFjh49yjZs2MBsbGwYALZ+/foi6ygsLGS3bt1iDx8+lMeuyJ2qnnoaNWoUA8AAMC0tLdazZ0/27t27Ytv6+fkx0a/+y5cvWXh4uMRpqLZt22rM+y0LGRkZrHLlyiwiIoLrUuRGbYNCKBSyVq1asTVr1nBdCqcePHjAKlWqxNq0acMKCgpKbLdw4UKJDwNRSBTXJ5Gbm8tsbGxYlSpVxOe91YWqBsWDBw/Y2bNn2c6dO5m3tzfr3r07S0lJKbbtl0HBWPFh8SV1fr9lYd26dczBwYEJhUKuS5EbtQ0Kxj7/JW1hYcEKCwu5LoUTycnJrGHDhqxOnTrs9evXJbYLCQlhPB6PDRs2jDEmPSRENm7cyACo3V9RqhoUX/Pw8GCOjo7Ffnh9HRSMfTss1PX9/l6FhYXM0tKS7dy5k+tS5Eot+yhEevfujYyMDJw8eZLrUhTuw4cP6Ny5M9LT03Hq1CmYmZkV2+7s2bMYOHAgvL29sXHjxlKPuBY99+7dO7nUT75Pz549ERMTIzF+RppvDcqj97t4Z86cQXp6Ovr06cN1KXKl1kGhq6uLMWPGYPXq1VyXolA5OTnw9fXF48ePcezYMVhZWRXbLjo6Gt27d0erVq2wf/9+vH//vtTTcjx9+hQApF4FRbiTnZ0N4PMfDKUlLSzo/S7e6tWrMXr0aOjp6XFdinxxfUgjbykpKUxPT4/dvXuX61IUoqCggAkEAsbn89nx48dLbHf//n1WvXp1Zm1tzd69e1fi6aa0tLQir/348SNr1KgRq1GjRpExG6pO1U49FXeqKC8vjzk4ODADAwOWkZFR5PniTj2JpKWlFTkNpc7v9/d48OAB09PTY8nJyVyXIndqNzL7a8bGxhgyZAj++OMPHDp0iOty5G7KlCkICwuDr68v3r17hz179kg8/8svvyAjIwNeXl54//49fvvtN+zdu1c84jo9PR2NGjVCmzZtAADr1q1DaGgofH19UbduXSQnJyMwMBAvXrzA7t27i4zZIIo1atQofPz4Ee3bt0ft2rWRkpKCoKAgPHz4ECtXrhSPmXj+/Dl2794NALhx4wYAYMGCBQCAevXqYcCAAQD+9367uLjg9OnTMDQ0xL59++j9LsYff/yBgQMHqu8lsV/iOqkU4fXr18zQ0JBFR0dzXYrcubi4iC+TLO7BGGPPnj2T2mbQoEHi9Z05c4Z5eHgwExMTpqOjw6pUqcI8PT3Z+fPnOdpD+VK1I4q9e/eyjh07MmNjY8bn81nVqlVZx44d2dGjRyXaXbx4scT328XFRdzu6/fbyMiIubq6qu37XV4xMTHM0NCQvXr1iutSFILHGGOKjSZuzJw5E1FRUTh//rzUCdE0CU0VXlR+fj5OnDiBLl26QEdHh+tyOPfq1SvcunULrVu3Rq1atbguR2l4eHigZcuWRSZKVFdq3Zn9pWnTpuHWrVs4c+YM16UoBQoJUhp0P4uizp07hxs3bmD69Olcl6IwGhMUVapUwcyZM+Hv76/xc+dTSJCyoLD4H6FQCH9/f8yYMQNVq1bluhyF0ZigAIBx48bh7du32LdvH9elcIZCgpQHhcVnBw8eREpKCsaPH891KQqlUUGhr6+PefPmYfbs2cjLy+O6HIWjkCDfQ9PDIj8/H7NmzcLcuXPFM/FqCo0KCgAYOHAg9PT0NO52qRQSRBY0OSwCAwOhra2ttlOJS6NxQcHn87Fo0SLMnz8fnz594rochaCQILKkiWGRlZWFefPmYeHCheDz1X74WREaFxQA0LVrVzRs2BCrVq3iuhS5o5Ag8qBpYbF69WrUqVMHPXr04LoUTmhkUIhuFL98+XK8ffuW63LkhkKCyJOmhMW7d++wdOlSLFmyRGPHYGlkUABA+/bt0a5dOyxatIjrUuSCQoIogiaExeLFi+Hs7Aw3NzeuS+GMxozMLs7t27fh5OSEhw8fol69elyXIzMUEuVHI7PLR11HcL969QpNmjRBZGQkWrRowXU5nNHYIwoAsLOzQ58+fTBhwgSoS15SSBAuqOORBWMMEyZMwE8//aTRIQFoeFAAwMqVKxEdHY2goCCuS/luFBLc0sSxOV9St7AICQlBZGQk/v77b65L4ZzGB0X16tWxadMmTJgwAcnJyVyXU26aHhIxMTEYN24crK2tYWRkhLp166J3795F7vDG4/FKfHh4eEi0FQqFWLZsGRo0aAB9fX3Y2dlh7969Rbadk5ODfv36wcjICMbGxti/f79c91WZqUtYpKSkYNy4cdiwYQNq1KjBdTmc07wLgovRtWtXdOnSBaNGjcLRo0dV7soGTQ8JAFi6dCkiIyPRq1cv2NnZISUlBWvXroWDgwOioqJgY2MDAOJ7Mnzpxo0bWL16NTw9PSWWz5o1C0uWLMGIESPg6OiIo0ePol+/fuDxeOjbt6+43cqVK3Hnzh3s3bsXz58/x/Dhw+Hs7Iy6devKd6eVlLm5OQDg+vXrKtlnwRjDmDFj4OnpqbGXwxbB4RTnSuW///5jJiYmbNeuXVyXUiYl3ZlO00RGRha5+9rjx4+Znp4e69+/v9TXDhs2jPF4PPby5Uvx/SiePXvGdHR0mJ+fn7idUChkP/74IzM3N2cFBQXi5d7e3iw0NFT8dbdu3djBgwdltGeq6+s75amKoKAgVqtWLfbmzRuuS1EaGn/qSaRatWriU1BJSUlcl1MqdCTxP23bti1y9zULCwtYW1vjwYMHJb4uNzcXhw4dgouLi/gvYQAIDw9Hfn4+xo4dK17G4/EwZswYvHr1CteuXRMvb9iwITZv3oxHjx7h7NmzuHLlCho3bizDvVNNqngaKjk5GePGjcPGjRvplNMXKCi+IBAI4OPjg5EjRyr9VVAUEt/GGENqaqrUX/gTJ04gPT0d/fv3l1h+69YtGBkZoVmzZhLLW7duDQC4efOmeNmMGTOQkJCApk2bwtPTEyNHjkTz5s1luCeqS5XCgjGG0aNHo1OnTujevTvX5SgV6qP4yurVq2FtbY1du3Zh0KBBXJdTLAqJ0gkKCsLr168xf/58qW309PTQs2dPieUpKSkwNjYu0l9lamoKABJHnaamprh9+zbu3LmDGjVqqNWYHFlQlT6LoKAgREdH4969e1yXonToiOIr1apVw+bNmzFx4kS8fv2a63KKoJAonYcPH8LPzw9t2rQpMfA/fvyI48ePo0uXLqhSpYrEc9nZ2dDT0yvyGn19ffHzX9LV1UXLli0pJEqg7EcWycnJmDBhAjZu3Ijq1atzXY7SoaAohq+vL3x9fZXuFBSFROmkpKTA29sblStXxsGDB6GtrV1su0OHDiEnJ6fIaScAMDAwQG5ubpHlOTk54udJ2ShrWDDGMGrUKHTu3BndunXjuhylREFRglWrViEuLg47d+7kuhQAFBKl9eHDB3Tu3Bnp6ek4deoUzMzMSmwbFBSEypUrw8fHp8hzJiYmSElJKfKHgmisjbT1kpIpY1js2bMH169fR0BAANelKC0KihIo0ykoConSycnJga+vLx4/foxjx47BysqqxLbJycm4ePEifvrpp2JPMTVv3hxZWVlFrpiKjo4GANjb28u0dk2iTGGRlJSECRMmYNOmTXTKSQoKCil8fX0hEAgwdOhQFBYWclIDhUTpFBYWok+fPrh27RoOHDiANm3aSG0fEhICoVBY7Gkn4PN7r6Ojg/Xr14uXMcawceNG1K5dG23btpVp/ZpGGcJCKBRi+PDh8Pb2RteuXTmpQVXQVU/fEBAQACcnJ/EoXUWikCi9KVOmICwsDL6+vnj37h327Nkj8fwvv/wi8XVQUBDMzMzg6upa7PrMzc0xceJELF++HPn5+XB0dERoaCgiIiIQFBRUYr8HKT2ur4b6/fffER8fLz5KJFJwONhPZTx8+JBVqVKF7dmzR2HbpBHXZePi4sIAlPj40sOHDxkANnny5CLrEY3MzsvLY4WFhWzRokWsXr16TFdXl1lbWyv0Z0BTcDGCOzg4mFWuXJk9ePBAYdtUZRp9P4qyOH36NH766SdcvHgRjo6Oct0WHUlwh+5HwQ1F3s8iNjYWLi4uOHDgADp37izXbakL6qMoJS8vL8yfPx/dunWT6xQfFBJEEymqzyIlJQVdu3bF3LlzKSTKgIKiDCZNmgQPDw90795dfD29LFFIEE0m77DIzc1F9+7d4e7ujilTpsh8/eqMgqIMeDweNm7cCC0tLZkPxqOQIER+YcH+fx4noVCIzZs3q9ytBLhGQVFG+vr6OHz4MC5cuICVK1fKZJ0UEoT8jzzCYtWqVThz5gyOHDkinoaFlB5dHlsOpqamCA0NhaurK6ysrNClS5dyr4tCgpCiZHnp7OnTp/H777/j4sWLNKK+nOiIopxatWqFLVu2oF+/fnj48GG51kEhQUjJZHFk8fjxY/Tt2xebNm2S+9WK6oyC4jv8/PPPGDt2LAQCAd6/f1+m11JIEPJt3xMW6enp8PX1xahRo0ocgU9Kh8ZRfCehUIhu3bohJycHJ06cAJ//7bN5FBLKi8ZRKKeyjrMoLCyEt7c3+Hw+jh49SiPpvxMdUXwnLS0t7NmzB69fvxZfVSENhQQhZVeWIwvGGMaOHYsXL17QdCsyQkEhA5UqVcLp06dx4cIFTJgwocTLZikkCCm/0oQFYwwTJ07EmTNncPr0aVSuXFnBVaonuupJRszNzXHhwgW0b98e+vr6WL58ucS12hQShHw/aVdDMcYwffp0HD58GFeuXKHfMxmioJCh+vXri8PCwMAAf/75JwAKCUJkqaSwmDt3Lnbv3o0rV66gQYMGXJaodigoZKxx48a4cOECXFxcoK+vj5EjR1JIECJjX4fFtm3bsGHDBly6dAkWFhYcV6d+KCjkoGnTpjh37hxcXV2RkJCAefPmUUgQImOisJg5cyaOHDmCCxcuSL2rISk/6syWE1tbW5w9exZHjx7Frl27uC6HELW0e/duHD58GGfOnEHz5s25Lkdt0RGFHDk4OODixYvo2LEjcnJyMH/+fJqMjBAZYIxh7ty52LBhAy5evEghIWcUFHJmZ2eHy5cvo0OHDsjOzi5yNRQhpGwYY/D398euXbtw6dIlOt2kABQUCtCsWTNcuXIF7u7uyMnJQUBAALS06KwfIWUlGichugSWOq4Vg4JCQRo3biwOi9zcXGzcuJFGjBJSBoWFhRg7dizOnDlDl8AqGP1Zq0D169fHlStXEBkZCR8fH6Snp3NdEiEq4cOHDxAIBLh8+TKFBAc0OigSExPB4/GkPr7+ME9OTsbvv/8OJycnVK9eHTo6OqhWrRqcnZ3h7++P+/fvS92mubk5rl27Bi0tLTg5OeHRo0dy3ENCVN+TJ0/g7OwMxhiio6PLfKk5j8dD06ZNxV/v2LEDPB4PS5YsKdI2Pz8fffv2BY/HQ8eOHfHp06fvrl8d0KknAI0aNcIvv/xS7HNf3g0rJCQEw4YNQ1ZWFuzs7NCrVy9Ur14dHz9+xK1bt7By5UosW7YMhw4dQvfu3UvcXuXKlREWFoaZM2fC2dkZISEh8PLykvl+EaLqzp49iz59+mD48OFYvHixXE/XZmVloUePHjh9+jR69OiB4OBg6OnpyW17qoSCAp/7D+bOnSu1zcmTJ9G/f39Uq1YNhw8fLvaD/fXr11i8eHGp7k2hra2NpUuXwtbWFj169MCff/6JSZMm0RVRhOBzp3VAQABmzZqFDRs2YMCAAXLdXnp6Ory9vfHPP/9g2LBh2LRpE/UhfoGCohQKCgrg5+cHoVCIAwcOwNXVtdh2tWvXxtq1a1FQUFDqdf/yyy9o0qQJunXrhtu3b2Pjxo10T1+i0XJzczF27FicPHkS58+fh5OTk1y3l5ycDC8vL9y5cwe//fYbli1bJtftqSKN7qMorYsXL+LZs2do165diSHxpdLcvOhLrVu3xo0bN3D//n24ubkhOTm5nJUSotpSU1Ph7u6O27dvIyYmRu4h8fTpU7Rr1w537tzB0qVLKSRKQEcUAOLj44s99dSpUyc4Ozvj2rVrAAA3Nze51WBmZobLly9j5MiRcHR0RGhoKFq1aiW37RGibOLi4tC1a1e0b98eW7duhYGBgVy3d/fuXQQEBCAtLQ1btmzB8OHD5bo9VUZBAYgn7vtalSpV4OzsjJSUFACfP8y/lpiYiB07dkgsq1+/PgYPHlzmOgwMDLBr1y6sWLECrq6u2Lp1K/r27Vvm9RCiavbv34+hQ4fi999/x7Rp0xTSVxcUFAQA8Pf3p5D4BgoKAF5eXjh16lS5XpuYmFgkZFxcXMoVFMDnS/l+++03WFtb4+eff8adO3fw559/0khuopaEQiHmzJmDgIAAhISEwMfHR2HbdnV1RWRkJFatWgU3Nzd4enoqbNuqhj59SsHY2BgAkJSUVOQ5V1dXMMbAGJNp30KXLl0QFRWF/fv3w8fHh/otiNpJSUlB165dsXfvXly7dk2hIQF8/gPx4MGDEAqFEAgEOHnypEK3r0ooKEqhbdu2AD53aitSs2bNcP36dVSpUgXW1tYICgoq8X7chKgKxhj27t0La2trGBkZ4fr165xN7CcQCHD48GEAQPfu3XH8+HFO6lB2FBSl4ObmhgYNGuDq1au4cuWKQrddtWpVBAcHY+vWrZg8eTK6d+8u7jMhRNWkpqbip59+wq+//orNmzcjJCQE1apV47Qmb29vHDlyBDweDz169EBYWBin9SgjCopS4PP5WLt2LbS0tNCzZ0+cPXu22HbynLupR48euHfvHgwMDGBtbY3g4GA6uiAqgzGGkJAQWFtbQ1dXF/fv38dPP/3EdVlinTt3xtGjR8W/46GhoVyXpFQoKEqpS5cu2LNnDzIzM+Hp6Ql7e3uMGTMGs2bNgp+fHzp37gw7OzvweDz88MMPcqmhRo0a2Lt3L7Zs2YKJEyeiR48eSE1Nlcu2CJGV1NRU9OzZExMmTMDGjRsREhKCGjVqcF1WEZ6enggPDwefz0fv3r1x6NAhrktSGhQUZfDzzz8jPj4es2bNgq6uLkJCQrB06VIEBwfjv//+w8SJE3H37l0sXLhQrnX06NED9+/fh56eHqysrLB37146uiBKhzGGffv2wdraGtra2rh37x569uyp0BoKCwsBALq6uqVq37FjRxw/fhw6Ojro27cv9u/fL8/yVAaP0SeMSjt06BDGjBmDH3/8EevXrxdfoUXKJz8/HydOnECXLl2go6PDdTkqKy0tDWPHjsXly5exfv169OrVi5M6UlJSYGpqCjc3N1y4cIGTGtQBHVGouJ9++gn37t0Dn8+HtbU1QkJC6OiCcGr//v2wtrYGj8fDvXv3OAsJADh69CgAyH0qEHVHRxRq5ODBgxgzZgzat2+PNWvWFDuSnEhHRxTll5ycjAkTJuDSpUtYt24devfuzVktixYtwt27d7F//37o6+vj7t27qF+/Pmf1qDo6olAjPXv2FPddWFhYYMaMGXQXPSJ36enpmDlzJho3bizui+AyJABg+fLlOHbsGDp06ICLFy9SSHwnCgo1U7NmTQQHB+PSpUuIiYlBw4YNsXz5cmRnZ3NdGlEz2dnZWLFiBRo2bIioqChcvHgRISEhqFWrFtel4f379/j48SNOnz4NR0dHrstReRQUasrR0RHnzp3Dvn37EBISAgsLC2zdurVM98ogpDgFBQUIDAxEkyZNEBwcjJCQEJw/fx6tW7fmujQiJxQUas7DwwMxMTFYuXKl+I56hw8fpg5vUmaMMRw5cgR2dnZYtGgRli9fjhs3bsDT05PuzKjmKCg0gJaWFvr06YP79+9jwoQJ8PPzg7Ozs8LnriKq6/Lly2jbti3GjBmDcePG4f79++jbty/Naqwh6F3WIDo6OhgzZgzi4+MhEAjQrVs3dOrUCTdv3uS6NKKk/v33X3Tp0gW+vr7w9vZGfHw8xo4dW+oBbEQ9UFBoICMjI8yaNQtPnz6FjY0NfvjhB/Tr1w9PnjzhujSiJBISEvDLL7/A2dkZTZs2xdOnTzF79mxUqFCB69IIBygoNFj16tWxYsUKPHz4EPr6+rCxsYFAIMCFCxeoD0MDMcZw8eJFdOvWDVZWVuDz+Xj48CH++usvpZybiSgOBQVB3bp1ERgYiISEBNjY2KB3796ws7PD1q1b6bJaDZCdnY1t27bB3t4ePXv2RLNmzRAfH48dO3agXr16XJdHlACNzCZFZGdnIygoCKtXr0ZycjJGjhyJMWPGoE6dOlyXJneaNDL71atX2LBhAzZt2gQTExP8+uuv6N+/PwwNDbkujSgZOqIgRRgYGGD48OG4ffs29u/fj3v37qFRo0bw8fHB0aNHaSyGCisoKEBYWBh8fX3RsGFD3LlzB/v27cOdO3cwYsQICglSLAoKUiIejwd3d3ccPXoUCQkJcHR0xPjx41G3bl3Mnj0bz54947pEUkrPnj3D7NmzUa9ePfj5+aFly5aIj49HWFgYOnToQOMgiFQUFKRU6tSpgzlz5uDZs2fYtm0b7t27B0tLS3h6eiI4OBjv37/nukTylfT0dAQHB8PLywuWlpa4d+8etmzZgsTERMydOxd169blukSiIqiPgpRbcnIyduzYgX379uHevXv48ccf4evrC4FAgEaNGnFdXrmoeh9FQkICwsPDER4ejitXrsDKygp9+vTBkCFDYGpqynV5REVRUBCZeP78ufgD6uLFi7CwsBCHhpOTE7S1tbkusVRULSgKCwtx/fp1hIWFISwsDE+ePIGrqysEAgF8fX3pqiUiExQUROZEs3aGh4fj+PHj0NbWhre3NwQCATw8PJR60JYqBEVmZibOnj2LsLAwHDt2DIWFhejSpQsEAgG8vLxQqVIlrkskaoaCgshVQUEBrl27hrCwMISHhyMxMRHu7u4QCATw8fGBubk51yVKUNageP36NY4dO4awsDCcP38e9erVEx81tG3bFnw+n+sSiRqjoCAK9ejRI/EpqqtXr6J27dpo2bKlxIPL+xkoQ1CkpaUhNjZW4vH69Wv88MMP4nCwtLTkpDaimSgoCGc+fPiAuLg4xMXFiT8QHz9+XGx4mJiYKKQmRQdFampqkVB49eoVLCwsJPbfwcEBlStXlns9hBSHgoIolY8fP+LmzZsSH5yPHz+GqampxAdn8+bNYWpqKvNTLvIKioKCAqSkpODWrVsS+5aUlIQmTZpI7FuLFi0oFIhSoaAgSi8jI6NIeDx69Ag8Hg81a9aEmZkZTE1NJR5fLjMxMSn1tNhlDYq8vDykpKQgOTlZ/EhKSpL4Ojk5GWlpaWCMFRsK1PlMlB0FBVFJpf2ATk1NBWMM1atXF4dHrVq1oKenBz6fDz6fDx0dHfH/eTwe4uPjUb9+fTDGUFBQgPz8fBQUFKCgoAC5ublIS0sTr//t27fg8XioVatWkYD6OrSMjY2hp6fH9beOkDKjoCBqraCgQOKDXfTXvejD/8sQEH0tFAqhq6srESCiQNHR0SlyFFOrVi266oioNQoKQgghUtFcT4QQQqSioCCEECIVBQUhhBCpKCgIIYRIRUFBCCFEKgoKQgghUlFQEEIIkYqCghBCiFQUFIQQQqSioCCEECIVBQXROImJieDxeOjUqVOJbS5dugQej4fRo0eLlw0ePBg8Hg9RUVGKKJMQpUFBQQghRCoKCkIIIVJRUBBCCJGKgoIQQohUdLcVorHi4+Mxd+7cYp9LTExUaC2EKDMKCqKxEhISMG/ePK7LIETp0aknorG8vLzAGCv2cfHiRa7LI0RpUFAQQgiRioKCEEKIVBQUhBBCpKKgIIQQIhUFBSGEEKkoKAghhEjFY4wxrosghBCivOiIghBCiFQUFIQQQqSioCCEECIVBQUhhBCpKCgIIYRIRUFBCCFEKgoKQgghUlFQEEIIkYqCghBCiFQUFIQQQqSioCCEECIVBQUhhBCp/g+v2SLSo7wIuAAAAABJRU5ErkJggg==" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 2 + ] }, { "cell_type": "markdown", + "id": "e7d40972d74b1c13", + "metadata": { + "collapsed": false + }, "source": [ "### The Structural Summary Method\n", "\n", "The Structural Summary Method (SSM) is a technique for analyzing circumplex data that offers practical and interpretive benefits over alternative techniques. It consists of fitting a cosine curve to the data, which captures the pattern of correlations among scores associated with a circumplex scale (i.e., mean scores on circumplex scales or correlations between circumplex scales and an external measure). By plotting a set of example scores below, we can gain a visual intuition that a cosine curve makes sense in this case. First, we can examine the scores with a bar chart ignoring the circular relationship among them." - ], - "metadata": { - "collapsed": false - }, - "id": "e7d40972d74b1c13" + ] }, { "cell_type": "code", - "source": [ - "from circumplex.datasets import JZ2017\n", - "import matplotlib.pyplot as plt\n", - "\n", - "jz_data = JZ2017\n", - "r = circumplex.ssm_analyze(jz_data.data, jz_data.scales.abbrev, angles=angles, measures = [\"NARPD\"])\n", - "plt.figure(figsize=(8, 5))\n", - "plt.bar(r.scales, r.scores[r.scales].values[0], color='red')\n", - "plt.ylim(0, 0.5)\n", - "plt.ylabel(\"Score\")\n", - "plt.xlabel(\"Scale\")\n", - "plt.title(\"NARPD Scores\")\n", - "plt.grid(True)\n", - "plt.show()" - ], + "execution_count": 3, + "id": "21f5a12726008489", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-07-11T18:37:04.774698Z", "start_time": "2024-07-11T18:37:02.341401Z" - } + }, + "collapsed": false }, - "id": "21f5a12726008489", "outputs": [ { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 3 + "source": [ + "from circumplex.datasets import JZ2017\n", + "import matplotlib.pyplot as plt\n", + "\n", + "jz_data = JZ2017\n", + "r = circumplex.ssm_analyze(\n", + " jz_data.data, jz_data.scales.abbrev, angles=angles, measures=[\"NARPD\"]\n", + ")\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(r.scales, r.scores[r.scales].values[0], color=\"red\")\n", + "plt.ylim(0, 0.5)\n", + "plt.ylabel(\"Score\")\n", + "plt.xlabel(\"Scale\")\n", + "plt.title(\"NARPD Scores\")\n", + "plt.grid(True)\n", + "plt.show()" + ] }, { "cell_type": "markdown", - "source": [ - "Next, we can leverage the fact that these subscales have specific angular displacements in the circumplex model (and that 0 and 360 degrees are the same) to create a path diagram.\n" - ], + "id": "cafd4ba1e88bf65f", "metadata": { "collapsed": false }, - "id": "cafd4ba1e88bf65f" + "source": [ + "Next, we can leverage the fact that these subscales have specific angular displacements in the circumplex model (and that 0 and 360 degrees are the same) to create a path diagram.\n" + ] }, { "cell_type": "code", - "source": [ - "fig, ax = r.profile_plot(incl_amp=False, incl_disp=False, incl_pred=False, incl_fit=False, reorder_scales=True)\n", - "\n", - "ax[0].grid(True)\n", - "plt.ylim(0, 0.5)\n", - "plt.xlabel(\"Angle\")\n", - "plt.title(\"Scores by Angle\")\n", - "plt.show()" - ], + "execution_count": 4, + "id": "c90c1bcb4a07781b", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-07-11T18:37:04.841796Z", "start_time": "2024-07-11T18:37:04.775420Z" - } + }, + "collapsed": false }, - "id": "c90c1bcb4a07781b", "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGECAYAAAA4IlRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABdeElEQVR4nO3dd1yV5f/H8ddhi1tRVBw4UnNv0zQ0wVG5Z+WIzMpy/agsM8WVWpmaqVmmWUrmqLSlqeRKyZkNy1VuxT1RAeH+/XF/IZGDIAL3OfB+Ph7n0X2uc537fM7VLXy4r2UzDMNAREREJIdzsToAEREREUegpEhEREQEJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEJAew2WwMGDDA6jAynb+/P0899ZTVYYg4LSVFIjnQH3/8QZcuXShTpgxeXl74+fkRFBTE+++/b3Vo2cIPP/yAzWajRIkSxMfHWx2OiKSRkiKRHGbz5s3Uq1eP3377jX79+jF9+nSeeeYZXFxceO+996wOL1sICwvD39+fkydP8tNPP1kdjoikkZvVAYhI1nrzzTfJnz8/27Zto0CBAkleO336dJbGcu3aNby9vbP0MzNbVFQUy5cvZ8KECXzyySeEhYURGBhodVgikga6UySSw/zzzz9UrVo1WUIEULRo0WRlCxYsoEGDBnh7e1OwYEEeeughVq1alaTOzJkzqVq1Kp6enpQoUYIXX3yRixcvJqnTrFkzqlWrxo4dO3jooYfw9vbm9ddfByA6OprQ0FAqVKiAp6cnpUqVYujQoURHRyc5x+rVq2nSpAkFChQgT548VKpUKfEcaREWFkalSpXw8vKibt26bNiwIfG1tWvXYrPZ+Prrr5O97/PPP8dmsxEREZHqZ3z99ddcv36drl270qNHD7766itu3LiRrF7COKdly5ZRrVo1PD09qVq1KitXrkxWd926ddSrVw8vLy/Kly/Phx9+yKhRo7DZbKnGc/HiRYYMGUKpUqXw9PSkQoUKvPXWW+rWE7HDZhiGYXUQIpJ1WrVqRUREBJs3b6ZatWp3rDt69GhGjRpF48aN6dixIx4eHmzZsoVSpUoxceJEAEaNGsXo0aMJDAykffv27N27lw8++IA6deqwadMm3N3dATMp2rt3L3FxcfTo0YNq1arh6+tL27ZtadOmDT///DPPPvss999/P3/88QezZs3i0UcfZdmyZQDs3r2bOnXqUKNGDXr16oWnpycHDhxg69atrF+//o7fw2azUa1aNSIjIxk0aBCenp7MnDmT06dPs3XrVqpVq4ZhGJQpU4YGDRqwdOnSJO9/9NFH2bt3LwcOHEi1fdu0aUNsbCxr1qzhyJEj+Pv7s2jRIrp27Zosppo1a3L69GleeOEF8ubNy7Rp04iMjOTIkSMULlwYgF9//ZVGjRpRvHhxnn/+eeLi4pgxYwZFihTht99+49Yf4f7+/jRr1ox58+YB5p24Ro0acfz4cZ577jlKly7N5s2bmT9/PoMGDWLq1Kmpfh+RHMUQkRxl1apVhqurq+Hq6mo0atTIGDp0qPHjjz8aMTExSert37/fcHFxMTp27GjExcUleS0+Pt4wDMM4ffq04eHhYbRs2TJJnenTpxuAMXfu3MSygIAAAzBmzZqV5Fzz5883XFxcjI0bNyYpnzVrlgEYmzZtMgzDMKZMmWIAxpkzZ+76OwMGYGzfvj2x7PDhw4aXl5fRsWPHxLJhw4YZnp6exsWLFxPLTp8+bbi5uRmhoaGpfs6pU6cMNzc3Y/bs2YlljRs3Ntq3b283Jg8PD+PAgQOJZb/99psBGO+//35iWdu2bQ1vb2/j+PHjiWX79+833NzcjNt/hJcpU8bo06dP4vOxY8cauXPnNvbt25ek3muvvWa4uroaR44cSfU7ieQk6j4TyWGCgoKIiIigXbt2/Pbbb7z99tu0atUKPz8/vvnmm8R6y5YtIz4+npEjR+LikvRHRUK3zZo1a4iJiWHIkCFJ6vTr1498+fLx/fffJ3mfp6cnwcHBScqWLFnC/fffT+XKlTl79mzi4+GHHwbMbi0gsbtv+fLl6er6adSoEXXr1k18Xrp0adq3b8+PP/5IXFwcAL179yY6OjrJnaJFixZx8+ZNevbsmepnfPHFF7i4uNC5c+fEsscff5wVK1Zw4cKFZPUDAwMpX7584vMaNWqQL18+/v33XwDi4uJYs2YNHTp0oESJEon1KlSoQJs2bVKNZ8mSJTRt2pSCBQsmadvAwEDi4uKSdB+KiMYUieRI9evX56uvvuLChQts3bqVYcOGceXKFbp06cJff/0FmGOPXFxcqFKlSornOXz4MACVKlVKUu7h4UG5cuUSX0/g5+eHh4dHkrL9+/eze/duihQpkuRRsWJF4L/B3927d+fBBx/kmWeewdfXlx49erB48eI0J0j33XdfsrKKFSty7do1zpw5A0DlypWpX78+YWFhiXXCwsJ44IEHqFChQqqfkTD+6ty5cxw4cIADBw5Qu3ZtYmJiWLJkSbL6pUuXTlZWsGDBxATq9OnTXL9+3e5npyWe/fv3s3LlymRtmzDwO6sH1os4Os0+E8nBPDw8qF+/PvXr16dixYoEBwezZMkSQkNDM+XzcuXKlawsPj6e6tWrM3nyZLvvKVWqVOJ7N2zYwNq1a/n+++9ZuXIlixYt4uGHH2bVqlW4urpmSIy9e/dm8ODBHDt2jOjoaH755RemT5+e6vv279/Ptm3bAPsJWFhYGM8++2ySspRiNjJoqGd8fDxBQUEMHTrU7usJiaeImJQUiQgA9erVA+DkyZMAlC9fnvj4eP766y9q1apl9z1lypQBYO/evZQrVy6xPCYmhoMHD6ZpKnr58uX57bffaNGiRaqzqVxcXGjRogUtWrRg8uTJjB8/nuHDh7N27dpUP2v//v3Jyvbt24e3tzdFihRJLOvRowchISEsXLiQ69ev4+7uTvfu3VP9HmFhYbi7uzN//vxkyc7PP//MtGnTOHLkiN27QykpWrQoXl5edgd4p2XQd/ny5bl69aqWBBBJI3WfieQwa9eutXsn4ocffgD+6wrr0KEDLi4ujBkzJlkXVcL7AwMD8fDwYNq0aUnOOWfOHC5dusSjjz6aajzdunXj+PHjzJ49O9lr169fJyoqCoDz588nez0hWbt96r49ERER7Ny5M/H50aNHWb58OS1btkySxPj4+NCmTRsWLFhAWFgYrVu3xsfHJ9Xzh4WF0bRpU7p3706XLl2SPF555RUAFi5cmOp5buXq6kpgYCDLli3jxIkTieUHDhxgxYoVqb6/W7duRERE8OOPPyZ77eLFi9y8efOu4hHJ7nSnSCSHGThwINeuXaNjx45UrlyZmJgYNm/ezKJFi/D3908cCF2hQgWGDx/O2LFjadq0KZ06dcLT05Nt27ZRokQJJkyYQJEiRRg2bBijR4+mdevWtGvXjr179zJz5kzq16+fpsHJvXr1YvHixTz//POsXbuWBx98kLi4OPbs2cPixYv58ccfqVevHmPGjGHDhg08+uijlClThtOnTzNz5kxKlixJkyZNUv2catWq0apVqyRT8sFcduB2vXv3pkuXLgCMHTs21XNv2bKFAwcOpLi/mp+fH3Xq1CEsLIxXX3011fPdatSoUaxatYoHH3yQ/v37ExcXx/Tp06lWrRq7du2643tfeeUVvvnmGx577DGeeuop6tatS1RUFH/88QdLly7l0KFDaUr4RHIMaye/iUhWW7FihfH0008blStXNvLkyWN4eHgYFSpUMAYOHGicOnUqWf25c+catWvXNjw9PY2CBQsaAQEBxurVq5PUmT59ulG5cmXD3d3d8PX1Nfr3729cuHAhSZ2AgACjatWqdmOKiYkx3nrrLaNq1aqJn1O3bl1j9OjRxqVLlwzDMIzw8HCjffv2RokSJQwPDw+jRIkSxuOPP55surk9gPHiiy8aCxYsMO677z7D09PTqF27trF27Vq79aOjo42CBQsa+fPnN65fv57q+QcOHGgAxj///JNinVGjRhmA8dtvvyWJ6Xa3T6s3DPO7165d2/Dw8DDKly9vfPzxx8ZLL71keHl5pfreK1euGMOGDTMqVKhgeHh4GD4+Pkbjxo2NSZMmJVuGQSSn0+KNIiK3uXnzJiVKlKBt27bMmTPH6nDs6tChA7t377Y7VkpE0kdjikREbrNs2TLOnDlD7969rQ4FMMdW3Wr//v388MMPNGvWzJqARLIp3SkSEfmfLVu28PvvvzN27Fh8fHySDMy2UvHixXnqqacS13764IMPiI6O5tdff7U7/V9E0kcDrUVE/ueDDz5gwYIF1KpVK3H/MEfQunVrFi5cSGRkJJ6enjRq1Ijx48crIRLJYA57p2jGjBm88847REZGUrNmTd5//30aNGhgt+68efOSbR3g6elpd2dqEREREXscckzRokWLCAkJITQ0lJ07d1KzZk1atWp1xyXp8+XLx8mTJxMft28vICIiInInDpkUTZ48mX79+hEcHEyVKlWYNWsW3t7ezJ07N8X32Gw2ihUrlvjw9fXNwohFRETE2TncmKKYmBh27NjBsGHDEstcXFwIDAwkIiIixfddvXqVMmXKEB8fT506dRg/fjxVq1a1Wzc6OjrJCrjx8fGcP3+ewoULp7rNgIiIiDgPwzC4cuUKJUqUwMXlzveCHC4pOnv2LHFxccnu9Pj6+rJnzx6776lUqRJz586lRo0aXLp0iUmTJtG4cWN2795NyZIlk9WfMGGC3VVsRUREJHs6evSo3ZzgVg6XFKVHo0aNaNSoUeLzxo0bc//99/Phhx/aXaJ/2LBhhISEJD6/dOkSpUuX5uDBg+TNmzdDY4uNjWXt2rU0b94cd3f3DD23M1E7qA0SqB1Mage1QQK1Q+a2wZUrVyhbtmyafr87XFLk4+ODq6srp06dSlJ+6tQpihUrlqZzuLu7U7t27RR3kfb09MTT0zNZeaFChciXL9/dB30HsbGxeHt7U7hw4Rx7sYPaAdQGCdQOJrWD2iCB2iFz2yDhfGkZHuNwA609PDyoW7cu4eHhiWXx8fGEh4cnuRt0J3Fxcfzxxx8UL148s8IUERGRbMbh7hQBhISE0KdPH+rVq0eDBg2YOnUqUVFRiWsR9e7dGz8/PyZMmADAmDFjeOCBB6hQoQIXL17knXfe4fDhwzzzzDNWfg0RERFxIg6ZFHXv3p0zZ84wcuRIIiMjqVWrFitXrkwcfH3kyJEkI8gvXLhAv379iIyMpGDBgtStW5fNmzdTpUoVq76CiIiIOBmHTIoABgwYwIABA+y+tm7duiTPp0yZwpQpU7IgKhEREcmuHG5MkYiIiIgVlBSJiIiIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIiIiKAkiIRERERQEmRiIiICKCkSERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIiIiKAkiIRERERQEmRiIiICKCkSERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIlkjLg7b+vX4bdiAbf16iIuzOiIREbmNwyZFM2bMwN/fHy8vLxo2bMjWrVvT9L4vvvgCm81Ghw4dMjdAkbT66ivw98ctKIh6kyfjFhQE/v5muYiIOAyHTIoWLVpESEgIoaGh7Ny5k5o1a9KqVStOnz59x/cdOnSIl19+maZNm2ZRpCKp+Oor6NIFjh1LWn78uFmuxEhExGE4ZFI0efJk+vXrR3BwMFWqVGHWrFl4e3szd+7cFN8TFxfHk08+yejRoylXrlwWRiuSgrg4GDwYDCP5awllQ4aoK01ExEG4WR3A7WJiYtixYwfDhg1LLHNxcSEwMJCIiIgU3zdmzBiKFi1K37592bhx4x0/Izo6mujo6MTnly9fBiA2NpbY2Nh7/AZJJZwvo8/rbHJiO9jWr8ft9jtEtzIMOHqUm2FhGJ07g4dH1gVnoZx4LdijdlAbJFA7ZG4b3M05HS4pOnv2LHFxcfj6+iYp9/X1Zc+ePXbf8/PPPzNnzhx27dqVps+YMGECo0ePTla+atUqvL297zrmtFi9enWmnNfZ5KR28NuwgXppqOfWpw9GcDDXCxXiWtGiXC9alChfX64XLcq1okWJKlqUGz4+GK6umR5zVspJ18KdqB3UBgnUDpnTBteuXUtzXYdLiu7WlStX6NWrF7Nnz8bHxydN7xk2bBghISGJzy9fvkypUqVo2bIl+fLly9D4YmNjWb16NUFBQbi7u2fouZ1JTmwHW+7cMHlyqvUMd3dssbF4nz2L99mz8Ndfyeu4ukLJkhj+/lCmDEaZMuaxvz9GmTLg5wdOkjTlxGvBHrWD2iCB2iFz2yChNygtHC4p8vHxwdXVlVOnTiUpP3XqFMWKFUtW/59//uHQoUO0bds2sSw+Ph4ANzc39u7dS/ny5ZO8x9PTE09Pz2Tncnd3z7QLMjPP7UxyVDs0bgy5csH16/Zft9mgZEls//4L587BoUNw8KD539uObTExcPgwtsOH7Z/LzQ1KlzZntfn7Q9mySY+LFwcXxxpCmKOuhTtQO6gNEqgdMqcN7uZ8DpcUeXh4ULduXcLDwxOn1cfHxxMeHs6AAQOS1a9cuTJ//PFHkrI33niDK1eu8N5771GqVKmsCFskqYsXoWPHOydEAFOnmgmNr6/5aNgwed34eIiMtJsscfAgHDkCsbHw77/mwx4PDzNpuj1ZSjj29XW4pElEJKs5XFIEEBISQp8+fahXrx4NGjRg6tSpREVFERwcDEDv3r3x8/NjwoQJeHl5Ua1atSTvL1CgAECycpEscewYtGkDf/4JefPC//0fzJ2bdFp+yZJmQtSpU+rnc3GBEiXMR+PGyV+Pi4OTJ1O8y8SRIxATAwcOmA97vLygTJmU7zQVKfJfIncvbl3EMnduaN7cabr9RCT7c8ikqHv37pw5c4aRI0cSGRlJrVq1WLlyZeLg6yNHjuCiv2rFEe3eDa1bmwlQsWKwYgXUqgUjR3Jz7Vp2rVhBrTZtcMvIZOB/440oWRLsrdF186a5LlJKd5qOHYMbN2DvXvNhT65c9pOlhOPChVNPmr76CgYPxu3YMXMA+uTJZszvvZe25FBEJJM5ZFIEMGDAALvdZQDr1q2743vnzZuX8QGJpGbDBmjf3uw6q1zZTIj8/c3XXF0xAgI4HhVFzYCArL074uZm3gUqUwYCApK/HhtrJkYp3Wk6ftzsBvz7b/NhT548/yVI9pKnn36Crl2Tr9mUsIjl0qVKjETEcg6bFIk4laVL4cknzW6qxo3h22+hUCGro0obd3czcSlb1v7r0dFw9GjyZCnh+cmTcPWq2V3455/2z2GzpbyIpc1mLmLZvr260kTEUkqKRO7VtGnmL3XDgA4d4PPPze6m7MLTEypUMB/23LhhjltK6U7TqVP2E6IE/1vEko0boVmzDA9fRCStlBSJpFd8PLz2Grzzjvn8hRfMBCmn3e3w8oKKFc2HPfPmwf8mSdzRyZMZGpaIyN1SUiSSHjEx8PTTEBZmPh8/3kyQMmKGVnaTMK4qNcWLZ2oYIiKpUVIkcrcuXzYHBYeHm4OY58yB3r2tjspxNW1qzjI7fjzlbrRSpezPnBMRyUKa1y5yN06cgIceMhOiPHng+++VEKXG1dWcdg8p30l78cWc1+0oIg5HSZFIWv39NzRqBL/9Zq4AvX49tGxpdVTOoVMnc4aen1/S8oQB6R9+CJcuZX1cIiK3UFIkkhabNsGDD5qzrO67DzZvhjp1rI7KuXTqBIcOcXP1araHhHBz9Wpz1lnZsuZstX797jxLTUQkkykpEknN119DYCBcuGDuTbZ5M5QrZ3VUzilhEcuHHsIICDBXwv7iC3Ns1pIl8NFHVkcoIjmYkiKRO5k5Ezp3NtfiadvWXJnZx8fqqLKXBg1g4kTzeMgQuG2DZxGRrKKkSMQew4DXXzcHABsGPPusuXeXt7fVkWVP//d/8MgjZvLZrRtERVkdkYjkQEqKRG4XGwtPPQUTJpjPx4yBWbPMLh7JHC4u8OmnUKIE7NkDAwdaHZGI5EBKikRudeUKPPYYfPaZOUV8zhwYMUKLMmYFHx9zixQXF/jkE1iwwOqIRCSHUVIkkiAy0txFftUqs5vs22/NVasl6wQEwMiR5vHzz8O+fdbGIyI5ipIiETB/+TZqBL/+CkWKwLp10KaN1VHlTG+8YW4MGxUF3bub44xERLKAkiKRX36Bxo3NHd3Ll4eICKhf3+qoci5XV3NPOR8f2LULXnnF6ohEJIdQUiQ52zffwMMPw7lzUK+euQZR+fJWRyUlSsD8+ebx9OnmWlEiIplMSZHkXB9+CB07wvXr5nTwtWuhaFGro5IErVv/d5fo6afh8GFr4xGRbE9JkeQ8hmEO5n3+eYiPN3/hLl9ubvAqjuXNN81VxC9ehMcfN5dLEBHJJEqKJGeJjYW+fWHsWPP5yJHw8cdag8hRubub24Dkz2+O9RoxwuqIRCQbU1IkOcfVq9C+vbkGjouLuc/W6NFag8jR+fub60UBvPUW/PijpeGISPalpEhyhtOnoXlzWLECcuWCZcvMXdnFOXTuDP37m8e9esHJk9bGIyLZkpIiyf4OHDCn3G/fbu7KvnatubmrOJfJk6FGDThzBnr2hLg4qyMSkWxGSZFkb1u3mgnRP/9A2bLmlPuGDa2OStLDywsWL4bcueGnn/7bm05EJIMoKZLs6/vvzS6zM2egTh1zoG7FilZHJfeiUiWYOdM8Dg2FjRutjUdEshUlRZI9zZljDqq+dg1atTK37fD1tToqyQi9e5uP+Hhzmv7Zs1ZHJCLZhJIiyV4MA8aMgWeeMcec9OljbuyaN6/VkUlGmjHDvGt0/DgEB5v/30VE7pGSIsk+bt6E554zu1UAXn/dnH7v7m5tXJLx8uSBRYvA0xO++w6mTrU6IhHJBpQUSfYQFWVu2TF7trkG0cyZ5mrIWoMo+6pZ05yRBvDqq+bsQhGRe6CkSJzfmTPQooV5x8DLC7788r81bSR769/fXMMoNha6d4dLl6yOSEScmJIicW7//gsPPghbtkChQhAeDh06WB2VZBWbzdymxd/fvBaee07ji0Qk3ZQUifPasQMaNYL9+6FMGdi0yVyTSHKWAgXM/dHc3MxxRh9/bHVEIuKklBSJc1q5EgICzO07atUy1yCqXNnqqMQqDRvC+PHm8aBB8Oef1sYjIk5JSZE4n08/NbfpiIqCwEBYvx6KF7c6KrHaSy9BmzZw4wZ062ZeHyIid0FJkTgPwzDvBjz1lDn9/sknzVWr8+WzOjJxBC4uZsJcvDj8/bd5x0hE5C4oKRLnEBcHL74Iw4ebz199FT77DDw8rI1LHEuRIhAWZg7AnjsXPv/c6ohExIkoKRLHd/06dOkCH3xg/rKbNg0mTjTvDIjcrnlzGDHCPH7uOXMgvohIGui3iji2c+fMcUPLlpmrFy9ZAgMHWh2VOLoRI+Chh+DqVejRA6KjrY5IRJyAkiJxXIcOmWsQbd5sTrtevdpcqE8kNW5uZtdZ4cKwcycMHWp1RCLiBJQUiWPatctcg2jvXihVCn7+GZo2tToqcSZ+fua4MzC7XJctszQcEXF8SorE8axZY3Z9REZC9ermGkRVq1odlTijRx4xp+oDPP00HDlibTwi4tCUFIljWbDAXGvmyhVzwOzGjeZf/CLpNX48NGgAFy7A44+b+6SJiNihpEgcg2HA229Dr17mGkQ9esCKFZA/v9WRibPz8ICFC831rDZvhtBQqyMSEQelpEisFxcHgwebaw+B2d0RFmbONhPJCOXK/bcn2sSJ5qB9EZHbKCkSa924Ad27w/vvm88nT4ZJk7QGkWS8rl3NdYsMA3r2NMesiYjcQr95xDoXLkDLlvDll2YXxxdfwP/9n9VRSXY2ZYo5eP/0abOrNj7e6ohExIEoKRJrHDkCTZqYA6nz54cffzTvGIlkply5YPFi8PY2ZzlOnGh1RCLiQBw2KZoxYwb+/v54eXnRsGFDtm7dmmLdr776inr16lGgQAFy585NrVq1mD9/fhZGK3cUF4dt/Xr8NmzAtn49/PqruQbRX3+ZM8s2boRmzayOUnKKypVhxgzzeORIcw0sEREcNClatGgRISEhhIaGsnPnTmrWrEmrVq04ffq03fqFChVi+PDhRERE8PvvvxMcHExwcDA//vhjFkcuyXz1Ffj74xYURL3Jk3ELCoK6deHECXPtoYgIsztDJCv16WOOK4qLM6fpnztndUQi4gAcMimaPHky/fr1Izg4mCpVqjBr1iy8vb2ZO3eu3frNmjWjY8eO3H///ZQvX57BgwdTo0YNftZfgNb66itzI9djx5KWG4b536FDzdWqRbKazQYzZ8J995nX59NP/3ddikiO5XBJUUxMDDt27CAwMDCxzMXFhcDAQCIiIlJ9v2EYhIeHs3fvXh566KHMDFXuJGGafUq/aGw2eOMNs56IFfLmNccXeXjAN9+YW4GISI7mZnUAtzt79ixxcXH4+vomKff19WXPnj0pvu/SpUv4+fkRHR2Nq6srM2fOJCgoyG7d6Ohoom/ZNfvy5csAxMbGEpvBq90mnC+jz+vobOvX43b7HaJbGQYcPcrNtWsxAgKyLjAL5dRr4XYO1Q5Vq+Ly9tu4DhmC8cor3HzgAahTJ0s+2qHawSJqA5PaIXPb4G7O6XBJUXrlzZuXXbt2cfXqVcLDwwkJCaFcuXI0szOAd8KECYwePTpZ+apVq/D29s6U+FbnsMXi/DZsoF4a6u1asYLjUVGZHo8jyWnXQkocph3KlKH+Aw9Q4pdfiO7QgfWTJ3Mzk34O2OMw7WAhtYFJ7ZA5bXDt2rU017UZhmN1pMfExODt7c3SpUvp0KFDYnmfPn24ePEiy5cvT9N5nnnmGY4ePWp3sLW9O0WlSpXi7Nmz5MuX756/w61iY2NZvXo1QUFBuLu7Z+i5HZlt/XpzUHUqbq5enaPuFOXEa+F2DtkOFy7g1qABtsOHie/enbjPPjO7eDORQ7ZDFlMbmNQOmdsGly9fxsfHh0uXLqX6O97h7hR5eHhQt25dwsPDE5Oi+Ph4wsPDGTBgQJrPEx8fnyTxuZWnpyeedraQcHd3z7QLMjPP7ZCaN4eSJZMPsk5gs0HJkrg1bw6urlkbm8Vy3LWQAodqh6JFzf3RmjbFZdEiXIKCoG/fLPloh2oHi6gNTGqHzGmDuzmfww20BggJCWH27Nl8+umn/P333/Tv35+oqCiCg4MB6N27N8OGDUusP2HCBFavXs2///7L33//zbvvvsv8+fPp2bOnVV9BXF2hWzf7ryX8BT51ao5LiMSBNWoEb75pHg8cCLt3WxuPiGQ5h7tTBNC9e3fOnDnDyJEjiYyMpFatWqxcuTJx8PWRI0dwuWVvrKioKF544QWOHTtGrly5qFy5MgsWLKC7Vki2zs2b8P335nG+fPC/weyAeQdp6lTo1MmS0ERS9MorsHatucJ6t26wbZu5+rWI5Aj3nBR9/fXXLFy4kD179nDt2jUOHDgAwJ49e/jmm2948skn8fPzu+vzDhgwIMXusnXr1iV5Pm7cOMaNG3fXnyGZKCwM9u6FwoVh/35u7tjBrhUrqNWmTY7sMhMn4eICn30GNWuaK64PHgyzZ1sdlYhkkXQnRfHx8Tz++OMsXboUgFy5cnH9+vXE1wsWLMjw4cOJi4tL0tUlOUBMDCTM7nv1VShYECMggONRUdQMCFBCJI6taFFYsACCguDjj6FFC+jRw+qoRCQLpHtM0ZQpU1iyZAnPPfccFy5c4OWXX07yuq+vL02bNuX7hC4UyTk++QQOHoRixeDFF62ORuTutWgBw4ebx88+C/+7Ay4i2Vu6k6J58+ZRv359Zs6cSb58+bDZmb5aoUIFDh48eE8BipO5cQPGjjWPhw/XeAxxXqGh0LQpXLli3ilKYTariGQf6U6KDhw4QNOmTe9Yp3DhwpzTRos5y6xZcPy4uadZv35WRyOSfm5u8Pnn5ri4HTvgtdesjkhEMlm6k6JcuXJx6dKlO9Y5fPgwBQoUSO9HiLO5ehUmTDCPR44EO2tBiTiVkiVh3jzzeOpUc480Ecm20p0U1a5dmx9//JEbN27Yff38+fOsXLmSBx54IN3BiZOZPh1On4by5aFPH6ujEckYjz0G//d/5nFwMBw9am08IpJp0p0UDRo0iGPHjtG5c2eO3bZq8T///EPHjh25dOkSgwYNuucgxQlcvAhvv20ejxoFOXxVVslmJk6EevXg/Hl4/HFzHS4RyXbSPSW/ffv2vPrqq7z11luUKVOG3LlzA1C0aFHOnTuHYRiMGDGChx9+OMOCFQc2ZQpcuABVqpi/NESyEw8P+OILqF0bNm0yE3+tjSaS7dzTNh8TJkzgxx9/5LHHHsPb2xtXV1fi4+Np3bo1K1assLsTvWRDZ8+aSRHAmDFah0iyp/Ll/1vIcfx4WLPG2nhEJMOl+07RkSNH8PDwICgoiKA07IYu2dg775jTlmvXho4drY5GJPN07w7h4WZy1LMn/PYb/G/7IRFxfum+U1S2bFlef/31jIxFnNHJk/D+++bx2LHmNgki2dnUqVCtGpw6Bb16QXy81RGJSAZJ92+wggULUrhw4YyMRZzRhAlw/bq5w/gjj1gdjUjm8/aGRYsgVy5YvRreesvqiEQkg6Q7KWratClbtmzJyFjE2Rw5Ah9+aB6PGwd2VjUXyZaqVDGXoAAYMcIcfC0iTi/dSdGECRP4/fffGTNmDDc1PTVnGjfO3Py1eXPQLEPJaYKD4YknIC7OnHF5/rzVEYnIPUr3QOu3336b6tWrM3r0aD788ENq1qyJr69vsj3QbDYbc+bMuedAxcEcOABz55rHmposOZHNZm5rs3Wr+e+hb1/46ivdMRVxYulOiuYlLH0PnDx5kpMnT9qtp6Qomxo92vwL+ZFHoHFjq6MRsUbevOb4okaNYNkys0tt4ECroxKRdEp3UnTw4MGMjEOcyV9/QViYeTxmjLWxiFitTh1zWYrBg+Hll+HBB80yEXE66U6KypQpk5FxiDMJDQXDgE6doG5dq6MRsd7AgfDTT7B8ubmW0c6d5l0kEXEqWlRG7s6vv8LSpea4Cd0lEjHZbOYYu1KlzPFFzz9v/uEgIk7lnpOisLAwgoKCKFKkCJ6enhQpUoSWLVvy+eefZ0R84mhGjDD/+8QTULWqtbGIOJJChcz90Vxd4fPP4ZNPrI5IRO5SupOiuLg4OnfuTO/evQkPDycqKooSJUoQFRXFmjVr6NWrF507dyZeq71mHxER8P335g/90FCroxFxPI0bmyu7AwwYYI6/ExGnke6kaNq0aXz99dc8+OCDbNq0iWvXrnHw4EGuXbvG5s2badKkCcuWLeP9hC0gxPkl3CV66im47z5LQxFxWK++CkFB5krv3bub/xURp5DupOjTTz+lYsWKhIeH06hRoySvPfDAA6xZs4aKFSvyiW4hZw9r15obYbq7/5cciUhyLi4wf765Ueyff8KQIVZHJCJplO6kaN++fbRr1w53d3e7r7u7u9O2bVv27duX7uDEQRgGvPGGefzss6CZhyJ35usLCxaYA7A/+ggWL7Y6IhFJg3QnRR4eHkRFRd2xTlRUFB4eHun9CHEUK1fC5s3g5QXDh1sdjYhzCAyEYcPM43794J9/rI1HRFKV7qSodu3aLF68mBMnTth9/eTJkyxevJg6WsTMud16l2jAAChe3Np4RJzJ6NHmYo6XL0OPHuZegSLisNKdFIWEhHDu3Dnq1avHu+++y/bt2zl69Cjbt29n0qRJ1K1bl/PnzxMSEpKR8UpWW7bMXIguTx4YOtTqaESci5sbLFxoTtffvh1ee83qiETkDtK9onXbtm2ZNGkSr732GkNv+2VpGAZubm5MmjSJxx577J6DFIvExf03qHrIEChSxNJwRJxSqVLmmkXt28OUKfDww9CmDbb16/HbsAFb7tzQvLm51IWIWCrdSRGYd4s6dOhAWFgYu3bt4vLly+TLl4/atWvzxBNPUK5cuYyKU6ywaBHs3g0FCsBLL1kdjYjzatfO3Bvtvffg8cchb17cTp6kHsDkyVCypPlap05WRyqSo91TUgRQrlw5RmiKdvZz8+Z/CzS+8oqZGIlI+r31FnzzDRw8CFevJn3t+HHo0sXcQkeJkYhltPeZ2PfZZ+YeTj4+MGiQ1dGIOD83t5QXckzYJ23IELPbWkQske6k6N1338XHxyfF2WcnTpygSJEiTJs2Ld3BiUWio81ZM2BOKc6Tx9p4RLKDjRshMjLl1w0Djh4164mIJdKdFC1ZsoSaNWtSokQJu6+XKFGCWrVq8cUXX6Q7OLHIxx/DkSNQogT07291NCLZw8mTGVtPRDJcupOi/fv3UzWVXdKrVq3K/v370/sRYoVr12DcOPP4jTcgVy5r4xHJLtK6xpfWAhOxTLqTouvXr5M7d+471vHy8uLq7QMKxbF98IF5i79MGejb1+poRLKPpk3NWWY2m/3XbTZz+n7Tplkbl4gkSndSVLp0aTZv3nzHOhEREZQsWTK9HyFZ7coVmDjRPA4NBW3RIpJxXF3NafdgPzEyDJg0SesViVgo3UnRo48+ys8//8zcuXPtvv7xxx/z888/07Zt23QHJ1nsvffg7FmoWBF69bI6GpHsp1Mnc9q9n1/S8oQk6ZtvID4+6+MSEeAe1il67bXXWLhwIf369WPBggUEBQXh5+fH8ePHWbVqFRs2bKBEiRIMS9gQURzbhQvmX6lgzjxzu+clrETEnk6doH17bq5dy64VK6jVpg1usbHmAo9hYWYX2oQJVkcpkiOl+zdfkSJFWLt2LT179mTdunWsW7cOm82G8b/1NurXr09YWBhFtDWEc3j3Xbh0CapVg27drI5GJHtzdcUICOB4VBQ1AwLA3R1mz4bgYLMLu1QpeOEFq6MUyXHu6XZApUqV2LZtG9u2bWPr1q1cunSJAgUK0KBBA+rVq5dRMUpmO30apk41j8eOBRet6SmS5Z56ylynaORIGDjQ7GJr397qqERylAzpI6lfvz7169fn5s2b/PHHHwDExsbi7u6eEaeXzPbWWxAVBfXq6YewiJXeeMNMjGbPhh494KefoFEjq6MSyTHu6pbAwYMHmTt3Lvv27Uv22nfffYefnx/16tWjXr16FC9enMWLF2dYoJJJjh+HmTPN43HjUp4uLCKZz2Yz/z0+8gjcuAFt24Kdn7cikjnuKimaPXs2/fr1w9PTM0n5gQMH6NatG2fOnKF06dLcf//9XLhwgSeffJJff/01QwOWDDZ+vPnDt0kTaNnS6mhExM0NFi0y79yeOwdt2phd3CKS6e4qKfr555+pVasWZcqUSVL+3nvvcePGDV588UUOHjzIn3/+yZdffklcXBzTp0/P0IAlAx06ZN6mB90lEnEkefLAd99BuXLw77/w2GNmF7eIZKq77j5r0KBBsvKVK1fi4eHB+PHjE8s6dOhA06ZN2ajNDR3XmDEQGwuBgRAQYHU0InIrX19YsQIKF4Zt26B7d7h50+qoRLK1u0qKzpw5g4+PT5Ky8+fP888//9CwYUPy5s2b5LXatWtz/Pjxe49SMt6+ffDpp+Zxwl5nIuJYKlaEb78FLy/4/ntzmv7/lj0RkYx3V0mRu7s7586dS1K2Y8cOALtT8FPbG00sNGqUuXJu27bQsKHV0YhISho1goULzaUyZs+GN9+0OiKRbOuukqKKFSsSHh6epGzVqlXYbDYaN26crP6JEycorh2fHc8ff8AXX5jHY8ZYG4uIpK5DB5g2zTweMQLmzbMyGpFs666Sos6dO7N//36ef/55fv/9d5YuXcpHH31Enjx5aN26dbL6mzZtokKFCukKbMaMGfj7++Pl5UXDhg3ZunVrinVnz55N06ZNKViwIAULFiQwMPCO9XO8kSPNW/Bdu0KtWlZHIyJp8eKL8Oqr5nG/frBqlbXxiGRDd5UUDRkyhOrVq/PRRx9Ru3ZtunfvzpUrVxg9enSyrrLt27dz4MABgoKC7jqoRYsWERISQmhoKDt37qRmzZq0atWK0ylMS123bh2PP/44a9euJSIiglKlStGyZUuNZ7Jn+3ZYtsy8FT96tNXRiMjdGD8ennjCHHDduTPs2mV1RCLZyl0lRd7e3mzatInRo0fTunVrnnzySZYvX86QIUOS1d25cyft27enXbt2dx3U5MmT6devH8HBwVSpUoVZs2bh7e3N3Llz7dYPCwvjhRdeoFatWlSuXJmPP/6Y+Pj4ZF19gnnrHaBnT7j/fmtjEZG74+ICc+dC8+Zw9aq5htHhw1ZHJZJt3PU2H3ny5GFEwi/WO3j22Wd59tln7zqgmJgYduzYwbBhwxLLXFxcCAwMJCIiIk3nuHbtGrGxsRQqVMju69HR0URHRyc+v3z5MmBuTRIbG3vXMd9Jwvky+rzpYdu0CbeVKzHc3Lg5bJg5HT+LOFI7WEVtYFI7mNLdDi4usHgxbs2bY/vzT4zWrbm5bh2k8PPOkelaMKkdMrcN7uacNsNwrPmdJ06cwM/Pj82bN9Polj1/hg4dyvr169myZUuq53jhhRf48ccf2b17N15eXsleHzVqFKPtdB19/vnneHt739sXcFSGwYNvvIHP7t0catmS37QDt4hT8zp7lodefZVc585xtkoVIkaNIt7Dw+qwRBzOtWvXeOKJJ7h06RL58uW7Y90M2RDWkUycOJEvvviCdevW2U2IAIYNG0ZISEji88uXLyeOQ0qtwe5WbGwsq1evJigoyNINcm3h4bjt3o3h6YnfrFn4lSyZpZ/vKO1gJbWBSe1gypB2qF0bo3lzfP76i0cXLSIuLMy8k+QkdC2Y1A6Z2wYJvUFp4XBJkY+PD66urpw6dSpJ+alTpyhWrNgd3ztp0iQmTpzImjVrqFGjRor1PD09k+3fBuY6TJl1QWbmuVNlGOa6RIDt+edxL1vWmjiwuB0chNrApHYw3VM71KljTpxo1QqXL7/EpXRpmDw5Q+PLCroWTGqHzGmDuzmfw/1J4eHhQd26dZMMkk4YNH1rd9rt3n77bcaOHcvKlSvtLiSZo33/PWzZAt7e8NprVkcjIhmpefP/1i2aMsV8iEi6OFxSBBASEsLs2bP59NNP+fvvv+nfvz9RUVEEBwcD0Lt37yQDsd966y1GjBjB3Llz8ff3JzIyksjISK5evWrVV3Ac8fHwxhvm8cCBkMrdNhFxQk88AW+9ZR6/9BIsWWJtPCJOyuG6zwC6d+/OmTNnGDlyJJGRkdSqVYuVK1fi6+sLwJEjR3C5pd/8gw8+ICYmhi5duiQ5T2hoKKP+122UY335Jfz2G+TLB0OHWh2NiGSWV16BI0dgxgzo1cv8A6hpU6ujEnEqDpkUAQwYMIABAwbYfW3dunVJnh86dCjzA3JGcXHm6tUAISFOOWVXRNLIZoP33oPjx81xRu3awaZNUKWK1ZGJOA2H7D6TDPL557Bnj5kM2VlgU0SyGVdX8999o0Zw8aK5uOOJE1ZHJeI0lBRlV7GxiTPOGDoU8ue3NBwRySK5csE338B995ndaY8+CncxJVkkJ1NSlF198gn8+y/4+kIK3ZAikk35+MDKlVC0qLk/WpcuWbqCvYizUlKUHd24AWPHmsevvw63bdYrIjlAuXLmchze3rB6NfTrZ65ZJiIpUlKUHX30ERw7BiVLQjr2nxORbKJePXN6vqsrfPrpfxMvRMQuJUXZTVQUvPmmeTxiBKSw1YmI5BCPPAKzZpnH48aZfzSJiF1KirKb6dPh9Gnz1vn/FrsUkRzumWf+u0vUvz9895218Yg4KCVF2cmlS/+tajtqFOTwPXRE5BajRsFTT5mr3HfvDtu2WR2RiMNRUpSdTJ0KFy5A5crmsv8iIglsNrPrrGVLuHbNnKr/zz9WRyXiUJQUZRfnzsG775rHY8aYAytFRG7l7g5Ll0Lt2nDmDLRubf5XRAAlRdnHO+/AlStQsyZ07mx1NCLiqPLmNafqlykDBw6Y24Fcu2Z1VCIOQUlRdhAZCdOmmcfjxoGL/reKyB0ULw4rVkDBgvDLL2Z3e1yc1VGJWE6/PbODiRPh+nVo2NAcJyAikpr77ze3A/H0hOXLYeBALe4oOZ6SImd39Ch88IF5PG6cOZhSRCQtmjSBsDDz58YHH8Dbb1sdkYillBQ5u3HjICYGAgKgRQuroxERZ9O5M0yZYh6/9pqZJInkUEqKnNk//8Dcueax7hKJSHoNHgwhIeZxcDCEh1sbj4hFlBQ5szFj4OZNc1ptkyZWRyMizuydd6BbN4iNhU6d4PffrY5IJMspKXJWf/8NCxaYx2PHWhuLiDg/Fxdz09iHHoLLl809044etToqkSylpMhZhYaay/V36GDuhC0icq+8vGDZMnNm2vHj0KYNXLxodVQiWUZJkTPatQuWLDHHEI0ZY3U0IpKdFCwIK1eaaxnt3g0dO0J0tNVRiWQJJUXOKGG36x49oHp1a2MRkeyndGn44Qdz9et16/7bSFYkm1NS5Gy2bIFvvzX7/0eNsjoaEcmuatWCL78ENzf44gsYNszqiEQynZIiZ/PGG+Z/+/SBihWtjUVEsregIJgzxzx++22YPt3aeEQymZIiZ7JuHaxZY+50ndCFJiKSmXr3NtdBAxg0CL7+2tp4RDKRkiJnYRgwYoR53K8f+PtbGo6I5CCvvw7PPWf+HHriCdi82eqIRDKFkiJnsWoV/PyzOWV2+HCroxGRnMRmM7vOHnsMbtyAtm1h716roxLJcEqKnIFh/DeW6IUXoEQJa+MRkZwnYcB1gwZw/ry5kn5kpNVRiWQoJUXOYPly2L4dcueGV1+1OhoRyaly5zZnv5YvD4cOmXeOrl61OiqRDKOkyNHFx/83lmjIECha1NJwRCSHK1rUXNzRxwd27DD3S7t50+qoRDKEkiJHt3gx/Pkn5M8PL71kdTQiIlChAnz3HeTKBStWwPPPm938Ik5OSZEju3nT3OMM4OWXzeX3RUQcQcOG5hgjFxdzLSNtTC3ZgJIiRzZ/PuzbZ96mHjzY6mhERJJq1w5mzDCPQ0Phk0+sjUfkHikpclQxMTB6tHn82mvmHkQiIo7m+ef/2wKkXz9zvJGIk1JS5KjmzIHDh82dqvv3tzoaEZGUvfkm9OwJcXHQpQvs3Gl1RCLpoqTIEV2//t+y+sOHg7e3tfGIiNyJzWb+IdeiBURFwSOPmFP2RZyMkiJH9MEHcOIElC4NzzxjdTQiIqnz8IAvv4QaNeDUKXNxx/PnrY5K5K4oKXI0V6/ChAnm8ciR4OlpbTwiImmVPz/88AOULGluA9KunXnnW8RJKClyNNOmwdmz5jogffpYHY2IyN3x8zMHW+fPD5s2/TfWSMQJKClyJBcvwjvvmMejR5t7DYmIOJuqVWHZMrNL7auvICREizuKU1BS5EjefddMjKpWhe7drY5GRCT9mjWDTz81j6dNg8mTLQ1HJC2UFDmKM2dg6lTzeMwYcHW1NBwRkXvWo8d/d79fftlcAVvEgSkpchRvv20Osq5TBzp2tDoaEZGM8dJLMHCgedynD6xfb208InegpMgRnDgB06ebx+PGmWt+iIhkBzYbTJkCnTqZK/V36AC7d1sdlYhdSoocwfjxcOMGNG5sru0hIpKduLrCggXmz7iLF6FNGzhyBNv69fht2IBt/XrNUBOHoKTIaocPw0cfmce6SyQi2VWuXPDNN1CpEhw9ChUq4BYURL3Jk3ELCgJ/f3OmmoiFlBRZbexYiI01l8dv3tzqaEREMk/hwjB4sHkcG5v0tePHzX3TlBiJhZQUWWn/fpg3zzweO9bSUEREMl1cnDlcwJ6EdYyGDFFXmlhGSZGVRo0y//E/+ig0amR1NCIimWvjRjh2LOXXDcPsWtu4MetiErmFQyZFM2bMwN/fHy8vLxo2bMjWrVtTrLt79246d+6Mv78/NpuNqQlr/Ti6P/+EhQvNY90lEpGc4OTJtNU7dChTwxBJicMlRYsWLSIkJITQ0FB27txJzZo1adWqFadPn7Zb/9q1a5QrV46JEydSrFixLI72HoSGmn8VdekCtWtbHY2ISOYrXjxt9UJCzGn82kxWspjDJUWTJ0+mX79+BAcHU6VKFWbNmoW3tzdz5861W79+/fq888479OjRA09n2VF+xw5zMKHNZu5xJiKSEzRtCiVL3nmWrasrXLhgJkbly8P775tLlohkAYfacTQmJoYdO3YwbNiwxDIXFxcCAwOJiIjIsM+Jjo4mOjo68fnly5cBiI2NJfb2GRH3KOF8t57X9Y03cAHiH3+cuPvuSz4LIxuy1w45jdrApHYw5dR2sL37Lq49eoDNhu2WTWKN/yVKcfPnw+XLuI4fj+3IERg0COOtt4h/9VXig4PBWf74vQs59Vq4VWa2wd2c06GSorNnzxIXF4evr2+Scl9fX/bs2ZNhnzNhwgRG27lDs2rVKry9vTPsc261evVqAAr9/TdNV64k3sWFn5o2JeqHHzLl8xxVQjvkZGoDk9rBlOPawdOT4kOHUv3jj8l17lxi8fXChfmzb19OenuDtze2d9+lTHg4FZcsIdfx47gOGkT0mDHs69qVIw8/jOHubuGXyBw57lqwIzPa4Nq1a2mu61BJUVYZNmwYISEhic8vX75MqVKlaNmyJfny5cvQz4qNjWX16tUEBQXh7u6Oa8JA8KeeIqBv3wz9LEd2ezvkRGoDk9rBlKPb4ZFHYNQobqxbx5+rV1MtKAj3Zs2o7epKkhGW7dvDO+8QN3cuLm+9hfeJE9T64ANq/vADca+/jtGzJ2SDtsvR18L/ZGYbJPQGpYVDJUU+Pj64urpy6tSpJOWnTp3K0EHUnp6edscfubu7Z9oF6e7ujvvGjbBuHXh44BIaiksOvPgzs42dhdrApHYw5dh2cHeHFi04Hh1NzRYtUm4Dd3cYNAj69TNX/584Edvhw7g99xy89RaMGAE9e4KbQ/06S5ccey3cIjPa4G7O51ADrT08PKhbty7h4eGJZfHx8YSHh9PI2dfxMQwYPtw8fu45KF3a2nhERJxJrlzmatj//APvvgtFi8K//0JwMNx/P8yfr0Uf5Z45VFIEEBISwuzZs/n000/5+++/6d+/P1FRUQQHBwPQu3fvJAOxY2Ji2LVrF7t27SImJobjx4+za9cuDhw4YNVXsMu2YgX88ov5D/uW+EVE5C54e5sz0/79F95+G3x84MAB6N0bqlY1139TciTp5HBJUffu3Zk0aRIjR46kVq1a7Nq1i5UrVyYOvj5y5Agnb1kA7MSJE9SuXZvatWtz8uRJJk2aRO3atXnmmWes+gr/iYszd4Fevx7Xl14yywYMSPtaHSIiYl/u3PDKK3DwIEyYAIUKwd698MQTUL06LF4M8fFWRylOxiE7YQcMGMCAAQPsvrZu3bokz/39/TFumdbpML76CgYPxu3YMeollNls5l8yIiKSMfLkgddegxdeMNc0mjQJ/v4buneHatXM7ZQ6dgQXh7sHIA5IV0lm+Oorc6Xq2/f4MQyz/1u7QIuIZKx8+cxxm4cOmYlQ/vzmdkpdukCdOrBs2X+bzoqkQElRRouLMwcD3ukfn3aBFhHJHPnzm9soHTxozkzLmxd++828W1SvHnz7rZIjSZGSooymXaBFRKxXsCCMGWMmR6+/bo5B2rkT2rWDBg1gxQolR5KMkqKMltZdoNNaT0RE0q9wYXjzTbNb7dVXzdlr27ebC0g2agSrVik5kkRKijJaWmeWaQaaiEjW8fGBiRPNO0cvvWQuj7JlC7RqZW5UGx6u5EiUFGW41HaBttmgVCmznoiIZK2iRc0Zav/+a47v9PSETZsgMBCaNYP1662OUCykpCijubrCe++Zx7cnRgnPp04164mIiDWKFYMpU8zkaOBA8PCADRvMxOjhh+Hnn62OUCygpCgzdOoES5eCn1/S8pIlzfJOnayJS0REkipRAqZNM7cP6d/f3Gtt7Vrzbn7LlhARYXWEkoWUFGWWTp3g0CFurl7N9pAQbq5ebfZlKyESEXE8JUvCzJmwfz88+6y5wezq1dC4MbRpA1u3Wh2hZAElRZnJ1RUjIIDjDz2EERCgLjMREUdXpgx8+CHs2wd9+5o/t1euhIYN4bHHYMcOqyOUTKSkSERE5HZly8LHH5v7qfXpY24T8v335gKQ7dvDrl1WRyiZQEmRiIhISsqXh3nzzP3UevY0k6NvvoHataFzZ/jjD6sjlAykpEhERCQ1FSvC/Pmwezc8/rg5m/irr6BGDejWzSwXp6ekSEREJK0qV4bPPzfvEHXrZpYtWQLVq5vJ0p491sbnjOLisK1fj9+GDdjWr7d0b1AlRSIiIneralVYtMjcbLZTJ3M17C++MMt79TJnsUnqvvoK/P1xCwqi3uTJuAUFgb+/WW4BJUUiIiLpVaMGfPkl/PqrOQA7Ph4WLDDvKD31lLn+kdj31VfQpUvyTdSPHzfLLUiMlBSJiIjcq1q1YNkyc7PZxx4zk6NPP4VKlcyp/QcPWh2hYzAMiIqCI0fghRfs7zeXUDZkSJZ3pbll6aeJiIhkZ3Xrwrffmos9jhoFK1bA3Lnw2WcQHAzDh5trISW4dTxN7tzQvLljr2mXkNRcvJj649Il++U3b6btc44ehY0bza1XsoiSIhERkYzWoAH88IO5TUhoqLk69uzZ5vT+Z56B1183E6fBg3E7dox6AJMnmytrv/de5u1+EB8PV6+mPYGxVy8j7t7YbPbvEt3u5Ml7/6y7oKRIREQkszRqBKtWmRvMhobCTz/BBx+YCZK9OyYJ42lS2iczPh4uX767JOb25/Hx9/693NygYEEoUCDpI3/+5GX2Hlu3mhvvpqZ48XuP9S4oKRIREclsTZpAeDisXw8jRpjdQvYk3D3p1csck3R7UnP5ctrusKTGwyNtyUtKiU6uXObdnvR66CHzrtjx4/a/j81mvt60afo/Ix2UFImIiGSVgAAYPTr1uyTXrpkrZ6fEyyt9d2gSHl5e9/pN7o2rq9lN2KVL8q60hGRr6tQsH1+lpEhERCQrRUamrV7fvhAUZP/OjdVJTUbo1MnsJhw8OOm0/JIlzYQos8ZV3YGSIhERkayU1nEyPXtm6cwrS3TqBO3bc3PtWnatWEGtNm1ws3AGnpIiERGRrNS0qUOOp7GMqytGQADHo6KoGRBg6ZIEWrxRREQkKyWMp4Hkg5UtHE8jSopERESyXsJ4Gj+/pOUlS6Y8HV8ynbrPRERErOBg42lESZGIiIh1HGg8jaj7TERERARQUiQiIiICKCkSERERAZQUiYiIiABKikREREQAJUUiIiIigJIiEREREUBJkYiIiAigpEhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgI4cFI0Y8YM/P398fLyomHDhmzduvWO9ZcsWULlypXx8vKievXq/PDDD1kUqYiIiGQHDpkULVq0iJCQEEJDQ9m5cyc1a9akVatWnD592m79zZs38/jjj9O3b19+/fVXOnToQIcOHfjzzz+zOHIRERFxVg6ZFE2ePJl+/foRHBxMlSpVmDVrFt7e3sydO9du/ffee4/WrVvzyiuvcP/99zN27Fjq1KnD9OnTszhyERERcVYOlxTFxMSwY8cOAgMDE8tcXFwIDAwkIiLC7nsiIiKS1Ado1apVivVFREREbudmdQC3O3v2LHFxcfj6+iYp9/X1Zc+ePXbfExkZabd+ZGSk3frR0dFER0cnPr906RIA58+fJzY29l7CTyY2NpZr165x7tw53N3dM/TczkTtoDZIoHYwqR3UBgnUDpnbBleuXAHAMIxU6zpcUpQVJkyYwOjRo5OVly1b1oJoREREJLNduXKF/Pnz37GOwyVFPj4+uLq6curUqSTlp06dolixYnbfU6xYsbuqP2zYMEJCQhKfx8fHc/78eQoXLozNZrvHb5DU5cuXKVWqFEePHiVfvnwZem5nonZQGyRQO5jUDmqDBGqHzG0DwzC4cuUKJUqUSLWuwyVFHh4e1K1bl/DwcDp06ACYSUt4eDgDBgyw+55GjRoRHh7OkCFDEstWr15No0aN7Nb39PTE09MzSVmBAgUyIvwU5cuXL8de7LdSO6gNEqgdTGoHtUECtUPmtUFqd4gSOFxSBBASEkKfPn2oV68eDRo0YOrUqURFRREcHAxA79698fPzY8KECQAMHjyYgIAA3n33XR599FG++OILtm/fzkcffWTl1xAREREn4pBJUffu3Tlz5gwjR44kMjKSWrVqsXLlysTB1EeOHMHF5b+Jc40bN+bzzz/njTfe4PXXX+e+++5j2bJlVKtWzaqvICIiIk7GIZMigAEDBqTYXbZu3bpkZV27dqVr166ZHNXd8/T0JDQ0NFl3XU6jdlAbJFA7mNQOaoMEagfHaQObkZY5aiIiIiLZnMMt3igiIiJiBSVFIiIiIigpEhEREQGUFGWa6OhoXn31VUqUKEGuXLlo2LAhq1evtjqsLPPmm29is9mSzQBs1qwZNpst2aN169YWRZqxduzYQevWrcmXLx958+alZcuW7Nq1y27dzZs306RJE7y9vSlWrBiDBg3i6tWrWRvwPbp69SqhoaG0bt2aQoUKYbPZmDdvXrJ6s2fPJiAgAF9fXzw9PSlbtizBwcEcOnQoWV1714fNZmPixImZ/4XSKa3tALB48WIeeOABChQoQOHChQkICOD7779PVi8+Pp63336bsmXL4uXlRY0aNVi4cGEmf5P027ZtGwMGDKBq1arkzp2b0qVL061bN/bt25dYJz4+nnnz5tGuXTtKlSpF7ty5qVatGuPGjePGjRvJzuls10Ja2gBS/l42m42goKAkdZ3tOgDYvXs3Xbt2pVy5cnh7e+Pj48NDDz3Et99+m6Te1q1beeGFF6hbty7u7u53XDw5q64Fh5195uyeeuopli5dypAhQ7jvvvuYN28ejzzyCGvXrqVJkyZWh5epjh07xvjx48mdO7fd10uWLJm4xlSCtKw06uh27txJkyZNKFWqFKGhocTHxzNz5kwCAgLYunUrlSpVSqy7a9cuWrRowf3338/kyZM5duwYkyZNYv/+/axYscLCb3F3zp49y5gxYyhdujQ1a9a0OzMU4Ndff6Vs2bK0a9eOggULcvDgQWbPns13333Hb7/9luz/f1BQEL17905SVrt27cz6Gvcsre3w/vvvM2jQIB599FEmTpzIjRs3mDdvHo899hhffvklnTp1Sqw7fPhwJk6cSL9+/ahfvz7Lly/niSeewGaz0aNHjyz6Zmn31ltvsWnTJrp27UqNGjWIjIxk+vTp1KlTh19++YVq1apx7do1goODeeCBB3j++ecpWrQoERERhIaGEh4ezk8//ZTsF6MzXQtpaQOA+fPnJ3vv9u3bee+992jZsmWScme7DgAOHz7MlStX6NOnDyVKlODatWt8+eWXtGvXjg8//JBnn30WgB9++IGPP/6YGjVqUK5cuWTJ4+2y5FowJMNt2bLFAIx33nknsez69etG+fLljUaNGlkYWdbo3r278fDDDxsBAQFG1apVk7xmryy7eOSRR4yCBQsaZ8+eTSw7ceKEkSdPHqNTp05J6rZp08YoXry4cenSpcSy2bNnG4Dx448/ZlnM9+rGjRvGyZMnDcMwjG3bthmA8cknn6Tpvdu3bzcAY8KECUnKAePFF1/M6FAzVVrb4b777jPq169vxMfHJ5ZdunTJyJMnj9GuXbvEsmPHjhnu7u5J2iE+Pt5o2rSpUbJkSePmzZuZ92XSadOmTUZ0dHSSsn379hmenp7Gk08+aRiGYURHRxubNm1K9t7Ro0cbgLF69eok5c52LaSlDVLSt29fw2azGUePHk0sc8brICU3b940atasaVSqVCmxLDIy0rh27ZphGIbx4osvGndKSbLqWlD3WSZYunQprq6uidkwgJeXF3379iUiIoKjR49aGF3m2rBhA0uXLmXq1Kl3rHfz5k2n6ypKzcaNGwkMDKRw4cKJZcWLFycgIIDvvvsu8ftevnyZ1atX07NnzyTL2ffu3Zs8efKwePHiLI89vTw9PVPcYzA1/v7+AFy8eNHu69evX7fbpeKI0toOly9fpmjRoknuhuTLl488efKQK1euxLLly5cTGxvLCy+8kFhms9no378/x44dIyIiImO/QAZo3LgxHh4eScruu+8+qlatyt9//w2Y2zg1btw42Xs7duwIkFjvds5yLaSlDeyJjo7myy+/JCAggJIlSyaWO+N1kBJXV1dKlSqV5N+7r69vkus+LTL7WlBSlAl+/fVXKlasmGz/lgYNGgCkOMbE2cXFxTFw4ECeeeYZqlevnmK9ffv2kTt3bvLmzUuxYsUYMWIEsbGxWRhp5oiOjrb7D9zb25uYmBj+/PNPAP744w9u3rxJvXr1ktTz8PCgVq1a/Prrr1kSrxXOnTvH6dOn2b59e+K2PS1atEhWb968eeTOnZtcuXJRpUoVPv/886wONVM0a9aMlStX8v7773Po0CH27NnDiy++yKVLlxg8eHBivV9//ZXcuXNz//33J3l/ws8QZ7lGDMPg1KlT+Pj43LFeZGQkgN16zn4tpKUNfvjhBy5evMiTTz6ZpNzZr4OoqCjOnj3LP//8w5QpU1ixYoXdf+9plRXXgsYUZYKTJ09SvHjxZOUJZSdOnMjqkLLErFmzOHz4MGvWrEmxTvny5WnevDnVq1cnKiqKpUuXMm7cOPbt28eiRYuyMNqMV6lSJX755Rfi4uJwdXUFICYmhi1btgBw/PhxwLw+gBSvkY0bN2ZRxFnPz8+P6OhoAAoXLsy0adOSDSxt3Lgx3bp1o2zZspw4cYIZM2bw5JNPcunSJfr3729F2Blm2rRpnD17lkGDBjFo0CDATATCw8OTbGB98uRJfH19k42vcbafIWFhYRw/fpwxY8bcsd7bb79Nvnz5aNOmTZLy7HAtpKUNwsLC8PT0pEuXLknKnf06eOmll/jwww8BcHFxoVOnTkyfPj1d58qqa0FJUSa4fv263aXKvby8El/Pbs6dO8fIkSMZMWIERYoUSbHenDlzkjzv1asXzz77LLNnz+b//u//eOCBBzI71Ezzwgsv0L9/f/r27cvQoUOJj49n3LhxiUlQwv/3hP+mdI1kx+sjwYoVK7hx4wZ///03CxYsICoqKlmdTZs2JXn+9NNPU7duXV5//XWeeuqpu77d7ki8vb2pVKkSJUuW5LHHHuPKlStMmTKFTp06sXHjRipUqABkj58hCXfBGjVqRJ8+fVKsN378eNasWcPMmTMpUKBAktec/VpISxtcvnyZ77//nkceeSTZ93f262DIkCF06dKFEydOsHjxYuLi4oiJiUnXubLqWlD3WSbIlStX4l/Dt0roB3X0f8jp8cYbb1CoUCEGDhx41+996aWXAO54h8kZPP/887z++ut8/vnnVK1alerVq/PPP/8wdOhQAPLkyQP89/8/pWskO14fCZo3b06bNm0ICQlhyZIljB49OtW/HD08PBgwYAAXL15kx44dWRRp5ujatStHjhxh3rx5dOnSheDgYNatW0dMTAzDhw9PrOfsP0MiIyN59NFHyZ8/f+IYS3sWLVrEG2+8Qd++fdP0174zXQtpbYMvv/ySGzduJOs6A+e/DipXrkxgYCC9e/dOHFfZtm1bjAzYXSyzrgUlRZmgePHiiXcHbpVQlh2mn99q//79fPTRRwwaNIgTJ05w6NAhDh06xI0bN4iNjeXQoUOcP38+xfeXKlUK4I51nMWbb77JqVOn2LhxI7///jvbtm0jPj4egIoVKwL/3fpO6RrJbtdHSsqXL0/t2rUJCwtLtW52uEb+/fdfVq5cSbt27ZKUFypUiCZNmiT5S7h48eJERkYm++XhDD9DLl26RJs2bbh48SIrV65MMdbVq1fTu3dvHn30UWbNmpXm8zvDtZDWNgCz6yx//vw89thjyV5z5uvAni5durBt27ZUp96nVWZcC0qKMkGtWrXYt28fly9fTlKeMLakVq1aFkSVeY4fP058fDyDBg2ibNmyiY8tW7awb98+ypYte8f+9H///Rfgjt1uzqRgwYI0adIkcbD5mjVrKFmyJJUrVwagWrVquLm5sX379iTvi4mJYdeuXdnu+riT69evc+nSpVTrZYdr5NSpU4A5IeF2sbGx3Lx5M/F5rVq1uHbtWrIZS47+M+TGjRu0bduWffv28d1331GlShW79bZs2ULHjh2pV68eixcvxs0t7SM5HP1aSGsbgJncrF27ls6dO9vtJnPW6yAlCd19afk3nxaZci1k+qT/HOiXX35Jtk7RjRs3jAoVKhgNGza0MLLMcebMGePrr79O9qhatapRunRp4+uvvzZ+//1349KlS8aNGzeSvDc+Pt7o3r27ARg7duyw6Btkni+++MIAjEmTJiUpb926tVG8eHHj8uXLiWUff/yxARgrVqzI6jAzRErr88TGxhrnz59PVn/Lli2Gq6ur0atXr8Sy06dPJ6t3+fJlo3z58oaPj0+yNWAcUUrtcPr0acPFxcVo1qxZknWKjh49auTJk8do3bp1krKU1qfx8/NzyPVpbt68abRr185wc3Mzvv/++xTr/fXXX0bhwoWNqlWr2r0uEjjjtZDWNkgwefJkAzDCw8Ptvu6M14FhGMapU6eSlcXExBh16tQxcuXKZVy5ciXZ63dapygrrwUNtM4EDRs2pGvXrgwbNozTp09ToUIFPv30Uw4dOpRsoHF24OPjQ4cOHZKVJ6xVlPDaunXrePzxx3n88cepUKEC169f5+uvv2bTpk08++yz1KlTJ+uCzgQbNmxgzJgxtGzZksKFC/PLL7/wySef0Lp16yTTrcHsZmvcuDEBAQE8++yzHDt2jHfffZeWLVs63ZYn06dP5+LFi4kzYb799luOHTsGwMCBAzEMg1KlStG9e/fE7Q/++OMPPvnkE/Lnz8+IESMSzzVjxgyWLVtG27ZtKV26NCdPnmTu3LkcOXKE+fPnJ1sDxpGk1g5FihTh6aef5uOPP6ZFixZ06tSJK1euMHPmTK5fv86wYcMSz1WyZEmGDBnCO++8Q2xsLPXr12fZsmVs3LiRsLCwFMenWOmll17im2++oW3btpw/f54FCxYkeb1nz55cuXKFVq1aceHCBV555ZVk25uUL18+cRaeM14LaWmDW4WFhVGiRAmaNWtm93zOeB0APPfcc1y+fJmHHnoIPz8/IiMjCQsLY8+ePbz77ruJ4ysPHz6cuLp3wp3zcePGAVCmTBl69eoFZPG1kGHplSRx/fp14+WXXzaKFStmeHp6GvXr1zdWrlxpdVhZ6vbVq//991+ja9euhr+/v+Hl5WV4e3sbdevWNWbNmpXkL2dndeDAAaNly5aGj4+P4enpaVSuXNmYMGFCin/FbNy40WjcuLHh5eVlFClSxHjxxReT3DlyFmXKlDEAu4+DBw8a0dHRxuDBg40aNWoY+fLlM9zd3Y0yZcoYffv2NQ4ePJjkXKtWrTKCgoKMYsWKGe7u7kaBAgWMli1bpviXtCNJrR0Mw7xr9v777xu1atUy8uTJY+TJk8do3ry58dNPPyU7X1xcnDF+/HijTJkyhoeHh1G1alVjwYIFWfyt0i4gICDF75/wq+bgwYN3rNOnT5/E8znjtZCWNkiwZ88eAzBCQkLueE5nuw4MwzAWLlxoBAYGGr6+voabm5tRsGBBIzAw0Fi+fHmSemvXrk2xrQICAhLrZeW1YDOMDBgGLiIiIuLkNNBaREREBCVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBFBSJCIiIgIoKRIREREBlBSJiIiIAEqKRERERAAlRSIid3To0CFsNhtPPfWU1aGISCZTUiQiDuvpp5/GZrNRuHBhoqOjrQ5HRLI5JUUi4pCuXLnC4sWLsdlsnD9/nmXLllkdkohkc0qKRMQhLVq0iKioKP7v//4PFxcX5syZY3VIIpLNKSkSEYc0Z84c3NzcGDp0KM2bNyc8PJzDhw8nq+fv74+/vz9Xr15l8ODBlChRAk9PT2rUqMHSpUvtnvvQoUN0796dQoUKkSdPHgICAtiwYQOjRo3CZrOxbt26NMV45coVQkNDqVq1Krly5aJAgQK0atWKn3/++V6+uohYREmRiDicv/76i19++YWWLVvi6+tL7969iY+P55NPPrFbPzY2lpYtW7Jq1So6d+5Mz549+eeff+jWrRurVq1KUvf48eM0btyYxYsX07BhQwYNGoSPjw9BQUFs2bIlzTGeP3+eRo0aMWbMGAoWLMjzzz9P586d2bFjB82bN1d3n4gzMkREHExISIgBGAsXLjQMwzCuXLli5M6d2yhdurQRFxeXpG6ZMmUMwGjfvr0RHR2dWL5mzRoDMFq1apWkfs+ePQ3AePPNN5OUz5kzxwAMwFi7dm1i+cGDBw3A6NOnT5L6TzzxhAEYs2fPTlJ+6tQpo1SpUkaRIkWM69evp7cJRMQCulMkIg4lNjaW+fPnky9fPjp06ABAnjx56NixI0eOHGHNmjV23zdlyhQ8PDwSn7do0YIyZcqwbdu2xLLo6GiWLFlC0aJFeemll5K8Pzg4mEqVKqUpxrNnz7Jo0SIefvhhnnnmmSSvFS1alFdeeYUzZ86kGKuIOCY3qwMQEbnV8uXLOXPmDH379sXLyyuxvHfv3ixYsIA5c+bQsmXLJO8pUKAAZcuWTXaukiVLEhERkfh87969REdHU69ePTw9PZPUtdlsNG7cmL1796Ya47Zt24iLiyM6OppRo0Yle33//v0A7Nmzh8ceeyzV84mIY1BSJCIOJWGWWe/evZOUt2jRAj8/P5YvX8758+cpVKhQ4mv58+e3ey43Nzfi4+MTn1++fBkw7+bY4+vrm6YYz58/D8CmTZvYtGlTivWioqLSdD4RcQzqPhMRh3H06NHEgdEBAQHYbLbEh6urK8ePHyc6OpoFCxak6/z58uUD4PTp03ZfP3Xq1F2d56WXXsIwjBQfoaGh6YpTRKyhO0Ui4jDmzZtHfHw8TZo0sTu+5+bNm3z66afMmTOHQYMG3fX5K1WqhKenJzt27CA6OjpJF5phGEm62u6kfv362Gy2NNcXEeegpEhEHIJhGHzyySfYbDY+/fRTypUrZ7fevn37iIiIYPv27dSrV++uPsPT05MuXboQFhbG1KlTefXVVxNf++yzz9izZ0+azlOsWDG6devGokWLeOedd3j55Zex2WxJ6mzZsoXq1avj7e19VzGKiHWUFImIQ/jpp584ePAgAQEBKSZEYM4Si4iIYM6cOXedFAFMmDCBNWvW8Nprr7F+/Xpq167N3r17+e6772jdujUrV67ExSX1kQUzZ85k7969DB06lPnz59OoUSMKFCjA0aNH2b59O/v37+fkyZNKikSciMYUiYhDSBhgndpu9N27dydXrlwsXLiQ69ev3/XnlCpVioiICLp27crmzZuZOnUqp0+fZtWqVVSoUAH4b8zQnRQqVIjNmzfz9ttv4+HhQVhYGO+//z6//PILVatW5bPPPsPHx+eu4xMR69gMwzCsDkJExBE0adKEiIgILl26RJ48eawOR0SymO4UiUiOc/LkyWRlCxYsYNOmTQQGBiohEsmhdKdIRHKcwoULU7t2bapUqYKrqyu7du1i3bp15M2bl02bNlG9enWrQxQRCygpEpEcZ/jw4Xz77bccOXKEqKgoihQpQvPmzRkxYgSVK1e2OjwRsYiSIhERERE0pkhEREQEUFIkIiIiAigpEhEREQGUFImIiIgASopEREREACVFIiIiIoCSIhERERFASZGIiIgIoKRIREREBID/BzJ0E4hMu2nnAAAAAElFTkSuQmCC", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 4 + "source": [ + "fig, ax = r.profile_plot(\n", + " incl_amp=False,\n", + " incl_disp=False,\n", + " incl_pred=False,\n", + " incl_fit=False,\n", + " reorder_scales=True,\n", + ")\n", + "\n", + "ax[0].grid(True)\n", + "plt.ylim(0, 0.5)\n", + "plt.xlabel(\"Angle\")\n", + "plt.title(\"Scores by Angle\")\n", + "plt.show()" + ] }, { "cell_type": "markdown", - "source": [ - "This already looks like a cosine curve, and we can finally use the SSM to estimate the parameters of the curve that best fits the observed data. By plotting it alongside the data, we can get a sense of how well the model fits our example data." - ], + "id": "933eea60765a4afe", "metadata": { "collapsed": false }, - "id": "933eea60765a4afe" + "source": [ + "This already looks like a cosine curve, and we can finally use the SSM to estimate the parameters of the curve that best fits the observed data. By plotting it alongside the data, we can get a sense of how well the model fits our example data." + ] }, { "cell_type": "code", - "source": [ - "fig, ax = r.profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False);\n", - "ax[0].grid(True)\n", - "plt.ylim(0, 0.5)\n", - "plt.xlabel(\"Angle\")\n", - "plt.title(\"Cosine curve estimated by SSM\")\n", - "plt.show()\n" - ], + "execution_count": 5, + "id": "c826947d0b98109e", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-07-11T18:37:04.908090Z", "start_time": "2024-07-11T18:37:04.843764Z" - } + }, + "collapsed": false }, - "id": "c826947d0b98109e", "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGECAYAAAA4IlRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACEE0lEQVR4nO3ddVxV5x/A8c+lw0JBxMR2dreis2eLijEDc7bD+E03RZ2Ks50xO2Zs9pwtdmG3s1tRbECl7/n9ceTOKyEw4F7g+369eHl5znPO/T4chC/nKY2iKApCCCGEEGmciaEDEEIIIYQwBpIUCSGEEEIgSZEQQgghBCBJkRBCCCEEIEmREEIIIQQgSZEQQgghBCBJkRBCCCEEIEmREEIIIQQgSZEQQgghBCBJkRDJRqPRMGbMGEOHIeIoNd6v5cuXo9FouH//fqz1unbtSrp06ZInKCGMiCRFIk26c+cOvXv3Jl++fFhZWZEhQwaqVavGrFmzCAoKMnR4Ipns2LHD6BKfDx8+MGbMGA4ePGjoUJJcaGgos2bNokyZMmTIkIFMmTJRrFgxevXqxfXr1/XqXr58mdatW5MnTx6srKzIkSMH9erVY/bs2Xr1nJ2d0Wg01K1bN9r3XLRoERqNBo1Gw5kzZ5KsbSJlMjN0AEIkt+3bt9OmTRssLS3p3LkzxYsXJzQ0lKNHjzJs2DCuXr3KwoULE/19g4KCMDOT/3LGZMeOHcydOzfaxMhQ9+vDhw+MHTsWgFq1aiX7+ycnV1dXdu7cSfv27enZsydhYWFcv36dbdu2UbVqVYoUKQLA8ePHqV27Nrlz56Znz55ky5aNR48eceLECWbNmsWAAQP0rmtlZcWBAwd49uwZ2bJl0zu2evVqrKysCA4OTrZ2ipRDfkKLNOXevXu0a9eOPHnysH//fpycnHTH+vXrx+3bt9m+fXuSvLeVlVWSXNfQFEUhODgYa2trQ4eSqFLr/TIWp0+fZtu2bUyYMIGRI0fqHZszZw5v377VfT5hwgQyZszI6dOnyZQpk17d58+fR7l2tWrVOH36NGvXrmXQoEG68sePH3PkyBFatmzJxo0bE7U9InWQ7jORpkyePJl3796xZMkSvYQoUoECBfR+iIaHh/Pzzz+TP39+LC0tcXZ2ZuTIkYSEhOidd+bMGRo0aIC9vT3W1tbkzZuXbt266dX5fIzKmDFj0Gg03L59m65du5IpUyYyZsyIu7s7Hz58iBLbqlWrKFeuHNbW1mTOnJl27drx6NGjOLX7yZMndO/enezZs2NpaUnevHnp06cPoaGherF8LroxKM7OzjRp0oTdu3dTvnx5rK2tWbBgAcWLF6d27dpRrqHVasmRIwetW7fWK5s5cybFihXDysoKR0dHevfuzZs3b+LUnuvXr9O6dWsyZ86MlZUV5cuX5++//9arExYWxtixYylYsCBWVlZkyZKF6tWr4+3tDajjZubOnQug60759GsQ0/26efMm3377LRkzZsTBwYFRo0ahKAqPHj2iefPmZMiQgWzZsjFt2jS9eEJDQxk9ejTlypUjY8aM2NraUqNGDQ4cOKCrc//+fRwcHAAYO3asLqZP44hL2wGuXr3K119/jbW1NTlz5mT8+PFotdo4fX0j3b17lwYNGmBra0v27NkZN24ciqIAajLs7OxM8+bNo5wXHBxMxowZ6d27d4zXvnPnDqAmMJ8zNTUlS5YsenWLFSsWJSECyJo1a5QyKysrWrVqxZo1a/TK//jjD+zs7GjQoEGMcYm0TZ4UiTRl69at5MuXj6pVq8apfo8ePVixYgWtW7dmyJAhnDx5Ei8vL65du8bmzZsB9S/V+vXr4+DgwA8//ECmTJm4f/8+mzZtitN7tG3blrx58+Ll5cW5c+dYvHgxWbNm5ZdfftHVmTBhAqNGjaJt27b06NGDFy9eMHv2bGrWrMn58+ej/WURydfXl4oVK/L27Vt69epFkSJFePLkCRs2bODDhw9YWFjEKc5P3bhxg/bt29O7d2969uxJ4cKFcXNzY8yYMVG6LI4ePYqvry/t2rXTlfXu3Zvly5fj7u7OwIEDuXfvHnPmzOH8+fMcO3YMc3PzGN/76tWrVKtWjRw5cvDDDz9ga2vLunXraNGiBRs3bqRly5aAmsR4eXnRo0cPKlasSEBAAGfOnOHcuXPUq1eP3r174+vri7e3NytXroxz293c3Pjqq6+YNGkS27dvZ/z48WTOnJkFCxbw9ddf88svv7B69WqGDh1KhQoVqFmzJgABAQEsXrxY11UUGBjIkiVLaNCgAadOnaJ06dI4ODjw22+/0adPH1q2bEmrVq0AKFmyZLza/uzZM2rXrk14eLiu3sKFC+P1NC8iIoKGDRtSuXJlJk+ezK5du/D09CQ8PJxx48ah0Wj49ttvmTx5Mq9fvyZz5sy6c7du3UpAQADffvttjNfPkycPoHZnVatWLdauyjx58uDj48OVK1coXrx4nOLv0KED9evX586dO+TPnx+ANWvW0Lp161i/v0QapwiRRvj7+yuA0rx58zjVv3DhggIoPXr00CsfOnSoAij79+9XFEVRNm/erADK6dOnY70eoHh6euo+9/T0VAClW7duevVatmypZMmSRff5/fv3FVNTU2XChAl69S5fvqyYmZlFKf9c586dFRMTk2jj02q1erF8btmyZQqg3Lt3T1eWJ08eBVB27dqlV/fGjRsKoMyePVuvvG/fvkq6dOmUDx8+KIqiKEeOHFEAZfXq1Xr1du3aFW355+rUqaOUKFFCCQ4O1mtH1apVlYIFC+rKSpUqpTRu3DjWa/Xr1y/aditKzPerV69eurLw8HAlZ86cikajUSZNmqQrf/PmjWJtba106dJFr25ISIjee7x580ZxdHTU+x548eJFlPeOb9sHDx6sAMrJkyd1Zc+fP1cyZswY5X5Gp0uXLgqgDBgwQO99GjdurFhYWCgvXrxQFOXfe/7bb7/pnd+sWTPF2dlZ9/0VHa1Wq7i4uCiA4ujoqLRv316ZO3eu8uDBgyh19+zZo5iamiqmpqZKlSpVlOHDhyu7d+9WQkNDo9TNkyeP0rhxYyU8PFzJli2b8vPPPyuKoij//POPAiiHDh3SfV9/6f+sSHuk+0ykGQEBAQCkT58+TvV37NgBgIeHh175kCFDAHRjjyKf0mzbto2wsLB4x/Xdd9/pfV6jRg1evXqli3fTpk1otVratm3Ly5cvdR/ZsmWjYMGCet0vn9Nqtfz11180bdqU8uXLRzkeXZdZXOTNmzdKF0ShQoUoXbo0a9eu1ZVFRESwYcMGmjZtqntKsX79ejJmzEi9evX02lOuXDnSpUsXa3tev37N/v37adu2LYGBgbpzX716RYMGDbh16xZPnjwB1Pty9epVbt26laA2xqRHjx6616amppQvXx5FUejevbuuPFOmTBQuXJi7d+/q1Y18KqfVann9+jXh4eGUL1+ec+fOffF949P2HTt2ULlyZSpWrKg738HBgY4dO8arrf3799e91mg09O/fn9DQUPbu3Quo97xSpUqsXr1aL86dO3fSsWPHWL+/NBoNu3fvZvz48djZ2fHHH3/Qr18/8uTJg5ubm96Yonr16uHj40OzZs24ePEikydPpkGDBuTIkSParkNQv95t27bljz/+ANQnUrly5aJGjRrx+hqItEWSIpFmZMiQAYDAwMA41X/w4AEmJiYUKFBArzxbtmxkypSJBw8eAODi4oKrqytjx47F3t6e5s2bs2zZsijjjmKSO3duvc/t7OwAdONrbt26haIoFCxYEAcHB72Pa9euRTvQNNKLFy8ICAiIc5dDXOXNmzfacjc3N44dO6b75Xzw4EGeP3+Om5ubrs6tW7fw9/cna9asUdrz7t27WNtz+/ZtFEVh1KhRUc719PQE/h14O27cON6+fUuhQoUoUaIEw4YN49KlS/+57Z/fr4wZM2JlZYW9vX2U8s/HSK1YsYKSJUvqxjg5ODiwfft2/P39v/i+8Wn7gwcPKFiwYJRrFC5cOM7tNDExIV++fHplhQoVAtAbY9a5c2eOHTum+/+wfv16wsLC6NSp0xffw9LSkh9//JFr167h6+vLH3/8QeXKlVm3bp1eQgZQoUIFNm3axJs3bzh16hQjRowgMDCQ1q1b888//0R7/Q4dOvDPP/9w8eJF1qxZQ7t27RL8h4BIG2RMkUgzMmTIQPbs2bly5Uq8zvvSD1GNRsOGDRs4ceIEW7duZffu3XTr1o1p06Zx4sSJLy6CZ2pqGm258nFAq1arRaPRsHPnzmjrJsYiezG1MSIiItrymMamuLm5MWLECNavX8/gwYNZt24dGTNmpGHDhro6Wq2WrFmz6j1d+FTkQOPoRA4UHjp0aIyDZSOT2Jo1a3Lnzh22bNnCnj17WLx4MTNmzGD+/Pl6T3viK7p78KV7COpA+a5du9KiRQuGDRtG1qxZMTU1xcvLSzfoODbxaXtyateuHd9//z2rV69m5MiRrFq1ivLly8crAQNwcnKiXbt2uLq6UqxYMdatW8fy5cujjDWysLCgQoUKVKhQgUKFCuHu7s769et1ieGnKlWqRP78+Rk8eDD37t2jQ4cO/6mtIvWTpEikKU2aNGHhwoX4+PhQpUqVWOvmyZMHrVbLrVu3+Oqrr3Tlfn5+vH37VjdQNFLlypWpXLkyEyZMYM2aNXTs2JE///zzP/0CBsifPz+KopA3b17dX+px5eDgQIYMGb6YCEY+nXr79q3eoO3Iv/7jKm/evFSsWJG1a9fSv39/Nm3aRIsWLbC0tNTVyZ8/P3v37qVatWrxnsYf+eTC3Nw8xsX5PpU5c2bc3d1xd3fn3bt31KxZkzFjxujuSXI+NdiwYQP58uVj06ZNeu/7+S/zmGKKT9vz5MkTbbfhjRs34hyvVqvl7t27et9zN2/eBNQZiJEyZ85M48aNWb16NR07duTYsWPMnDkzzu/zOXNzc0qWLMmtW7d03cQxiewSfvr0aYx12rdvz/jx4/nqq68oXbp0guMSaYN0n4k0Zfjw4dja2tKjRw/8/PyiHL9z5w6zZs0C4JtvvgGI8gN++vTpADRu3BhQu7k+fSIA6H74xrULLTatWrXC1NSUsWPHRnkfRVF49epVjOeamJjQokULtm7dGu3qvZHXi5ydc/jwYd2x9+/fs2LFinjH6+bmxokTJ1i6dCkvX77U6zoDdbZdREQEP//8c5Rzw8PD9caSfC5r1qzUqlWLBQsWRPuL8MWLF7rXn39d0qVLR4ECBfTuia2tLUCs75lYIp8mfXoPT548iY+Pj149GxubaGOKT9u/+eYbTpw4walTp/SOx/R0LiZz5szRvVYUhTlz5mBubk6dOnX06nXq1Il//vmHYcOGYWpqqjfTMCa3bt3i4cOHUcrfvn2Lj48PdnZ2uqeGBw4ciPK9D/+O+4vtqVSPHj3w9PSMskSCENGRJ0UiTcmfPz9r1qzRTav+dEXr48ePs379erp27QpAqVKl6NKlCwsXLuTt27e4uLhw6tQpVqxYQYsWLXRr8qxYsYJ58+bRsmVL8ufPT2BgIIsWLSJDhgy6xOq/xjx+/HhGjBjB/fv3adGiBenTp+fevXts3ryZXr16MXTo0BjPnzhxInv27MHFxYVevXrx1Vdf8fTpU9avX8/Ro0fJlCkT9evXJ3fu3HTv3l33i23p0qU4ODhE+4srNm3btmXo0KEMHTqUzJkzR3mq4eLiQu/evfHy8uLChQvUr18fc3Nzbt26xfr165k1a5bemkafmzt3LtWrV6dEiRL07NmTfPny4efnh4+PD48fP+bixYsAFC1alFq1alGuXDkyZ87MmTNn2LBhg95YlXLlygEwcOBAGjRoEOdf6AnRpEkTNm3aRMuWLWncuDH37t1j/vz5FC1alHfv3unqWVtbU7RoUdauXUuhQoXInDkzxYsXp3jx4nFu+/Dhw1m5ciUNGzZk0KBBuin5efLkifO4KisrK3bt2kWXLl2oVKkSO3fuZPv27YwcOTJKF2fjxo3JkiUL69evp1GjRtGuHfS5ixcv0qFDBxo1akSNGjXInDkzT548YcWKFfj6+jJz5kxdIjlgwAA+fPhAy5YtKVKkiO7/69q1a3F2dsbd3T3G98mTJ4/RbeUijJghprwJYWg3b95UevbsqTg7OysWFhZK+vTplWrVqimzZ8/Wm+4cFhamjB07VsmbN69ibm6u5MqVSxkxYoRenXPnzint27dXcufOrVhaWipZs2ZVmjRpopw5c0bvPYlhinfk9OZI0U2DVxRF2bhxo1K9enXF1tZWsbW1VYoUKaL069dPuXHjxhfb++DBA6Vz586Kg4ODYmlpqeTLl0/p16+f3hTxs2fPKpUqVVIsLCyU3LlzK9OnT49xSv6XprpXq1Yt2uUMPrVw4UKlXLlyirW1tZI+fXqlRIkSyvDhwxVfX98vtufOnTtK586dlWzZsinm5uZKjhw5lCZNmigbNmzQ1Rk/frxSsWJFJVOmTIq1tbVSpEgRZcKECXrTuMPDw5UBAwYoDg4Oikaj0ZueH9f71aVLF8XW1jZKjC4uLkqxYsV0n2u1WmXixIlKnjx5FEtLS6VMmTLKtm3blC5duih58uTRO/f48eNKuXLlFAsLiyhxxKXtiqIoly5dUlxcXBQrKyslR44cys8//6wsWbIkzlPybW1tlTt37ij169dXbGxsFEdHR8XT01OJiIiI9py+ffsqgLJmzZpYrx3Jz89PmTRpkuLi4qI4OTkpZmZmip2dnfL1119HacvOnTuVbt26KUWKFFHSpUunWFhYKAUKFFAGDBig+Pn56dWNy/enTMkXMdEoSjTPJIUQQoh4+P7771myZAnPnj3TdQEKkdLImCIhhBD/SXBwMKtWrcLV1VUSIpGiyZgiIYQQCfL8+XP27t3Lhg0bePXqld6+gUKkRJIUCSGESJB//vmHjh07kjVrVn799VeZ8i5SPKPtPps7dy7Ozs5YWVlRqVIlvamln4vcyfvTDysrq2SMVggh0p5atWqhKAp+fn5RVqAWIiUyyqRo7dq1eHh44Onpyblz5yhVqhQNGjSIdfn/DBky8PTpU91HfBedE0IIIUTaZpRJ0fTp0+nZsyfu7u4ULVqU+fPnY2Njw9KlS2M8R6PRkC1bNt2Ho6NjMkYshBBCiJTO6MYUhYaGcvbsWUaMGKErMzExoW7dulFWfv3Uu3fvdNsylC1blokTJ1KsWLFo64aEhOitahu5Y3WWLFlks0AhhBAiFVEUhcDAQLJnz46JSezPgowuKXr58iURERFRnvQ4Ojpy/fr1aM8pXLgwS5cupWTJkvj7+zN16lSqVq3K1atXyZkzZ5T6Xl5ejB07NkniF0IIIYTxefToUbQ5waeMLilKiCpVquht7lm1alW++uorFixYEO3+SiNGjMDDw0P3ub+/P7lz5+bevXukT58+UWMLCwvjwIED1K5dG3Nz80S9tjFJC+2UNqYeaaGdaaGNkDbamRbamJQCAwPJmzdvnH6/G11SZG9vj6mpaZTNOv38/GLdLflT5ubmlClThtu3b0d73NLSUm/X7kiZM2cmQ4YM8Q86FmFhYdjY2JAlS5ZU/c2cFtopbUw90kI700IbIW20My20MSlFfs3iMjzG6AZaW1hYUK5cOfbt26cr02q17Nu3T+9pUGwiIiK4fPkyTk5OSRWmEEIIIVIZo3tSBODh4UGXLl0oX748FStWZObMmbx//163E3Lnzp3JkSMHXl5eAIwbN47KlStToEAB3r59y5QpU3jw4AE9evQwZDOEEEIIkYIYZVLk5ubGixcvGD16NM+ePaN06dLs2rVLN/j64cOHeiPI37x5Q8+ePXn27Bl2dnaUK1eO48ePU7RoUUM1QQghhBApjFEmRQD9+/ePcYXUgwcP6n0+Y8YMZsyYkQxRCSGEECK1MroxRUIIIYQQhiBJkRBCCCEEkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJIYQQQgCSFAkhhBBCAJIUCSGEEEIAkhQJETcREWgOHSLH4cNoDh2CiAhDRySEECKRGW1SNHfuXJydnbGysqJSpUqcOnUqTuf9+eefaDQaWrRokbQBirRj0yZwdsasXj3KT5+OWb164OyslgshhEg1jDIpWrt2LR4eHnh6enLu3DlKlSpFgwYNeP78eazn3b9/n6FDh1KjRo1kilSkeps2QevW8PixfvmTJ2q5JEZCCJFqGGVSNH36dHr27Im7uztFixZl/vz52NjYsHTp0hjPiYiIoGPHjowdO5Z8+fIlY7Qi1YqIgEGDQFGiHossGzxYutKEECKVMDN0AJ8LDQ3l7NmzjBgxQldmYmJC3bp18fHxifG8cePGkTVrVrp3786RI0difY+QkBBCQkJ0nwcEBAAQFhZGWFjYf2yBvsjrJfZ1jU1qbKfm0CHMPn9C9ClFgUePCN+7F+Xrr5MvsCSUGu9jdNJCO9NCGyFttDMttDEpxefrZnRJ0cuXL4mIiMDR0VGv3NHRkevXr0d7ztGjR1myZAkXLlyI03t4eXkxduzYKOV79uzBxsYm3jHHhbe3d5Jc19ikpnbmOHyY8nGoZ/LNN3zIlo132bPz3smJd05OvM+enXdOTgTZ24OpaZLHmthS032MTVpoZ1poI6SNdqaFNiaFDx8+xLmu0SVF8RUYGEinTp1YtGgR9vb2cTpnxIgReHh46D4PCAggV65c1K9fnwwZMiRqfGFhYXh7e1OvXj3Mzc0T9drGJDW2U2NrC9Onf7GeiVZLOl9f0vn6RjmmWFhA3rwoBQqgFCwIBQqorwsUgJw5wcS4erBT432MTlpoZ1poI6SNdqaFNialyN6guDC6pMje3h5TU1P8/Pz0yv38/MiWLVuU+nfu3OH+/fs0bdpUV6bVagEwMzPjxo0b5M+fX+8cS0tLLC0to1zL3Nw8yb7hkvLaxiRVtbNmTbC2hqCg6I9rNGpic/Ag3LsHt27pf9y5gyY0FG7cQHPjRtTzrawgf34oWDDqR/bs6vUNJFXdx1ikhXamhTZC2mhnWmhjUojP18zokiILCwvKlSvHvn37dNPqtVot+/bto3///lHqFylShMuXL+uV/fTTTwQGBjJr1ixy5cqVHGGL1CYiAnr0iD0hApg5E/LlUz/q1Il6jYcPoyZLt26pSVRwMFy9qn58RmttjZI/PyaFC6P5+IRJlzBly2bQhEkIIVIro0uKADw8POjSpQvly5enYsWKzJw5k/fv3+Pu7g5A586dyZEjB15eXlhZWVG8eHG98zNlygQQpVyIONFqoWdPWLlSHQ/0/ffw55/60/Jz5lQTolatYr6OqSnkzUtI9uxcyJiRK1ZWXDMz4xrw2Nwc8ydPcPD3pyBQACj48cMZMAsKgitX1I/PhH9MmMy/+irqEyYHh4QnTJ8uUGlrC7Vrp8jxUEIIkVBGmRS5ubnx4sULRo8ezbNnzyhdujS7du3SDb5++PAhJkY2FkOkElot9O4Ny5ap433WrIG2bWHSJMIPHODCzp2UbtQIs1gShrCwMI4ePcru3bs5duwYp0+f1pvt+Lld/Nula2ZmhjY4mKwfPuglSpEfeYg9YSJDhui74woWhCxZYm73pk0waBBmjx+rg8unT1cTv1mzYk/8hBAiFTHKpAigf//+0XaXARw8eDDWc5cvX574AYnUT1Ggf39YvFhNiFauVBMiAFNTFBcXnrx/TykXlygJUVBQEFu3bmX9+vXs2bMnysA+e3t7ypQpw1dffUXRokXJnz8/Tk5OZMuWDTs7uyhJvqIoBAUF4efnx5MnT3j06BE+N29y/eJF/M+fx/z+/ShJU26AgAA4e1b9+JydnX43XOTH9evQtWvU9ZgiF6jcsEESIyFEmmC0SZEQyUpR1IUaf/tN7X5atgw6dPjCKQpHjx5l2bJlbNiwgcDAQN0xBwcHGjVqRO3atalWrRoFChRAE49uLY1Gg42NDXnz5iVv3rxRjr9584bjx49z+PBhFnp7c/78eayAfKgJUsN8+aidMyf5FQWzu3fVBOfNGzh9Wv2I69dEo1EXqGzeXLrShBCpniRFQigKDBkCs2erny9eDJ07x1g9KCiI33//ndmzZ3Px4kVdeZ48eejQoQMtWrSgfPnySdrFa2dnR+PGjWncuDG//PILjx49Ytu2bWzYsIG/Dxxgy927cPcuGTNmpGfPngzo1o3cYWFRB3xfuaImSzH5uEAlR45ArVpJ1h4hhDAGkhSJtE1R4H//gxkz1M8XLIBu3aKt6u/vz9q1a+nevTuvXr0CwNramo4dO9KlSxeqVq1qsLFuuXLlok+fPvTp04eHDx+yatUqli1bxu3bt5k6dSrTp0+nVatW/Pjjj5R2df33xD/++OITMQCePk264IUQwkjIaGWRdikK/PQTTJmifj53LvTqFaWav78/P//8MwULFuSPP/7g1atX5MmThylTpvD48WMWLVpE9erVjWbwf+7cuRk5ciQ3btxg27Zt1KlTB61Wy4YNGyhTpgytW7fmauQyAE5OcbtoXOsJIUQKZhw/xYUwhLFjYeJE9fWsWdC3r97hsLAwZs+eTb58+Rg9ejRv374lZ86c/P7779y5c4ehQ4eSOXNmAwQeNyYmJjRu3Ji9e/dy6dIl2rdvj0ajYePGjZQoUYJvv/2WR87O6iyz2MY75coFNWokW9xCCGEokhSJtGn8eDUpAnX6+cCBeod37dpFqVKlGDhwIK9fv6ZIkSKsXLmSWbNm0a5dO0xT2KDjEiVKsGbNGi5dukSrVq1QFIXVq1dTuGhR1levjgIxJ0YDB8ogayFEmiBJkUh7Jk2CUaPU17/8oi7O+NGjR49o1qwZjRo14tq1a9jb2zN//nyuXLmCm5tbikuGPle8eHE2btzI2bNnqVGjBkFBQbT980/62NsT9PlTL2tr9d81ayA8PPmDFUKIZCZJkUhbpk2DESPU1xMmwPDhgLqVzNy5cylatChbt27F3NycIUOGcOvWLXr37p3ik6HPlS1blkOHDvHHH3+QM2dOFrx4QbpXrxjj4sLh774j3Nsbbt9W1zY6f179ugkhRConSZFIO2bNgqFD1ddjxsDIkQDcuHGDGjVq0L9/f969e0fVqlW5cOECU6dO1W0ZkxppNBratWvH9evX+d///ofG1JSxhw7RZPVq1vj6ojg5/Tsrz9MTbt40bMBCCJHEJCkSacPcueoihKDOOBs9GkVRWLhwIWXKlOH48eOkS5eOOXPmcOTIEYoWLWrQcJOTra0tkyZN4uTJk5QoUYLAwEC6dOlCmzZteNO0KdSvDyEh6n5wWq2hwxVCiCQjSZFI/RYsULfvAHVNonHjePnqFS1btqR3794EBQVRp04drl69Sr9+/Yxman1yK1euHCdOnKBDhw6YmZmxceNGSpUuzanu3cHWFg4fhoULDR2mEEIkmbT501+kHUuWwHffqa+HDAEvL44cPUrJkiXZsmUL5ubmTJ06lT179pA7d27DxmoEzM3Nadu2LUeOHKFAgQI8evSIKu3bs7N6dbXC8OHw+LFhgxRCiCQiSZFIvVasULt8AAYNQpk8mZmzZlG7dm2ePn1KkSJFOHXqFEOGDEmzT4diUq5cOc6dO0eXLl3QarU02b2bfzJmhMBA6NMn6uaxQgiRCshvApE6rV4N7u7qL+++fXn388+079CB77//noiICDp06MCZM2coXbq0oSM1WunTp2f58uWsWrUKS2tr2vj7EwqwbRusXWvo8IQQItFJUiRSn7Vr1Q1dFQV69eLO4MFUrlKFtWvXYmZmxq+//sqqVauwtbU1dKQpQseOHTlx4gTB+fIx/mNZcK9e8PKlQeMSQojEJkmRSF02bICOHdVZUt26cbRjRypVqcLVq1dxcnLi4MGDDBgwAE1s21qIKEqWLMmZM2e40KABlwGrwEDO1aqFVmajCSFSEUmKROrx11/Qvj1EREDnzqypXZs69erx6tUrypcvz9mzZ6lWrZqho0yx7Ozs+GvHDo65uxMBlL16lV9q1SI4ONjQoQkhRKKQpEikDtu2Qdu2EB6O0qED45yd6dipE6GhobRq1YpDhw7hJDu9/2cmJiZ8t3Qp1xs0AKDjkSM0rVWLl9KVJoRIBSQpEinfzp3g6gphYWjbtqWXhQWe48YBMGzYMNavX4+NjY2Bg0xdim3cSJCTE7mB5idPUrlyZW7fvm3osIQQ4j+RpEikbHv2QMuWEBpKRIsWtA0OZvHy5ZiYmLBgwQImT54s0+2Tgq0t1r//DkBfINudO1SvXp1Lly4ZNi4hhPgP5LeFSLn274fmzSEkhLDGjWn45g0b//4bS0tLNm7cSK9evQwdYepWty5064YJsNLSkrd+fri4uODj42PoyIQQIkEkKRIp06FD0KQJBAcTUr8+NXx92XvoEOnTp2fnzp20aNHC0BGmDVOnQrZs5A0JYX7OnLx9+5a6deuyZ88eQ0cmhBDxJkmRSHmOHoXGjSEoiJDatan08CEnz5/H3t6eAwcOULt2bUNHmHbY2amb7QJdnj3juypV+PDhA02aNGHz5s0GDk4IIeJHkiKRsvj4QKNG8P49ITVrUtnXl4vXr5M9e3aOHDlCuXLlDB1h2tOqFbRqhSY8nLkhIbi5uhIWFkbbtm0lMRJCpCiSFImU49QpaNgQ3r0jpHp1Kj97xoUbN8iRIwcHDx6kSJEiho4w7ZozBzJlwuTcOdZUqECHDh0IDw+XxEgIkaJIUiRShrNnoX59CAggpHJlqjx/zoWbN8mZMycHDx6kYMGCho4wbXNygmnTADAZM4bfR4/WS4z++usvg4YnhBBxIUmRMH4XLkC9euDvT2jFilR59YrzN2+SK1cuDh48SIECBQwdoQB1A946dSA4GNPvvmPF8uW6xKhNmzZs2bLF0BEKIUSsJCkSxu3yZXXq95s3hJcvj8v795y/dUuXEOXPn9/QEYpIGg0sXAg2NnDwIGbLl7NixQrat29PeHg4rVu3ZufOnYaOUgghYiRJkTBeV6+qTx5evSKiXDkaAieuXiVbtmzs37+ffPnyGTpC8bl8+WD8ePX10KGY+fnx+++/4+bmRnh4OK6urhw9etSwMQohRAwkKRLG6fp1NSF68QJtmTK0srVl35kz2NnZsWfPHukyM2YDB0LFihAQAH37YmZqysqVK/nmm28ICgqiSZMmXLhwwdBRCiFEFJIUCeNz8yZ8/TX4+aGUKkUXJyf+PnwYW1tbdu7cSYkSJQwdoYiNqSksWQLm5vD337B+Pebm5qxfv54aNWrg7+9PgwYNuHnzpqEjFUIIPZIUCeNy546aED19ilKiBAOKFGHVjh1YWlqydetWKlWqZOgIRVwULw4jR6qvBwyAV6+wsbFh69atlC5dmufPn1OvXj0ePXpk2DiFEOITkhQJ43HvHtSuDU+eQNGiTKpTh7lr12Jqasr69etlpeqUZsQIKFoUnj+HIUMAyJgxI7t376ZQoUI8fPiQBg0a8ObNGwMHKoQQKkmKhHF48EBNiB49gsKFWdm1KyNnzgRg4cKFNG3a1LDxifiztFS70TQaWLECdu8GIGvWrHh7e5MjRw6uXbtGq1atCAkJMXCwQgghSZEwBo8eqQnRgwdQsCDeI0bQ9YcfAPD09KRbt24GDlAkWOXK6sBrgN694d07AHLnzs327dtJnz49Bw8epFu3biiKYsBAhRBCkiJhaE+eqGOI7t2DfPm4MH06Lfr2RavV4u7ujqenp6EjFP/V+PHg7KwmvT/+qCsuVaoUGzZswMzMjDVr1vDjJ8eEEMIQJCkShvP0qZoQ3b4Nzs48WL6c+t268eHDBxo0aMCCBQvQaDSGjlL8V+nSwYIF6uvZs9VNfT+qX78+ixYtAsDLy4sFkfWEEMIAJCkShuHnp65DdPMm5M6N/19/Ub9HD168eEGZMmVY/3Eat0gl6teHrl1BUaB7d/hkDFHXrl0ZM2YMAH379mX79u2GiVEIkeZJUiSS34sXakJ07RrkzEn4nj20HjqUmx/3M4scayJSmWnTwNFRve8TJ+odGj16NF27dkWr1dKuXTuuXLlioCCFEGmZJEUieb16pe5ldvWqurP6/v14zJ3L3r17sbGx4e+//8bJycnQUYqkkDkzzJmjvp44Ud3X7iONRsPChQupXbs27969o2nTprx48cJAgQoh0ipJikTyefNG3e3+0iX1icGBAyzYv5/Zs2cDsGrVKkqXLm3YGEXScnWFFi0gPFztRouI0B2KXPU6f/783L9/n9atWxMaGmq4WIUQaY4kRSJ5vH2rjis5fx4cHGD/fg74+tK/f38AJkyYQMuWLQ0bo0h6Gg3MnQsZM8Lp0zBrlt7hLFmy8Pfff5M+fXoOHz5Mv379ZKq+ECLZSFIkkl5AADRsCGfOgL097N/PbQsLXF1dCQ8Pp0OHDowYMcLQUYrkkj07TJ2qvv7pJ7h7V+9w0aJF+fPPP9FoNCxevFj3JFEIIZKaJEUiaQUGQqNGcPKkOqZk7178c+WiadOmvHnzhooVK7J48WKZep/WdO+uLtgZFAQ9e6qz0j7xzTffMGXKFAC+//57dn9cDVsIIZKSJEUi6bx/D40bw/HjkCkTeHujLVGCTp06cf36dXLmzMlff/2FtbW1oSMVyU2jgUWLwNoa9u+HZcuiVPHw8NCbkXbnzh0DBCqESEskKRJJ48MHaNIEjhxRx494e0PZskycOJGtW7diaWnJ5s2bZaZZWpY/P/z8s/raw0NdzPMTGo2G+fPnU6lSJd6+fUurVq348OGDAQIVQqQVkhSJxBcUBM2awcGDkD69uhFo+fLs3LmT0aNHA/Dbb79Rvnx5w8YpDG/QIChfHvz94eOg+09ZWlqyYcMGsmbNyqVLl+jVq5cMvBZCJBmjTYrmzp2Ls7MzVlZWVKpUiVOnTsVYd9OmTZQvX55MmTJha2tL6dKlWblyZTJGm8ZFRKA5dIgchw+j8fZWp1zv26du77BrF1SqxN27d+nQoQOKotC7d2/c3d0NHbUwBmZmsGSJ+u+mTbBxY5QqOXPmZN26dZiamrJ69WrmRK51JIQQicwok6K1a9fi4eGBp6cn586do1SpUjRo0IDnz59HWz9z5sz8+OOP+Pj4cOnSJdzd3XF3d5fBmclh0yZwdsasXj3KT5+OWePGsGcPWFjAjh1QtSofPnygVatWvH37lkqVKjHrs2nYIo0rWRJ++EF93a+fup7VZ1xcXJg8eTKgjjU6evRockYohEgjjDIpmj59Oj179sTd3Z2iRYsyf/58bGxsWLp0abT1a9WqRcuWLfnqq6/Inz8/gwYNomTJkvKDM6lt2gStW8Pjx1GPhYbCixcoikKvXr24ePEiWbNmZcOGDVhaWiZ/rMK4/fQTFCmi7ok3ZEi0Vb7//nvc3NwIDw+nTZs2PP1sDJIQQvxXRpcUhYaGcvbsWerWrasrMzExoW7duvh8srt2TBRFYd++fdy4cYOaNWsmZahpW0SEOh4kpvEdGg0MHszcX39l9erVmJqasm7dOnLmzJm8cYqUwdJS7UbTaNSZaHv3RqkSuW5RsWLFePbsGW3atJEVr4UQicrM0AF87uXLl0RERODo6KhX7ujoyPXr12M8z9/fnxw5chASEoKpqSnz5s2jXr160dYNCQkh5JNdugMCAgAICwsjLCwsEVrxr8jrJfZ1DU1z6BBm0T0hiqQo8OgRf338q3/SpElUrVo1RX8dUuu9/JRB21ihAiZ9+2I6dy5Kz56Enz8PtrZ6VSwtLVm3bh1VqlTh2LFjDB8+XLeeUXzIvUw90kI700Ibk1J8vm5GlxQlVPr06blw4QLv3r1j3759eHh4kC9fPmrVqhWlrpeXF2PHjo1SvmfPHmxsbJIkPm9v7yS5rqHkOHyYuMwdc4iIoGrVqhQoUIAdO3YkeVzJIbXdy+gYqo2m1avz9bp12Ny/z4MuXbjarVu09fr164eXlxezZs3CxsaGSpUqJej95F6mHmmhnWmhjUkhPkt5aBQjm98aGhqKjY0NGzZsoEWLFrryLl268PbtW7Zs2RKn6/To0YNHjx5FO9g6uidFuXLl4uXLl2TIkOE/t+FTYWFheHt7U69ePczNzRP12oakOXQIsxiexH2qg5MTv166RMaMGZMhqqSVWu/lp4yhjZrduzFr2hRFoyHiyBGUihWjrTds2DBmzZpFpkyZOHXqFM7OznF+D2NoZ1JLC22EtNHOtNDGpBQQEIC9vT3+/v5f/B1vdE+KLCwsKFeuHPv27dMlRVqtln379uk2D40LrVarl/h8ytLSMtrBvubm5kn2DZeU1zaI2rUhZ87oB1kDWuAJMOSvv7C3t0/W0JJaqruX0TBoG5s0gU6d0KxciVnv3nDunDqb8TOTJ0/mxIkTnDx5kk6dOnH48GEsoqkXG7mXqUdaaGdaaGNSiM/XzOgGWoM65XbRokWsWLGCa9eu0adPH96/f69b26Zz5856G4h6eXnh7e3N3bt3uXbtGtOmTWPlypV8++23hmpC6mdqqu5fFQ3tx3+v9OhBuRj+yhciVjNmgIMDXL0KXl7RVrGwsGDt2rVkypSJkydPyqbCQoj/zCiTIjc3N6ZOncro0aMpXbo0Fy5cYNeuXbrB1w8fPtSbjvv+/Xv69u1LsWLFqFatGhs3bmTVqlX06NHDUE1IG06eVP/9bDDsY2BalSo0XLgw+WMSqUOWLDB7tvp6wgQ1OYpGnjx5WLFiBaAu5RHX7nUhhIjOf06KNm/eTNu2bSlZsiQFChTQlV+/fp3Jkyfz5MmTBF23f//+PHjwgJCQEE6ePKk3kPLgwYMsX75c9/n48eO5desWQUFBvH79muPHj+Pm5pbgNok4uHJFXa1ao4Fz5wjbs4dR+fNTC6iTNy+9du5Eo9EYOkqRkrVtq24XExamPpWMiIi2WrNmzfDw8ACga9eu3L9/PxmDFEKkJglOirRaLW5ubrRu3ZqNGzdy9+5d7t27pztuZ2fHjz/+yO+//54ogQojM326+m+rVlCoELMvX2b8nTv4WFjw5/r1qWJgtTAwjQbmzYMMGdSnkrFs7+Hl5aXbONbNzU3WLxJCJEiCk6IZM2awfv16evfuzZs3bxg6dKjecUdHR2rUqMH27dv/c5DCyDx9CqtWqa+HDuXMmTP88HGbhsmTJ1OuXDkDBidSlRw5IHIdopEj4ZM/vD716fiiU6dO8eOPPyZjkEKI1CLBSdHy5cupUKEC8+bNI0OGDNF2lRQoUEDv6ZFIJebMUbs0qlblXfHitG/fnrCwMCpXrkyfPn0MHZ1IbXr0ABcX+PABeveOcRX1PHny6LrVp06dyt5oVsUWQojYJDgpun37NjVq1Ii1TpYsWXj16lVC30IYo3fv4Lff1NdDhzJw4EBu375Nrly56N+/v4wjEonPxAQWLQIrK/D2ho8Dq6PTvHlzXWLeuXNnXrx4kVxRCiFSgQQnRdbW1vj7+8da58GDB2TKlCmhbyGM0bJl6i7mBQqwPiSEZcuWodFoWL58OenSpTN0dCK1KlgQIleh9/CAZ89irDp16lSKFi3K06dP6d69O0a2Pq0QwoglOCkqU6YMu3fvJjg4ONrjr1+/ZteuXVSuXDnBwQkjExGhrh8DvOrShZ7ffQfAjz/++MWnhkL8Zx4eULasmpQPGBBjNRsbG/744w8sLS3ZunUr8+bNS8YghRApWYKTooEDB/L48WNcXV15/Nmqxnfu3KFly5b4+/szcODA/xykMBKbN8O9eyhZstBu5078/f2pVKkSo0ePNnRkIi0wM4MlS9SFQzdsUL8fY1CyZEkmT54MwJAhQ7hy5UpyRSmESMESnBQ1b96c//3vf+zcuZM8efIwbdo0ALJmzUqhQoU4cuQIP/30E19//XWiBSsMSFF0s4COlijB3uPHSZ8+PWvWrJFl50XyKV0a/vc/9XW/fvD2bYxVBwwYQKNGjQgJCaF9+/YEBQUlS4hCiJTrPy3e6OXlxe7du2nSpAk2NjaYmpqi1Wpp2LAhO3fujHYnepFCHTsGp06htbDA7fBhAObOnUu+fPkMHJhIc0aNgsKF1aUhhg2LsVrkWDdHR0euXLnC8OHDkzFIIURKlOCk6OHDhzx79ox69eqxZcsWnj17RmhoKC9fvmT79u00aNAgMeMUhvbxSeA6CwuearV06NBB9pYThmFlBYsXq68XL4b9+2OsmjVrVt02IHPmzGHr1q3JEaEQIoVKcFKUN29eRo4cmZixCGN18yZ83FNq7Lt3ODs7M2/ePJl+LwynenXo21d93bOnuoZRDBo0aKDbBqR79+74+fklR4RCiBQowUmRnZ0dWbJkScxYhLGaMQMUha3ALVNTVq9eLdt4CMPz8oJcueDuXfjCYP+JEydSsmRJXrx4Qc+ePWWavhAiWglOimrUqMHJyF3SRer14gXKsmUATAN++uknqlatatiYhAB1T7T589XXM2bA6dMxVrW0tGTVqlVYWFiwdetWln38nhZCiE8lOCny8vLi0qVLjBs3jvDw8MSMSRgRZd48NCEhnAHelysne0oJ4/LNN9CxI2i10L07xLIRbIkSJZgwYQKgTtN/+vRpckUphEghzBJ64uTJkylRogRjx45lwYIFlCpVCkdHxyjjTDQaDUuWLPnPgQoDCAoiaOpUbIBfzc1ZuWqVTL8XxmfmTNi9Gy5fhsmT4aefYqz6/fffs3XrVg4fPsyvv/5K165d5XtaCKGT4KQocuNFgKdPn8b4V5ckRSmX39SpOL57xwOgwi+/UKRIEUOHJERU9vbw66/QoQP8/DO4usJXX0Vb1dTUlBUrVlCyZEmuXbvGtGnT5OmnEEInwUnRvXv3EjMOYWTCQ0MJmjgRgB0FC9Jv0CADRyRELNq1gzVrYNs2tRvtyBF15etoODs7M2PGDHr06MHYsWNp3LgxpUuXTt54hRBGKcFJUZ48eRIzDmFkNnbrhltwMP5A0y1bMDH5T+t8CpG0NBr47Tc4dAh8fGDevFj3R+vUqROLFy/mxIkTfPvtt5w5cwYrK6tkDFgIYYzkN52I4ty5czitXg3A48aNyRlDV4QQRiVnTnVMEcCIEfDgQYxVNRoNffr0wdHRkatXr0oXmhACSISkaPXq1dSrVw8HBwcsLS1xcHCgfv36rFmzJjHiE8ksODiYX1q3piYQrtFQ9LffDB2SEHHXqxfUrAnv30Pv3uqefTHImDEjCxYsAGD69OkcOHAguaIUQhipBCdFERERuLq60rlzZ/bt28f79+/Jnj0779+/Z+/evXTq1AlXV1e0Wm1ixiuS2MiRI2n5cbxYeJs2aHLlMnBEQsSDiQksWgSWluqMtFWrYq3+zTff0KtXLwC6dOmCv79/ckQphDBSCU6Kfv31VzZv3ky1atU4duwYHz584N69e3z48IHjx49TvXp1/vrrL2bPnp2Y8YokdODAATbNmEGbj59byTYuIiUqVAjGjFFfDx4Mz5/HWn3atGnkz5+fR48e6bYDEUKkTQlOilasWEGhQoXYt28fVapU0TtWuXJl9u7dS6FChWTl2BTC39+frl27MhgwBahXD0qVMmxQQiTUkCFQpgy8fg0DB8ZaNV26dCxfvhyNRsPSpUvZsWNHMgUphDA2CU6Kbt68SbNmzWJc+Mzc3JymTZty8+bNBAcnko+HhwcBDx/SM3LxzSFDDBuQEP+FuTksWaJOy1+7Fv7+O9bq1atX5/vvvwegZ8+evHnzJjmiFEIYmQQnRRYWFrx//z7WOu/fv8fCwiKhbyGSye7du1m6dCm9AVtFgeLFoX59Q4clxH9TpgwMG6a+7tMHvjBeaPz48RQqVAhfX18GybpcQqRJCU6KypQpw7p16/D19Y32+NOnT1m3bh1ly5ZNcHAi6fn7+9OjRw/MgR9sbdXCoUPVdV+ESOlGj4aCBcHXF4YPj7WqtbU1K1aswMTEhJUrV7Jly5ZkClIIYSwSnBR5eHjw6tUrypcvz7Rp0zhz5gyPHj3izJkzTJ06lXLlyvH69WsZuGjkhg0bxuPHjxmYNSuZ3r8HJydo397QYQmROKytYfFi9fXChXDwYKzVK1euzNChQwHo3bs3r169SuIAhRDGJMFJUdOmTZk6dSovX75k+PDhVKpUCWdnZypVqsTw4cN5+fIlU6dOpUmTJokZr0hEe/bsYdGiRQCMSZdOLRw4EKTLU6QmNWvCd9+pr3v2hHfv0Bw6RI7Dh9EcOgQREXrVx44dS9GiRfHz86N///4GCFgIYSgJ3uYD1KdFLVq0YPXq1Vy4cIGAgAAyZMhAmTJl6NChA/ny5UusOEUiCwgIoGfPngDMadaMdH//Dba26oJ3QqQ2v/yi7ot2+zZkz45ZYCDlAaZPV1fCnjULWrUCwMrKiuXLl1OlShX+/PNPXF1dad26tUHDF0Ikj/+UFAHky5ePUaNGJUYsIhkNHz6chw8fkjdvXnq/e6cW9ugBdnaGDUyIpJAhA3TqBF5eEBiof+zJE2jdGjZs0CVGFSpU4IcffmDChAn06dOHmjVrkjVrVgMELoRITrL3WRq0b98+3fYGf44cidn+/epKwDLjRqRWERGwcmX0xyK3Ahk8WK8rbfTo0ZQsWZKXL1/St29flFi2DBFCpA4JToqmTZuGvb19jLPPfH19cXBw4Ndff01wcCLxBQYG0r17dwD69u1LxSNH1AOtW0PevAaMTIgkdOQIPH4c83FFgUeP1HofWVhYsHz5cszMzNi4cSNr165NhkCFEIaU4KRo/fr1lCpViuzZs0d7PHv27JQuXZo///wzwcGJxPfDDz/w4MEDnJ2dmTxoEERu3Ptxxo0QqdLTpwmqV6ZMGX766ScA+vXrx7NnzxI7MiGEEUlwUnTr1i2KFSsWa51ixYpx69athL6FSGQHDhxg3rx5ACxevBjbpUshPBxq1IAKFQwcnRBJyMkpwfVGjhxJmTJleP36Nd999510owmRiiU4KQoKCsI2crG/GFhZWfEuchCvMKh3797pus169+5NnYoVYf589aA8JRKpXY0a6iyzmBYl1WggVy613mfMzc1ZsWIF5ubmbNmyhdWrVydxsEIIQ0lwUpQ7d26OHz8eax0fHx9y5syZ0LcQiWjEiBHcu3eP3LlzM3nyZHVfKH9/dUdxWUtKpHampuq0e4g+MVIUmDlTrReNEiVK4OnpCcDAgQOlG02IVCrBSVHjxo05evQoS5cujfb44sWLOXr0KE2bNk1wcCJxHDp0iDlz5gDqfclgY6P+AgB141cTmYQo0oBWrdRp9zlyJOj04cOHU6ZMGd68eSOz0YRIpRL82/CHH37A0dGRnj178vXXX+Pl5cXvv/+Ol5cXtWvXpnfv3mTPnp0RI0YkZrwint6/f6/rNuvZsyf16tWDjRvhwQNwcFDXbhEirWjVCu7fJ9zbmzMeHoR7e0PkVkRdu8LNmzGeam5uzrJlyzAzM2Pz5s2sW7cueWIWQiSbBC/e6ODgwIEDB/j22285ePAgBw8eRKPR6P56qlChAqtXr8bBwSHRghXx9+OPP3Lnzh1y5szJlClT1G6CKVPUg/36qXtDCZGWmJqiuLjw5P17Srm4QK1acOYMHD4Mrq5w4oS6uns0SpUqxY8//sjYsWPp378/X3/9tfyMEyIV+U8rWhcuXJjTp09z+vRpTp06hb+/P5kyZaJixYqUL18+sWIUCXTkyBHdOlGLFi0iY8aMcOgQnD0LVlbQt6+BIxTCCJiZwZ9/QtmycOWKuk/a77/HOCh75MiRbN68mUuXLtG/f39Zv0iIVCRRBpNUqFCBfv36MXz4cKpUqYKpqSlhYWGJcWmRQB8+fKBbt24oikK3bt1o2LChemDaNPXfLl3U7jMhhDoVf+1adaD1qlX/zsyMhoWFBcuWLcPU1JR169axadOmZAxUCJGU4pUU3bt3j6VLl3Izmn73bdu2kSNHDsqXL0/58uVxcnKSPncDGjVqFLdv3yZHjhxMi0yErl+HrVvVv4C//96wAQphbGrWVDeOBXXLm1OnYqxatmxZ/ve//wHqyvCvXr1KjgiFEEksXknRokWL6NmzJ5aWlnrlt2/fpm3btrx48YLcuXPz1Vdf8ebNGzp27Mj58+cTNWDxZcePH2fGjBkALFy4kEyZMqkHpk9X/23WDAoXNkxwQhgzDw91MHZYmLr1zcuXMVYdPXo0RYsWxc/Pj8GDBydfjEKIJBOvpOjo0aOULl2aPHny6JXPmjWL4OBg+vXrx71797hy5QobN24kIiJCNxVcJI+goCDc3d1RFIWuXbvyzTffqAf8/NRxEiCLNQoRE40Gli2DggXVvdA6dtTbJPZTlpaWLFu2DBMTE1atWsW2bduSOVghRGKLd/dZxYoVo5Tv2rULCwsLJk6cqCtr0aIFNWrU4MgnGyyKpDd69Ghu3ryJk5MT0yOfDAHMmwchIVCxIlSrZrgAhTB2GTLApk1gYwN79sC4cTFWrVixIkOGDAHUleLfvn2bTEEKIZJCvJKiFy9eYG9vr1f2+vVr7ty5Q6VKlUifPr3esTJlyvDkyZP/HqWIEx8fH10itGDBAuzs7NQDHz7A3Lnq66FDY97qQAihKl4cFi5UX48bBzt2xFh17NixFCpUCF9fXzwi1zwSQqRI8UqKzM3NowwoPHv2LEC0U/C/tDeaSDzBwcF069YNrVZLp06d9FcSX7ECXr2CvHmhZUvDBSlEStKx47/LVnz7Ldy/H201a2trli5dikajYdmyZezatSv5YhRCJKp4JUWFChVi3759emV79uxBo9FQtWrVKPV9fX1xiuvu1OI/GTNmDNevXydbtmzMjNzCA9TxEB8HXTN4sLomixAibqZPV7uc37xRB14HB0dbrVq1agwcOBBQV44PCAhIziiFEIkkXkmRq6srt27d4rvvvuPSpUts2LCBhQsXki5dun/XwfnEsWPHKFCgQIICmzt3Ls7OzlhZWVGpUiVOxTI9dtGiRdSoUQM7Ozvs7OyoW7durPVTm1OnTqmrVaN2m2XOnPnfg1u3wq1bkCkTdOtmmACFSKksLWH9esiSRV30dNCgGKtOmDCBfPny8fjxY4YNG5aMQQohEku8kqLBgwdTokQJFi5cSJkyZXBzcyMwMJCxY8dG6So7c+YMt2/fVvfaiqe1a9fi4eGBp6cn586do1SpUjRo0IDnz59HW//gwYO0b9+eAwcO4OPjQ65cuahfv36aGM8UHByMu7s7Wq2Wjh070qxZM/0KU6eq//bpA+nSJX+AQqR0uXPDmjXqWLyFC2H58mir2drasmTJEkBdCuPzp+pCCOMXr6TIxsaGY8eOMXbsWBo2bEjHjh3ZsmVLtGt0nDt3jubNm0f9JR0H06dPp2fPnri7u1O0aFHmz5+PjY0NS5cujbb+6tWr6du3L6VLl6ZIkSIsXrwYrVabJn4ojRs3jn/++QdHR0dmzZqlf/DECTh2DMzNYcAAwwQoRGpQvz6MHau+7tMHLl6MtlqtWrXo+3EcUo8ePXj37l1yRSiESATxHmCSLl06Ro0a9cV6vXr1olevXvEOKDQ0lLNnzzJixAhdmYmJCXXr1sXHxydO1/jw4QNhYWH63UifCAkJISQkRPd5ZP9/WFhYom9PEnm9pNj25MyZM/zycQXe2bNnkyFDBr33MZ0yBRNA2749Efb26oJ0SSQp22kspI2pR4LaOXw4psePY7JrF4qrK+E+Pmq39GfGjx/P9u3buX//Pv/73//0x/glI7mXqUdaaGNSis/XTaNEbmtvJHx9fcmRIwfHjx+nSpUquvLhw4dz6NAhTp48+cVr9O3bl927d3P16lWsrKyiHB8zZgxjI//q+8SaNWuwsbH5bw1IJmFhYQwZMoSHDx9So0YN3VopkWyePqVuv35otFr2z5pF4GcLbgoh4s88MJBaHh7YvHjB04oVOfXDD2AS9YH7xYsX8fT0BNSxRsWKFUvuUIUQH3348IEOHTrg7+9PhgwZYq2b6qYiTZo0iT///JODBw9GmxABjBgxQm89kYCAAN04pC99weIrLCwMb29v6tWrh7m5eaJd19PTk4cPH+Lg4MDatWujrB9lMngwGq0WbYMG1OjTJ9HeNyZJ1U5jIm1MPf5TOwsWRKlZE6dTp2hy7RraaAZVf/PNNzx8+JAlS5awdOlSzp49m+x/cMm9TD3SQhuTUnxmgxpdUmRvb4+pqSl+fn565X5+fmTLli3Wc6dOncqkSZPYu3cvJUuWjLGepaVllP3bQF2HKam+4RLz2ufOnWPy5MkA/Pbbb1GXPXj9WjcY1GToUEyS8T9RUn4NjYW0MfVIUDsrVYI5c6BXL0xHjcK0ShWoXTtKtWnTprF7927u3LnD2LFj9VeYT0ZyL1OPtNDGpBCfr1m8BlonBwsLC8qVK6c3SDpy0PSn3Wmfmzx5Mj///DO7du2KdiHJ1CI0NJSuXbsSERFB27ZtcXV1jVpp/nx1FetSpaBOneQPUojUrkcP6NoVtFpo1w6imemaMWNGFn5cFXvmzJkcP348mYMUQsSX0SVFAB4eHixatIgVK1Zw7do1+vTpw/v373F3dwegc+fOegOxf/nlF0aNGsXSpUtxdnbm2bNnPHv2LFXO/JgwYQKXL1/G3t4++s12Q0Jg9mz1tWzpIUTS0GjUrXNKlYLnz6Ft22gnMjRq1IguXbqgKArdunUjKCjIAMEKIeLKKJMiNzc3pk6dyujRoyldujQXLlxg165dODo6AvDw4UOePn2qq//bb78RGhpK69atcXJy0n1MjVyjJ5U4f/68btPduXPn4uDgELXSmjXw7BnkyAFubskcoRBpiI0NbNgAGTPC8eMwfHi01WbMmIGTkxM3btxgzJgxyRujECJejG5MUaT+/fvTv3//aI8dPHhQ7/P7MexJlJqEhobi7u5OeHg4rq6utGnTJmolRfl3scZBg9T1iYQQSadAAXVvwRYtYOZMqFJFfWr0CTs7O+bPn0/z5s2ZOnUqrq6uVKxY0SDhCiFiZ5RPikRUXl5eXLx4kSxZsjB37lw00XWL7doF//wD6dNDAtaIEkIkQPPm8MMP6uvu3eHatShVmjVrRocOHdBqtbi7u+utkyaEMB6SFKUAFy9eZPz48QDMmTNH140YReRTop491Uf6Qojk8fPP6gy0d+/A1VX99zO//vorWbNm5Z9//uHnn382QJBCiC+RpMjIhYWF0bVrV8LDw2nZsiVuMY0TOn8e9u8HU9NYN60UQiQBMzP44w/Inl19UtSzp9qd/YksWbIwb948QF1P7dy5c4aIVAgRC0mKjJyXlxcXLlwgc+bM/Pbbb9F3mwFMm6b+27atuoGlECJ5OTrCunVqgvTnn+paRp+JHA8YERFB165dCQ0NNUCgQoiYSFJkxC5evKh7zB5rt9mjR+oPYYDPtvsQQiSjatX+7cb28IBo9muMnDl6+fJl6UYTwshIUmSkwsLCdLPNWrZsSbt27WKu/OuvEBEBtWpBuXLJFqMQIhoDB6pPbMPDoU0bdR2jTzg4OOi60by8vDh79qwhohRCREOSIiM1adIkzp8/T+bMmZk3b17M3Wb+/rBggfp66NDkC1AIET2NBhYvhiJF1JWu27dX/2j5ROvWrXFzcyMiIoIuXbrIbDQhjIQkRUbo0qVLusfqs2fPjn3Pt8WLITAQvvoKGjVKpgiFELFKnx42bgRbW3UCxOjRUarMmTOHrFmzcvXqVcaNG2eAIIUQn5OkyMhEzjYLCwujRYsWtG/fPrbK6oJxoI4lMpHbKYTRKFpU/aMFYOJE2LpV77C9vT2//fYboG5VdObMmeSOUAjxGfktamR++eUXzp8/j52dXeyzzQDWr4fHjyFrVujYMfmCFELETbt26hgjgE6d4O5dvcOtWrWiXbt2utlo0o0mhGFJUmRELl++rHuM/sVus0+39BgwAKyskiFCIUS8TZmibv/h768u7PjZprCRM0uvXr3K2LFjDRSkEAIkKTIan3abNW/enA4dOsR+woED6oKN1tbQp0/yBCmEiD8LC3X9IgcHuHABPtvTMUuWLMyfPx9QnxSfOnXKAEEKIUCSIqMxefJkzp07F7duM/h3sUZ3d8iSJekDFEIkXM6c6orXJiawdCksWaJ3uEWLFrq90bp27UpwcLCBAhUibZOkyAhcuXJF99h89uzZODk5xX7C1auwY4c69ff775MhQiHEf1anDnzcw5B+/eCzbT5+/fVXHB0duXbtGmPGjEn++IQQkhQZ2qfdZpE7aX/R9Onqvy1bQoECSRugECLx/O9/0LQphISo44tev9YdypIlCws+rjk2ZcoUTp48aagohUizJCkysMmTJ3P27Fns7OyYP3/+l7vNnj2DVavU17JYoxApi4kJrFgB+fLB/fvQuTNotbrDzZs359tvv5VuNCEMRJIiA7pw4YKu2+zXX3/9crcZqJtMhoaqs1mqVEniCIUQic7OTl3Y0coKtm8HLy+9w7NmzSJbtmxcv36d0dEs+iiESDqSFBlISEgInTp1IiwsjJYtW9IxLusMvX8PH/dMkqdEQqRgpUv/+3951Cjw9tYdypw5MwsXLgRg2rRpnDhxwgABCpE2SVJkIJ6enly5coWsWbOyYMGCL3ebASxbBm/eQP780Lx50gcphEg67u7Qo4e65liHDvDoke5Q06ZN6dy5s64bLeiztY2EEElDkiIDOH78OFOmTAFg4cKFODg4fPmkiAiYMUN9/f33YGqahBEKIZLF7NlQtiy8fAlt2qhd4x/NnDmT7Nmzc+PGDUaOHGnAIIVIOyQpSmbv37/X/QXYpUsXmsf1ic9ff6lbBGTODF27JmWIQojkYmUFGzZApkxw8qS6h+FHdnZ2LP64d9rMmTPZv3+/gYIUIu2QpCiZDR8+nDt37pArVy5mzZoV9xMjt/To21fdeVsIkTrkzfvvjNI5c2DNGt2hRo0a0bt3bwC6du3K27dvDRCgEGmHJEXJaM+ePcz7OLhy2bJlZMyYMW4nHj8OJ06o2wV8tkWAECIVaNwYfvpJfd2zp7pA60dTp04lf/78PHr0iIGRm8sKIZKEJEXJ5M2bN3Tr1g2A/v37U6dOnbifHPmUqFMncHRMguiEEAY3ZgzUrQsfPkCrVhAQAEC6dOlYuXIlJiYmrFy5ko0bNxo2TiFSMUmKksn333/PkydPKFiwIL/88kvcT7x1Sx1PBODhkSSxCSGMgKmp2nWWMyfcvAndu6sz04AqVarwww8/ANC7d2+ePXtmyEiFSLUkKUoGPj4+rFmzBhMTE37//XdsbGzifvKMGeoPxsaNoWjRpAtSCGF4Dg6wfj2Ym6sDsGfO1B3y9PSkdOnSvHr1ih49eqB8TJiEEIlHkqIk5ufnx2+//QbA//73PypXrhz3k1++hOXL1defzEoRQqRilSv/u/zGsGFw5AgAFhYWrFy5EgsLC7Zv366bmSZEahAQEMC1a9cMHYYkRUlJURT69u1LQEAAJUqUwNPTM34X+O03CApS1zGpVStJYhRCGKG+fdUFHSMiwM1N3fMQKF68OBMnTgTULvk7d+4YMkohEs2gQYMoW7YsK1euNGgckhQloXfv3vHmzRvMzMxYtmwZlpaWcT85OFidngvqlh5xWfFaCJE6aDSwcCEUKwZPn0K7dhAeDqjJkIuLC+/fv6dLly5EREQYOFgh/psNGzawfPlyQkNDyZs3r0FjkaQoCaVPnx5vb28mTpxIyZIl43fyqlXw/Dnkzg2tWydNgEII42Vrq24cmy4dHDoEP/4IgImJCcuXLyd9+vQcO3aMqZGzU4VIgXx9fXVrcf3www9Ur17doPFIUpTETE1NKVSoUPxO0mph2jT19aBB6qBLIUTaU7iwuuchwOTJsHkzAM7OzrrFX0eNGsXFixcNFaEQCRa5t9/r168pV65c/IeYJAFJiozRjh1w/TpkyKBuGCmESLtat/53OY6uXdVlOlBXuG7evDlhYWF06NBBNo0VKc6cOXPw9vbG2tqaVatWYWFhYeiQJCkySpGPw3v3VhMjIUTaNmkSVK+uLujo6gofPqDRaFi0aBHZsmXjn3/+YejQoYaOUog4u3z5MsOHDwdgypQpFClSxMARqSQpMjZnzqjjB8zMQJb0F0KA2oW+dq26ov3ly/Ddd6AoODg4sGLFCgDmzZvH33//beBAhfiyoKAg2rdvT0hICN988w19+/Y1dEg6khQZm8ixRO3aqSvbCiEEQPbsamJkagorV6qz04D69esz5OM6Zt26dcPX19eQUQrxRUOHDuXq1as4OjqybNkyNEY0u1qSImPy4IG6mi3IYo1CiKhcXMDLS309cCCcPg3AhAkTKFOmDK9evaJLly5otVoDBilEzP7++2/dxui///47WbNmNXBE+iQpMiazZqmLtdWtC6VLGzoaIYQxGjoUWrSA0FB1EParV1haWrJmzRqsra3Zu3cv06dPN3SUQkTx5MkT3cboQ4YMoX79+gaOKCpJiozF27ewaJH6Wp4SCSFiotGo2/8UKAAPH0LHjhARQZEiRXTT9EeOHMm5c+cMG6cQn9BqtXTu3JlXr15RtmxZ3crsxkaSImOxcCG8ewfFi0ODBoaORghhzDJmVBd2tLaG3bth/HgAevToQatWrQgLC6NTp04EBwcbOFAhVFOmTGH//v3Y2NiwZs0ao5h+Hx1JioxBaKjadQbqUyIjGnQmhDBSJUvCggXq67FjYdcu3TT9HDlycOvWLZYsWWLYGIUATp8+zU8//QTA7NmzKVy4sIEjipkkRcZg7Vrw9YVs2aB9e0NHI4RIKTp10k3Pp2NHePCAzJkzs3LlSjQaDd7e3qyPnLwhhAEEBgbSoUMHwsPDadOmDe7u7oYOKVaSFBmaovy7WOPAgRCfTWOFEGLmTChfHl6/Vgdeh4RQu3Zthg0bBsB3333H7du3DRujSJMURdF9/+XOnZsFCxYY1fT76EhSZGh798KlS+rmjx83xRNCiDiztIQNGyBzZnXx18GDARgzZgxfffUVgYGBuLm5ERISYtg4RZqzePFi1qxZg6mpKWvWrMHOzs7QIX2RJEWGFrlYY/fu6g81IYSIrzx5YPVqdTzi/PmwfDnmx44xt3p1mmXIwIVz52QbEJGsLl68yIABAwCYOHEi1apVM3BEcSNJkSFduqTOHDEx0f11J4QQCdKwIUTuMu7ujlm9etRetIgtAQHcB57MmcOGDRsMGaFIIwIDA2nTpg0hISE0btw4RSXkkhQZUuQCa66ukDevYWMRQqR8xYpFW5wT2AD81bkzd+7cSdaQRNqiKAq9e/fm1q1b5MyZkxUrVmBiknJSjZQTaWrj6wtr1qivZbFGIcR/FREB338f7aHIoa0Tg4Jo9/EveCGSwsKFC/njjz8wNTVl7dq1ZMmSxdAhxYskRYYyezaEhUH16lCpkqGjEUKkdEeOwOPHMR42AXIDtufPp6juDJFyXLhwgUGDBgHg5eVF1apVDRxR/BllUjR37lycnZ2xsrKiUqVKnDp1Ksa6V69exdXVFWdnZzQaDTNnzky+QBMqMFAdDAnqPkZCCPFfPX0ap2pOwJw5c1i3bl3SxiPSlICAANq2bUtISAhNmjRhSArtATG6pGjt2rV4eHjg6enJuXPnKFWqFA0aNOD58+fR1v/w4QP58uVj0qRJZMuWLZmjTaClS9W9zgoWhKZNDR2NECI1cHKKU7XR+fPjAHTr1o1//vknaWMSaYKiKHTt2pVbt26RK1culi9fnqLGEX3K6KKePn06PXv2xN3dnaJFizJ//nxsbGxYunRptPUrVKjAlClTaNeuHZYpYeHD8HB1sTVQxxKl0G8cIYSRqVEDcub84jZBX925w11TU3q9f0/bFi3w9/dPpgBFavXLL7+wefNmLCwsWL9+fYobR/QpM0MH8KnQ0FDOnj3LiBEjdGUmJibUrVsXHx+fRHufkJAQvYGGAQEBAISFhREWFpZo7xN5zU//1axfj9n9+yj29oS3b6+OK0oFPm9naiRtTD1Sazs106Zh2q4daDRoFEVXrnxMlLSenpj89RfpLlxgOnD91i1mNmjAD4cOpdi/7FPrvfyUMbdx7969/PjjjwDMnDmTsmXLGl2c8YnHqJKily9fEhERgaOjo165o6Mj169fT7T38fLyYuzYsVHK9+zZg42NTaK9z6e8vb1BUag5Zgx2wI06dbhx4ECSvJcheXt7GzqEJCdtTD1SXTstLXEaPpwSixdj/eqVrjgoSxaudO/O09KloUQJcu/fT6EVKyjy7h2eJ09yIV8+Xv34I+9y5DBc7P9RqruX0TC2Nvr5+TF06FC0Wi1169bFycmJHTt2GDqsKD58+BDnukaVFCWXESNG4OHhofs8ICCAXLlyUb9+fTJkyJCo7xUWFoa3tzf16tXD4uRJzG7dQrGyIv+0aeTPmjVR38uQPm2nubm5ocNJEtLG1CNVt/Obb2DMGIIPHuSKtzfF69XDvFYtypiaUiayTtOmMGYMF9u3p+jevZT29UU7cCDKgAFof/wRMmY0ZAviJVXfy4+MsY1BQUHUqlWLwMBAypUrx6ZNm7CysjJ0WNGK7A2KC6NKiuzt7TE1NcXPz0+v3M/PL1EHUVtaWkY7/sjc3DzJvuHMzc0x+ziWSNO5M+Yp+C+y2CTl19BYSBtTj1TbTnNzqFOHJyEhlKpTJ/o22ttTytubn9q0ofKGDTSJiICZMzFdvRomTIBu3cDUNPljT6BUey8/YSxtVBSFgQMHcv78eezt7dm0aRPp06c3dFgxis/XzKg6kS0sLChXrhz79u3TlWm1Wvbt20eVKlUMGFkiuHED/v5bff3JUyohhDCkn1auZGz58jQC7llawosX0KsXVKigrn0kxGfmz5+vW6n6zz//JHfu3IYOKdEYVVIE4OHhwaJFi1ixYgXXrl2jT58+vH//Hnd3dwA6d+6sNxA7NDSUCxcucOHCBUJDQ3ny5AkXLlzg9u3bhmpCtExmzVJfNGsGhQsbNhghhPjIysqKjRs3csbenkIhIawoVQolY0Y4fx5q1oR27eDhQ0OHKYzEwYMHGThwIACTJk2iTp06Bo4ocRldUuTm5sbUqVMZPXo0pUuX5sKFC+zatUs3+Prhw4c8/WSRMl9fX8qUKUOZMmV4+vQpU6dOpUyZMvTo0cNQTfhXRASaQ4fIs2sXJitWqGWyWKMQwsjkzp2bTZs2oTE3p+vFi0zr1Ut9WqTRwNq1UKQIjBkD8RiwKlKfu3fv4urqSnh4OO3atUuVK6MbXVIE0L9/fx48eEBISAgnT56k0ifbYBw8eJDly5frPnd2dkZRlCgfBw8eTP7AP7VpEzg7Y1avHqXnz0cTFqb288ewCKUQQhhSjRo1+O233wAYNmUKG+rVg7Nn1adFQUEwdqyaHP35J3wy3V+kDQEBATRt2pTXr19ToUIFli5diuYLa2KlREaZFKV4mzZB69ZR9yEKC4M2bdTjQghhZLp37873HzeV7dy5M+cUBQ4ehHXrIHduePQI2rdXE6Vz5wwbrEg2ERERtG/fnn/++Yfs2bPz119/YW1tbeiwkoQkRYktIgIGDYr9L6nBg9V6QghhZCZPnkzDhg0JCgqiefPmPH32TP1j7to19WmRtTUcPQrly0PPnvL0Ow344Ycf2LFjB9bW1mzZsoXs2bMbOqQkI0lRYvvCTtUoivrXlszqEEIYITMzM/7880+KFCnC48ePadmyJcHBwWBjA6NHqzNp27dXf5YtXqzu4ThtGoSGGjp0kQSWL1/O1KlTda/Lly9v4IiSliRFiS2OO1XHuZ4QQiSzjBkz8vfff2NnZ8fJkyfp0qULWq1WPZgrF6xZo/5hV7YsBASoE0hKlAAjXM1YJNz+/fvp1asXAKNHj6Zt27YGjijpSVKU2OK4U3Wc6wkhhAEULFiQjRs3Ym5uzrp16/jf//6nX6F6dTh1Sn1alDUr3LwJjRurK2on4rZMwjAuX75My5YtCQsLw83NDU9PT0OHlCwkKUpsX9qpWqNR/9KqUSN54xJCiHiqXbs2S5cuBWDq1KnMmTNHv4KpKXTvriZEQ4eqM2x37lSfGnl4wNu3yR+0+M8eP37MN998Q0BAADVr1tQt1JgWpI1WJidTU4hcqPHzxCjy85kzU9Ty+UKItOvbb79lwoQJAAwcOJC//voraqWMGWHKFLhyBZo0gfBwmDEDChWCRYtkYkkKEhAQQOPGjXn8+DFFihRh8+bN0W6LlVpJUpQUWrWCDRvg8/3NcuZUy1u1MkxcQgiRACNGjKBXr14oikL79u05ceJE9BULFYKtW9WnRUWK/LtlSPnycPhw8gYt4i00NBRXV1cuXbpEtmzZ2LlzJ5kzZzZ0WMlKkqKk0qoV3L9PuLc3Zzw8CPf2hnv3JCESQqQ4Go2GuXPn0rhxY4KDg2natCm3bt2K+YSGDeHSJfVpUcaMcOECuLiAmxs8eJBscYu402q19OzZk71792Jra8v27dtxdnY2dFjJTpKipGRqiuLiwpOaNVFcXKTLTAiRYkVO1S9XrhwvX76kXr16PI5t+RFzc3VNtlu3oHdvdfjAunXqEyRPT9kyxIgoisKQIUP4/fffMTU1Zf369ZQtW9bQYRmEJEVCCCHiJF26dGzfvp2CBQvy4MED6tWrx4sXL2I/ycEB5s9XV8CuWROCg2HcOHVjbNkyxCj8/PPPzJw5E4AlS5bQqFEjwwZkQJIUCSGEiDNHR0f27t1Lrly5uH79Og0bNsTf3//LJ5YurW4Zsn495MmjLnLbvr06E/fs2aQOW8Tg119/1U23nzVrFl26dDFwRIYlSZEQQoh4yZ07N97e3jg4OHDu3DmaNm3Kh7h0h2k06r6Q166pT4usreHYMahQAXr0AD+/pA9e6KxYsYJBgwYBMHbsWAYOHGjgiAxPkiIhhBDxVrhwYXbv3k3GjBk5cuQIrVu3JiQkJG4nW1vDqFHqliEdOqhdaEuWqLPXZMsQfRERaA4dIsfhw2gOHUq05Q02btxIt27dABg8eDCjRo1KlOumdJIUCSGESJAyZcqwfft2rK2t2blzZ/wSI1AXsl29Wt1gtly5f7cMKV4ctm+X8UabNoGzM2b16lF++nTM6tUDZ2e1/D9ddhPt2rVDq9XStWtXpk2bhiamBYfTGEmKhBBCJFi1atXYunUrVlZWbNu2DVdX1/glRupF1C1DlixRtwy5dUtdBDItbxmyaZPa1fj5DL8nT9TyBCZGmzZtws3NjfDwcDp27MjixYvTzGrVcSFfCSGEEP9JnTp12LZtG9bW1mzfvj1hiZGJCXTrpiZEw4apU/p37VK3DPn++7SzZUhoKPj6Qt++0T8piywbPDjeXWmfJ0QrVqzAVJaK0WNm6ACEEEKkfHXq1GHr1q00bdqU7du306pVKzZt2hT/LSIyZIDJk6FnT3X/tG3b1K2RVq2CCRPUvdYif5F/Ot7G1hZq1zae9eBCQuDNG3j1Cl6/jvoRXfmrV/Du3ZevrSjw6BEcOQK1asUpHEmI4kaSIiGEEIki8olRkyZN2LFjB82aNWPTpk3Y2trG/2IFC6pbhuzapT4pun5dXQRy3jx1f8lXr2DQIMweP6Y8wPTp6lZKs2Yl7s4BwcFxT2g+/fz9+8SLISZPn8ap2urVq+nataskRHEgSZEQQohE8/XXX7Nt2zaaNm3Knj17qFevHtu3b8fOzi5hF2zYEOrUUZMhT0+4eDHmpyOR422i22MyKCjuCc2n5UFBCYsb1C5BOzvInFn/I0uWqGWflp8/D3Xrfvn6Tk5frDJ37lz69+8PQKdOnVi2bJkkRLGQpEgIIUSi+vrrr9m7dy+NGzfGx8cHFxcXdu/ejVMcfolHy9wcBg1Sp+//9BMsXBh9vcjxNt9+q25C++bNvwlOcHDC3hvU5CauCc2nHxkzqufGV61a6lOvJ0+iH1ek0ajHa9SI8RKKojB+/HhGjx4NwIABA5g5c6YMqv4CSYqEEEIkuipVqnD48GHq16/P5cuXqV69Ot7e3uTLly/hF3VwUFfBjikpihQUpI63+ZyZWdwTmk/L06dPWHKTUKamajdg69ZqAvRpYhQ5dX7mzBjHT2m1WoYMGaLbusPT0xNPT0+Zdh8HkhQJIYRIEsWLF+fo0aPUq1ePu3fvUqVKFbZu3UrFihUTftE4jqNh4EBo2lQ/yUmf/t+kwti1aqV2Aw4apD8tP2dONSGKYdxUUFAQXbp0Yf369QDMnDlTt2q1+DJ5jiaEECLJ5MuXj6NHj1KqVCmeP3+Oi4sLGzduTPgF49oF17KlOi6nbFl1wcMMGVJOQhSpVSu4f59wb2/OeHgQ7u0N9+7FmBC9ePGCOnXqsH79eszNzfn9998lIYonSYqEEEIkKScnJ44cOULjxo0JDg6mTZs2TJkyBSUhK1bXqKE+LYkpwdFo1JWyYxlvk6KYmqK4uPCkZk0UF5cYu8yuX79O5cqV8fHxIVOmTOzZs4dOnTolc7ApnyRFQgghklz69On566+/6N+/P4qiMHz4cHr37h3/RR4jx9tA1MQoDuNtUqO9e/dStWpV7t69S968efHx8aFWHNcvEvokKRJCCJEszMzMmD17NrNmzUKj0bBo0SJcXFx4/PlWFl8SOd4mRw798pw5o5+On0opisKkSZNo0KABb968oUqVKpw8eZIiRYoYOrQUS5IiIYQQyWrgwIHs2LEDOzs7Tp48Sbly5Th48GD8LhLP8TapTUBAAK6urowYMQKtVku3bt3Yv38/Dg4Ohg4tRZOkSAghRLJr2LAhZ86coXTp0jx//py6desyderU+I0ziuN4m9Tm6tWrVKxYkc2bN2Nubs6CBQtYvHgxVlZWhg4txZOkSAghhEHky5ePY8eO0alTJyIiIhg2bBjffPMNfn5+hg7NKCmKwrx58yhfvjw3btwgR44cHDlyhF69eskaRIlEkiIhhBAGY2Njw4oVK/jtt9+wsrJi165dlChRgu3btxs6NKMSEBBAq1at6NevH8HBwTRo0ICzZ89SqVIlQ4eWqkhSJIQQwqA0Gg3fffcdZ86coWTJkrx48YImTZrQp08fAgICDB2ewf39998MGjSI7du3Y2FhwYwZM9ixYweOjo6GDi3VkaRICCGEUShWrBgnT57ULTg4f/58ihUrlmafGvn5+eHm5kbr1q158+YNRYoU4dSpUwwePFj2MEsi8lUVQghhNKysrJg5cyb79u0jX758PH78mCZNmtCxY8c0M9ZIq9WyfPlyihYtyrp16zA1NcXV1ZVTp05RqlQpQ4eXqklSJIQQwuh8/fXXXL58mSFDhmBiYsKaNWsoWLAgU6ZMif+CjynIyZMnqVq1Ku7u7rx+/ZrSpUtz/PhxOnXqJLPLkoEkRUIIIYySjY0NU6dO5cSJE5QvX57AwECGDx9O8eLF2bJlS8K2CTFSjx8/pkuXLlSuXJmTJ0+SLl06fvnlF06dOkWZMmUMHV6aIUmREEIIo1ahQgVOnjzJ8uXLyZYtG7dv36ZFixZUrlyZXbt2pejkyNfXlwEDBpA/f35+//13ALp27crNmzcZPnw45ubmBo4wbZGkSAghhNEzMTGhS5cu3Lx5kxEjRmBjY8OpU6do1qwZP/zwA9u3b0er1Ro6zDi7f/8+gwcPJn/+/MyZM4fQ0FBq1qzJqVOnWLZsGU5OToYOMU2SpEgIIUSKkT59eiZOnMi9e/cYMmQI1tbW3Lhxg5YtW1K4cGF+/fVXo53GrygKhw8fxtXVlfz58zNr1iyCg4OpVq0a+/bt4+DBg1SoUMHQYaZpkhQJIYRIcbJmzcrUqVO5ceMGLVq0IFOmTNy+fZtBgwaRM2dOevTowaFDh4zi6ZGvry9Tp06lVKlSuLi4sGnTJrRaLXXr1mX37t0cOXKEr7/+WlalNgKSFAkhhEixsmXLRteuXbl79y7z5s2jSJEiBAYGsmTJEmrVqkW+fPkYMmQIBw4cICwsLNniun//PnPmzKFevXrkypWLYcOGcfnyZaytrenVqxdXrlzB29ub+vXrSzJkRMwMHYAQQgjxX6VLl44+ffrQu3dvjhw5wsqVK1m/fj0PHjxg+vTpTJ8+nYwZM/L1119TvXp1qlWrRpkyZbCwsPjP760oCo8fP+bo0aMcPXqUQ4cOcfXqVb061apVo3PnzrRp0wY7O7v//J4iaUhSJIQQItUwMTHBxcUFFxcXZs+ezY4dO9i6dSvbt2/n5cuXbN68mc2bNwNgbm5OoUKFKFq0KEWKFCFHjhxkz56dbNmykS5dOqysrLCysiI8PJygoCCCg4N59eoVvr6++Pr6cvfuXa5evcrVq1d5/fp1lDiqV69O06ZNadmyJfnz5zfEl0PEkyRFQgghUiVra2tcXV1xdXUlIiKC06dPc/jwYY4ePcrx48d59eqVLqn5r0xNTSlTpgzVqlWjWrVq1KlTh8yZMydCK0RykqRICCFEqmdqakrlypWpXLkyw4cPR1EUHj58yD///MPVq1e5efMmT58+5enTp/j5+fHhwweCg4MJDg7GzMwMKysrrK2tyZQpk+6JUq5cuShatCjFihWjSJEiWFtbG7qZ4j+SpEgIIUSao9FoyJMnD3ny5KFRo0aGDkcYCZl9JoQQQgiBESdFc+fOxdnZGSsrKypVqsSpU6dirb9+/XqKFCmClZUVJUqUYMeOHckUqRBCCCFSA6NMitauXYuHhweenp6cO3eOUqVK0aBBA54/fx5t/ePHj9O+fXu6d+/O+fPnadGiBS1atODKlSvJHLkQQgghUiqjTIqmT59Oz549cXd3p2jRosyfPx8bGxuWLl0abf1Zs2bRsGFDhg0bxldffcXPP/9M2bJlmTNnTjJHLoQQQoiUyuiSotDQUM6ePUvdunV1ZSYmJtStWxcfH59oz/Hx8dGrD9CgQYMY6wshhBBCfM7oZp+9fPmSiIgIHB0d9codHR25fv16tOc8e/Ys2vrPnj2Ltn5ISAghISG6z/39/QF4/fp1oi8DHxYWxocPH3j16hXm5uaJem1jkhbaKW1MPdJCO9NCGyFttDMttDEpBQYGAurK419idElRcvDy8mLs2LFRyvPmzWuAaIQQQgiR1AIDA8mYMWOsdYwuKbK3t8fU1BQ/Pz+9cj8/P7JlyxbtOdmyZYtX/REjRuDh4aH7XKvV8vr1a7JkyZLoG/MFBASQK1cuHj16RIYMGRL12sYkLbRT2ph6pIV2poU2QtpoZ1poY1JSFIXAwECyZ8/+xbpGlxRZWFhQrlw59u3bR4sWLQA1adm3bx/9+/eP9pwqVaqwb98+Bg8erCvz9vamSpUq0da3tLTE0tJSryxTpkyJEX6MMmTIkCa+mdNCO6WNqUdaaGdaaCOkjXamhTYmlS89IYpkdEkRgIeHB126dKF8+fJUrFiRmTNn8v79e9zd3QHo3LkzOXLkwMvLC4BBgwbh4uLCtGnTaNy4MX/++Sdnzpxh4cKFhmyGEEIIIVIQo0yK3NzcePHiBaNHj+bZs2eULl2aXbt26QZTP3z4EBOTfyfOVa1alTVr1vDTTz8xcuRIChYsyF9//UXx4sUN1QQhhBBCpDBGmRQB9O/fP8busoMHD0Ypa9OmDW3atEniqOLP0tIST0/PKN11qU1aaKe0MfVIC+1MC22EtNHOtNBGY6FR4jJHTQghhBAilTO6xRuFEEIIIQxBkiIhhBBCCCQpEkIIIYQAJClKMiEhIfzvf/8je/bsWFtbU6lSJby9vQ0dVqKZMGECGo0mygy/WrVqodFoonw0bNjQQJHG3dmzZ2nYsCEZMmQgffr01K9fnwsXLkRb9/jx41SvXh0bGxuyZcvGwIEDeffuXfIG/AXv3r3D09OThg0bkjlzZjQaDcuXL49Sb9GiRbi4uODo6IilpSV58+bF3d2d+/fvR6kb3b3VaDRMmjQp6RsUg7i2E2DdunVUrlyZTJkykSVLFlxcXNi+fXuUelqtlsmTJ5M3b16srKwoWbIkf/zxRxK3JGanT5+mf//+FCtWDFtbW3Lnzk3btm25efOmXszLly+nWbNm5MqVC1tbW4oXL8748eMJDg6Ock1ju5dxaWNscWs0GurVq6dX19ju49WrV2nTpg358uXDxsYGe3t7atasydatW/XqnTp1ir59+1KuXDnMzc1jXVTY2O5jSme0s89Suq5du7JhwwYGDx5MwYIFWb58Od988w0HDhygevXqhg7vP3n8+DETJ07E1tY22uM5c+bUrSEVKS4riRrSuXPnqF69Orly5cLT0xOtVsu8efNwcXHh1KlTFC5cWFf3woUL1KlTh6+++orp06fz+PFjpk6dyq1bt9i5c6cBW6Hv5cuXjBs3jty5c1OqVKloZ20CnD9/nrx589KsWTPs7Oy4d+8eixYtYtu2bVy8eDHKvatXrx6dO3fWKytTpkxSNeOL4trO2bNnM3DgQBo3bsykSZMIDg5m+fLlNGnShI0bN9KqVStd3R9//JFJkybRs2dPKlSowJYtW+jQoQMajYZ27dolU8v+9csvv3Ds2DHatGlDyZIlefbsGXPmzKFs2bKcOHGC4sWL8+HDB9zd3alcuTLfffcdWbNmxcfHB09PT/bt28f+/fuj/HI1pnsZlzYCrFy5Msq5Z86cYdasWdSvX1+v3Nju44MHDwgMDKRLly5kz56dDx8+sHHjRpo1a8aCBQvo1asXADt27GDx4sWULFmSfPnyRUkMP2dM9zHFU0SiO3nypAIoU6ZM0ZUFBQUp+fPnV6pUqWLAyBKHm5ub8vXXXysuLi5KsWLF9I5FV5YSfPPNN4qdnZ3y8uVLXZmvr6+SLl06pVWrVnp1GzVqpDg5OSn+/v66skWLFimAsnv37mSL+UuCg4OVp0+fKoqiKKdPn1YAZdmyZXE698yZMwqgeHl56ZUDSr9+/RI71P8kru0sWLCgUqFCBUWr1erK/P39lXTp0inNmjXTlT1+/FgxNzfXa6dWq1Vq1Kih5MyZUwkPD0+6xsTg2LFjSkhIiF7ZzZs3FUtLS6Vjx46KoihKSEiIcuzYsSjnjh07VgEUb29vvXJju5dxaWNMunfvrmg0GuXRo0e6MmO8j9EJDw9XSpUqpRQuXFhX9uzZM+XDhw+KoihKv379lNh+VRvbfUzppPssCWzYsAFTU1Nd1g9gZWVF9+7d8fHx4dGjRwaM7r85fPgwGzZsYObMmbHWCw8PN7rupNgcOXKEunXrkiVLFl2Zk5MTLi4ubNu2TdeWgIAAvL29+fbbb/WW2+/cuTPp0qVj3bp1yR57TCwtLWPc/+9LnJ2dAXj79m20x4OCgqLtkjGEuLYzICCArFmz6j0tyZAhA+nSpcPa2lpXtmXLFsLCwujbt6+uTKPR0KdPHx4/foyPj0/iNiAOqlatioWFhV5ZwYIFKVasGNeuXQPULZKqVq0a5dyWLVsC6Op9zljuZVzaGJ2QkBA2btyIi4sLOXPm1JUb432MjqmpKbly5dL7v+bo6Kj3PRkXxnIfUzpJipLA+fPnKVSoUJQ9aipWrAgQ4zgVYxcREcGAAQPo0aMHJUqUiLHezZs3sbW1JX369GTLlo1Ro0YRFhaWjJHGX0hISLQ/hGxsbAgNDeXKlSsAXL58mfDwcMqXL69Xz8LCgtKlS3P+/PlkiTcpvHr1iufPn3PmzBndljp16tSJUm/58uXY2tpibW1N0aJFWbNmTXKHmiC1atVi165dzJ49m/v373P9+nX69euHv78/gwYN0tU7f/48tra2fPXVV3rnR/7/NZZ7rCgKfn5+2Nvbx1rv2bNnANHWM/Z7GZc27tixg7dv39KxY0e9cmO+j+/fv+fly5fcuXOHGTNmsHPnzmj/r8WVsd/HlETGFCWBp0+f4uTkFKU8sszX1ze5Q0oU8+fP58GDB+zduzfGOvnz56d27dqUKFGC9+/fs2HDBsaPH8/NmzdZu3ZtMkYbP4ULF+bEiRNERERgamoKQGhoKCdPngTgyZMngHpvgRjv75EjR5Ip4sSXI0cOQkJCAMiSJQu//vprlIGrVatWpW3btuTNmxdfX1/mzp1Lx44d8ff3p0+fPoYIO85+/fVXXr58ycCBAxk4cCCgJgr79u3T2zz66dOnODo6Rhl/Y2z/f1evXs2TJ08YN25crPUmT55MhgwZaNSokV55SriXcWnj6tWrsbS0pHXr1nrlxnwfhwwZwoIFCwAwMTGhVatWzJkzJ0HXSgn3MSWRpCgJBAUFRbscu5WVle54SvPq1StGjx7NqFGjcHBwiLHekiVL9D7v1KkTvXr1YtGiRXz//fdUrlw5qUNNkL59+9KnTx+6d+/O8OHD0Wq1jB8/XpcERd6zyH9jur8p8d5G2rlzJ8HBwVy7do1Vq1bx/v37KHWOHTum93m3bt0oV64cI0eOpGvXrvF+5J+cbGxsKFy4MDlz5qRJkyYEBgYyY8YMWrVqxZEjRyhQoACQMv7/Rj7lqlKlCl26dImx3sSJE9m7dy/z5s0jU6ZMeseM/V7GpY0BAQFs376db775Jkr7jPk+Dh48mNatW+Pr68u6deuIiIggNDQ0Qdcy9vuY0kj3WRKwtrbW/cX9qcj+3pT4TfrTTz+ROXNmBgwYEO9zhwwZAhDrEyZD++677xg5ciRr1qyhWLFilChRgjt37jB8+HAA0qVLB/x772K6vynx3kaqXbs2jRo1wsPDg/Xr1zN27Ngv/vVqYWFB//79efv2LWfPnk2mSBOmTZs2PHz4kOXLl9O6dWvc3d05ePAgoaGh/Pjjj7p6xv7/99mzZzRu3JiMGTPqxi9GZ+3atfz000907949Tk8MjOlexrWNGzduJDg4OErXGRj3fSxSpAh169alc+fOujGLTZs2RUmEXbeM6T6mRJIUJQEnJyfdE4ZPRZYZ+/T0z926dYuFCxcycOBAfH19uX//Pvfv3yc4OJiwsDDu37/P69evYzw/V65cALHWMQYTJkzAz8+PI0eOcOnSJU6fPo1WqwWgUKFCwL+P3mO6vynt3sYkf/78lClThtWrV3+xbkq4v3fv3mXXrl00a9ZMrzxz5sxUr15d769tJycnnj17FuUXlDH8//X396dRo0a8ffuWXbt2xRiLt7c3nTt3pnHjxsyfPz/O1zeGexnXNoLadZYxY0aaNGkS5Zgx38fPtW7dmtOnT39x6n1cGcN9TKkkKUoCpUuX5ubNmwQEBOiVR45PKV26tAGiSrgnT56g1WoZOHAgefPm1X2cPHmSmzdvkjdv3lj7/O/evQsQa7ebsbCzs6N69eq6geR79+4lZ86cFClSBIDixYtjZmbGmTNn9M4LDQ3lwoULKe7exiYoKAh/f/8v1ksJ99fPzw9QJwt8LiwsjPDwcN3npUuX5sOHD1FmPBn6/29wcDBNmzbl5s2bbNu2jaJFi0Zb7+TJk7Rs2ZLy5cuzbt06zMziPkrC0Pcyrm0ENbk5cOAArq6u0XaTGet9jE5kV15c/r/FhaHvY4pm0AUBUqkTJ05EWacoODhYKVCggFKpUiUDRpYwL168UDZv3hzlo1ixYkru3LmVzZs3K5cuXVL8/f2V4OBgvXO1Wq3i5uamAMrZs2cN1IKE+fPPPxVAmTp1ql55w4YNFScnJyUgIEBXtnjxYgVQdu7cmdxhxklM6/eEhYUpr1+/jlL/5MmTiqmpqdKpUydd2fPnz6PUCwgIUPLnz6/Y29tHWWPGEGJq5/PnzxUTExOlVq1aeusUPXr0SEmXLp3SsGFDvbKY1rfJkSOHQda3CQ8PV5o1a6aYmZkp27dvj7HeP//8o2TJkkUpVqxYtPc1kjHey7i2MdL06dMVQNm3b1+0x43xPvr5+UUpCw0NVcqWLatYW1srgYGBUY7Htk6RMd7HlE4GWieBSpUq0aZNG0aMGMHz588pUKAAK1as4P79+1EGIqcE9vb2tGjRIkp55FpFkccOHjxI+/btad++PQUKFCAoKIjNmzdz7NgxevXqRdmyZZMv6Hg6fPgw48aNo379+mTJkoUTJ06wbNkyGjZsqDddG9RutqpVq+Li4kKvXr14/Pgx06ZNo379+ka3ncmcOXN4+/atbqbN1q1befz4MQADBgxAURRy5cqFm5ubbnuFy5cvs2zZMjJmzMioUaN015o7dy5//fUXTZs2JXfu3Dx9+pSlS5fy8OFDVq5cGWWNmeT0pXY6ODjQrVs3Fi9eTJ06dWjVqhWBgYHMmzePoKAgRowYobtWzpw5GTx4MFOmTCEsLIwKFSrw119/ceTIEVavXh3j+JakNGTIEP7++2+aNm3K69evWbVqld7xb7/9lsDAQBo0aMCbN28YNmxYlO1L8ufPr5tlZ4z3Mi5t/NTq1avJnj07tWrVivZ6xngfe/fuTUBAADVr1iRHjhw8e/aM1atXc/36daZNm6Ybu/jgwQPdyt2RT6XHjx8PQJ48eejUqRNgnPcxxTN0VpZaBQUFKUOHDlWyZcumWFpaKhUqVFB27dpl6LAS1eerV9+9e1dp06aN4uzsrFhZWSk2NjZKuXLllPnz5+v9dW6Mbt++rdSvX1+xt7dXLC0tlSJFiiheXl4x/qV15MgRpWrVqoqVlZXi4OCg9OvXT+/JkbHIkyePAkT7ce/ePSUkJEQZNGiQUrJkSSVDhgyKubm5kidPHqV79+7KvXv39K61Z88epV69ekq2bNkUc3NzJVOmTEr9+vVj/Es9OX2pnYqiPhWbPXu2Urp0aSVdunRKunTplNq1ayv79++Pcr2IiAhl4sSJSp48eRQLCwulWLFiyqpVq5K5Vf9ycXGJsX2RP8bv3bsXa50uXbrormeM9zIubYx0/fp1BVA8PDxivaax3cc//vhDqVu3ruLo6KiYmZkpdnZ2St26dZUtW7bo1Ttw4ECMXwcXFxddPWO8jymdRlESYbi7EEIIIUQKJwOthRBCCCGQpEgIIYQQApCkSAghhBACkKRICCGEEAKQpEgIIYQQApCkSAghhBACkKRICCGEEAKQpEgIIYQQApCkSAghhBACkKRICCFidf/+fTQaDV27djV0KEKIJCZJkRDCaHXr1g2NRkOWLFkICQkxdDhCiFROkiIhhFEKDAxk3bp1aDQaXr9+zV9//WXokIQQqZwkRUIIo7R27Vrev3/P999/j4mJCUuWLDF0SEKIVE6SIiGEUVqyZAlmZmYMHz6c2rVrs2/fPh48eBClnrOzM87Ozrx7945BgwaRPXt2LC0tKVmyJBs2bIj22vfv38fNzY3MmTOTLl06XFxcOHz4MGPGjEGj0XDw4ME4xRgYGIinpyfFihXD2tqaTJky0aBBA44ePfpfmi6EMBBJioQQRueff/7hxIkT1K9fH0dHRzp37oxWq2XZsmXR1g8LC6N+/frs2bMHV1dXvv32W+7cuUPbtm3Zs2ePXt0nT55QtWpV1q1bR6VKlRg4cCD29vbUq1ePkydPxjnG169fU6VKFcaNG4ednR3fffcdrq6unD17ltq1a0t3nxApkSKEEEbGw8NDAZQ//vhDURRFCQwMVGxtbZXcuXMrERERenXz5MmjAErz5s2VkJAQXfnevXsVQGnQoIFe/W+//VYBlAkTJuiVL1myRAEUQDlw4ICu/N69ewqgdOnSRa9+hw4dFEBZtGiRXrmfn5+SK1cuxcHBQQkKCkrol0AIYQDypEgIYVTCwsJYuXIlGTJkoEWLFgCkS5eOli1b8vDhQ/bu3RvteTNmzMDCwkL3eZ06dciTJw+nT5/WlYWEhLB+/XqyZs3KkCFD9M53d3encOHCcYrx5cuXrF27lq+//poePXroHcuaNSvDhg3jxYsXMcYqhDBOZoYOQAghPrVlyxZevHhB9+7dsbKy0pV37tyZVatWsWTJEurXr693TqZMmcibN2+Ua+XMmRMfHx/d5zdu3CAkJITy5ctjaWmpV1ej0VC1alVu3LjxxRhPnz5NREQEISEhjBkzJsrxW7duAXD9+nWaNGnyxesJIYyDJEVCCKMSOcusc+fOeuV16tQhR44cbNmyhdevX5M5c2bdsYwZM0Z7LTMzM7Rare7zgIAAQH2aEx1HR8c4xfj69WsAjh07xrFjx2Ks9/79+zhdTwhhHKT7TAhhNB49eqQbGO3i4oJGo9F9mJqa8uTJE0JCQli1alWCrp8hQwYAnj9/Hu1xPz+/eF1nyJAhKIoS44enp2eC4hRCGIY8KRJCGI3ly5ej1WqpXr16tON7wsPDWbFiBUuWLGHgwIHxvn7hwoWxtLTk7NmzhISE6HWhKYqi19UWmwoVKqDRaOJcXwiRMkhSJIQwCoqisGzZMjQaDStWrCBfvnzR1rt58yY+Pj6cOXOG8uXLx+s9LC0tad26NatXr2bmzJn873//0x37/fffuX79epyuky1bNtq2bcvatWuZMmUKQ4cORaPR6NU5efIkJUqUwMbGJl4xCiEMR5IiIYRR2L9/P/fu3cPFxSXGhAjUWWI+Pj4sWbIk3kkRgJeXF3v37uWHH37g0KFDlClThhs3brBt2zYaNmzIrl27MDH58siCefPmcePGDYYPH87KlSupUqUKmTJl4tGjR5w5c4Zbt27x9OlTSYqESEFkTJEQwihEDrD+0m70bm5uWFtb88cffxAUFBTv98mVKxc+Pj60adOG48ePM3PmTJ4/f86ePXsoUKAA8O+YodhkzpyZ48ePM3nyZCwsLFi9ejWzZ8/mxIkTFCtWjN9//x17e/t4xyeEMByNoiiKoYMQQghjUL16dXx8fPD39yddunSGDkcIkczkSZEQIs15+vRplLJVq1Zx7Ngx6tatKwmREGmUPCkSQqQ5WbJkoUyZMhQtWhRTU1MuXLjAwYMHSZ8+PceOHaNEiRKGDlEIYQCSFAkh0pwff/yRrVu38vDhQ96/f4+DgwO1a9dm1KhRFClSxNDhCSEMRJIiIYQQQghkTJEQQgghBCBJkRBCCCEEIEmREEIIIQQgSZEQQgghBCBJkRBCCCEEIEmREEIIIQQgSZEQQgghBCBJkRBCCCEEIEmREEIIIQQA/wdL5hadQVflJwAAAABJRU5ErkJggg==", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 5 + "source": [ + "fig, ax = r.profile_plot(\n", + " reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False\n", + ")\n", + "ax[0].grid(True)\n", + "plt.ylim(0, 0.5)\n", + "plt.xlabel(\"Angle\")\n", + "plt.title(\"Cosine curve estimated by SSM\")\n", + "plt.show()" + ] }, { "cell_type": "markdown", + "id": "dcc2aa0d761cfcf8", + "metadata": { + "collapsed": false + }, "source": [ "## Understanding the SSM Parameters\n", "\n", @@ -249,23 +264,54 @@ "$$\n", "\n", "where $S_i$ and $\\theta_i$ are the score and angle on scale $i$, respectively, and $e$, $a$, and $d$ are the elevation, amplitude, and displacement of the curve, respectively. Before we discuss these parameters, however, we can also estimate the fit of the SSM model. This is essentially how close the cosine curve is to the observed data points." - ], - "metadata": { - "collapsed": false - }, - "id": "dcc2aa0d761cfcf8" + ] }, { "cell_type": "code", + "execution_count": 6, + "id": "3d4382669e2bbfa8", + "metadata": { + "ExecuteTime": { + "end_time": "2024-07-11T18:37:04.974845Z", + "start_time": "2024-07-11T18:37:04.908734Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from matplotlib import collections as mc\n", "import numpy as np\n", "\n", - "fig, ax = r.profile_plot(reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False, c_fit='black', c_scores='black');\n", - "\n", + "fig, ax = r.profile_plot(\n", + " reorder_scales=True,\n", + " incl_amp=False,\n", + " incl_disp=False,\n", + " incl_pred=True,\n", + " incl_fit=False,\n", + " c_fit=\"black\",\n", + " c_scores=\"black\",\n", + ")\n", "thetas = np.linspace(0, 360, 1000)\n", - "fit = circumplex.utils.cosine_form(np.deg2rad(thetas), r.results['a_est'][0], np.deg2rad(r.results['d_est'][0]), r.results['e_est'][0])\n", - "angles, scores = circumplex.utils.sort_angles(r.details['angles'], r.scores[r.scales].values[0])\n", + "fit = circumplex.utils.cosine_form(\n", + " np.deg2rad(thetas),\n", + " r.results[\"a_est\"][0],\n", + " np.deg2rad(r.results[\"d_est\"][0]),\n", + " r.results[\"e_est\"][0],\n", + ")\n", + "angles, scores = circumplex.utils.sort_angles(\n", + " r.details[\"angles\"], r.scores[r.scales].values[0]\n", + ")\n", "\n", "lines = []\n", "for i, angle in enumerate(angles):\n", @@ -274,7 +320,7 @@ " if angle == 360:\n", " lines.append([(0, fit[0]), (0, scores[i])])\n", "\n", - "lc = mc.LineCollection(lines, colors='red', linewidths=10)\n", + "lc = mc.LineCollection(lines, colors=\"red\", linewidths=10)\n", "ax[0].add_collection(lc)\n", "\n", "ax[0].grid(True)\n", @@ -282,84 +328,59 @@ "plt.xlabel(\"Angle\")\n", "plt.title(f\"Fit = {round(r.results.fit_est[0], 2)}\")\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-07-11T18:37:04.974845Z", - "start_time": "2024-07-11T18:37:04.908734Z" - } - }, - "id": "3d4382669e2bbfa8", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 6 + ] }, { - "metadata": {}, "cell_type": "markdown", + "id": "897bd12afd585fde", + "metadata": {}, "source": [ "If fit is less than 0.70, it is considered \"unacceptable\" and only the elevation parameter should be interpreted. If fit is between 0.70 and 0.80, it is considered \"adequate\", and if it is greater than 0.80, it is considered \"good\". Sometimes SSM model fit is called prototypicality or denoted using $R^2$. \n", "\n", "The first SSM parameter is elevation or $e$, which is calculated as the mean of all scores. It is the size of the general factor in the circumplex model and its interpretation varies from scale to scale. For measures of interpersonal problems, it is interpreted as generalized interpersonal distress. When using correlation-based SSM, $|e| \\geq 0.15$ is considered \"marked\" and $|e| \\leq .15$ is considered \"modest\"." - ], - "id": "897bd12afd585fde" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "The second SSM is amplitude or $a$, which is calculated as the difference between the highest point of the curve and the curve's mean. It is interpreted as the distinctiveness or differentiation of a profile: how much it is peaked versus flat. Similar to elevation, when using correlation based SSM, $a \\geq 0.15$ is considered \"marked\" and $a \\leq 0.15$ is considered \"modest\".", - "id": "b8e0a65d8bf43c20" + "id": "b8e0a65d8bf43c20", + "metadata": {}, + "source": "The second SSM is amplitude or $a$, which is calculated as the difference between the highest point of the curve and the curve's mean. It is interpreted as the distinctiveness or differentiation of a profile: how much it is peaked versus flat. Similar to elevation, when using correlation based SSM, $a \\geq 0.15$ is considered \"marked\" and $a \\leq 0.15$ is considered \"modest\"." }, { - "metadata": {}, "cell_type": "markdown", - "source": "The final SSM parameter is displacement or $d$, which is calculated as the angle at which the curve reaches its highest point. It is interpreted as the style of the profile. For instance, if $d = 90$ and we are using a circumplex scale that defines 90 degrees as \"domineering\", then the profile's style is domineering.", - "id": "83f2230678d86f83" + "id": "83f2230678d86f83", + "metadata": {}, + "source": "The final SSM parameter is displacement or $d$, which is calculated as the angle at which the curve reaches its highest point. It is interpreted as the style of the profile. For instance, if $d = 90$ and we are using a circumplex scale that defines 90 degrees as \"domineering\", then the profile's style is domineering." }, { - "metadata": {}, "cell_type": "markdown", - "source": "By interpreting these three parameters, we can understand a profile much more parsimoniously than by trying to interpret all eight subscales individually. This approach also leverages the circumplex relationship (i.e. dependency) among subscales. It is also possible to transform the amplitude and displacement parameters into estimates of distance from the x-axis and y-axis, which will be shown in the output discussed below.", - "id": "b1c952954bc8f60f" + "id": "b1c952954bc8f60f", + "metadata": {}, + "source": "By interpreting these three parameters, we can understand a profile much more parsimoniously than by trying to interpret all eight subscales individually. This approach also leverages the circumplex relationship (i.e. dependency) among subscales. It is also possible to transform the amplitude and displacement parameters into estimates of distance from the x-axis and y-axis, which will be shown in the output discussed below." }, { "cell_type": "markdown", + "id": "67084a8065287c69", + "metadata": { + "collapsed": false + }, "source": [ "## Example Data: jz2017\n", "\n", "To illustrate the SSM functions, we will use the example dataset `JZ2017`, which was provided by Zimmerman & Wright (2017). This dataset includes self-report data from 1166 undergraduate students. Students completed a circumplex measure of interpersonal problems with eight subscales (PA, BC, DE, FG, HI, JK, LM, and NO) and a measure of personality disorder symptoms with ten subscales (PARPD, SCZPD, SZTPD, ASPD, BORPD, HISPD, NARPD, AVPD, DPNPD, and OCPD). More information about these variables can be accessed by looking at the summary of the dataset with `jz_data.summary()`:" - ], - "metadata": { - "collapsed": false - }, - "id": "67084a8065287c69" + ] }, { "cell_type": "code", - "source": [ - "from circumplex.datasets import _jz2017_path\n", - "jz2017 = circumplex.instrument.load_instrument('IIPSC')\n", - "jz2017.attach_data(pd.read_csv(_jz2017_path))" - ], + "execution_count": 7, + "id": "d06f5b82ed8a562c", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-07-11T18:37:04.979706Z", "start_time": "2024-07-11T18:37:04.975364Z" - } + }, + "collapsed": false }, - "id": "d06f5b82ed8a562c", "outputs": [ { "data": { @@ -375,47 +396,37 @@ "output_type": "execute_result" } ], - "execution_count": 7 + "source": [ + "from circumplex.datasets import _jz2017_path\n", + "\n", + "jz2017 = circumplex.instrument.load_instrument(\"IIPSC\")\n", + "jz2017.attach_data(pd.read_csv(_jz2017_path))" + ] }, { "cell_type": "markdown", - "source": [ - "And we can view the accompanying dataset with:" - ], + "id": "c00508ca5abc4368", "metadata": { "collapsed": false }, - "id": "c00508ca5abc4368" + "source": [ + "And we can view the accompanying dataset with:" + ] }, { "cell_type": "code", - "source": "jz2017.data.head()\n", + "execution_count": 8, + "id": "3828a5802369696e", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-07-11T18:37:04.986807Z", "start_time": "2024-07-11T18:37:04.980309Z" - } + }, + "collapsed": false }, - "id": "3828a5802369696e", "outputs": [ { "data": { - "text/plain": [ - " Gender PA BC DE FG HI JK LM NO PARPD SCZPD \\\n", - "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 3 \n", - "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 0 \n", - "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 1 \n", - "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 0 \n", - "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 0 \n", - "\n", - " SZTPD ASPD BORPD HISPD NARPD AVPD DPNPD OCPD \n", - "0 7 7 8 4 6 3 4 6 \n", - "1 2 0 1 2 3 0 1 0 \n", - "2 0 4 1 5 4 0 0 1 \n", - "3 0 0 1 0 0 0 0 0 \n", - "4 0 0 1 0 0 1 0 0 " - ], "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GenderPABCDEFGHIJKLMNOPARPDSCZPDSZTPDASPDBORPDHISPDNARPDAVPDDPNPDOCPD
0Female1.501.501.251.002.002.502.252.504377846346
1Female0.000.250.000.251.251.752.252.251020123010
2Female0.000.000.000.000.000.000.000.000104154001
3Male2.001.751.752.502.001.752.002.501000100000
4Female0.250.500.250.000.000.000.000.000000100100
\n", + "
" + ], + "text/plain": [ + " Gender PA BC DE FG HI JK LM NO PARPD SCZPD \\\n", + "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 3 \n", + "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 0 \n", + "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 1 \n", + "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 0 \n", + "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 0 \n", + "\n", + " SZTPD ASPD BORPD HISPD NARPD AVPD DPNPD OCPD \n", + "0 7 7 8 4 6 3 4 6 \n", + "1 2 0 1 2 3 0 1 0 \n", + "2 0 4 1 5 4 0 0 1 \n", + "3 0 0 1 0 0 0 0 0 \n", + "4 0 0 1 0 0 1 0 0 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jz2017 = load_dataset(\"jz2017\")\n", + "jz2017.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Mean-Based SSM Analysis\n", + "\n", + "### Single Group Analysis\n", + "\n", + "Let's analyze the interpersonal problems of the average individual in the dataset using `ssm_analyze()`. The function returns an SSM object with results, scores, and analysis details." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Mean Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                  Profile[All]                   \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.917    │ 0.887    │ 0.946    │\n",
+       "│ X-Value      │ 0.351    │ 0.325    │ 0.379    │\n",
+       "│ Y-Value      │ -0.252   │ -0.283   │ -0.222   │\n",
+       "│ Amplitude    │ 0.432    │ 0.403    │ 0.464    │\n",
+       "│ Displacement │ 324.292  │ 320.937  │ 327.7    │\n",
+       "│ Model Fit    │ 0.878    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Mean Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[All] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.917 │ 0.887 │ 0.946 │\n", + "│ X-Value │ 0.351 │ 0.325 │ 0.379 │\n", + "│ Y-Value │ -0.252 │ -0.283 │ -0.222 │\n", + "│ Amplitude │ 0.432 │ 0.403 │ 0.464 │\n", + "│ Displacement │ 324.292 │ 320.937 │ 327.7 │\n", + "│ Model Fit │ 0.878 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define circumplex scales and their angular positions\n", + "scales = [\"PA\", \"BC\", \"DE\", \"FG\", \"HI\", \"JK\", \"LM\", \"NO\"]\n", + "angles = [90, 135, 180, 225, 270, 315, 360, 45]\n", + "\n", + "# Run SSM analysis\n", + "results = ssm_analyze(data=jz2017, scales=scales, angles=angles)\n", + "\n", + "# Display summary\n", + "results.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accessing Results\n", + "\n", + "The SSM object provides easy access to results, scores, and analysis details:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Label", + "rawType": "object", + "type": "string" + }, + { + "name": "Group", + "rawType": "object", + "type": "string" + }, + { + "name": "Measure", + "rawType": "object", + "type": "unknown" + }, + { + "name": "e_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "fit_est", + "rawType": "float64", + "type": "float" + } + ], + "ref": "22d14d0a-83c2-48a2-9c72-31ddec395a1d", + "rows": [ + [ + "0", + "All", + "All", + null, + "0.9168096054888508", + "0.8868963068181818", + "0.9458130092195539", + "0.3510608932309254", + "0.32460614165810453", + "0.378622951857467", + "-0.2523391128831408", + "-0.282768915130183", + "-0.2222968679265911", + "0.4323410443697726", + "0.4027535526363061", + "0.4637861621161283", + "324.291791715271", + "320.9370971905794", + "327.6999403209235", + "0.8776189329590804" + ] + ], + "shape": { + "columns": 19, + "rows": 1 + } + }, + "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", + "
LabelGroupMeasuree_este_lcie_ucix_estx_lcix_uciy_esty_lciy_ucia_esta_lcia_ucid_estd_lcid_ucifit_est
0AllAllNone0.916810.8868960.9458130.3510610.3246060.378623-0.252339-0.282769-0.2222970.4323410.4027540.463786324.291792320.937097327.699940.877619
\n", + "
" + ], + "text/plain": [ + " Label Group Measure e_est e_lci e_uci x_est x_lci \\\n", + "0 All All None 0.91681 0.886896 0.945813 0.351061 0.324606 \n", + "\n", + " x_uci y_est y_lci y_uci a_est a_lci a_uci \\\n", + "0 0.378623 -0.252339 -0.282769 -0.222297 0.432341 0.402754 0.463786 \n", + "\n", + " d_est d_lci d_uci fit_est \n", + "0 324.291792 320.937097 327.69994 0.877619 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# View results DataFrame with parameter estimates and confidence intervals\n", + "results.results" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Label", + "rawType": "object", + "type": "string" + }, + { + "name": "PA", + "rawType": "float64", + "type": "float" + }, + { + "name": "BC", + "rawType": "float64", + "type": "float" + }, + { + "name": "DE", + "rawType": "float64", + "type": "float" + }, + { + "name": "FG", + "rawType": "float64", + "type": "float" + }, + { + "name": "HI", + "rawType": "float64", + "type": "float" + }, + { + "name": "JK", + "rawType": "float64", + "type": "float" + }, + { + "name": "LM", + "rawType": "float64", + "type": "float" + }, + { + "name": "NO", + "rawType": "float64", + "type": "float" + } + ], + "ref": "d5927066-f8ce-4738-a03d-7f8cd9ceed0c", + "rows": [ + [ + "0", + "All", + "0.5501715265866209", + "0.5834048027444254", + "0.6239279588336192", + "0.7645797598627787", + "1.2109777015437393", + "1.2144082332761579", + "1.4843481989708405", + "0.9026586620926244" + ] + ], + "shape": { + "columns": 9, + "rows": 1 + } + }, + "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", + "
LabelPABCDEFGHIJKLMNO
0All0.5501720.5834050.6239280.764581.2109781.2144081.4843480.902659
\n", + "
" + ], + "text/plain": [ + " Label PA BC DE FG HI JK LM \\\n", + "0 All 0.550172 0.583405 0.623928 0.76458 1.210978 1.214408 1.484348 \n", + "\n", + " NO \n", + "0 0.902659 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# View scores DataFrame\n", + "results.scores" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analysis type: mean\n", + "Angles: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n", + "Bootstrap resamples: 2000\n", + "Confidence level: 0.95\n" + ] + } + ], + "source": [ + "# View analysis details\n", + "print(f\"Analysis type: {results.type}\")\n", + "print(f\"Angles: {results.details.angles}\")\n", + "print(f\"Bootstrap resamples: {results.details.boots}\")\n", + "print(f\"Confidence level: {results.details.interval}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Visualizing SSM Results\n", + "\n", + "The circumplex package provides three visualization functions:\n", + "\n", + "1. **Circle Plot**: Shows amplitude and displacement on a circular plot\n", + "2. **Curve Plot**: Shows fitted cosine curves overlaid on observed scores \n", + "3. **Contrast Plot**: Shows parameter differences between groups (for contrast analyses)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Circle Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create circle plot\n", + "fig = results.plot_circle(title=\"Interpersonal Problems Profile\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Curve Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create curve plot showing observed scores and fitted curve\n", + "fig = results.plot_curve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Correlation-Based SSM Analysis\n", + "\n", + "To examine how personality disorder symptoms relate to interpersonal problems, we can perform correlation-based SSM analysis by specifying external measures." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Correlation Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                 Profile[NARPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.202    │ 0.168    │ 0.235    │\n",
+       "│ X-Value      │ -0.062   │ -0.094   │ -0.03    │\n",
+       "│ Y-Value      │ 0.179    │ 0.145    │ 0.211    │\n",
+       "│ Amplitude    │ 0.189    │ 0.157    │ 0.223    │\n",
+       "│ Displacement │ 108.967  │ 99.266   │ 118.299  │\n",
+       "│ Model Fit    │ 0.957    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Correlation Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[NARPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.202 │ 0.168 │ 0.235 │\n", + "│ X-Value │ -0.062 │ -0.094 │ -0.03 │\n", + "│ Y-Value │ 0.179 │ 0.145 │ 0.211 │\n", + "│ Amplitude │ 0.189 │ 0.157 │ 0.223 │\n", + "│ Displacement │ 108.967 │ 99.266 │ 118.299 │\n", + "│ Model Fit │ 0.957 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze narcissistic personality disorder symptoms\n", + "results_corr = ssm_analyze(\n", + " data=jz2017,\n", + " scales=scales,\n", + " angles=angles,\n", + " measures=\"NARPD\",\n", + ")\n", + "\n", + "results_corr.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize correlation-based results\n", + "fig = results_corr.plot_circle(title=\"NARPD Correlations\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Group Comparisons\n", + "\n", + "### Multiple Groups" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Mean Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                 Profile[Female]                 \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.946    │ 0.907    │ 0.983    │\n",
+       "│ X-Value      │ 0.459    │ 0.42     │ 0.5      │\n",
+       "│ Y-Value      │ -0.31    │ -0.354   │ -0.269   │\n",
+       "│ Amplitude    │ 0.554    │ 0.51     │ 0.6      │\n",
+       "│ Displacement │ 325.963  │ 321.974  │ 329.968  │\n",
+       "│ Model Fit    │ 0.889    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "                  Profile[Male]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.884    │ 0.84     │ 0.927    │\n",
+       "│ X-Value      │ 0.227    │ 0.192    │ 0.262    │\n",
+       "│ Y-Value      │ -0.186   │ -0.225   │ -0.147   │\n",
+       "│ Amplitude    │ 0.294    │ 0.258    │ 0.33     │\n",
+       "│ Displacement │ 320.685  │ 313.789  │ 327.926  │\n",
+       "│ Model Fit    │ 0.824    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Mean Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[Female] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.946 │ 0.907 │ 0.983 │\n", + "│ X-Value │ 0.459 │ 0.42 │ 0.5 │\n", + "│ Y-Value │ -0.31 │ -0.354 │ -0.269 │\n", + "│ Amplitude │ 0.554 │ 0.51 │ 0.6 │\n", + "│ Displacement │ 325.963 │ 321.974 │ 329.968 │\n", + "│ Model Fit │ 0.889 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[Male] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.884 │ 0.84 │ 0.927 │\n", + "│ X-Value │ 0.227 │ 0.192 │ 0.262 │\n", + "│ Y-Value │ -0.186 │ -0.225 │ -0.147 │\n", + "│ Amplitude │ 0.294 │ 0.258 │ 0.33 │\n", + "│ Displacement │ 320.685 │ 313.789 │ 327.926 │\n", + "│ Model Fit │ 0.824 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze by gender\n", + "results_group = ssm_analyze(\n", + " data=jz2017,\n", + " scales=scales,\n", + " angles=angles,\n", + " grouping=\"Gender\",\n", + ")\n", + "\n", + "results_group.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare groups on circle plot\n", + "fig = results_group.plot_circle(colors=\"Set2\", title=\"Interpersonal Problems by Gender\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare groups with curve plots\n", + "fig = results_group.plot_curve(angle_labels=scales)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiple Measures" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Correlation Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                 Profile[NARPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.202    │ 0.169    │ 0.236    │\n",
+       "│ X-Value      │ -0.062   │ -0.094   │ -0.028   │\n",
+       "│ Y-Value      │ 0.179    │ 0.146    │ 0.213    │\n",
+       "│ Amplitude    │ 0.189    │ 0.156    │ 0.225    │\n",
+       "│ Displacement │ 108.967  │ 99.019   │ 118.283  │\n",
+       "│ Model Fit    │ 0.957    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "                  Profile[ASPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.124    │ 0.09     │ 0.157    │\n",
+       "│ X-Value      │ -0.099   │ -0.134   │ -0.064   │\n",
+       "│ Y-Value      │ 0.203    │ 0.168    │ 0.238    │\n",
+       "│ Amplitude    │ 0.226    │ 0.19     │ 0.263    │\n",
+       "│ Displacement │ 115.927  │ 107.57   │ 124.018  │\n",
+       "│ Model Fit    │ 0.964    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "                 Profile[BORPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.277    │ 0.242    │ 0.311    │\n",
+       "│ X-Value      │ -0.036   │ -0.068   │ -0.002   │\n",
+       "│ Y-Value      │ 0.097    │ 0.058    │ 0.139    │\n",
+       "│ Amplitude    │ 0.103    │ 0.065    │ 0.147    │\n",
+       "│ Displacement │ 110.358  │ 91.269   │ 128.695  │\n",
+       "│ Model Fit    │ 0.872    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Correlation Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[NARPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.202 │ 0.169 │ 0.236 │\n", + "│ X-Value │ -0.062 │ -0.094 │ -0.028 │\n", + "│ Y-Value │ 0.179 │ 0.146 │ 0.213 │\n", + "│ Amplitude │ 0.189 │ 0.156 │ 0.225 │\n", + "│ Displacement │ 108.967 │ 99.019 │ 118.283 │\n", + "│ Model Fit │ 0.957 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[ASPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.124 │ 0.09 │ 0.157 │\n", + "│ X-Value │ -0.099 │ -0.134 │ -0.064 │\n", + "│ Y-Value │ 0.203 │ 0.168 │ 0.238 │\n", + "│ Amplitude │ 0.226 │ 0.19 │ 0.263 │\n", + "│ Displacement │ 115.927 │ 107.57 │ 124.018 │\n", + "│ Model Fit │ 0.964 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[BORPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.277 │ 0.242 │ 0.311 │\n", + "│ X-Value │ -0.036 │ -0.068 │ -0.002 │\n", + "│ Y-Value │ 0.097 │ 0.058 │ 0.139 │\n", + "│ Amplitude │ 0.103 │ 0.065 │ 0.147 │\n", + "│ Displacement │ 110.358 │ 91.269 │ 128.695 │\n", + "│ Model Fit │ 0.872 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare multiple personality disorder symptoms\n", + "results_multi = ssm_analyze(\n", + " data=jz2017,\n", + " scales=scales,\n", + " angles=angles,\n", + " measures=[\"NARPD\", \"ASPD\", \"BORPD\"],\n", + ")\n", + "\n", + "results_multi.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize multiple measures\n", + "fig = results_multi.plot_circle(\n", + " colors=[\"red\", \"blue\", \"green\"], title=\"Personality Disorder Symptoms\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Contrast Analyses\n", + "\n", + "### Group Contrasts\n", + "\n", + "To test whether groups differ significantly on SSM parameters, use `contrast=True`:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Mean Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                 Profile[Female]                 \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.946    │ 0.907    │ 0.983    │\n",
+       "│ X-Value      │ 0.459    │ 0.42     │ 0.497    │\n",
+       "│ Y-Value      │ -0.31    │ -0.352   │ -0.266   │\n",
+       "│ Amplitude    │ 0.554    │ 0.51     │ 0.597    │\n",
+       "│ Displacement │ 325.963  │ 322.158  │ 329.859  │\n",
+       "│ Model Fit    │ 0.889    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "                  Profile[Male]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.884    │ 0.842    │ 0.926    │\n",
+       "│ X-Value      │ 0.227    │ 0.19     │ 0.263    │\n",
+       "│ Y-Value      │ -0.186   │ -0.225   │ -0.15    │\n",
+       "│ Amplitude    │ 0.294    │ 0.257    │ 0.329    │\n",
+       "│ Displacement │ 320.685  │ 313.368  │ 327.546  │\n",
+       "│ Model Fit    │ 0.824    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "             Profile[Male - Female]              \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ -0.062   │ -0.118   │ -0.004   │\n",
+       "│ X-Value      │ -0.232   │ -0.286   │ -0.176   │\n",
+       "│ Y-Value      │ 0.124    │ 0.065    │ 0.181    │\n",
+       "│ Amplitude    │ -0.261   │ -0.318   │ -0.203   │\n",
+       "│ Displacement │ -5.278   │ 346.016  │ 3.136    │\n",
+       "│ Model Fit    │ -0.066   │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Mean Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[Female] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.946 │ 0.907 │ 0.983 │\n", + "│ X-Value │ 0.459 │ 0.42 │ 0.497 │\n", + "│ Y-Value │ -0.31 │ -0.352 │ -0.266 │\n", + "│ Amplitude │ 0.554 │ 0.51 │ 0.597 │\n", + "│ Displacement │ 325.963 │ 322.158 │ 329.859 │\n", + "│ Model Fit │ 0.889 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[Male] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.884 │ 0.842 │ 0.926 │\n", + "│ X-Value │ 0.227 │ 0.19 │ 0.263 │\n", + "│ Y-Value │ -0.186 │ -0.225 │ -0.15 │\n", + "│ Amplitude │ 0.294 │ 0.257 │ 0.329 │\n", + "│ Displacement │ 320.685 │ 313.368 │ 327.546 │\n", + "│ Model Fit │ 0.824 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[Male - Female] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ -0.062 │ -0.118 │ -0.004 │\n", + "│ X-Value │ -0.232 │ -0.286 │ -0.176 │\n", + "│ Y-Value │ 0.124 │ 0.065 │ 0.181 │\n", + "│ Amplitude │ -0.261 │ -0.318 │ -0.203 │\n", + "│ Displacement │ -5.278 │ 346.016 │ 3.136 │\n", + "│ Model Fit │ -0.066 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Contrast analysis between genders\n", + "results_contrast = ssm_analyze(\n", + " data=jz2017,\n", + " scales=scales,\n", + " angles=angles,\n", + " grouping=\"Gender\",\n", + " contrast=True,\n", + ")\n", + "\n", + "results_contrast.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Label", + "rawType": "object", + "type": "string" + }, + { + "name": "Group", + "rawType": "object", + "type": "string" + }, + { + "name": "Measure", + "rawType": "object", + "type": "unknown" + }, + { + "name": "e_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "fit_est", + "rawType": "float64", + "type": "float" + } + ], + "ref": "24cace74-1e5d-4b97-8ed8-b249b88f6ed1", + "rows": [ + [ + "0", + "Female", + "Female", + null, + "0.9457897909967846", + "0.9067009143890676", + "0.9832207094051446", + "0.4593176682777965", + "0.41964463719648665", + "0.49710156404391115", + "-0.3102451433597703", + "-0.3516049131983191", + "-0.26608707009701194", + "0.5542786026633866", + "0.510352566902124", + "0.597080495604968", + "325.96302454734587", + "322.15825635936517", + "329.8590848011998", + "0.8894488937356706" + ], + [ + "1", + "Male", + "Male", + null, + "0.8836741727941176", + "0.8423684512867647", + "0.9258990119485293", + "0.22728200705601015", + "0.1902394409426811", + "0.26290749134248953", + "-0.18613037950728867", + "-0.22465241728529523", + "-0.15015752618031636", + "0.29377138885013215", + "0.2574487184693303", + "0.32940395981089093", + "320.6845735000274", + "313.36818117423877", + "327.5455577467306", + "0.8238287760741773" + ], + [ + "2", + "Male - Female", + "Male - Female", + null, + "-0.06211561820266698", + "-0.11831790757400232", + "-0.003855445476522732", + "-0.23203566122178637", + "-0.28629075873753257", + "-0.17605790941889368", + "0.12411476385248166", + "0.06522792233765794", + "0.18088952422779847", + "-0.2605072138132544", + "-0.3184797747215601", + "-0.2033984918889706", + "-5.278451047318445", + "346.01584668819066", + "3.13569372010508", + "-0.06562011766149334" + ] + ], + "shape": { + "columns": 19, + "rows": 3 + } + }, + "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", + "
LabelGroupMeasuree_este_lcie_ucix_estx_lcix_uciy_esty_lciy_ucia_esta_lcia_ucid_estd_lcid_ucifit_est
0FemaleFemaleNone0.9457900.9067010.9832210.4593180.4196450.497102-0.310245-0.351605-0.2660870.5542790.5103530.597080325.963025322.158256329.8590850.889449
1MaleMaleNone0.8836740.8423680.9258990.2272820.1902390.262907-0.186130-0.224652-0.1501580.2937710.2574490.329404320.684574313.368181327.5455580.823829
2Male - FemaleMale - FemaleNone-0.062116-0.118318-0.003855-0.232036-0.286291-0.1760580.1241150.0652280.180890-0.260507-0.318480-0.203398-5.278451346.0158473.135694-0.065620
\n", + "
" + ], + "text/plain": [ + " Label Group Measure e_est e_lci e_uci \\\n", + "0 Female Female None 0.945790 0.906701 0.983221 \n", + "1 Male Male None 0.883674 0.842368 0.925899 \n", + "2 Male - Female Male - Female None -0.062116 -0.118318 -0.003855 \n", + "\n", + " x_est x_lci x_uci y_est y_lci y_uci a_est \\\n", + "0 0.459318 0.419645 0.497102 -0.310245 -0.351605 -0.266087 0.554279 \n", + "1 0.227282 0.190239 0.262907 -0.186130 -0.224652 -0.150158 0.293771 \n", + "2 -0.232036 -0.286291 -0.176058 0.124115 0.065228 0.180890 -0.260507 \n", + "\n", + " a_lci a_uci d_est d_lci d_uci fit_est \n", + "0 0.510353 0.597080 325.963025 322.158256 329.859085 0.889449 \n", + "1 0.257449 0.329404 320.684574 313.368181 327.545558 0.823829 \n", + "2 -0.318480 -0.203398 -5.278451 346.015847 3.135694 -0.065620 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# View contrast results (last row shows Male - Female differences)\n", + "results_contrast.results" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize contrasts\n", + "fig = results_contrast.plot_contrast()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Simplified contrast plot (drop X and Y parameters)\n", + "fig = results_contrast.plot_contrast(drop_xy=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Measure Contrasts" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Correlation Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [90.0, 135.0, 180.0, 225.0, 270.0, 315.0, 360.0, 45.0]\n",
+       "\n",
+       "\n",
+       "                 Profile[NARPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.202    │ 0.169    │ 0.235    │\n",
+       "│ X-Value      │ -0.062   │ -0.094   │ -0.029   │\n",
+       "│ Y-Value      │ 0.179    │ 0.145    │ 0.212    │\n",
+       "│ Amplitude    │ 0.189    │ 0.155    │ 0.224    │\n",
+       "│ Displacement │ 108.967  │ 99.689   │ 118.438  │\n",
+       "│ Model Fit    │ 0.957    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "                  Profile[ASPD]                  \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 0.124    │ 0.089    │ 0.158    │\n",
+       "│ X-Value      │ -0.099   │ -0.134   │ -0.065   │\n",
+       "│ Y-Value      │ 0.203    │ 0.169    │ 0.238    │\n",
+       "│ Amplitude    │ 0.226    │ 0.19     │ 0.262    │\n",
+       "│ Displacement │ 115.927  │ 107.728  │ 124.75   │\n",
+       "│ Model Fit    │ 0.964    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "              Profile[ASPD - NARPD]              \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ -0.079   │ -0.115   │ -0.041   │\n",
+       "│ X-Value      │ -0.037   │ -0.078   │ -0.0     │\n",
+       "│ Y-Value      │ 0.024    │ -0.014   │ 0.06     │\n",
+       "│ Amplitude    │ 0.037    │ -0.003   │ 0.075    │\n",
+       "│ Displacement │ 6.96     │ 356.694  │ 17.513   │\n",
+       "│ Model Fit    │ 0.007    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Correlation Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m90.0\u001b[0m, \u001b[1;36m135.0\u001b[0m, \u001b[1;36m180.0\u001b[0m, \u001b[1;36m225.0\u001b[0m, \u001b[1;36m270.0\u001b[0m, \u001b[1;36m315.0\u001b[0m, \u001b[1;36m360.0\u001b[0m, \u001b[1;36m45.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[NARPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.202 │ 0.169 │ 0.235 │\n", + "│ X-Value │ -0.062 │ -0.094 │ -0.029 │\n", + "│ Y-Value │ 0.179 │ 0.145 │ 0.212 │\n", + "│ Amplitude │ 0.189 │ 0.155 │ 0.224 │\n", + "│ Displacement │ 108.967 │ 99.689 │ 118.438 │\n", + "│ Model Fit │ 0.957 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[ASPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 0.124 │ 0.089 │ 0.158 │\n", + "│ X-Value │ -0.099 │ -0.134 │ -0.065 │\n", + "│ Y-Value │ 0.203 │ 0.169 │ 0.238 │\n", + "│ Amplitude │ 0.226 │ 0.19 │ 0.262 │\n", + "│ Displacement │ 115.927 │ 107.728 │ 124.75 │\n", + "│ Model Fit │ 0.964 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n", + "\u001b[3m Profile[ASPD - NARPD] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ -0.079 │ -0.115 │ -0.041 │\n", + "│ X-Value │ -0.037 │ -0.078 │ -0.0 │\n", + "│ Y-Value │ 0.024 │ -0.014 │ 0.06 │\n", + "│ Amplitude │ 0.037 │ -0.003 │ 0.075 │\n", + "│ Displacement │ 6.96 │ 356.694 │ 17.513 │\n", + "│ Model Fit │ 0.007 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare two measures\n", + "results_meas_contrast = ssm_analyze(\n", + " data=jz2017,\n", + " scales=scales,\n", + " angles=angles,\n", + " measures=[\"NARPD\", \"ASPD\"],\n", + " contrast=True,\n", + ")\n", + "\n", + "results_meas_contrast.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize measure contrasts\n", + "fig = results_meas_contrast.plot_contrast()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Customizing Visualizations\n", + "\n", + "All plot functions support extensive customization:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Circle plot with custom options\n", + "fig = results_group.plot_circle(\n", + " colors=\"husl\", # Color palette\n", + " fontsize=14, # Font size\n", + " figsize=(10, 10), # Figure size\n", + " title=\"Custom Circle Plot\",\n", + " angle_labels=scales, # Custom angle labels\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Curve plot with custom options\n", + "fig = results_group.plot_curve(\n", + " angle_labels=scales,\n", + " base_size=12,\n", + " figsize=(12, 5),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Contrast plot with custom colors\n", + "fig = results_contrast.plot_contrast(\n", + " sig_color=\"darkred\",\n", + " ns_color=\"lightgray\",\n", + " fontsize=14,\n", + " drop_xy=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Saving Plots\n", + "\n", + "All plots return matplotlib Figure objects that can be saved:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Save plots\n", + "fig1 = results.plot_circle()\n", + "fig1.savefig(\"circle_plot.png\", dpi=300, bbox_inches=\"tight\")\n", + "\n", + "fig2 = results.plot_curve()\n", + "fig2.savefig(\"curve_plot.png\", dpi=300, bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The circumplex package provides a comprehensive toolkit for SSM analysis:\n", + "\n", + "- **`ssm_analyze()`**: Performs mean-based or correlation-based SSM analysis\n", + "- **`plot_circle()`**: Visualizes amplitude/displacement on circular plots\n", + "- **`plot_curve()`**: Shows fitted curves with observed data\n", + "- **`plot_contrast()`**: Displays parameter differences between groups\n", + "\n", + "All functions support:\n", + "- Single or multiple groups\n", + "- Single or multiple measures\n", + "- Bootstrap confidence intervals\n", + "- Contrast analyses\n", + "- Extensive customization options" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python-circumplex (3.12.5)", + "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.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/ssm_analysis_demo.py b/examples/ssm_analysis_demo.py new file mode 100644 index 0000000..d7f3954 --- /dev/null +++ b/examples/ssm_analysis_demo.py @@ -0,0 +1,362 @@ +""" +# Structural Summary Method (SSM) Analysis Demo. + +This notebook demonstrates the core functionality of the `circumplex` package +for analyzing circumplex data using the Structural Summary Method (SSM). + +The SSM provides six key parameters that summarize circular data patterns: +- **Elevation ($e$)**: Mean level across all scales +- **X-value ($x$)**: Projection onto the x-axis (cosine component) +- **Y-value ($y$)**: Projection onto the y-axis (sine component) +- **Amplitude ($a$)**: Vector length (prototypicality of the pattern) +- **Displacement ($d$)**: Angular position in degrees $[0, 360)$ +- **Fit ($R^2$)**: Proportion of variance explained by the model + +Bootstrap confidence intervals are computed for all parameters except fit. +""" + +# %% +# ## Setup + +import numpy as np +from rich.console import Console + +from circumplex import load_dataset, ssm_analyze + +console = Console() + +# Set random seed for reproducible bootstrap results +np.random.seed(12345) + +# %% +# ## Example 1: Single-Group Mean-Based Analysis + +# Load a small example dataset (5 observations, 8 octant scales) +aw2009 = load_dataset("aw2009") +console.print(f"[bold]aw2009 dataset shape:[/bold] {aw2009.shape}") +console.print("\n[bold]First few rows:[/bold]") +console.print(aw2009.head()) + +# %% +# ### Run SSM Analysis +# +# For mean-based analysis, we analyze the profile of mean scale scores. +# The `ssm_analyze()` function automatically uses octant angles [90, 135, 180, 225, 270, 315, 360, 45] +# when 8 scales are provided and angles=None. + +results_single = ssm_analyze( + aw2009, + scales=list(range(8)), # Use all 8 scales (or specify column names) + boots=2000, # Number of bootstrap resamples + interval=0.95, # 95% confidence intervals + seed=12345, # For reproducibility +) + +console.print("\n[bold]SSM Parameters:[/bold]") +console.print( + results_single.results[ + ["Label", "e_est", "x_est", "y_est", "a_est", "d_est", "fit_est"] + ] +) + +console.print("\n[bold]Confidence Intervals:[/bold]") +console.print( + results_single.results[ + ["Label", "e_lci", "e_uci", "a_lci", "a_uci", "d_lci", "d_uci"] + ] +) + +# %% +# ### Interpretation +# +# - **Elevation (e_est)**: 0.423 - The mean level across all scales is positive +# - **Amplitude (a_est)**: 0.981 - Strong prototypicality (high consistency with circular model) +# - **Displacement (d_est)**: 344.4° - The peak is near 360° (quadrant IV) +# - **Fit (fit_est)**: 0.954 - The circular model explains 95.4% of variance +# +# The 95% CIs show the uncertainty in these estimates based on bootstrap resampling. + +# %% +# ## Example 2: Multi-Group Mean-Based Analysis + +# Load a larger dataset with multiple groups +jz2017 = load_dataset("jz2017") +console.print(f"[bold]jz2017 dataset shape:[/bold] {jz2017.shape}") +console.print(f"\n[bold]Columns:[/bold] {jz2017.columns.tolist()}") +console.print("\n[bold]Gender distribution:[/bold]") +console.print(jz2017["Gender"].value_counts()) + +# %% +# ### Compare Groups +# +# Analyze interpersonal circumplex profiles separately for females and males. + +results_groups = ssm_analyze( + jz2017, + scales=list(range(1, 9)), # Columns 1-8 (PA, BC, DE, FG, HI, JK, LM, NO) + grouping="Gender", # Split by gender + boots=2000, + seed=12345, +) + +console.print("\n[bold]SSM Parameters by Group:[/bold]") +console.print( + results_groups.results[ + ["Label", "e_est", "x_est", "y_est", "a_est", "d_est", "fit_est"] + ] +) + +console.print("\n[bold]Mean Scale Scores by Group:[/bold]") +console.print(results_groups.scores) + +# %% +# ### Group Comparison +# +# Both groups show similar displacement (around 320-326°) but differ in amplitude: +# - **Female**: Amplitude = 0.553 (moderate prototypicality) +# - **Male**: Amplitude = 0.299 (lower prototypicality) +# +# This suggests females show a more consistent interpersonal pattern than males +# in this sample. + +# %% +# ## Example 3: Multi-Group Analysis with Contrast + +# Compute the difference between groups (Male - Female) +results_contrast = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + grouping="Gender", + contrast=True, # Add contrast row + boots=2000, + seed=12345, +) + +console.print("\n[bold]SSM Parameters with Contrast:[/bold]") +console.print( + results_contrast.results[["Label", "e_est", "x_est", "y_est", "a_est", "d_est"]] +) + +console.print("\n[bold]Contrast Interpretation:[/bold]") +contrast_row = results_contrast.results.iloc[2] +console.print(f" Elevation difference: {contrast_row['e_est']:.3f}") +console.print(f" Amplitude difference: {contrast_row['a_est']:.3f}") +console.print(f" Angular difference: {contrast_row['d_est']:.3f}°") + +# %% +# ### Contrast Interpretation +# +# The contrast row shows Male - Female differences: +# - **Elevation**: -0.062 (males slightly lower overall) +# - **Amplitude**: -0.254 (males show much less prototypicality) +# - **Displacement**: -5.28° (minimal angular difference) +# +# The key finding is that males have significantly lower amplitude, indicating +# their interpersonal patterns are less differentiated/prototypical. + +# %% +# ## Example 4: Correlation-Based Analysis + +# Analyze how personality disorder symptoms (PARPD) relate to interpersonal scales +results_corr = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures="PARPD", # Paranoid personality disorder scale + boots=2000, + seed=12345, +) + +console.print("\n[bold]Correlation-Based SSM Parameters:[/bold]") +console.print( + results_corr.results[ + ["Label", "e_est", "x_est", "y_est", "a_est", "d_est", "fit_est"] + ] +) + +console.print("\n[bold]Correlation Profile:[/bold]") +console.print(results_corr.scores) + +# %% +# ### Correlation Interpretation +# +# The correlation profile shows how PARPD symptoms relate to interpersonal behavior: +# - **Elevation (e_est)**: 0.250 - PARPD is positively correlated with interpersonal problems overall +# - **Amplitude (a_est)**: 0.150 - Moderate differentiation in the correlation pattern +# - **Displacement (d_est)**: 128.9° - Peak correlation around 135° (Quadrant II) +# - **Fit (fit_est)**: 0.802 - The circular model explains 80% of the correlation variance +# +# This suggests PARPD is most strongly associated with interpersonal behaviors +# in the cold-dominant quadrant (quadrant II). + +# %% +# ## Example 5: Multi-Measure Correlation with Contrast + +# Compare correlation profiles for two different personality disorders +results_measure_contrast = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures=["ASPD", "NARPD"], # Antisocial and Narcissistic PD + contrast=True, + boots=2000, + seed=12345, +) + +console.print("\n[bold]Multi-Measure SSM Parameters:[/bold]") +console.print( + results_measure_contrast.results[["Label", "e_est", "a_est", "d_est", "fit_est"]] +) + +console.print("\n[bold]Measure Contrast:[/bold]") +contrast_row = results_measure_contrast.results.iloc[2] +console.print(f" Elevation difference (NARPD - ASPD): {contrast_row['e_est']:.3f}") +console.print(f" Amplitude difference: {contrast_row['a_est']:.3f}") +console.print(f" Angular difference: {contrast_row['d_est']:.1f}°") + +# %% +# ### Multi-Measure Interpretation +# +# Comparing ASPD vs NARPD interpersonal profiles: +# - **ASPD**: Displacement at ~315° (dominant-cold), moderate amplitude +# - **NARPD**: Displacement at ~82° (dominant-warm), higher amplitude +# - **Contrast**: NARPD shows 0.148 higher amplitude (more differentiated pattern) +# and is ~127° apart (nearly opposite on the circle) +# +# This reveals distinct interpersonal correlates: ASPD associates with cold-dominance +# while NARPD associates with warm-dominance. + +# %% +# ## Example 6: Group x Measure Correlation + +# Analyze how NARPD relates to interpersonal behavior differently by gender +results_group_corr = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures="NARPD", + grouping="Gender", + contrast=True, # Compare genders + boots=2000, + seed=12345, +) + +console.print("\n[bold]Group x Measure SSM Parameters:[/bold]") +console.print( + results_group_corr.results[["Label", "e_est", "a_est", "d_est", "fit_est"]] +) + +# %% +# ### Group x Measure Interpretation +# +# NARPD-interpersonal relationships by gender: +# - **Female**: Higher elevation (0.334) and amplitude (0.231) +# - **Male**: Lower elevation (0.281) and amplitude (0.160) +# - **Contrast**: Females show stronger and more differentiated NARPD-interpersonal associations +# +# Both groups have similar angular positions (~73-82°), suggesting the _location_ +# of NARPD correlates is similar, but the _strength_ differs by gender. + +# %% +# ## Example 7: Custom Angles + +# You can specify custom angular positions for non-octant circumplex models +# For example, using 4 scales at quadrant positions: + +results_custom = ssm_analyze( + jz2017, + scales=["PA", "DE", "HI", "LM"], # 4 scales at quadrant positions + angles=[90, 180, 270, 360], # Quadrant angles in degrees + boots=1000, # Fewer boots for speed + seed=12345, +) + +console.print("\n[bold]Custom Angles SSM Parameters:[/bold]") +console.print(results_custom.results[["Label", "e_est", "a_est", "d_est", "fit_est"]]) + +# %% +# ## Key Features Summary + +console.print(""" +[bold cyan]circumplex Package Features[/bold cyan] + +✓ [green]Mean-based SSM:[/green] Analyze profiles of mean scale scores +✓ [green]Correlation-based SSM:[/green] Analyze how measures correlate with circumplex scales +✓ [green]Multi-group designs:[/green] Compare profiles across groups (e.g., gender, diagnosis) +✓ [green]Contrast analysis:[/green] Test differences between 2 groups or 2 measures +✓ [green]Bootstrap CIs:[/green] Percentile confidence intervals via resampling +✓ [green]Circular statistics:[/green] Proper handling of angular data +✓ [green]Flexible angles:[/green] Support for any circumplex configuration (OCTANTS, QUADRANTS, etc.) +✓ [green]Numerical parity:[/green] Results match R circumplex package to 3+ decimal places + +[bold cyan]Analysis Types Supported[/bold cyan] + +1. Single-group mean profile +2. Multi-group mean profiles +3. Multi-group mean profiles with contrast +4. Single-group correlation profile +5. Multi-group correlation profiles +6. Multi-measure correlation profiles with contrast +7. Group x measure correlation with contrast + +[bold cyan]Bootstrap Implementation[/bold cyan] + +• Stratified sampling when groups are present +• Circular quantile method for displacement CIs +• Listwise or pairwise deletion options +• Reproducible with seed parameter + +[bold cyan]Next Steps[/bold cyan] + +• Visualization components (coming soon) +• Instrument registry for standard scales (coming soon) +• Export/reporting functions (coming soon) +""") + +# %% +# ## Technical Notes + +console.print(""" +[bold cyan]Parameter Calculation Details[/bold cyan] + +The SSM parameters are calculated using the following formulas: + +[bold]Elevation:[/bold] e = mean(scores) + +[bold]X-value:[/bold] x = (2/n) x Σ(scores x cos(angles)) + +[bold]Y-value:[/bold] y = (2/n) x Σ(scores x sin(angles)) + +[bold]Amplitude:[/bold] a = √(x² + y²) + +[bold]Displacement:[/bold] d = arctan2(y, x) [converted to degrees, [0, 360)] + +[bold]Fit:[/bold] R² = 1 - (SS_residual / SS_total) + +where predicted scores = e + a x cos(angles - d) + +[bold cyan]Bootstrap Confidence Intervals[/bold cyan] + +CIs are computed using the percentile method: +• Lower CI: 2.5th percentile of bootstrap distribution (for 95% CI) +• Upper CI: 97.5th percentile of bootstrap distribution + +For displacement (circular data), a special circular quantile method is used +that accounts for angular wrapping at 0°/360°. + +[bold cyan]Contrast Calculations[/bold cyan] + +Contrasts are computed as second minus first (e.g., Male - Female): +• For linear parameters: simple subtraction +• For displacement: circular distance using angle_dist() + - Returns shortest angular distance in [-180°, 180°] + +[bold cyan]Data Requirements[/bold cyan] + +• [bold]Scales:[/bold] Must be equally spaced around the circle (or specify custom angles) +• [bold]Sample size:[/bold] Minimum ~30 for stable bootstrap CIs (n=5 works but CIs are wide) +• [bold]Missing data:[/bold] Listwise deletion (default) or pairwise deletion available +• [bold]Grouping:[/bold] Groups are treated as categorical factors (alphabetical ordering) +""") + +# %% +console.print( + "\n✓ [bold green]Demo complete! The circumplex package is ready for SSM analysis.[/bold green]" +) diff --git a/examples/using-instruments.ipynb b/examples/using-instruments.ipynb new file mode 100644 index 0000000..db3b7e9 --- /dev/null +++ b/examples/using-instruments.ipynb @@ -0,0 +1,3206 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "33d6280b", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext rich\n", + "import numpy as np\n", + "\n", + "from circumplex import (\n", + " get_instrument,\n", + " ipsatize,\n", + " norm_standardize,\n", + " score,\n", + " show_instruments,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cd871616", + "metadata": {}, + "source": [ + "# Using Circumplex Instruments\n", + "\n", + "## 1. Overview of Instrument-related Functions" + ] + }, + { + "cell_type": "markdown", + "id": "bc25eb0a", + "metadata": {}, + "source": [ + "## 2. Loading and Examining Instrument Objects\n", + "\n", + "### Previewing the available instruments\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4552fc97", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
          The circumplex package currently includes 3 instruments          \n",
+       "┏━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃    Abbreviation  Name                                                 ┃\n",
+       "┡━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ 1 │ CSIG          Circumplex Scales of Interpersonal Goals             │\n",
+       "│ 2 │ IIPSC         Inventory of Interpersonal Problems Short Circumplex │\n",
+       "│ 3 │ IPIPIPC       IPIP Interpersonal Circumplex                        │\n",
+       "└───┴──────────────┴──────────────────────────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m The circumplex package currently includes 3 instruments \u001b[0m\n", + "┏━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mAbbreviation\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mName \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ 1 │\u001b[36m \u001b[0m\u001b[36mCSIG \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mCircumplex Scales of Interpersonal Goals \u001b[0m\u001b[35m \u001b[0m│\n", + "│ 2 │\u001b[36m \u001b[0m\u001b[36mIIPSC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mInventory of Interpersonal Problems Short Circumplex\u001b[0m\u001b[35m \u001b[0m│\n", + "│ 3 │\u001b[36m \u001b[0m\u001b[36mIPIPIPC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mIPIP Interpersonal Circumplex \u001b[0m\u001b[35m \u001b[0m│\n", + "└───┴──────────────┴──────────────────────────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_instruments()" + ] + }, + { + "cell_type": "markdown", + "id": "7df02ac6", + "metadata": {}, + "source": [ + "### Loading a specific instrument" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d3596a68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\n",
+       "\u001b[1;35mInstrument\u001b[0m\u001b[1m(\u001b[0m\n",
+       "    \u001b[32m'CSIG: Circumplex Scales of Interpersonal Goals'\u001b[0m,\n",
+       "    \u001b[32m'32 items, 8 scales, 1 normative data sets'\u001b[0m,\n",
+       "    \u001b[32m'Lock \u001b[0m\u001b[32m(\u001b[0m\u001b[32m2014\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m,\n",
+       "    \u001b[32m'\u001b[0m\u001b[32m<\u001b[0m\u001b[32m https://doi.org/10.1177/0146167213514280 \u001b[0m\u001b[32m>\u001b[0m\u001b[32m'\u001b[0m\n",
+       "\u001b[1m)\u001b[0m"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "csig = get_instrument(\"csig\")\n",
+    "csig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f1450aa9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
CSIG: Circumplex Scales of Interpersonal Goals\n",
+       "32 items, 8 scales, 1 normative data sets\n",
+       "Lock (2014)\n",
+       "< https://doi.org/10.1177/0146167213514280 >\n",
+       "\n",
+       "\n",
+       "The CSIG contains 8 scales:\n",
+       "├── PA (90°): Be authoritative\n",
+       "├── BC (135°): Be tough\n",
+       "├── DE (180°): Be self-protective\n",
+       "├── FG (225°): Be wary\n",
+       "├── HI (270°): Be conflict-avoidant\n",
+       "├── JK (315°): Be cooperative\n",
+       "├── LM (360°): Be understanding\n",
+       "└── NO (45°): Be respected\n",
+       "\n",
+       "\n",
+       "The CSIG is rated using the following 5-point scale:\n",
+       "  0. It is not at all important that...\n",
+       "  1. It is somewhat important that...\n",
+       "  2. It is moderately important that...\n",
+       "  3. It is very important that...\n",
+       "  4. It is extremely important that...\n",
+       "\n",
+       "\n",
+       "\n",
+       "The CSIG currently has 1 normative data set(s):\n",
+       "\n",
+       "1. 665 MTurkers from US, Canada, and India about interactions between nations\n",
+       "   Lock (2014)\n",
+       "   https://doi.org/10.1177/0146167213514280\n",
+       "\n",
+       "
\n" + ], + "text/plain": [ + "CSIG: Circumplex Scales of Interpersonal Goals\n", + "\u001b[1;36m32\u001b[0m items, \u001b[1;36m8\u001b[0m scales, \u001b[1;36m1\u001b[0m normative data sets\n", + "Lock \u001b[1m(\u001b[0m\u001b[1;36m2014\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m<\u001b[0m\u001b[39m \u001b[0m\u001b[4;94mhttps://doi.org/10.1177/0146167213514280\u001b[0m\u001b[39m \u001b[0m\u001b[1m>\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Be authoritative\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Be tough\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Be self-protective\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Be wary\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Be conflict-avoidant\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Be cooperative\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Be understanding\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Be respected\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG is rated using the following 5-point scale:\u001b[0m\n", + " 0. It is not at all important that...\n", + " 1. It is somewhat important that...\n", + " 2. It is moderately important that...\n", + " 3. It is very important that...\n", + " 4. It is extremely important that...\n", + "\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG currently has 1 normative data set(s):\u001b[0m\n", + "\n", + "1. 665 MTurkers from US, Canada, and India about interactions between nations\n", + " Lock (2014)\n", + " https://doi.org/10.1177/0146167213514280\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "csig.info()" + ] + }, + { + "cell_type": "markdown", + "id": "b9ab8ac2", + "metadata": {}, + "source": [ + "## 3. Instrument-related Tidying Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7e0c229c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n",
+       "32 items, 8 scales, 2 normative data sets\n",
+       "Soldz, Budman, Demby, & Merry (1995)\n",
+       "< https://doi.org/10.1177/1073191195002001006 >\n",
+       "\n",
+       "\n",
+       "The IIP-SC contains 8 scales:\n",
+       "├── PA (90°): Domineering\n",
+       "├── BC (135°): Vindictive\n",
+       "├── DE (180°): Cold\n",
+       "├── FG (225°): Socially avoidant\n",
+       "├── HI (270°): Nonassertive\n",
+       "├── JK (315°): Exploitable\n",
+       "├── LM (360°): Overly nurturant\n",
+       "└── NO (45°): Intrusive\n",
+       "\n",
+       "\n",
+       "The IIP-SC is rated using the following 5-point scale:\n",
+       "  0. Not at all\n",
+       "  1. Somewhat\n",
+       "  2. Moderately\n",
+       "  3. Very\n",
+       "  4. Extremely\n",
+       "\n",
+       "\n",
+       "\n",
+       "The IIP-SC currently has 2 normative data set(s):\n",
+       "\n",
+       "1. 872 American college students\n",
+       "   Hopwood, Pincus, DeMoor, & Koonce (2011)\n",
+       "   https://doi.org/10.1080/00223890802388665\n",
+       "2. 106 American psychiatric outpatients\n",
+       "   Soldz, Budman, Demby, & Merry (1995)\n",
+       "   https://doi.org/10.1177/1073191195002001006\n",
+       "\n",
+       "
\n" + ], + "text/plain": [ + "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", + "\u001b[1;36m32\u001b[0m items, \u001b[1;36m8\u001b[0m scales, \u001b[1;36m2\u001b[0m normative data sets\n", + "Soldz, Budman, Demby, & Merry \u001b[1m(\u001b[0m\u001b[1;36m1995\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m<\u001b[0m\u001b[39m \u001b[0m\u001b[4;94mhttps://doi.org/10.1177/1073191195002001006\u001b[0m\u001b[39m \u001b[0m\u001b[1m>\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Domineering\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Vindictive\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Cold\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Socially avoidant\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Nonassertive\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Exploitable\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Overly nurturant\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Intrusive\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC is rated using the following 5-point scale:\u001b[0m\n", + " 0. Not at all\n", + " 1. Somewhat\n", + " 2. Moderately\n", + " 3. Very\n", + " 4. Extremely\n", + "\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC currently has 2 normative data set(s):\u001b[0m\n", + "\n", + "1. 872 American college students\n", + " Hopwood, Pincus, DeMoor, & Koonce (2011)\n", + " https://doi.org/10.1080/00223890802388665\n", + "2. 106 American psychiatric outpatients\n", + " Soldz, Budman, Demby, & Merry (1995)\n", + " https://doi.org/10.1177/1073191195002001006\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iipsc = get_instrument(\"iipsc\")\n", + "iipsc.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8781def3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP01",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP02",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP03",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP04",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "IIP05",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP06",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP07",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP08",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP09",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP10",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP11",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP12",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP13",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP14",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "IIP15",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP16",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP17",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP18",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP19",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP20",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP21",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP22",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP23",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP24",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP25",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP26",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP27",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP28",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP29",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP30",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP31",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "IIP32",
+         "rawType": "int64",
+         "type": "integer"
+        }
+       ],
+       "ref": "03af6d77-2a28-4f28-8aa3-34983b8ff470",
+       "rows": [
+        [
+         "0",
+         "0",
+         "0",
+         "0",
+         "0.0",
+         "1",
+         "0",
+         "1",
+         "0",
+         "2",
+         "1",
+         "0",
+         "0",
+         "0",
+         "1.0",
+         "4",
+         "3",
+         "2",
+         "4",
+         "2",
+         "0",
+         "1",
+         "0",
+         "0",
+         "0",
+         "3",
+         "3",
+         "3",
+         "0",
+         "0",
+         "0",
+         "1",
+         "0"
+        ],
+        [
+         "1",
+         "1",
+         "1",
+         "0",
+         "0.0",
+         "3",
+         "2",
+         "2",
+         "1",
+         "0",
+         "1",
+         "0",
+         "1",
+         "4",
+         "3.0",
+         "3",
+         "1",
+         "0",
+         "0",
+         "1",
+         "0",
+         "1",
+         "2",
+         "0",
+         "0",
+         "0",
+         "0",
+         "0",
+         "1",
+         "0",
+         "0",
+         "0",
+         "2"
+        ],
+        [
+         "2",
+         "1",
+         "0",
+         "1",
+         "0.0",
+         "1",
+         "1",
+         "1",
+         "3",
+         "0",
+         "1",
+         "0",
+         "0",
+         "2",
+         "3.0",
+         "3",
+         "2",
+         "2",
+         "1",
+         "1",
+         "0",
+         "3",
+         "2",
+         "3",
+         "1",
+         "1",
+         "1",
+         "1",
+         "0",
+         "3",
+         "2",
+         "3",
+         "2"
+        ],
+        [
+         "3",
+         "3",
+         "2",
+         "3",
+         null,
+         "2",
+         "3",
+         "2",
+         "3",
+         "2",
+         "3",
+         "2",
+         "4",
+         "2",
+         "1.0",
+         "2",
+         "3",
+         "1",
+         "2",
+         "2",
+         "1",
+         "3",
+         "2",
+         "3",
+         "2",
+         "1",
+         "2",
+         "3",
+         "2",
+         "3",
+         "2",
+         "3",
+         "2"
+        ],
+        [
+         "4",
+         "0",
+         "0",
+         "0",
+         "1.0",
+         "0",
+         "0",
+         "1",
+         "1",
+         "0",
+         "1",
+         "0",
+         "2",
+         "1",
+         "1.0",
+         "3",
+         "1",
+         "0",
+         "1",
+         "0",
+         "1",
+         "1",
+         "0",
+         "1",
+         "1",
+         "2",
+         "1",
+         "0",
+         "0",
+         "0",
+         "0",
+         "0",
+         "0"
+        ]
+       ],
+       "shape": {
+        "columns": 32,
+        "rows": 5
+       }
+      },
+      "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", + " \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", + "
IIP01IIP02IIP03IIP04IIP05IIP06IIP07IIP08IIP09IIP10...IIP23IIP24IIP25IIP26IIP27IIP28IIP29IIP30IIP31IIP32
00000.0101021...0033300010
11100.0322101...0000010002
21010.0111301...3111103232
3323NaN232323...3212323232
40001.0001101...1121000000
\n", + "

5 rows × 32 columns

\n", + "
" + ], + "text/plain": [ + "\n", + " IIP01 IIP02 IIP03 IIP04 IIP05 IIP06 IIP07 IIP08 IIP09 IIP10 \u001b[33m...\u001b[0m \\\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0.0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m1\u001b[0m \u001b[33m...\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0.0\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[33m...\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0.0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[33m...\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m NaN \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[33m...\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1.0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[33m...\u001b[0m \n", + "\n", + " IIP23 IIP24 IIP25 IIP26 IIP27 IIP28 IIP29 IIP30 IIP31 IIP32 \n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m2\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;36m2\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;36m0\u001b[0m \n", + "\n", + "\u001b[1m[\u001b[0m\u001b[1;36m5\u001b[0m rows x \u001b[1;36m32\u001b[0m columns\u001b[1m]\u001b[0m" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "raw_iipsc = pd.read_csv(\n", + " \"/Users/mitch/Documents/GitHub/python-circumplex/src/circumplex/data/raw_iipsc.csv\"\n", + ")\n", + "raw_iipsc.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f811e679", + "metadata": {}, + "source": [ + "### Ipsatizing item-level data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0e76e58e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "0_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "1_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "2_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "3_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "4_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "5_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "6_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "7_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "8_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "9_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "10_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "11_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "12_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "13_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "14_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "15_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "16_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "17_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "18_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "19_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "20_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "21_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "22_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "23_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "24_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "25_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "26_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "27_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "28_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "29_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "30_i",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "31_i",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "02322768-8991-4a47-a370-b78475d2aacb",
+       "rows": [
+        [
+         "0",
+         "-1.0",
+         "-1.0",
+         "-1.0",
+         "-1.0",
+         "0.0",
+         "-1.0",
+         "0.0",
+         "-1.0",
+         "1.0",
+         "0.0",
+         "-1.0",
+         "-1.0",
+         "-1.0",
+         "0.0",
+         "3.0",
+         "2.0",
+         "1.0",
+         "3.0",
+         "1.0",
+         "-1.0",
+         "0.0",
+         "-1.0",
+         "-1.0",
+         "-1.0",
+         "2.0",
+         "2.0",
+         "2.0",
+         "-1.0",
+         "-1.0",
+         "-1.0",
+         "0.0",
+         "-1.0"
+        ],
+        [
+         "1",
+         "0.0625",
+         "0.0625",
+         "-0.9375",
+         "-0.9375",
+         "2.0625",
+         "1.0625",
+         "1.0625",
+         "0.0625",
+         "-0.9375",
+         "0.0625",
+         "-0.9375",
+         "0.0625",
+         "3.0625",
+         "2.0625",
+         "2.0625",
+         "0.0625",
+         "-0.9375",
+         "-0.9375",
+         "0.0625",
+         "-0.9375",
+         "0.0625",
+         "1.0625",
+         "-0.9375",
+         "-0.9375",
+         "-0.9375",
+         "-0.9375",
+         "-0.9375",
+         "0.0625",
+         "-0.9375",
+         "-0.9375",
+         "-0.9375",
+         "1.0625"
+        ],
+        [
+         "2",
+         "-0.40625",
+         "-1.40625",
+         "-0.40625",
+         "-1.40625",
+         "-0.40625",
+         "-0.40625",
+         "-0.40625",
+         "1.59375",
+         "-1.40625",
+         "-0.40625",
+         "-1.40625",
+         "-1.40625",
+         "0.59375",
+         "1.59375",
+         "1.59375",
+         "0.59375",
+         "0.59375",
+         "-0.40625",
+         "-0.40625",
+         "-1.40625",
+         "1.59375",
+         "0.59375",
+         "1.59375",
+         "-0.40625",
+         "-0.40625",
+         "-0.40625",
+         "-0.40625",
+         "-1.40625",
+         "1.59375",
+         "0.59375",
+         "1.59375",
+         "0.59375"
+        ],
+        [
+         "3",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         null,
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "1.7096774193548385",
+         "-0.2903225806451615",
+         "-1.2903225806451615",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-1.2903225806451615",
+         "-0.2903225806451615",
+         "-0.2903225806451615",
+         "-1.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "-1.2903225806451615",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615",
+         "0.7096774193548385",
+         "-0.2903225806451615"
+        ],
+        [
+         "4",
+         "-0.625",
+         "-0.625",
+         "-0.625",
+         "0.375",
+         "-0.625",
+         "-0.625",
+         "0.375",
+         "0.375",
+         "-0.625",
+         "0.375",
+         "-0.625",
+         "1.375",
+         "0.375",
+         "0.375",
+         "2.375",
+         "0.375",
+         "-0.625",
+         "0.375",
+         "-0.625",
+         "0.375",
+         "0.375",
+         "-0.625",
+         "0.375",
+         "0.375",
+         "1.375",
+         "0.375",
+         "-0.625",
+         "-0.625",
+         "-0.625",
+         "-0.625",
+         "-0.625",
+         "-0.625"
+        ],
+        [
+         "5",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "0.71875",
+         "0.71875",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "1.71875",
+         "0.71875",
+         "0.71875",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "0.71875",
+         "0.71875",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "-0.28125",
+         "0.71875"
+        ],
+        [
+         "6",
+         "0.5",
+         "-0.5",
+         "-0.5",
+         "-0.5",
+         "1.5",
+         "0.5",
+         "0.5",
+         "-0.5",
+         "0.5",
+         "-0.5",
+         "-0.5",
+         "-0.5",
+         "0.5",
+         "0.5",
+         "0.5",
+         "-0.5",
+         "0.5",
+         "-0.5",
+         "-0.5",
+         "-0.5",
+         "-0.5",
+         "0.5",
+         "0.5",
+         "0.5",
+         "0.5",
+         "-0.5",
+         "-0.5",
+         "-0.5",
+         "0.5",
+         "0.5",
+         "-0.5",
+         "-0.5"
+        ],
+        [
+         "7",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "1.2580645161290323",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "-0.7419354838709677",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         null,
+         "1.2580645161290323",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "-0.7419354838709677",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "0.25806451612903225",
+         "-0.7419354838709677",
+         "-0.7419354838709677",
+         "0.25806451612903225",
+         "1.2580645161290323",
+         "0.25806451612903225"
+        ],
+        [
+         "8",
+         "-0.96875",
+         "-0.96875",
+         "1.03125",
+         "1.03125",
+         "-0.96875",
+         "0.03125",
+         "2.03125",
+         "-0.96875",
+         "0.03125",
+         "-0.96875",
+         "0.03125",
+         "0.03125",
+         "-0.96875",
+         "1.03125",
+         "1.03125",
+         "1.03125",
+         "0.03125",
+         "1.03125",
+         "1.03125",
+         "-0.96875",
+         "-0.96875",
+         "-0.96875",
+         "2.03125",
+         "-0.96875",
+         "0.03125",
+         "-0.96875",
+         "0.03125",
+         "-0.96875",
+         "-0.96875",
+         "0.03125",
+         "2.03125",
+         "-0.96875"
+        ],
+        [
+         "9",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "1.78125",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "1.78125",
+         "1.78125",
+         "0.78125",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875",
+         "-0.21875"
+        ]
+       ],
+       "shape": {
+        "columns": 32,
+        "rows": 10
+       }
+      },
+      "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", + " \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", + " \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", + "
0_i1_i2_i3_i4_i5_i6_i7_i8_i9_i...22_i23_i24_i25_i26_i27_i28_i29_i30_i31_i
0-1.000000-1.000000-1.000000-1.0000000.000000-1.0000000.000000-1.0000001.0000000.000000...-1.000000-1.0000002.0000002.0000002.000000-1.000000-1.000000-1.0000000.000000-1.000000
10.0625000.062500-0.937500-0.9375002.0625001.0625001.0625000.062500-0.9375000.062500...-0.937500-0.937500-0.937500-0.937500-0.9375000.062500-0.937500-0.937500-0.9375001.062500
2-0.406250-1.406250-0.406250-1.406250-0.406250-0.406250-0.4062501.593750-1.406250-0.406250...1.593750-0.406250-0.406250-0.406250-0.406250-1.4062501.5937500.5937501.5937500.593750
30.709677-0.2903230.709677NaN-0.2903230.709677-0.2903230.709677-0.2903230.709677...0.709677-0.290323-1.290323-0.2903230.709677-0.2903230.709677-0.2903230.709677-0.290323
4-0.625000-0.625000-0.6250000.375000-0.625000-0.6250000.3750000.375000-0.6250000.375000...0.3750000.3750001.3750000.375000-0.625000-0.625000-0.625000-0.625000-0.625000-0.625000
5-0.281250-0.281250-0.281250-0.281250-0.281250-0.2812500.7187500.718750-0.281250-0.281250...0.7187500.718750-0.281250-0.281250-0.281250-0.281250-0.281250-0.281250-0.2812500.718750
60.500000-0.500000-0.500000-0.5000001.5000000.5000000.500000-0.5000000.500000-0.500000...0.5000000.5000000.500000-0.500000-0.500000-0.5000000.5000000.500000-0.500000-0.500000
70.258065-0.7419350.258065-0.7419350.2580650.2580651.2580650.2580650.258065-0.741935...0.2580650.2580650.2580650.2580650.258065-0.741935-0.7419350.2580651.2580650.258065
8-0.968750-0.9687501.0312501.031250-0.9687500.0312502.031250-0.9687500.031250-0.968750...2.031250-0.9687500.031250-0.9687500.031250-0.968750-0.9687500.0312502.031250-0.968750
9-0.218750-0.218750-0.218750-0.218750-0.218750-0.2187501.781250-0.218750-0.218750-0.218750...-0.218750-0.218750-0.218750-0.218750-0.218750-0.218750-0.218750-0.218750-0.218750-0.218750
\n", + "

10 rows × 32 columns

\n", + "
" + ], + "text/plain": [ + "\n", + " 0_i 1_i 2_i 3_i 4_i 5_i 6_i \\\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m0.000000\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m0.062500\u001b[0m \u001b[1;36m0.062500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m2.062500\u001b[0m \u001b[1;36m1.062500\u001b[0m \u001b[1;36m1.062500\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-1.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-1.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m0.709677\u001b[0m NaN \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m0.375000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m0.375000\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m0.718750\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m1.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m-0.741935\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m-0.741935\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m1.258065\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m1.031250\u001b[0m \u001b[1;36m1.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m0.031250\u001b[0m \u001b[1;36m2.031250\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m1.781250\u001b[0m \n", + "\n", + " 7_i 8_i 9_i \u001b[33m...\u001b[0m 22_i 23_i 24_i 25_i \\\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m1.000000\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m2.000000\u001b[0m \u001b[1;36m2.000000\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m0.062500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m0.062500\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m1.593750\u001b[0m \u001b[1;36m-1.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m1.593750\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-0.406250\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m-1.290323\u001b[0m \u001b[1;36m-0.290323\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m0.375000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m0.375000\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m0.375000\u001b[0m \u001b[1;36m0.375000\u001b[0m \u001b[1;36m1.375000\u001b[0m \u001b[1;36m0.375000\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m0.718750\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m0.718750\u001b[0m \u001b[1;36m0.718750\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m-0.741935\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m0.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m2.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m0.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[33m...\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \n", + "\n", + " 26_i 27_i 28_i 29_i 30_i 31_i \n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m2.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m-1.000000\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m0.062500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m-0.937500\u001b[0m \u001b[1;36m1.062500\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m-0.406250\u001b[0m \u001b[1;36m-1.406250\u001b[0m \u001b[1;36m1.593750\u001b[0m \u001b[1;36m0.593750\u001b[0m \u001b[1;36m1.593750\u001b[0m \u001b[1;36m0.593750\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \u001b[1;36m0.709677\u001b[0m \u001b[1;36m-0.290323\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \u001b[1;36m-0.625000\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m-0.281250\u001b[0m \u001b[1;36m0.718750\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \u001b[1;36m-0.500000\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m-0.741935\u001b[0m \u001b[1;36m-0.741935\u001b[0m \u001b[1;36m0.258065\u001b[0m \u001b[1;36m1.258065\u001b[0m \u001b[1;36m0.258065\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m0.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m-0.968750\u001b[0m \u001b[1;36m0.031250\u001b[0m \u001b[1;36m2.031250\u001b[0m \u001b[1;36m-0.968750\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \u001b[1;36m-0.218750\u001b[0m \n", + "\n", + "\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m rows x \u001b[1;36m32\u001b[0m columns\u001b[1m]\u001b[0m" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ips_iipsc = ipsatize(\n", + " data=raw_iipsc,\n", + " items=np.arange(0, 32),\n", + " append=False,\n", + ")\n", + "ips_iipsc" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0dbd5c56", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "0",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "622d720a-6966-44bb-b549-7c604deee3b7",
+       "rows": [
+        [
+         "0",
+         "1.0"
+        ],
+        [
+         "1",
+         "0.94"
+        ],
+        [
+         "2",
+         "1.41"
+        ],
+        [
+         "3",
+         "2.29"
+        ],
+        [
+         "4",
+         "0.62"
+        ],
+        [
+         "5",
+         "0.28"
+        ],
+        [
+         "6",
+         "0.5"
+        ],
+        [
+         "7",
+         "0.74"
+        ],
+        [
+         "8",
+         "0.97"
+        ],
+        [
+         "9",
+         "0.22"
+        ]
+       ],
+       "shape": {
+        "columns": 1,
+        "rows": 10
+       }
+      },
+      "text/plain": [
+       "\n",
+       "\u001b[1;36m0\u001b[0m    \u001b[1;36m1.00\u001b[0m\n",
+       "\u001b[1;36m1\u001b[0m    \u001b[1;36m0.94\u001b[0m\n",
+       "\u001b[1;36m2\u001b[0m    \u001b[1;36m1.41\u001b[0m\n",
+       "\u001b[1;36m3\u001b[0m    \u001b[1;36m2.29\u001b[0m\n",
+       "\u001b[1;36m4\u001b[0m    \u001b[1;36m0.62\u001b[0m\n",
+       "\u001b[1;36m5\u001b[0m    \u001b[1;36m0.28\u001b[0m\n",
+       "\u001b[1;36m6\u001b[0m    \u001b[1;36m0.50\u001b[0m\n",
+       "\u001b[1;36m7\u001b[0m    \u001b[1;36m0.74\u001b[0m\n",
+       "\u001b[1;36m8\u001b[0m    \u001b[1;36m0.97\u001b[0m\n",
+       "\u001b[1;36m9\u001b[0m    \u001b[1;36m0.22\u001b[0m\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "round(raw_iipsc.mean(axis=1, skipna=True), 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6bdf3124",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "0",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "0698d557-1775-4aef-a95f-d66adc825e7b",
+       "rows": [
+        [
+         "0",
+         "0.0"
+        ],
+        [
+         "1",
+         "0.0"
+        ],
+        [
+         "2",
+         "0.0"
+        ],
+        [
+         "3",
+         "-0.0"
+        ],
+        [
+         "4",
+         "0.0"
+        ],
+        [
+         "5",
+         "0.0"
+        ],
+        [
+         "6",
+         "0.0"
+        ],
+        [
+         "7",
+         "0.0"
+        ],
+        [
+         "8",
+         "0.0"
+        ],
+        [
+         "9",
+         "0.0"
+        ]
+       ],
+       "shape": {
+        "columns": 1,
+        "rows": 10
+       }
+      },
+      "text/plain": [
+       "\n",
+       "\u001b[1;36m0\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m1\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m2\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m3\u001b[0m   \u001b[1;36m-0.0\u001b[0m\n",
+       "\u001b[1;36m4\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m5\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m6\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m7\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m8\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "\u001b[1;36m9\u001b[0m    \u001b[1;36m0.0\u001b[0m\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "round(ips_iipsc.mean(axis=1, skipna=True), 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3971ab9d",
+   "metadata": {},
+   "source": [
+    "### Scoring item-level data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "cc2939a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
The IIP-SC contains 8 scales:\n",
+       "├── PA (90°): Domineering\n",
+       "├── BC (135°): Vindictive\n",
+       "├── DE (180°): Cold\n",
+       "├── FG (225°): Socially avoidant\n",
+       "├── HI (270°): Nonassertive\n",
+       "├── JK (315°): Exploitable\n",
+       "├── LM (360°): Overly nurturant\n",
+       "└── NO (45°): Intrusive\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;36mThe IIP-SC contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Domineering\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Vindictive\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Cold\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Socially avoidant\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Nonassertive\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Exploitable\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Overly nurturant\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Intrusive\u001b[0m\n" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iipsc.info_scales()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ceb1b5d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "PA",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "BC",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "DE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "FG",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "HI",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "JK",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "LM",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "NO",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "b4555af4-ff32-4809-80cc-e3edde9516af",
+       "rows": [
+        [
+         "0",
+         "1.75",
+         "2.0",
+         "1.25",
+         "0.0",
+         "0.5",
+         "0.25",
+         "1.5",
+         "0.75"
+        ],
+        [
+         "1",
+         "0.25",
+         "0.5",
+         "0.25",
+         "0.5",
+         "2.0",
+         "1.75",
+         "1.25",
+         "1.0"
+        ],
+        [
+         "2",
+         "1.0",
+         "0.75",
+         "0.75",
+         "0.0",
+         "2.25",
+         "2.0",
+         "2.5",
+         "2.0"
+        ],
+        [
+         "3",
+         "1.75",
+         "2.25",
+         "2.5",
+         "2.3333333333333335",
+         "2.5",
+         "2.0",
+         "2.5",
+         "2.5"
+        ],
+        [
+         "4",
+         "0.5",
+         "0.75",
+         "0.0",
+         "1.0",
+         "0.5",
+         "0.25",
+         "1.25",
+         "0.75"
+        ],
+        [
+         "5",
+         "0.25",
+         "0.0",
+         "0.0",
+         "0.0",
+         "0.0",
+         "0.0",
+         "1.0",
+         "1.0"
+        ],
+        [
+         "6",
+         "1.0",
+         "0.0",
+         "0.0",
+         "0.0",
+         "1.0",
+         "1.0",
+         "0.75",
+         "0.25"
+        ],
+        [
+         "7",
+         "1.0",
+         "0.25",
+         "0.75",
+         "0.0",
+         "0.5",
+         "0.6666666666666666",
+         "1.75",
+         "1.0"
+        ],
+        [
+         "8",
+         "0.75",
+         "0.5",
+         "1.5",
+         "0.75",
+         "0.0",
+         "1.0",
+         "2.75",
+         "0.5"
+        ],
+        [
+         "9",
+         "0.0",
+         "0.0",
+         "0.0",
+         "0.0",
+         "0.0",
+         "0.5",
+         "1.0",
+         "0.25"
+        ]
+       ],
+       "shape": {
+        "columns": 8,
+        "rows": 10
+       }
+      },
+      "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PABCDEFGHIJKLMNO
01.752.001.250.0000000.500.2500001.500.75
10.250.500.250.5000002.001.7500001.251.00
21.000.750.750.0000002.252.0000002.502.00
31.752.252.502.3333332.502.0000002.502.50
40.500.750.001.0000000.500.2500001.250.75
50.250.000.000.0000000.000.0000001.001.00
61.000.000.000.0000001.001.0000000.750.25
71.000.250.750.0000000.500.6666671.751.00
80.750.501.500.7500000.001.0000002.750.50
90.000.000.000.0000000.000.5000001.000.25
\n", + "
" + ], + "text/plain": [ + "\n", + " PA BC DE FG HI JK LM NO\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m1.75\u001b[0m \u001b[1;36m2.00\u001b[0m \u001b[1;36m1.25\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m0.250000\u001b[0m \u001b[1;36m1.50\u001b[0m \u001b[1;36m0.75\u001b[0m\n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m0.25\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m0.25\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m2.00\u001b[0m \u001b[1;36m1.750000\u001b[0m \u001b[1;36m1.25\u001b[0m \u001b[1;36m1.00\u001b[0m\n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m2.25\u001b[0m \u001b[1;36m2.000000\u001b[0m \u001b[1;36m2.50\u001b[0m \u001b[1;36m2.00\u001b[0m\n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m1.75\u001b[0m \u001b[1;36m2.25\u001b[0m \u001b[1;36m2.50\u001b[0m \u001b[1;36m2.333333\u001b[0m \u001b[1;36m2.50\u001b[0m \u001b[1;36m2.000000\u001b[0m \u001b[1;36m2.50\u001b[0m \u001b[1;36m2.50\u001b[0m\n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m1.000000\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m0.250000\u001b[0m \u001b[1;36m1.25\u001b[0m \u001b[1;36m0.75\u001b[0m\n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m0.25\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m1.00\u001b[0m\n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m1.000000\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.25\u001b[0m\n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m0.25\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m0.666667\u001b[0m \u001b[1;36m1.75\u001b[0m \u001b[1;36m1.00\u001b[0m\n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m0.75\u001b[0m \u001b[1;36m0.50\u001b[0m \u001b[1;36m1.50\u001b[0m \u001b[1;36m0.750000\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m1.000000\u001b[0m \u001b[1;36m2.75\u001b[0m \u001b[1;36m0.50\u001b[0m\n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.000000\u001b[0m \u001b[1;36m0.00\u001b[0m \u001b[1;36m0.500000\u001b[0m \u001b[1;36m1.00\u001b[0m \u001b[1;36m0.25\u001b[0m" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scale_scores = score(\n", + " data=raw_iipsc, items=np.arange(0, 32), append=False, instrument=\"iipsc\"\n", + ")\n", + "scale_scores" + ] + }, + { + "cell_type": "markdown", + "id": "942a523d", + "metadata": {}, + "source": [ + "### Standardizing scale-level data" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a8942359", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
The IIP-SC currently has 2 normative data set(s):\n",
+       "\n",
+       "1. 872 American college students\n",
+       "   Hopwood, Pincus, DeMoor, & Koonce (2011)\n",
+       "   https://doi.org/10.1080/00223890802388665\n",
+       "2. 106 American psychiatric outpatients\n",
+       "   Soldz, Budman, Demby, & Merry (1995)\n",
+       "   https://doi.org/10.1177/1073191195002001006\n",
+       "\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;36mThe IIP-SC currently has 2 normative data set(s):\u001b[0m\n", + "\n", + "1. 872 American college students\n", + " Hopwood, Pincus, DeMoor, & Koonce (2011)\n", + " https://doi.org/10.1080/00223890802388665\n", + "2. 106 American psychiatric outpatients\n", + " Soldz, Budman, Demby, & Merry (1995)\n", + " https://doi.org/10.1177/1073191195002001006\n", + "\n" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iipsc.info_norms()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ca6ac236", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "PA",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "BC",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "DE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "FG",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "HI",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "JK",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "LM",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "NO",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "ad675127-1765-46dd-8371-634fe3569bb1",
+       "rows": [
+        [
+         "0",
+         "1.5",
+         "1.7500000000000002",
+         "0.4093567251461988",
+         "-1.1055408970976255",
+         "-1.0054644808743167",
+         "-1.3313782991202345",
+         "0.04242424242424233",
+         "-0.3437499999999999"
+        ],
+        [
+         "1",
+         "-0.7727272727272727",
+         "-0.42391304347826086",
+         "-0.760233918128655",
+         "-0.5778364116094987",
+         "0.6338797814207651",
+         "0.42815249266862165",
+         "-0.26060606060606073",
+         "-0.03124999999999989"
+        ],
+        [
+         "2",
+         "0.3636363636363636",
+         "-0.06159420289855071",
+         "-0.1754385964912281",
+         "-1.1055408970976255",
+         "0.907103825136612",
+         "0.721407624633431",
+         "1.2545454545454544",
+         "1.21875"
+        ],
+        [
+         "3",
+         "1.5",
+         "2.1123188405797104",
+         "1.8713450292397662",
+         "1.3570800351802992",
+         "1.180327868852459",
+         "0.721407624633431",
+         "1.2545454545454544",
+         "1.84375"
+        ],
+        [
+         "4",
+         "-0.3939393939393939",
+         "-0.06159420289855071",
+         "-1.0526315789473684",
+         "-0.050131926121372135",
+         "-1.0054644808743167",
+         "-1.3313782991202345",
+         "-0.26060606060606073",
+         "-0.3437499999999999"
+        ],
+        [
+         "5",
+         "-0.7727272727272727",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-1.5519125683060109",
+         "-1.6246334310850439",
+         "-0.5636363636363637",
+         "-0.03124999999999989"
+        ],
+        [
+         "6",
+         "0.3636363636363636",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-0.45901639344262285",
+         "-0.45161290322580644",
+         "-0.8666666666666668",
+         "-0.9687499999999999"
+        ],
+        [
+         "7",
+         "0.3636363636363636",
+         "-0.7862318840579711",
+         "-0.1754385964912281",
+         "-1.1055408970976255",
+         "-1.0054644808743167",
+         "-0.8426197458455523",
+         "0.3454545454545454",
+         "-0.03124999999999989"
+        ],
+        [
+         "8",
+         "-0.015151515151515164",
+         "-0.42391304347826086",
+         "0.7017543859649122",
+         "-0.31398416886543545",
+         "-1.5519125683060109",
+         "-0.45161290322580644",
+         "1.5575757575757576",
+         "-0.6562499999999999"
+        ],
+        [
+         "9",
+         "-1.1515151515151514",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-1.5519125683060109",
+         "-1.0381231671554252",
+         "-0.5636363636363637",
+         "-0.9687499999999999"
+        ]
+       ],
+       "shape": {
+        "columns": 8,
+        "rows": 10
+       }
+      },
+      "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PABCDEFGHIJKLMNO
01.5000001.7500000.409357-1.105541-1.005464-1.3313780.042424-0.34375
1-0.772727-0.423913-0.760234-0.5778360.6338800.428152-0.260606-0.03125
20.363636-0.061594-0.175439-1.1055410.9071040.7214081.2545451.21875
31.5000002.1123191.8713451.3570801.1803280.7214081.2545451.84375
4-0.393939-0.061594-1.052632-0.050132-1.005464-1.331378-0.260606-0.34375
5-0.772727-1.148551-1.052632-1.105541-1.551913-1.624633-0.563636-0.03125
60.363636-1.148551-1.052632-1.105541-0.459016-0.451613-0.866667-0.96875
70.363636-0.786232-0.175439-1.105541-1.005464-0.8426200.345455-0.03125
8-0.015152-0.4239130.701754-0.313984-1.551913-0.4516131.557576-0.65625
9-1.151515-1.148551-1.052632-1.105541-1.551913-1.038123-0.563636-0.96875
\n", + "
" + ], + "text/plain": [ + "\n", + " PA BC DE FG HI JK LM \\\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m1.500000\u001b[0m \u001b[1;36m1.750000\u001b[0m \u001b[1;36m0.409357\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-1.331378\u001b[0m \u001b[1;36m0.042424\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m-0.772727\u001b[0m \u001b[1;36m-0.423913\u001b[0m \u001b[1;36m-0.760234\u001b[0m \u001b[1;36m-0.577836\u001b[0m \u001b[1;36m0.633880\u001b[0m \u001b[1;36m0.428152\u001b[0m \u001b[1;36m-0.260606\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-0.061594\u001b[0m \u001b[1;36m-0.175439\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m0.907104\u001b[0m \u001b[1;36m0.721408\u001b[0m \u001b[1;36m1.254545\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m1.500000\u001b[0m \u001b[1;36m2.112319\u001b[0m \u001b[1;36m1.871345\u001b[0m \u001b[1;36m1.357080\u001b[0m \u001b[1;36m1.180328\u001b[0m \u001b[1;36m0.721408\u001b[0m \u001b[1;36m1.254545\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.393939\u001b[0m \u001b[1;36m-0.061594\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-0.050132\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-1.331378\u001b[0m \u001b[1;36m-0.260606\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.772727\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-1.624633\u001b[0m \u001b[1;36m-0.563636\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-0.459016\u001b[0m \u001b[1;36m-0.451613\u001b[0m \u001b[1;36m-0.866667\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-0.786232\u001b[0m \u001b[1;36m-0.175439\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-0.842620\u001b[0m \u001b[1;36m0.345455\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.015152\u001b[0m \u001b[1;36m-0.423913\u001b[0m \u001b[1;36m0.701754\u001b[0m \u001b[1;36m-0.313984\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-0.451613\u001b[0m \u001b[1;36m1.557576\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-1.151515\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-1.038123\u001b[0m \u001b[1;36m-0.563636\u001b[0m \n", + "\n", + " NO \n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m-0.34375\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m1.21875\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m1.84375\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.34375\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m-0.96875\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.65625\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-0.96875\u001b[0m " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z_scales = iipsc.norm_standardize(\n", + " data=scale_scores,\n", + " scales=np.arange(0, 8),\n", + " sample_id=1,\n", + " append=False,\n", + ")\n", + "z_scales" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "804b5b83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "PA_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "BC_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "DE_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "FG_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "HI_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "JK_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "LM_z",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "NO_z",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "b106b218-fba5-4d11-bf30-5aefa8c99694",
+       "rows": [
+        [
+         "0",
+         "1.5",
+         "1.7500000000000002",
+         "0.4093567251461988",
+         "-1.1055408970976255",
+         "-1.0054644808743167",
+         "-1.3313782991202345",
+         "0.04242424242424233",
+         "-0.3437499999999999"
+        ],
+        [
+         "1",
+         "-0.7727272727272727",
+         "-0.42391304347826086",
+         "-0.760233918128655",
+         "-0.5778364116094987",
+         "0.6338797814207651",
+         "0.42815249266862165",
+         "-0.26060606060606073",
+         "-0.03124999999999989"
+        ],
+        [
+         "2",
+         "0.3636363636363636",
+         "-0.06159420289855071",
+         "-0.1754385964912281",
+         "-1.1055408970976255",
+         "0.907103825136612",
+         "0.721407624633431",
+         "1.2545454545454544",
+         "1.21875"
+        ],
+        [
+         "3",
+         "1.5",
+         "2.1123188405797104",
+         "1.8713450292397662",
+         "1.3570800351802992",
+         "1.180327868852459",
+         "0.721407624633431",
+         "1.2545454545454544",
+         "1.84375"
+        ],
+        [
+         "4",
+         "-0.3939393939393939",
+         "-0.06159420289855071",
+         "-1.0526315789473684",
+         "-0.050131926121372135",
+         "-1.0054644808743167",
+         "-1.3313782991202345",
+         "-0.26060606060606073",
+         "-0.3437499999999999"
+        ],
+        [
+         "5",
+         "-0.7727272727272727",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-1.5519125683060109",
+         "-1.6246334310850439",
+         "-0.5636363636363637",
+         "-0.03124999999999989"
+        ],
+        [
+         "6",
+         "0.3636363636363636",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-0.45901639344262285",
+         "-0.45161290322580644",
+         "-0.8666666666666668",
+         "-0.9687499999999999"
+        ],
+        [
+         "7",
+         "0.3636363636363636",
+         "-0.7862318840579711",
+         "-0.1754385964912281",
+         "-1.1055408970976255",
+         "-1.0054644808743167",
+         "-0.8426197458455523",
+         "0.3454545454545454",
+         "-0.03124999999999989"
+        ],
+        [
+         "8",
+         "-0.015151515151515164",
+         "-0.42391304347826086",
+         "0.7017543859649122",
+         "-0.31398416886543545",
+         "-1.5519125683060109",
+         "-0.45161290322580644",
+         "1.5575757575757576",
+         "-0.6562499999999999"
+        ],
+        [
+         "9",
+         "-1.1515151515151514",
+         "-1.1485507246376812",
+         "-1.0526315789473684",
+         "-1.1055408970976255",
+         "-1.5519125683060109",
+         "-1.0381231671554252",
+         "-0.5636363636363637",
+         "-0.9687499999999999"
+        ]
+       ],
+       "shape": {
+        "columns": 8,
+        "rows": 10
+       }
+      },
+      "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PA_zBC_zDE_zFG_zHI_zJK_zLM_zNO_z
01.5000001.7500000.409357-1.105541-1.005464-1.3313780.042424-0.34375
1-0.772727-0.423913-0.760234-0.5778360.6338800.428152-0.260606-0.03125
20.363636-0.061594-0.175439-1.1055410.9071040.7214081.2545451.21875
31.5000002.1123191.8713451.3570801.1803280.7214081.2545451.84375
4-0.393939-0.061594-1.052632-0.050132-1.005464-1.331378-0.260606-0.34375
5-0.772727-1.148551-1.052632-1.105541-1.551913-1.624633-0.563636-0.03125
60.363636-1.148551-1.052632-1.105541-0.459016-0.451613-0.866667-0.96875
70.363636-0.786232-0.175439-1.105541-1.005464-0.8426200.345455-0.03125
8-0.015152-0.4239130.701754-0.313984-1.551913-0.4516131.557576-0.65625
9-1.151515-1.148551-1.052632-1.105541-1.551913-1.038123-0.563636-0.96875
\n", + "
" + ], + "text/plain": [ + "\n", + " PA_z BC_z DE_z FG_z HI_z JK_z LM_z \\\n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m1.500000\u001b[0m \u001b[1;36m1.750000\u001b[0m \u001b[1;36m0.409357\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-1.331378\u001b[0m \u001b[1;36m0.042424\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m-0.772727\u001b[0m \u001b[1;36m-0.423913\u001b[0m \u001b[1;36m-0.760234\u001b[0m \u001b[1;36m-0.577836\u001b[0m \u001b[1;36m0.633880\u001b[0m \u001b[1;36m0.428152\u001b[0m \u001b[1;36m-0.260606\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-0.061594\u001b[0m \u001b[1;36m-0.175439\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m0.907104\u001b[0m \u001b[1;36m0.721408\u001b[0m \u001b[1;36m1.254545\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m1.500000\u001b[0m \u001b[1;36m2.112319\u001b[0m \u001b[1;36m1.871345\u001b[0m \u001b[1;36m1.357080\u001b[0m \u001b[1;36m1.180328\u001b[0m \u001b[1;36m0.721408\u001b[0m \u001b[1;36m1.254545\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.393939\u001b[0m \u001b[1;36m-0.061594\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-0.050132\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-1.331378\u001b[0m \u001b[1;36m-0.260606\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.772727\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-1.624633\u001b[0m \u001b[1;36m-0.563636\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-0.459016\u001b[0m \u001b[1;36m-0.451613\u001b[0m \u001b[1;36m-0.866667\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m0.363636\u001b[0m \u001b[1;36m-0.786232\u001b[0m \u001b[1;36m-0.175439\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.005464\u001b[0m \u001b[1;36m-0.842620\u001b[0m \u001b[1;36m0.345455\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.015152\u001b[0m \u001b[1;36m-0.423913\u001b[0m \u001b[1;36m0.701754\u001b[0m \u001b[1;36m-0.313984\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-0.451613\u001b[0m \u001b[1;36m1.557576\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-1.151515\u001b[0m \u001b[1;36m-1.148551\u001b[0m \u001b[1;36m-1.052632\u001b[0m \u001b[1;36m-1.105541\u001b[0m \u001b[1;36m-1.551913\u001b[0m \u001b[1;36m-1.038123\u001b[0m \u001b[1;36m-0.563636\u001b[0m \n", + "\n", + " NO_z \n", + "\u001b[1;36m0\u001b[0m \u001b[1;36m-0.34375\u001b[0m \n", + "\u001b[1;36m1\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m2\u001b[0m \u001b[1;36m1.21875\u001b[0m \n", + "\u001b[1;36m3\u001b[0m \u001b[1;36m1.84375\u001b[0m \n", + "\u001b[1;36m4\u001b[0m \u001b[1;36m-0.34375\u001b[0m \n", + "\u001b[1;36m5\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m6\u001b[0m \u001b[1;36m-0.96875\u001b[0m \n", + "\u001b[1;36m7\u001b[0m \u001b[1;36m-0.03125\u001b[0m \n", + "\u001b[1;36m8\u001b[0m \u001b[1;36m-0.65625\u001b[0m \n", + "\u001b[1;36m9\u001b[0m \u001b[1;36m-0.96875\u001b[0m " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norm_standardize(\n", + " data=scale_scores,\n", + " instrument=\"iipsc\",\n", + " scales=np.arange(0, 8),\n", + " sample_id=1,\n", + " append=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "25fd8e2d", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python-circumplex (3.12.5)", + "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.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/visualization_demo.py b/examples/visualization_demo.py new file mode 100644 index 0000000..4d65e92 --- /dev/null +++ b/examples/visualization_demo.py @@ -0,0 +1,292 @@ +"""Circumplex Visualization Demo. + +This script demonstrates the visualization capabilities of the `circumplex` package, +showing how to create publication-ready plots of SSM analysis results. + +The package provides three main plot types: +- Circle plots: Show amplitude/displacement on circumplex circle +- Curve plots: Show fitted curves overlaid on observed scores +- Contrast plots: Show parameter differences between groups +""" + +# %% +# ## Setup + +import numpy as np + +from circumplex import load_dataset, plot_circle, ssm_analyze + +# Set random seed for reproducible results +np.random.seed(12345) + +# %% +# ## Example 1: Single Profile - Circle Plot + +# Load data and run analysis +aw2009 = load_dataset("aw2009") +results_single = ssm_analyze( + aw2009, + scales=list(range(8)), + boots=1000, + seed=12345, +) + +# Display summary +results_single.summary() + +# Create basic circle plot using SSM object method +fig = results_single.plot_circle() + +# %% +# ## Example 2: Single Profile - Curve Plot + +# Create curve plot showing fitted curve overlaid on observed scores +fig = results_single.plot_curve() + +# %% +# ## Example 3: Customized Single Profile + +# Customize circle plot appearance +fig = results_single.plot_circle( + colors=None, # Single blue color + figsize=(10, 10), + fontsize=14, + title="Interpersonal Profile (aw2009 dataset)", +) + + +# %% +# ## Example 4: Multi-Group Comparison - Circle Plot + +# Analyze by gender +jz2017 = load_dataset("jz2017") +results_groups = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + grouping="Gender", + boots=1000, + seed=12345, +) + +# Plot comparison with default palette +fig = results_groups.plot_circle() + +# %% +# ## Example 5: Multi-Group - Custom Colors + +# Use custom colors for groups +fig = results_groups.plot_circle( + colors=["#FF6B6B", "#4ECDC4"], # Custom hex colors + figsize=(10, 10), + title="Gender Comparison: Interpersonal Profiles", +) + +# %% +# ## Example 6: Multi-Group - Curve Plots + +# Compare groups with curve plots +scale_names = ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"] +fig = results_groups.plot_curve(angle_labels=scale_names) + +# %% +# ## Example 7: Group Contrast Analysis + +# Include contrast in analysis +results_contrast = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + grouping="Gender", + contrast=True, + boots=1000, + seed=12345, +) + +# Plot all three profiles (Female, Male, Male - Female) +fig = results_contrast.plot_circle() + +# Plot contrast differences +fig = results_contrast.plot_contrast() + +# %% +# ## Example 8: Simplified Contrast Plot (Drop X/Y) + +# Plot contrasts without X and Y parameters for simpler view +fig = results_contrast.plot_contrast(drop_xy=True) + +# %% +# ## Example 9: Correlation-Based Profile + +# Analyze correlation with personality disorder measure +results_corr = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures="PARPD", + boots=1000, + seed=12345, +) + +# Plot correlation profile +fig = results_corr.plot_circle( + colors=["purple"], + title="PARPD Correlations with Interpersonal Scales", +) + +# %% +# ## Example 10: Multi-Measure Comparison + +# Compare two personality disorder measures +results_measures = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures=["ASPD", "NARPD"], + boots=1000, + seed=12345, +) + +# Circle plot comparison +fig = results_measures.plot_circle( + colors=["#E74C3C", "#3498DB"], + title="Personality Disorder Profiles: ASPD vs NARPD", +) + +# Curve plots comparison +fig = results_measures.plot_curve( + angle_labels=scale_names, + colors=["#E74C3C", "#3498DB"], +) + +# %% +# ## Example 11: Measure Contrast + +# Compare measures with contrast +results_measure_contrast = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures=["ASPD", "NARPD"], + contrast=True, + boots=1000, + seed=12345, +) + +# Plot measure contrast +fig = results_measure_contrast.plot_contrast(drop_xy=True) +# fig.savefig("examples/output/contrast_measures.png", dpi=300, bbox_inches="tight") # noqa: ERA001 + +# %% +# ## Example 12: Profile Selection + +# Plot only specific profiles from multi-profile results +# Using the imported plot_circle function directly + +# Plot only first profile from measure results +fig = plot_circle( + results_measures.results, + results_measures.details.angles, + profile_indices=[0], + colors=["#E74C3C"], + title="ASPD Profile Only", +) + +# %% +# ## Example 13: Seaborn Palettes + +# Try different seaborn color palettes +results_multi = ssm_analyze( + jz2017, + scales=list(range(1, 9)), + measures=["ASPD", "NARPD", "BORPD"], + boots=500, # Fewer boots for speed + seed=12345, +) + +# Using 'husl' palette +fig = results_multi.plot_circle(colors="husl", title="HUSL Palette") + +# Using 'colorblind' palette +fig = results_multi.plot_circle(colors="colorblind", title="Colorblind Palette") + +# %% +# ## Visualization Features Summary + +print( + """ +### Circumplex Visualization Features + +✓ **Three Plot Types**: + - Circle plots: Amplitude/displacement on circumplex circle + - Curve plots: Fitted cosine curves overlaid on observed scores + - Contrast plots: Parameter differences with confidence intervals + +✓ **SSM Object Methods**: Convenient plotting directly from results + - results.plot_circle() + - results.plot_curve() + - results.plot_contrast() + +✓ **Customization**: Colors, sizes, fonts, titles +✓ **Confidence intervals**: Bootstrap CIs displayed as arc bars (circle) + or error bars (contrast) +✓ **Publication-ready**: High-resolution output (300 dpi) +✓ **Flexible colors**: Seaborn palettes or custom color lists + +### Plot Types in Detail + +**Circle Plot (plot_circle)**: +- Shows amplitude and displacement on circular plot +- Profile points at (x, y) Cartesian coordinates +- Arc bars show confidence intervals for amplitude and displacement +- Supports single or multiple profiles +- Automatic legend for multiple profiles + +**Curve Plot (plot_curve)**: +- Faceted plots (one subplot per profile) +- Fitted cosine curve overlaid on observed scale scores +- Black points and lines show observed data +- Colored curve shows SSM model fit +- Dashed curves indicate low fit (R² < 0.70) + +**Contrast Plot (plot_contrast)**: +- Shows differences between two profiles/groups +- One subplot per SSM parameter (elevation, amplitude, displacement, etc.) +- Points colored by significance (CI excludes zero) +- Optional drop_xy parameter for simplified plot + +### Customization Options + +**Common Parameters**: +- colors: Seaborn palette name ('Set2', 'husl', etc.) or list of custom colors +- figsize: Figure dimensions in inches (width, height) +- fontsize/base_size: Font size for labels and text +- drop_lowfit: Omit profiles with fit < 0.70 + +**Circle Plot Specific**: +- amax: Maximum amplitude for scaling +- angle_labels: Custom labels for angles +- title: Plot title + +**Curve Plot Specific**: +- angle_labels: Labels for x-axis (scale names) + +**Contrast Plot Specific**: +- drop_xy: Omit x-value and y-value parameters +- sig_color: Color for significant contrasts +- ns_color: Color for non-significant contrasts + +### Usage Patterns + +**Method 1: SSM Object Methods (Recommended)** +```python +results = ssm_analyze(data, scales=[...]) +fig = results.plot_circle() +fig = results.plot_curve() +``` + +**Method 2: Direct Function Calls (Advanced)** +```python +from circumplex import plot_circle, plot_curve, plot_contrast +fig = plot_circle(results.results, results.details.angles) +fig = plot_curve(results.results, results.scores, results.details.angles) +``` + +Both patterns support the same customization options. +""" +) From ba68b54625c7a7111027557ec3e3b2b16073653d Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:52:16 +0000 Subject: [PATCH 70/97] Remove legacy modules and files --- src/circumplex/datasets.py | 18 - src/circumplex/instrument.py | 384 -------------- src/circumplex/py.typed | 0 src/circumplex/ssm_analysis.py | 883 -------------------------------- src/circumplex/ssm_results.py | 154 ------ src/circumplex/utils.py | 135 ----- src/circumplex/visualization.py | 490 ------------------ 7 files changed, 2064 deletions(-) delete mode 100644 src/circumplex/datasets.py delete mode 100644 src/circumplex/instrument.py create mode 100644 src/circumplex/py.typed delete mode 100644 src/circumplex/ssm_analysis.py delete mode 100644 src/circumplex/ssm_results.py delete mode 100644 src/circumplex/utils.py delete mode 100644 src/circumplex/visualization.py diff --git a/src/circumplex/datasets.py b/src/circumplex/datasets.py deleted file mode 100644 index 3a122c9..0000000 --- a/src/circumplex/datasets.py +++ /dev/null @@ -1,18 +0,0 @@ -# %% -from importlib.resources import files - -import pandas as pd - -from circumplex import instrument - -_jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) -JZ2017 = instrument.load_instrument("CSIP").attach_data(pd.read_csv(_jz2017_path)) - -_raw_iipsc_path = str(files("circumplex.data").joinpath("raw_iipsc.csv")) -# RAW_IIPSC = instrument.load_instrument("IIPSC").attach_data(pd.read_csv(_raw_iipsc_path)) - -_satp_path = str(files("circumplex.data").joinpath("SATP Dataset v1.4.xlsx")) -satp_data = pd.read_excel(_satp_path) -SATP_ENG = instrument.load_instrument("SATP-eng").attach_data( - satp_data.query("Language == 'eng'") -) diff --git a/src/circumplex/instrument.py b/src/circumplex/instrument.py deleted file mode 100644 index 0dff308..0000000 --- a/src/circumplex/instrument.py +++ /dev/null @@ -1,384 +0,0 @@ -from __future__ import annotations - -import json -from dataclasses import dataclass -from importlib.resources import files -from typing import Any - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd - -import circumplex.ssm_analysis as ssm -import circumplex.ssm_results as ssm_results - -INSTRUMENT_JSONS = { - "CSIP": str(files("circumplex.instruments").joinpath("CSIP.json")), - "IIPSC": str(files("circumplex.instruments").joinpath("IIPSC.json")), - "SSQP-eng": str(files("circumplex.instruments").joinpath("SSQP-eng.json")), - "SATP-eng": str(files("circumplex.instruments").joinpath("SATP-eng.json")), -} - - -def instruments() -> None: - """ - Print a list of the instruments included in the circumplex package. - - Args: - None - - Returns: - None - """ - ins = {name: load_instrument(name) for name in INSTRUMENT_JSONS.keys()} - print(f"The circumplex package currently includes {len(ins)} instruments:") - i = 1 - for name, inst in ins.items(): - print(f"{i}. {name}: {inst.details.name} ({inst.details.abbrev})") - i += 1 - - return None - - -def from_dict(inst_dict: dict) -> Instrument: - """ - Compose an Instrument object from a dictionary. - - Typically this would be used to load an instrument from one of our built in JSON files. - Args: - inst_dict: A dictionary containing the instrument's details, scales, anchors, and items. - - Returns: - Instrument: An Instrument object. - """ - items_exist = sum( - ["inst_items" in scale.keys() for scale in inst_dict["scales"].values()] - ) - scales = Scales( - abbrev=list(inst_dict["scales"].keys()), - label=[scale["label"] for scale in inst_dict["scales"].values()], - angle=[scale["angle"] for scale in inst_dict["scales"].values()], - inst_items=[ - inst_dict["scales"][scale]["inst_items"] - for scale in inst_dict["scales"].keys() - ] - if items_exist - else None, - ) - anchors = Anchors( - value=[int(key) for key in inst_dict["anchors"].keys()], - label=list(inst_dict["anchors"].values()), - ) - norms = ( - Norms( - table=pd.DataFrame.from_dict(inst_dict["norms"]), - src=pd.DataFrame.from_dict(inst_dict["norms_src"]), - ) - if "norms" in inst_dict - else None - ) - details = InstrumentDetails(**inst_dict["details"]) # type: ignore[missing-argument] - return Instrument(scales, anchors, details, norms) - - -def load_instrument(instrument: str) -> Instrument: - """ - Load an instrument from one of our built-in JSON files. - - Args: - instrument: The name of the instrument to load. Must be one of the following: - - CSIP - - Returns: - Instrument: An Instrument object. - """ - with open(INSTRUMENT_JSONS[instrument], "r") as f: - instrument = json.load(f) - - return from_dict(instrument) - - -@dataclass -class Anchors: - value: list[int] - label: list[str] - - def __post_init__(self): - assert len(self.value) == len(self.label) - - def __repr__(self): - return f"Anchors({self.value}, {self.label})" - - def __str__(self): - return "\n".join( - [f"{value}. {label}" for value, label in zip(self.value, self.label)] - ) - - def show(self): - return print(self) - - -@dataclass -class Items: - data: dict - - def __getitem__(self, key: Any) -> Any: - return self.data[key] - - def __setitem__(self, key: Any, value: Any) -> None: - self.data[key] = value - - def __delitem__(self, key: Any) -> None: - del self.data[key] - - def keys(self) -> list: - return list(self.data.keys()) - - def values(self) -> list: - return list(self.data.values()) - - def inst_items(self) -> list: - return list(self.data.items()) - - def __str__(self): - return "\n".join([f"{number}. {text}" for number, text in self.data.items()]) - - def show(self, n=10): - n = len(self.data) if n is None or n > len(self.data) else n - p = "\n".join( - [f"{number}. {text}" for number, text in list(self.data.items())[:n]] - ) - if n < len(self.data): - p += f"\n\n...and {len(self.data) - n} more items." - - return print(p) - - -@dataclass -class Scales: - abbrev: list[str] - label: list[str] - angle: list[float] - inst_items: list[dict] | None = None - - def __post_init__(self): - assert len(self.abbrev) == len(self.angle) - assert len(self.abbrev) == len(set(self.abbrev)), "Abbreviations must be unique" - assert max(self.angle) <= 360 and min(self.angle) >= 0, ( - "Angles must be between 0 and 360" - ) - - def __str__(self): - return "\n".join( - [ - f"{abbrev}: {label} ({angle}°)" - for abbrev, label, angle in zip(self.abbrev, self.label, self.angle) - ] - ) - - def show(self, inst_items: bool = True): - if inst_items is False: - return print(self) - else: - p = [] - for i, abbrev in enumerate(self.abbrev): - p.append(f"{abbrev}: {self.label[i]} ({self.angle[i]}°)") - p.append( - "\n".join( - [f"\t{key}: {val}" for key, val in self.inst_items[i].items()] # type: ignore[non-subscriptable] - ) - ) - return print("\n".join(p)) - - -@dataclass -class Norms: - table: pd.DataFrame - src: pd.DataFrame - - def get_sample(self, sample: int) -> pd.DataFrame: - return self.table.query("sample == @sample") - - def show(self): - return print(self.src) - - -@dataclass -class InstrumentDetails: - name: str - abbrev: str - inst_items: int | None = None - scales: int | None = None - prefix: str | None = None - suffix: str | None = None - status: str | None = None - construct: str | None = None - reference: str | None = None - url: str | None = None - - def __str__(self): - return ( - f"{self.abbrev}: {self.name}\n" - f"{self.inst_items} Items, {self.scales} Scales\n" - f"{self.reference}\n" - f"<{self.url}>" - ) - - -@dataclass -class Instrument: - """ - A class for representing circumplex instruments. - - Attributes: - scales: Scales - anchors: Anchors - details: InstrumentDetails - inst_items: Items | None = None - _data: pd.DataFrame | None = None - """ - - scales: Scales - anchors: Anchors - details: InstrumentDetails - norms: Norms | None = None - _data: pd.DataFrame | None = None - - def __repr__(self): - return ( - ( - f"{self.details.abbrev}: {self.details.name}\n" - f"{self.details.inst_items} Items, {self.details.scales} Scales\n" - f"{self.details.reference}\n" - f"<{self.details.url}>" - ) - if self.norms is None - else ( - f"{self.details.abbrev}: {self.details.name}\n" - f"{self.details.inst_items} Items, {self.details.scales} Scales, {len(self.norms.src)} normative data sets\n" - f"{self.details.reference}\n" - f"<{self.details.url}>" - ) - ) - - @property - def data(self): - if self._data is None: - raise UserWarning( - "No data has been loaded for this instrument. Use attach_data() to load data." - ) - else: - return self._data - - @property - def inst_items(self): - if self.scales.inst_items is None: - raise UserWarning("No items have been defined for this instrument.") - else: - item_dict = {} - for val in self.scales.inst_items: - for key, value in val.items(): - item_dict[int(key)] = value - item_dict = {k: v for k, v in sorted(item_dict.items())} - - return Items(item_dict) - - def summary(self): - print(self.details) - print( - f"\nThe {self.details.abbrev} contains {self.details.scales} circumplex scales." - ) - print(self.scales) - print( - f"\nThe {self.details.abbrev} is rated using the following {len(self.anchors.value)}-point scale." - ) - print(self.anchors) - print( - f"\nThe {self.details.abbrev} contains {self.details.inst_items} items ({self.details.status})." - ) - try: - print(self.inst_items) - except UserWarning: - print("\nNo items have been defined for this instrument.") - try: - print(self.data) - except UserWarning: - print( - "\nNo data has been loaded for this instrument. Use attach_data() to load data." - ) - - def attach_data( - self, data: pd.DataFrame, scales: list | dict | None = None - ) -> Instrument: - # check scales - assert set(self.scales.abbrev).issubset(data.columns), ( - f"Data is missing scales. " - f"Missing scales: {set(self.scales.abbrev) - set(data.columns)}" - ) - self._data = data - return self - - def ssm_analyze( - self, measures: list[str] | None = None, grouping: str | None = None - ) -> ssm_results.SSMResults: - """ - Perform Structural Summary Method analysis on the instrument's data. - - Parameters - ---------- - measures : list of str, optional - Variables to be correlated with the circumplex scales. - grouping : list of str, optional - Variable name that indicates group membership of each observation. - - Returns - ------- - SSMResults - An object containing the results and description of the analysis. - """ - return ssm.ssm_analyze( - self.data, - self.scales.abbrev, - measures=measures, - grouping=grouping, - angles=tuple(self.scales.angle), - ) - - def demo_plot(self): - # alabel = self.scales.label - # angles = self.scales.angle - degree_sign = "\N{DEGREE SIGN}" - - # Create plot --------------------------------------------------------------- - fig, ax = plt.subplots(figsize=(4, 4), subplot_kw=dict(polar=True)) - - ax.plot() - ax.tick_params(axis="both", pad=10) - ax.set_xticks( - np.radians(self.scales.angle), - labels=self.scales.label, - fontsize=12, - ) - - ax.set_yticks([]) - ax.grid(True) - for i, angle in enumerate(self.scales.angle): - ax.text( - np.radians(angle), - 0.4, - f"{angle}{degree_sign}", - ha="center", - va="center", - fontsize=12, - color="gray", - ) - ax.text( - np.radians(angle), - 0.75, - self.scales.abbrev[i], - ha="center", - va="center", - fontsize=12, - color="gray", - ) - plt.show() diff --git a/src/circumplex/py.typed b/src/circumplex/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/src/circumplex/ssm_analysis.py b/src/circumplex/ssm_analysis.py deleted file mode 100644 index d7ac418..0000000 --- a/src/circumplex/ssm_analysis.py +++ /dev/null @@ -1,883 +0,0 @@ -from __future__ import annotations - -import warnings -from typing import Callable, List, Optional, Tuple, Union, Dict, Any, TYPE_CHECKING - -import numpy as np -import pandas as pd -from scipy.optimize import curve_fit - -import circumplex.ssm_results as ssm_results -import circumplex.utils as utils - -if TYPE_CHECKING: - from nptyping import NDArray - -BOUNDS = ([0, -2 * np.pi, -np.inf], [np.inf, 2 * np.pi, np.inf]) -OCTANTS = utils.OCTANTS - - -def validate_ssm_input( - data: pd.DataFrame, - scales: List[str], - angles: Tuple[float, ...], - measures: Optional[List[str]] = None, - grouping: Optional[str] = None, - contrast: str = "none", - boots: int = 500, - interval: float = 0.95, - listwise: bool = True, - measures_labels: Optional[List[str]] = None, -) -> None: - """ - Validate input parameters for SSM analysis functions. - - Raises ValueError with helpful messages if validation fails. - - Parameters - ---------- - data : pd.DataFrame - A DataFrame containing at least circumplex scales. - scales : List[str] - The variable names for the circumplex scales to be analyzed. - angles : Tuple[float] - Angular displacement of each circumplex scale (in degrees). - measures : Optional[List[str]] - Variables to be correlated with the circumplex scales. - grouping : Optional[str] - Variable name that indicates group membership of each observation. - contrast : str - Type of contrast to run ("none", "model", or "test"). - boots : int - Number of bootstrap resamples for estimating confidence intervals. - interval : float - Confidence level for estimating the confidence intervals. - listwise : bool - Whether to use listwise deletion for missing values. - measures_labels : Optional[List[str]] - Labels for each measure provided in measures. - - Returns - ------- - None - """ - # Data validation - if not isinstance(data, pd.DataFrame): - raise ValueError("data must be a pandas DataFrame") - - # Scales validation - if not all(scale in data.columns for scale in scales): - missing = set(scales) - set(data.columns) - raise ValueError(f"Scales missing from data: {missing}") - - # Angles validation - if not ( - isinstance(angles, tuple) and all(isinstance(a, (int, float)) for a in angles) - ): - raise ValueError("angles must be a tuple of numbers") - if len(angles) != len(scales): - raise ValueError( - f"angles and scales must have the same length (angles: {len(angles)}, scales: {len(scales)})" - ) - - # Bootstrap validation - if not (isinstance(boots, int) and boots > 0): - raise ValueError("boots must be a positive integer") - - # Interval validation - if not (0 < interval < 1): - raise ValueError("interval must be between 0 and 1") - - # Listwise validation - if not isinstance(listwise, bool): - raise ValueError("listwise must be a boolean") - - # Contrast validation - if contrast not in ["none", "model", "test"]: - raise ValueError("contrast must be 'none', 'model', or 'test'") - - # Measures validation - if measures is not None and not all( - measure in data.columns for measure in measures - ): - missing = set(measures) - set(data.columns) - raise ValueError(f"Measures missing from data: {missing}") - - # Grouping validation - if grouping is not None and grouping not in data.columns: - raise ValueError(f"grouping variable '{grouping}' not found in data") - - # Measures labels validation - if measures_labels is not None: - if measures is None: - raise ValueError( - "measures must be provided when measures_labels is provided" - ) - if len(measures_labels) != len(measures): - raise ValueError("measures_labels must have the same length as measures") - - # Contrast possibility validation - if contrast != "none" and measures is None and grouping is None: - raise ValueError( - "Without specifying measures or grouping, no contrasts are possible. " - "Set contrast = 'none' or add the measures or grouping arguments." - ) - - -def ssm_analyze( - data: pd.DataFrame, - scales: List[str], - angles: Tuple[float, ...] = OCTANTS, - measures: Optional[List[str]] = None, - grouping: Optional[str] = None, - contrast: str = "none", - boots: int = 500, - interval: float = 0.95, - listwise: bool = True, - measures_labels: Optional[List[str]] = None, -) -> ssm_results.SSMResults: - """ - Perform analyses using the Structural Summary Method. - - This function calculates SSM parameters with bootstrapped confidence intervals for various - analysis types. Depending on the arguments supplied, it performs either mean-based or - correlation-based analyses, uses one or more groups to stratify the data, and calculates - contrasts between groups or measures. - - Parameters - ---------- - data : pd.DataFrame - A DataFrame containing at least circumplex scales. - scales : List[str] - The variable names for the circumplex scales to be analyzed. - angles : Tuple[float], optional - Angular displacement of each circumplex scale (in degrees). - Default is (0, 45, 90, 135, 180, 225, 270, 315). - measures : Optional[List[str]], optional - Variables to be correlated with the circumplex scales. - grouping : Optional[str], optional - Variable name that indicates group membership of each observation. - contrast : str, optional - Type of contrast to run ("none", "model", or "test"). - Default is "none". - boots : int, optional - Number of bootstrap resamples for estimating confidence intervals. - Default is 500. - interval : float, optional - Confidence level for estimating the confidence intervals. - Default is 0.95. - listwise : bool, optional - Whether to use listwise deletion for missing values. - Default is True. - measures_labels : Optional[List[str]], optional - Labels for each measure provided in measures. - - Returns - ------- - SSMResults - An object containing the results and description of the analysis. - - Examples - -------- - >>> import pandas as pd - >>> from circumplex import ssm_analyze - >>> - >>> # Simple analysis of means - >>> results = ssm_analyze( - ... data, - ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - ... angles=(0, 45, 90, 135, 180, 225, 270, 315) - ... ) - >>> - >>> # Analysis with correlations and groups - >>> results = ssm_analyze( - ... data, - ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - ... angles=(0, 45, 90, 135, 180, 225, 270, 315), - ... measures=["Extraversion", "Neuroticism"], - ... grouping="Gender" - ... ) - """ - # Validate all input parameters - validate_ssm_input( - data=data, - scales=scales, - angles=angles, - measures=measures, - grouping=grouping, - contrast=contrast, - boots=boots, - interval=interval, - listwise=listwise, - measures_labels=measures_labels, - ) - - # Determine analysis type and forward to appropriate subfunction - if measures is not None: - if grouping is not None: - # Multiple group correlations - results = ssm_analyze_corrs( - data, - scales, - angles, - measures, - grouping, - contrast, - boots, - interval, - listwise, - measures_labels, - ) - else: - # Single group correlations - results = ssm_analyze_corrs( - data, - scales, - angles, - measures, - None, - contrast, - boots, - interval, - listwise, - measures_labels, - ) - else: - if grouping is not None: - # Multiple group means - results = ssm_analyze_means( - data, scales, angles, grouping, contrast, boots, interval, listwise - ) - else: - # Single group means - if contrast != "none": - raise ValueError( - "Without specifying measures or grouping, no contrasts are possible. " - "Set contrast = 'none' or add the measures or grouping arguments." - ) - results = ssm_analyze_means( - data, scales, angles, None, "none", boots, interval, listwise - ) - - # Create the call string - call_str = ( - f"ssm_analyze(data, scales={scales}, angles={angles}, measures={measures}, " - f"grouping={grouping}, contrast={contrast}, boots={boots}, " - f"interval={interval}, listwise={listwise}, measures_labels={measures_labels})" - ) - - # Create and return the SSMResults object - return ssm_results.SSMResults( - results=results["results"], - scales=scales, - scores=results["scores"], - details=results["details"], - call=call_str, - ) - - -def ssm_analyze_means( - data: pd.DataFrame, - scales: List[str], - angles: Tuple[float, ...], - grouping: Optional[str] = None, - contrast: str = "none", - boots: int = 2000, - interval: float = 0.95, - listwise: bool = True, -) -> Dict[str, Any]: - """ - Perform analyses using the mean-based Structural Summary Method. - - This function calculates SSM parameters based on the mean scores of - circumplex scales, optionally grouped by a categorical variable. - - Parameters - ---------- - data : pd.DataFrame - A DataFrame containing at least circumplex scales. - scales : List[str] - The variable names for the circumplex scales to be analyzed. - angles : Tuple[float] - Angular displacement of each circumplex scale (in degrees). - grouping : Optional[str], optional - Variable name that indicates group membership of each observation. - contrast : str, optional - Type of contrast to run ("none", "model", or "test"). - Default is "none". - boots : int, optional - Number of bootstrap resamples for estimating confidence intervals. - Default is 2000. - interval : float, optional - Confidence level for estimating the confidence intervals. - Default is 0.95. - listwise : bool, optional - Whether to use listwise deletion for missing values. - Default is True. - - Returns - ------- - Dict[str, Any] - A dictionary containing the results and description of the analysis: - - results: DataFrame with SSM parameters for each group - - details: Dictionary with analysis details - - call: String representation of the function call - - scores: DataFrame with mean scores for each scale and group - - Examples - -------- - >>> results_dict = ssm_analyze_means( - ... data, - ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - ... angles=(0, 45, 90, 135, 180, 225, 270, 315), - ... grouping="Gender" - ... ) - """ - # Select circumplex scales and grouping variable (if applicable) - if grouping is not None: - bs_input = data[scales + [grouping]].copy() - bs_input["Group"] = bs_input[grouping].astype("category") - - # Check if more than one contrast is possible - if contrast != "none" and len(bs_input["Group"].cat.categories) != 2: - raise ValueError( - "Only two groups can be contrasted at a time. Set contrast = 'none' or use a dichotomous grouping variable." - ) - else: - bs_input = data[scales].copy() - bs_input["Group"] = "All" - - # Perform listwise deletion if requested - if listwise: - bs_input = bs_input.dropna() - - # Calculate mean observed scores - scores = bs_input.groupby("Group", observed=False)[scales].mean().reset_index() - scores = scores.rename_axis("label").reset_index() - - # Define bootstrap function - def bs_function(data, index, angles, contrast, listwise): - resample = data.iloc[index] - scores_r = resample.groupby("Group", observed=False)[scales].mean() - return ssm_by_group(scores_r, angles, contrast) - - # Perform bootstrapping - bs_output = ssm_bootstrap( - bs_input=bs_input, - bs_function=bs_function, - angles=angles, - boots=boots, - interval=interval, - contrast=contrast, - listwise=listwise, - strata=bs_input["Group"], - ) - - # Select and label results - group_levels = bs_input["Group"].unique() - if contrast == "none": - row_data = bs_output - row_labels = group_levels - else: - row_data = bs_output.iloc[-1:] - row_labels = [f"{group_levels[1]} - {group_levels[0]}"] - - results = row_data.copy() - results["label"] = row_labels - - # Collect analysis details - details = { - "boots": boots, - "interval": interval, - "listwise": listwise, - "angles": angles, - "contrast": contrast, - "score_type": "Mean", - "results_type": "Profile" if contrast == "none" else "Contrast", - } - - call_str = ( - f"ssm_analyze_means(data, scales={scales}, angles={angles}, " - f"grouping={grouping}, contrast={contrast}, boots={boots}, " - f"interval={interval}, listwise={listwise})" - ) - - return {"results": results, "details": details, "call": call_str, "scores": scores} - - -def ssm_by_group( - scores: pd.DataFrame, angles: Tuple[float], contrast: str -) -> np.ndarray: - """ - Calculate SSM parameters for each group, potentially with contrast. - - Args: - scores (pd.DataFrame): DataFrame containing scores for each group. - angles (List[float]): Angular displacement of each circumplex scale (in radians). - contrast (str): Type of contrast to run ("none", "model", or "test"). - - Returns: - np.ndarray: Array of SSM parameters for each group (and contrast if applicable). - """ - # Convert scores DataFrame to numpy array - scores_array = scores.to_numpy() - - # To model contrast, subtract scores then SSM - if contrast == "model": - contrast_scores = scores_array[1] - scores_array[0] - scores_array = np.vstack([scores_array, contrast_scores]) - - # Calculate parameters per group - results = group_parameters(scores_array, angles) - - # To test contrast, SSM then subtract parameters - if contrast == "test": - contrast_params = results[6:] - results[:6] - results = np.concatenate([results, contrast_params]) - - return results - - -def group_parameters(scores: np.ndarray, angles: Tuple[float]) -> np.ndarray: - """ - Calculate the SSM parameters as a vector for each group where rows are groups. - - Args: - scores (np.ndarray): 2D array where each row represents a group's scores. - angles (List[float]): Angular displacement of each circumplex scale (in radians). - - Returns: - np.ndarray: 1D array of SSM parameters for all groups. - """ - n = scores.shape[0] # Number of groups - out = np.zeros(n * 6) # Initialize output array - - for i in range(n): - out[i * 6 : (i + 1) * 6] = ssm_parameters(scores[i], angles) - - return out - - -def ssm_parameters( - scores: NDArray, angles: Tuple[float, ...], bounds=BOUNDS -) -> NDArray: - """Calculate SSM parameters (without confidence intervals) for a set of scores. - - Args: - scores (np.array): A numeric vector (or single row dataframe) containing one score for each of a - set of circumplex scales. - angles (tuple): A numeric vector containing the angular displacement of each circumplex scale - included in `scores`. - bounds (tuple, optional): The bounds for each of the parameters of the curve optimisation. - Defaults to ([0, 0, -1], [np.inf, 360, 1]). - - Returns: - tuple: A tuple containing the elevation, x-value, y-value, amplitude, displacement, and R2 fit of the SSM curve. - - Examples: - # >>> scores = np.array([-0.5, 0, 0.25, 0.51, 0.52, 0.05, -0.26, -0.7]) - # >>> angles = OCTANTS - # >>> results = ssm_parameters_cpp(scores, angles) - # >>> [round(i, 3) for i in results] - [-0.016, -0.478, 0.333, 0.582, 145.158, 0.967] - """ - - # noinspection PyTupleAssignmentBalance - # NOTE: Bug - Sometimes returns displacement at the trough, not the crest, so 180 degrees off - # This was addressed by setting the lower bound of amplitude to 0, not -np.inf. Need a less hard-coded solution - param, covariance = curve_fit( - utils.cosine_form, xdata=np.deg2rad(angles), ydata=scores, bounds=bounds - ) - r2 = utils.r2_score(scores, utils.cosine_form(np.deg2rad(angles), *param)) - ampl, disp, elev = param - - def polar2cart(r, theta): - x = r * np.cos(theta) - y = r * np.sin(theta) - return x, y - - xval, yval = polar2cart(ampl, disp) - return np.array([elev, xval, yval, ampl, np.rad2deg(disp), r2]) - - -def ssm_bootstrap( - bs_input: pd.DataFrame, - bs_function: Callable, - angles: Tuple[float, ...], - boots: int, - interval: float, - contrast: str, - listwise: bool, - strata: Optional[pd.Series] = None, -) -> pd.DataFrame: - """ - Perform bootstrap to get confidence intervals around SSM parameters. - - Args: - bs_input (pd.DataFrame): Input data for bootstrapping. - bs_function (Callable): Function to calculate SSM parameters. - angles (List[float]): Angular displacement of each circumplex scale (in radians). - boots (int): Number of bootstrap resamples. - interval (float): Confidence interval level. - contrast (str): Type of contrast to run ("none", "model", or "test"). - listwise (bool): Whether to use listwise deletion for missing values. - strata (Optional[pd.Series]): Series to use for stratified sampling. - - Returns: - pd.DataFrame: DataFrame containing bootstrap results. - """ - # Perform bootstrapping - bootstrap_results = [] - for _ in range(boots): - if strata is not None: - # Note: Using observed=False for categorical data - # The DeprecationWarning about operating on grouping columns is expected - # but won't affect functionality - resample = ( - bs_input.groupby(strata, observed=False) - .apply(lambda x: x.sample(n=len(x), replace=True)) - .reset_index(drop=True) - ) - else: - resample = bs_input.sample(n=len(bs_input), replace=True) - bootstrap_results.append( - bs_function(resample, range(len(resample)), angles, contrast, listwise) - ) - - bs_t = np.array(bootstrap_results) - - # Calculate point estimates - bs_est = pd.DataFrame( - bs_function(bs_input, range(len(bs_input)), angles, contrast, listwise).reshape( - -1, 6 - ), - columns=[f"{p}_est" for p in ["e", "x", "y", "a", "d", "fit"]], - ) - - # Calculate confidence intervals - bs_lci = pd.DataFrame( - np.percentile(bs_t, (1 - interval) / 2 * 100, axis=0).reshape(-1, 6), - columns=[f"{p}_lci" for p in ["e", "x", "y", "a", "d", "fit"]], - ) - bs_uci = pd.DataFrame( - np.percentile(bs_t, (1 + interval) / 2 * 100, axis=0).reshape(-1, 6), - columns=[f"{p}_uci" for p in ["e", "x", "y", "a", "d", "fit"]], - ) - - # Combine results and convert radians to degrees for displacement - results = pd.concat([bs_est, bs_lci, bs_uci], axis=1) - results["d_est"] = results["d_est"] % 360 # normalize to 0-360 - - return results - - -def ssm_analyze_corrs( - data: pd.DataFrame, - scales: List[str], - angles: Tuple[float, ...], - measures: List[str], - grouping: Optional[str] = None, - contrast: str = "none", - boots: int = 2000, - interval: float = 0.95, - listwise: bool = True, - measures_labels: Optional[List[str]] = None, -) -> Dict[str, Any]: - """ - Perform analyses using the correlation-based Structural Summary Method. - - This function calculates SSM parameters based on the correlations between - circumplex scales and external measures, optionally grouped by a categorical variable. - - Parameters - ---------- - data : pd.DataFrame - A DataFrame containing at least circumplex scales and measures. - scales : List[str] - The variable names for the circumplex scales to be analyzed. - angles : Tuple[float] - Angular displacement of each circumplex scale (in degrees). - measures : List[str] - Variables to be correlated with the circumplex scales. - grouping : Optional[str], optional - Variable name that indicates group membership of each observation. - contrast : str, optional - Type of contrast to run ("none", "model", or "test"). - Default is "none". - boots : int, optional - Number of bootstrap resamples for estimating confidence intervals. - Default is 2000. - interval : float, optional - Confidence level for estimating the confidence intervals. - Default is 0.95. - listwise : bool, optional - Whether to use listwise deletion for missing values. - Default is True. - measures_labels : Optional[List[str]], optional - Labels for each measure provided in measures. - - Returns - ------- - Dict[str, Any] - A dictionary containing the results and description of the analysis: - - results: DataFrame with SSM parameters for each measure-group combination - - details: Dictionary with analysis details - - call: String representation of the function call - - scores: DataFrame with correlation scores between measures and scales - - Examples - -------- - >>> results_dict = ssm_analyze_corrs( - ... data, - ... scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - ... angles=(0, 45, 90, 135, 180, 225, 270, 315), - ... measures=["Extraversion", "Neuroticism"], - ... measures_labels=["Extraversion Scale", "Neuroticism Scale"] - ... ) - """ - # Select circumplex scales, measure variables, and grouping variable - if grouping is not None: - bs_input = data[scales + measures + [grouping]].copy() - # Perform listwise deletion if requested - if listwise: - bs_input = bs_input.dropna() - bs_input["Group"] = bs_input[grouping].astype("category") - if bs_input["Group"].nunique() != data[grouping].nunique(): - warnings.warn("Listwise deletion removed some groups.") - - else: - bs_input = data[scales + measures].copy() - # Perform listwise deletion if requested - if listwise: - bs_input = bs_input.dropna() - bs_input["Group"] = "All" - bs_input["Group"] = bs_input["Group"].astype("category") - if bs_input.empty: - raise ValueError("No data remains after listwise deletion.") - - # Check that this combination of arguments is executable - n_measures = len(measures) - n_groups = bs_input["Group"].nunique() - if contrast != "none": - contrast_measures = n_measures == 2 and n_groups == 1 - contrast_groups = n_measures == 1 and n_groups == 2 - if not (contrast_measures or contrast_groups): - raise ValueError( - "No valid contrasts were possible. To contrast measures, ensure " - "there are 2 measures and no grouping variable. To contrast groups, " - "ensure there is 1 measure and a dichotomous grouping variable." - ) - - # Select and label results - if measures_labels is None: - measure_names = measures - else: - measure_names = measures_labels - - # Calculate observed scores (i.e., correlations) - cs = bs_input[scales].values - mv = bs_input[measures].values - grp = bs_input["Group"].astype("category").cat.codes.values - scores = corr_scores(cs, mv, grp, listwise, scales) - scores_df = pd.DataFrame(scores, columns=scales) - scores_df["Group"] = np.repeat(bs_input["Group"].unique(), len(measures)) - scores_df["Measure"] = np.tile(measure_names, n_groups) - if grouping is not None: - scores_df["label"] = scores_df["Group"].astype(str) + "_" + scores_df["Measure"] - else: - scores_df["label"] = scores_df["Measure"] - - # Define bootstrap function - def bs_function(data, index, angles, contrast, listwise): - resample = data.iloc[index] - grp = resample["Group"].astype("category").cat.codes.values - cs = resample[scales].values - mv = resample[measures].values - scores_r = corr_scores(cs, mv, grp, listwise) - scores_r = scores_r.drop(columns=["Group", "Measure"]) - return ssm_by_group(scores_r, angles, contrast) - - # Perform bootstrapping - bs_output = ssm_bootstrap( - bs_input=bs_input, - bs_function=bs_function, - angles=angles, - boots=boots, - interval=interval, - contrast=contrast, - listwise=listwise, - strata=bs_input["Group"], - ) - - # Select and label results - group_names = bs_input["Group"].cat.categories - if contrast == "none": - row_data = bs_output - grp_labels = np.repeat(group_names, len(measures)) - msr_labels = np.tile(measure_names, n_groups) - if grouping is not None: - lbl_labels = grp_labels + "_" + msr_labels - else: - lbl_labels = msr_labels - results = row_data.assign( - label=lbl_labels, Group=grp_labels, Measure=msr_labels - ) - else: - row_data = bs_output.iloc[-1:].copy() - if n_measures == 2: - row_labels = [f"{measure_names[1]} - {measure_names[0]}"] - else: - row_labels = [f"{measure_names[0]}: {group_names[1]} - {group_names[0]}"] - results = row_data.assign(label=row_labels) - - # Collect analysis details - details = { - "boots": boots, - "interval": interval, - "listwise": listwise, - "angles": angles, - "contrast": contrast, - "score_type": "Correlation", - "results_type": "Profile" if contrast == "none" else "Contrast", - } - - call_str = ( - f"ssm_analyze_corrs(data, scales={scales}, angles={angles}, " - f"measures={measures}, grouping={grouping}, contrast={contrast}, " - f"boots={boots}, interval={interval}, listwise={listwise}, " - f"measures_labels={measures_labels})" - ) - - return { - "results": results, - "details": details, - "call": call_str, - "scores": scores_df, - } - - -def corr_scores( - scores: Union[np.ndarray, pd.DataFrame], - measures: Union[np.ndarray, pd.DataFrame], - grouping: Union[np.ndarray, pd.Series], - listwise: bool, - scales: List[str] | None = None, -) -> pd.DataFrame: - """ - Calculate the correlation of each measure with each scale by group. - - Args: - scores (Union[np.ndarray, pd.DataFrame]): Circumplex scale scores. - measures (Union[np.ndarray, pd.DataFrame]): Measure variable scores. - grouping (Union[np.ndarray, pd.Series]): Group codes. - listwise (bool): Whether to use listwise deletion (True) or pairwise deletion (False). - scales (List[str], optional): Names of the circumplex scales. If None, will use column names if cs is a DataFrame, else will use default names. - - Returns: - pd.DataFrame: Correlation scores. - """ - # Convert inputs to numpy arrays if they're not already - cs_array = scores.values if isinstance(scores, pd.DataFrame) else scores - mv_array = measures.values if isinstance(measures, pd.DataFrame) else measures - grp_array = ( - grouping.values if isinstance(grouping, (pd.Series, pd.DataFrame)) else grouping - ) - - levels = np.unique(grp_array) - ng = len(levels) - pm, ps = mv_array.shape[1], cs_array.shape[1] - out = np.zeros((ng * pm, ps)) - - if ng == 1: - if listwise: - # Single group and LWD - out = np.corrcoef(mv_array.T, cs_array.T)[:pm, pm:] - else: - # Single group and PWD - for m in range(pm): - x = mv_array[:, m] - for s in range(ps): - y = cs_array[:, s] - out[m, s] = pairwise_r(x, y) - else: - if listwise: - # Multiple groups and LWD - for g, level in enumerate(levels): - mask = grp_array == level - gcs = cs_array[mask] - gmv = mv_array[mask] - out[g * pm : (g + 1) * pm, :] = np.corrcoef(gmv.T, gcs.T)[:pm, pm:] - else: - # Multiple groups and PWD - for g, level in enumerate(levels): - mask = grp_array == level - gcs = cs_array[mask] - gmv = mv_array[mask] - for m in range(pm): - x = gmv[:, m] - for s in range(ps): - y = gcs[:, s] - out[g * pm + m, s] = pairwise_r(x, y) - - # Create a DataFrame from the output - if scales is None: - if isinstance(scores, pd.DataFrame): - scales = scores.columns.tolist() - else: - scales = [f"Scale_{i + 1}" for i in range(ps)] - - df_out = pd.DataFrame(out, columns=scales) - - # Add group and measure information - if isinstance(measures, pd.DataFrame): - measure_names = measures.columns.tolist() - else: - measure_names = [f"Measure_{i + 1}" for i in range(pm)] - - df_out["Group"] = np.repeat(levels, pm) - df_out["Measure"] = np.tile(measure_names, ng) - - return df_out - - -def pairwise_r(x: np.ndarray, y: np.ndarray) -> float: - """ - Calculate the Pearson correlation coefficient using pairwise deletion. - - Args: - x (np.ndarray): First array of values. - y (np.ndarray): Second array of values. - - Returns: - float: Pearson correlation coefficient. - """ - mask = ~(np.isnan(x) | np.isnan(y)) - x, y = x[mask], y[mask] - return np.corrcoef(x, y)[0, 1] if len(x) > 1 else np.nan - - -if __name__ == "__main__": - ######## SCRATCH ######## - from importlib.resources import files - - import matplotlib.pyplot as plt - - _jz2017_path = str(files("circumplex.data").joinpath("jz2017.csv")) - data = pd.read_csv(_jz2017_path) - - results = ssm_analyze( - data=data, - scales=["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], - angles=(90, 135, 180, 225, 270, 315, 0, 45), - # grouping="Gender", - # contrast='model', - measures=["NARPD", "ASPD"], - # measures_labels=['Narcissistic PD', 'Antisocial PD'], - ) - print(results.scores) - # print(results) - print(results.summary()) - - # fig = ssm_plot(results) - fig, ax = results.profile_plot(incl_elev=True) - plt.show() diff --git a/src/circumplex/ssm_results.py b/src/circumplex/ssm_results.py deleted file mode 100644 index 2473559..0000000 --- a/src/circumplex/ssm_results.py +++ /dev/null @@ -1,154 +0,0 @@ -from __future__ import annotations - -from typing import Any, Dict, List, Tuple - -import pandas as pd -from matplotlib import pyplot as plt -from matplotlib.figure import Figure -from matplotlib.axes import Axes - -import circumplex.visualization as vis - - -class SSMResults: - def __init__( - self, - results: pd.DataFrame, - scales: List[str], - scores: pd.DataFrame, - details: Dict[str, Any], - call: str, - ): - self.results = results - self.scales = scales - self.scores = scores - self.details = details - self.call = call - - def __str__(self): - output = [f"Call:\n{self.call}\n"] - for _, row in self.results.iterrows(): - output.append(f"\n{self.details['results_type']} [{row['label']}]:") - params = [ - "Elevation", - "X-Value", - "Y-Value", - "Amplitude", - "Displacement", - "Model Fit", - ] - output.append(f"{'Parameter ':<10} {'Estimate ':>8} [LCI, UCI]") - param_abbrev = [f"{p.lower()[0]}" for p in params] - param_abbrev.pop(-1) - param_abbrev.append("fit") - estimates = [row[f"{p}_est"] for p in param_abbrev] - lower_ci = [row[f"{p}_lci"] for p in param_abbrev] - upper_ci = [row[f"{p}_uci"] for p in param_abbrev] - - max_len = max(len(p) for p in params) - for param, est, lci, uci in zip(params, estimates, lower_ci, upper_ci): - output.append( - f"{param:<{max_len}} {est:>8.3f} [{lci:>8.3f}, {uci:>8.3f}]" - ) - - return "\n".join(output) - - def summary(self): - output = [f"Call:\n{self.call}\n"] - output.extend( - [ - f"Statistical Basis: {self.details['score_type']} Scores", - f"Bootstrap Resamples: {self.details['boots']}", - f"Confidence Level: {self.details['interval']}", - f"Listwise Deletion: {self.details['listwise']}", - f"Scale Displacements: {self.details['angles']}\n", - ] - ) - - output.extend(str(self).split("\n")[2:]) # Add the formatted results - return "\n".join(output) - - def table(self): - table = pd.DataFrame( - columns=[ - "Profile", - "Elevation", - "X-Value", - "Y-Value", - "Amplitude", - "Displacement", - "Fit", - ], - index=self.results.index, - ) - for i, (_, row) in enumerate(self.results.iterrows()): - table.loc[i] = [ - row["label"], - row["e_est"], - row["x_est"], - row["y_est"], - row["a_est"], - row["d_est"], - row["fit_est"], - ] - return table - - def plot(self, **kwargs) -> Figure: - """ - Create a figure from SSM results. - - This is a convenience wrapper for ssm_plot(). - - Parameters - ---------- - **kwargs - Additional arguments to pass to ssm_plot(). - - Returns - ------- - matplotlib.figure.Figure - A figure object representing the plot. - """ - return vis.ssm_plot(self, **kwargs) - - def profile_plot(self, **kwargs) -> Tuple[Figure, List[Axes]]: - """ - Create profile plots from SSM results. - - Creates one profile plot for each component in the results. - - Parameters - ---------- - **kwargs - Additional arguments to pass to ssm_profile_plot(). - - Returns - ------- - Tuple[matplotlib.figure.Figure, List[matplotlib.axes.Axes]] - A tuple containing the figure and axes objects. - """ - results = self.results - scores = self.scores - details = self.details - - n_components = results.shape[0] - fig, axes = plt.subplots(n_components, 1, figsize=(6, 4 * n_components)) - if n_components == 1: - axes = [axes] - - for i, (ax, (_, row)) in enumerate(zip(axes, results.iterrows())): - fig, ax = vis.ssm_profile_plot( - scores=scores.iloc[i][self.scales], - angles=details["angles"], - amplitude=row["a_est"], - displacement=row["d_est"], - elevation=row["e_est"], - r2=row["fit_est"], - title=f"{results.iloc[i]['label']} Profile", - ax=ax, - **kwargs, - ) - - plt.tight_layout() - - return fig, axes diff --git a/src/circumplex/utils.py b/src/circumplex/utils.py deleted file mode 100644 index ba95951..0000000 --- a/src/circumplex/utils.py +++ /dev/null @@ -1,135 +0,0 @@ -from __future__ import annotations - -from typing import List, Union - -import numpy as np -import pandas as pd - -# Import Instrument type for type annotation only -from typing import TYPE_CHECKING, Any - -if TYPE_CHECKING: - from circumplex.instrument import Instrument - from nptyping import NDArray, Float, Shape - -# Common constants -OCTANTS: tuple[int, ...] = (0, 45, 90, 135, 180, 225, 270, 315) - - -def cosine_form( - theta: NDArray[Shape[Any], Float], ampl: float, disp: float, elev: float -) -> NDArray[Shape[Any], Float]: - """ - Cosine function with amplitude, displacement and elevation parameters. - - This is the mathematical model used in the Structural Summary Method. - - Parameters - ---------- - theta : np.ndarray - Angular positions in radians. - ampl : float - Amplitude of the cosine curve. - disp : float - Angular displacement in radians. - elev : float - Elevation (mean level) of the cosine curve. - - Returns - ------- - np.ndarray - Predicted values at each theta position. - """ - return elev + ampl * np.cos(theta - disp) - - -def angle_median(angles: NDArray[Shape[Any], Float]) -> float: - """ - Calculate the median of circular data. - - Args: - angles (np.ndarray): Array of angles in radians. - - Returns: - float: Median angle in radians. - """ - return np.arctan2(np.median(np.sin(angles)), np.median(np.cos(angles))) - - -def r2_score( - y_true: NDArray[Shape[Any], Float], y_pred: NDArray[Shape[Any], Float] -) -> float: - """ - Calculate the R² coefficient of determination for a set of predictions. - - Measures how well the predictions match the observed data. - - Parameters - ---------- - y_true : np.ndarray - True values. - y_pred : np.ndarray - Predicted values. - - Returns - ------- - float - R² value between 0 and 1, where 1 indicates perfect prediction. - """ - ss_res = np.sum(np.square(y_true - y_pred)) - ss_tot = np.sum(np.square(y_true - np.mean(y_true))) - return 1 - (ss_res / ss_tot) - - -def sort_angles( - angles: NDArray[Shape[Any], Float], scores: NDArray[Shape[Any], Float] -) -> tuple[NDArray[Shape[Any], Float], NDArray[Shape[Any], Float]]: - """Sort angles and corresponding scores in ascending order.""" - sorted_indices = np.argsort(angles) - return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] - - -def standardize( - data: pd.DataFrame, - scales: Union[List[str], pd.Index], - angles: List[float], - instrument: "Instrument", - sample: int = 1, - prefix: str = "", - suffix: str = "_z", -) -> pd.DataFrame: - """ - Standardize circumplex scales using normative data. - - Args: - data (pd.DataFrame): A DataFrame containing at least circumplex scales. - scales (Union[List[str], pd.Index]): The column names for the variables in data that contain circumplex scales to be standardized. - angles (List[float]): A numeric list containing the angular displacement of each circumplex scale (in degrees). - instrument (Instrument): An instrument object containing normative data. - sample (int): An integer corresponding to the normative sample to use in standardizing the scale scores (default = 1). - prefix (str): A string to include at the beginning of the newly calculated scale variables' names (default = ""). - suffix (str): A string to include at the end of the newly calculated scale variables' names (default = "_z"). - - Returns: - pd.DataFrame: A DataFrame that matches data except that new variables are appended that contain standardized versions of scales. - """ - assert isinstance(data, pd.DataFrame), "data must be a pandas DataFrame" - assert all(scale in data.columns for scale in scales), ( - "All scales must be present in data" - ) - assert len(scales) == len(angles), "scales and angles must have the same length" - assert isinstance(sample, int), "sample must be an integer" - assert isinstance(prefix, str), "prefix must be a string" - assert isinstance(suffix, str), "suffix must be a string" - - norms = instrument.norms - key = norms.table.query("sample == @sample") # type: ignore[probably-unbound-attribute] - assert len(key) == len(scales) - - for scale, angle in zip(scales, angles): - new_var = f"{prefix}{scale}{suffix}" - m = key.query("scale == @scale")["m"].values[0] - sd = key.query("scale == @scale")["sd"].values[0] - data[new_var] = (data[scale] - m) / sd - - return data diff --git a/src/circumplex/visualization.py b/src/circumplex/visualization.py deleted file mode 100644 index c560e94..0000000 --- a/src/circumplex/visualization.py +++ /dev/null @@ -1,490 +0,0 @@ -from __future__ import annotations - -from typing import List, Optional, Tuple, Union - -import matplotlib.patches as patches -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -import seaborn as sns -from matplotlib.figure import Figure -from matplotlib.axes import Axes - -# Import only the utils module to avoid circular imports -import circumplex.utils as utils - -# Forward type hint for SSMResults to avoid circular imports -# This is needed because ssm_results imports visualization -from typing import TYPE_CHECKING, cast - -if TYPE_CHECKING: - from circumplex.ssm_results import SSMResults - - -def ssm_plot(ssm_object: "SSMResults", fontsize: int = 12, **kwargs) -> Figure: - """ - Create a figure from SSM results. - - Creates either a circular plot or a contrast plot depending on the - type of results in ssm_object. - - Parameters - ---------- - ssm_object : SSMResults - The results output of ssm_analyze. - fontsize : int, optional - Font size of text in the figure, in points. - Default is 12. - **kwargs - Additional arguments to pass on to the plotting function. - - Returns - ------- - matplotlib.figure.Figure - A figure object representing the plot. - - Examples - -------- - >>> from circumplex import ssm_analyze, ssm_plot - >>> results = ssm_analyze(data, scales, angles) - >>> fig = ssm_plot(results) - >>> fig.savefig('ssm_plot.png', dpi=300) - """ - # Input validation - if not hasattr(ssm_object, "details") or not hasattr(ssm_object, "results"): - raise ValueError("ssm_object must be an SSMResults instance") - if not isinstance(fontsize, (int, float)) or fontsize <= 0: - raise ValueError("fontsize must be a positive number") - - sns.set(style="whitegrid", font_scale=fontsize / 12) - - if ssm_object.details["contrast"] == "test": - return ssm_plot_contrast(ssm_object, fontsize=fontsize, **kwargs) - else: - return ssm_plot_circle(ssm_object, fontsize=fontsize, **kwargs) - - -def ssm_plot_circle( - ssm_object: "SSMResults", - amax: Optional[float] = None, - legend_font_size: int = 12, - scale_font_size: int = 12, - lowfit: bool = True, - repel: bool = False, - angle_labels: Optional[List[str]] = None, - palette: Optional[str] = "husl", - **kwargs, -) -> Figure: - """ - Create a Circular Plot of SSM Results using Seaborn. - - Args: - ssm_object (SSMResults): The output of ssm_analyze. - amax (Optional[float]): A positive number corresponding to the radius of the circle. - legend_font_size (int): Size of the text labels in the legend. - scale_font_size (int): Size of the text labels for the amplitude and displacement scales. - lowfit (bool): Whether profiles with low model fit (<.70) should be plotted with dashed borders. - repel (bool): Experimental argument for plotting text labels instead of colors. - angle_labels (Optional[List[str]]): Text labels to plot around the circle for each scale. - palette (Optional[str]): Color palette to use for the plot. - **kwargs: Additional arguments for seaborn. - - Returns: - matplotlib.figure.Figure: A figure object containing the circular plot. - """ - df = ssm_object.results - angles = np.round(ssm_object.details["angles"]).astype(int) - - if amax is None: - amax = df["a_uci"].abs().max() * 1.5 - - # Convert results to numbers usable by seaborn - df_plot = df.copy() - df_plot["d_uci"] = np.where( - df_plot["d_uci"] < df_plot["d_lci"], df_plot["d_uci"] + 360, df_plot["d_uci"] - ) - df_plot["a_lci"] = df_plot["a_lci"] * 5 / amax - df_plot["a_uci"] = df_plot["a_uci"] * 5 / amax - df_plot["x_est"] = df_plot["x_est"] * 5 / amax - df_plot["y_est"] = df_plot["y_est"] * 5 / amax - - # Remove profiles with low model fit (unless overridden) - if not lowfit: - df_plot = df_plot[df_plot["fit_est"] >= 0.70] - if len(df_plot) < 1: - raise ValueError("After removing profiles, there were none left to plot.") - - df_plot["linestyle"] = np.where(df_plot["fit_est"] >= 0.70, "solid", "dashed") - - fig, ax = plt.subplots(figsize=(10, 10)) - circle_base(ax, angles, amax, fontsize=scale_font_size, labels=angle_labels) - - # Use seaborn color palette - colors = sns.color_palette(palette, n_colors=len(df_plot)) - - # Plot confidence regions - for i, row in df_plot.iterrows(): - wedge = patches.Wedge( - (0, 0), - row["a_uci"], - row["d_lci"], - row["d_uci"], - width=row["a_uci"] - row["a_lci"], - fc=list(colors[i]) + [0.5], # face opacity at 0.5 - linestyle=row["linestyle"], - edgecolor=list(colors[i]) + [1], # edge opacity at 1 - linewidth=2, - ) - ax.add_patch(wedge) - - # Plot points - sns.scatterplot( - data=df_plot, - x="x_est", - y="y_est", - hue="label", - palette=palette, - s=100, - ax=ax, - legend="brief", - ) - - if repel: - for _, row in df_plot.iterrows(): - ax.annotate( - row["label"], - (row["x_est"], row["y_est"]), - xytext=(-25 - row["x_est"], 0), - textcoords="offset points", - ha="right", - va="center", - fontsize=legend_font_size, - bbox=dict(boxstyle="round,pad=0.5", fc="white", alpha=0.8), - arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=0"), - ) - ax.legend().remove() - else: - ax.legend( - title=ssm_object.details["results_type"], - fontsize=legend_font_size, - title_fontsize=legend_font_size, - ) - - return fig - - -def circle_base(ax, angles, amax=0.5, amin=0, fontsize=12, labels=None): - """ - Create an Empty Circular Plot. - - Args: - ax (matplotlib.axes.Axes): The axes to draw on. - angles (List[float]): Angular displacement of each circumplex scale. - amax (float): Maximum amplitude. - amin (float): Minimum amplitude. - fontsize (int): Font size for labels. - labels (Optional[List[str]]): Labels for the angles. - - Returns: - None - """ - if labels is None: - labels = [f"{angle}°" for angle in angles] - - # Draw circles - for r in range(1, 6): - ax.add_artist(plt.Circle((0, 0), r, fill=False, color="gray")) - - # Draw lines - for angle in np.deg2rad(angles): - ax.plot( - [0, 5 * np.cos(angle)], [0, 5 * np.sin(angle)], color="gray", linewidth=0.5 - ) - - # Add labels - for angle, label in zip(np.deg2rad(angles), labels): - ax.text( - 5.1 * np.cos(angle), - 5.1 * np.sin(angle), - label, - ha="center", - va="center", - fontsize=fontsize, - ) - - # Add amplitude labels - ax.text( - 2, - 0, - f"{amin + (amax - amin) / 3:.2f}", - ha="left", - va="bottom", - fontsize=fontsize, - ) - ax.text( - 4, - 0, - f"{amin + 2 * (amax - amin) / 3:.2f}", - ha="left", - va="bottom", - fontsize=fontsize, - ) - - ax.set_xlim(-5.5, 5.5) - ax.set_ylim(-5.5, 5.5) - ax.set_aspect("equal") - ax.axis("off") - - -def ssm_plot_contrast( - ssm_object: "SSMResults", - axislabel: str = "Difference", - xy: bool = True, - color: str = "red", - linesize: float = 1.25, - fontsize: int = 12, -) -> Figure: - """ - Create a Difference Plot of SSM Contrast Results using Seaborn. - - Args: - ssm_object (SSMResults): The results output of ssm_analyze. - axislabel (str): Label for the y-axis. - xy (bool): Whether to include X-Value and Y-Value parameters in the plot. - color (str): Color of the point range. - linesize (float): Size of the point range elements in points. - fontsize (int): Size of the axis labels, numbers, and facet headings in points. - - Returns: - matplotlib.figure.Figure: A figure object containing the difference plot. - """ - plabs = { - "e": r"$\Delta$ Elevation", - "x": r"$\Delta$ X-Value", - "y": r"$\Delta$ Y-Value", - "a": r"$\Delta$ Amplitude", - "d": r"$\Delta$ Displacement", - } - - pvals = ["e", "x", "y", "a", "d"] - - res = ssm_object.results - - if not xy: - res = res.drop(columns=["x_est", "x_lci", "x_uci", "y_est", "y_lci", "y_uci"]) - plabs = {k: v for k, v in plabs.items() if k not in ["x", "y"]} - pvals = [p for p in pvals if p not in ["x", "y"]] - - res["d_est"] = res["d_est"].astype(float) - res["d_uci"] = np.where( - (res["d_uci"] < res["d_lci"]) & (res["d_uci"] < 180), - (res["d_uci"] + 360) % 360, - res["d_uci"], - ) - res["d_lci"] = np.where( - (res["d_lci"] > res["d_uci"]) & (res["d_lci"] > 180), - (res["d_lci"] - 360) % 360, - res["d_lci"], - ) - - # Reshape data for seaborn - plot_data = [] - for param in pvals: - for _, row in res.iterrows(): - plot_data.append( - { - "Parameter": plabs[param], - "Estimate": row[f"{param}_est"], - "Lower CI": row[f"{param}_lci"], - "Upper CI": row[f"{param}_uci"], - "Label": row["label"], - } - ) - plot_df = pd.DataFrame(plot_data) - - # Create plot - fig, ax = plt.subplots(figsize=(12, 6)) - sns.pointplot( - data=plot_df, - x="Parameter", - y="Estimate", - hue="Label", - join=False, - ci=None, - color=color, - scale=0.75, - ax=ax, - ) - - # Add error bars - ax.errorbar( - x=plot_df["Parameter"], - y=plot_df["Estimate"], - yerr=[ - plot_df["Estimate"] - plot_df["Lower CI"], - plot_df["Upper CI"] - plot_df["Estimate"], - ], - fmt="none", - ecolor=color, - elinewidth=linesize, - capsize=5, - ) - - # Customize plot - ax.axhline(y=0, color="gray", linestyle="--", linewidth=linesize) - ax.set_ylabel(axislabel, fontsize=fontsize) - ax.set_xlabel("") - ax.tick_params(axis="both", which="major", labelsize=fontsize - 2) - ax.legend( - title=ssm_object.details["results_type"], - fontsize=fontsize - 2, - title_fontsize=fontsize, - ) - - plt.tight_layout() - return fig - - -def ssm_profile_plot( - scores: Union[np.ndarray, List[float]], - angles: Union[np.ndarray, List[float], Tuple[float, ...]], - amplitude: float, - displacement: float, - elevation: float, - r2: Optional[float] = None, - title: str = "SSM Profile", - reorder_scales: bool = True, - incl_pred: bool = True, - incl_fit: bool = True, - incl_disp: bool = True, - incl_amp: bool = True, - incl_elev: bool = False, - c_scores: str = "red", - c_fit: str = "black", - fontsize: int = 12, - ax: Optional[Axes] = None, -) -> Tuple[Figure, Axes]: - """ - Plot the SSM profile showing scale scores and fitted cosine curve. - - Creates a profile plot with observed scores and the fitted cosine curve, - optionally showing displacement, amplitude, elevation, and fit statistics. - - Parameters - ---------- - scores : array-like - Array of scores for each scale. - angles : array-like - Array of angles for each scale (in degrees). - amplitude : float - Amplitude of the cosine function. - displacement : float - Angular displacement of the cosine function (in degrees). - elevation : float - Elevation (mean level) of the cosine function. - r2 : float, optional - R-squared value for the fit. - title : str, optional - Title of the plot. Default is "SSM Profile". - reorder_scales : bool, optional - Whether to reorder scales based on angles. Default is True. - incl_pred : bool, optional - Whether to include the predicted fit line. Default is True. - incl_fit : bool, optional - Whether to include the R-squared value. Default is True. - incl_disp : bool, optional - Whether to include the displacement line. Default is True. - incl_amp : bool, optional - Whether to include the amplitude line. Default is True. - incl_elev : bool, optional - Whether to include the elevation line. Default is False. - c_scores : str, optional - Color for the score points. Default is "red". - c_fit : str, optional - Color for the fit line. Default is "black". - fontsize : int, optional - Base font size for the plot. Default is 12. - ax : matplotlib.axes.Axes, optional - Existing axes to plot on. If None, creates new figure and axes. - - Returns - ------- - Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes] - A tuple containing the figure and axis objects. - - Examples - -------- - >>> import numpy as np - >>> from circumplex import ssm_profile_plot - >>> - >>> # Create a profile plot - >>> scores = np.array([0.5, 0.7, 0.3, -0.2, -0.5, -0.3, 0.1, 0.4]) - >>> angles = (0, 45, 90, 135, 180, 225, 270, 315) - >>> fig, ax = ssm_profile_plot( - ... scores=scores, - ... angles=angles, - ... amplitude=0.6, - ... displacement=30, - ... elevation=0.1, - ... r2=0.85, - ... title="Example Profile" - ... ) - """ - if ax is None: - fig, ax = plt.subplots(figsize=(10, 5)) - else: - fig = cast(Figure, ax.get_figure()) - - assert len(scores) == len(angles), "Scores and angles must be the same length." - # assert 0 <= elevation <= 1, "Elevation must be between 0 and 1." - if r2 is not None: - assert 0 <= r2 <= 1, "R2 must be between 0 and 1." - assert 0 <= amplitude, "Amplitude must be a positive number." - assert 0 <= displacement <= 360, "Displacement must be between 0 and 360." - - if reorder_scales: - angles, scores = utils.sort_angles(angles, scores) # type: ignore[invalid-argument] - if angles[-1] == 360: - angles = (0,) + angles - scores = (scores[-1],) + scores - - if incl_pred: - thetas = np.linspace(0, 360, 1000) - fit = utils.cosine_form( - np.deg2rad(thetas), amplitude, np.deg2rad(displacement), elevation - ) - ax.plot(thetas, fit, color=c_fit) - - ax.plot(angles, scores, color=c_scores, marker="o") - - if incl_disp: - ax.axvline(displacement, color="black", linestyle="--") - ax.text( - displacement + 5, elevation, f"d = {int(displacement)}", fontsize=fontsize - ) - - if incl_amp: - ax.axhline(amplitude + elevation, color="black", linestyle="--") - ax.text( - 0, elevation + amplitude * 0.5, f"a = {amplitude:.2f}", fontsize=fontsize - ) - - if incl_fit: - ylim = ax.get_ylim() - ax.text( - 0, ylim[0] + 0.25 * (ylim[1] - ylim[0]), f"R2 = {r2:.2f}", fontsize=fontsize - ) - - if incl_elev: - ax.axhline(elevation, color="black", linestyle="--") - ax.text(0, elevation, f"e = {elevation:.2f}", fontsize=fontsize) - - ax.set_xticks(utils.OCTANTS) - ax.set_xticklabels( - ["0", "45", "90", "135", "180", "225", "270", "315"], fontsize=fontsize - ) - ax.set_xlabel("Angle [deg]", fontsize=fontsize + 2) - ax.set_ylabel("Score", fontsize=fontsize + 2) - ax.set_title(title, fontsize=fontsize + 4) - - return fig, ax From be7c8c732dbe348d2aba81513c71c941e6890932 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:52:16 +0000 Subject: [PATCH 71/97] Add utility module for package detection --- src/circumplex/_utils.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 src/circumplex/_utils.py diff --git a/src/circumplex/_utils.py b/src/circumplex/_utils.py new file mode 100644 index 0000000..bb8fc5e --- /dev/null +++ b/src/circumplex/_utils.py @@ -0,0 +1,13 @@ +import importlib.util + + +def is_package_installed(package_name: str) -> bool: + """Check if a package is installed.""" + package_spec = importlib.util.find_spec(package_name) + return package_spec is not None + + +if is_package_installed("rich"): + from rich.console import Console + + console = Console() From f0fbbc542aa57cea4b91a772e2bc932cbccc9429 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:52:16 +0000 Subject: [PATCH 72/97] Add SSM analysis results classes --- src/circumplex/ssm.py | 341 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 src/circumplex/ssm.py diff --git a/src/circumplex/ssm.py b/src/circumplex/ssm.py new file mode 100644 index 0000000..033bd2e --- /dev/null +++ b/src/circumplex/ssm.py @@ -0,0 +1,341 @@ +"""Structural Summary Method (SSM) analysis results and configuration classes. + +This module provides dataclasses for representing SSM analysis results: + +- SSMDetails: Configuration and parameters used in SSM analysis +- SSM: Complete SSM analysis results with estimates and confidence intervals +""" + +from __future__ import annotations + +from collections.abc import Iterable +from dataclasses import dataclass +from typing import Any + +import pandas as pd +from matplotlib.figure import Figure + +from circumplex._utils import is_package_installed +from circumplex.visualization import plot_circle, plot_contrast, plot_curve + +console = None +if is_package_installed("rich"): + from rich.console import Group + from rich.table import Table + + from circumplex import _utils + + console = getattr(_utils, "console", None) + + +@dataclass +class SSMDetails: + """Details of SSM analysis configuration and parameters. + + Attributes + ---------- + boots + Number of bootstrap resamples used for confidence intervals. + interval + Confidence interval level (e.g., 0.95 for 95% CI). + listwise + Whether listwise deletion was used for missing data. + angles + Angular displacements of the circumplex scales in degrees. + contrast + Whether the analysis involves contrasts between groups. + score_type + Type of scores used in analysis ('mean' or 'correlation').Pterm + """ + + boots: int + interval: float + listwise: bool + angles: list[float] + contrast: bool + score_type: str + + @classmethod + def from_dict(cls, data: dict) -> SSMDetails: + """Create SSMDetails instance from dictionary. + + Parameters + ---------- + data + Dictionary containing SSM analysis parameters with keys: + boots, interval, listwise, angles, contrast, score_type. + + Returns + ------- + New SSMDetails instance populated from dictionary data. + """ + return cls( + boots=data["boots"], + interval=data["interval"], + listwise=data["listwise"], + angles=data["angles"], + contrast=data["contrast"], + score_type=data["score_type"], + ) + + def to_dict(self) -> dict[str, Any]: + """Convert SSMDetails instance to dictionary. + + Returns + ------- + Dictionary containing all SSMDetails attributes. + """ + return self.__dict__.copy() + + def __rich_repr__(self) -> Iterable[str]: + """Generate rich console representation of SSM analysis details.""" + yield f"Statistical Basis: {self.score_type.capitalize()} Scores" + yield f"Bootstrap Resamples: {self.boots}" + yield f"Confidence Level: {self.interval}" + yield f"Listwise Deletion: {self.listwise}" + yield f"Scale Displacements: {self.angles}" + + +@dataclass +class SSM: + """Results from a Structural Summary Method (SSM) analysis. + + Attributes + ---------- + results + DataFrame containing SSM parameter estimates and confidence intervals. + scores + DataFrame containing the circumplex scale scores used in the analysis. + details + Configuration and parameters used in the SSM analysis. + type + Type of SSM analysis performed (e.g., 'profile', 'contrast'). + """ + + results: pd.DataFrame + scores: pd.DataFrame + details: SSMDetails + type: str + + @classmethod + def from_dict(cls, data: dict) -> SSM: + """Create SSM instance from dictionary. + + Parameters + ---------- + data + Dictionary containing SSM analysis results with keys: + results, scores, details, type. + + Returns + ------- + New SSM instance populated from dictionary data. + """ + return cls( + results=data["results"], + scores=data["scores"], + details=SSMDetails.from_dict(data["details"]), + type=data["type"], + ) + + def to_dict(self) -> dict[str, Any]: + """Convert SSM instance to dictionary. + + Returns + ------- + Dictionary containing all SSM attributes with details converted to dict format. + """ + d = self.__dict__.copy() + d["details"] = self.details.to_dict() + return d + + def summary(self, *, rich_print: bool = True) -> None: + """Print a formatted summary of SSM analysis results. + + Parameters + ---------- + rich_print + Whether to use rich console formatting for output, by default True. + If False or rich is not installed, falls back to standard printing. + """ + summ_secs = [] # Initialize summ_secs here + if is_package_installed("rich") and rich_print: + summ_secs = [*self.details.__rich_repr__()] + summ_secs.append("\n") + + for _, row in self.results.iterrows(): + tbl = Table(title=f"Profile[{row.Label}]") + tbl.add_column("") + tbl.add_column("Estimate") + tbl.add_column("Lower CI") + tbl.add_column("Upper CI") + + for label, val in zip( + ["Elevation", "X-Value", "Y-Value", "Amplitude", "Displacement"], + ["e", "x", "y", "a", "d"], + strict=False, + ): + tbl.add_row( + label, + str(round(row[f"{val}_est"], 3)), + str(round(row[f"{val}_lci"], 3)), + str(round(row[f"{val}_uci"], 3)), + ) + tbl.add_row("Model Fit", str(round(row.fit_est, 3))) + + summ_secs.append(tbl) + + summ_group = Group(*summ_secs) # This will now work correctly + if console is not None: + console.print(summ_group) + else: + # Non-rich version of the summary + print(f"Statistical Basis: {self.details.score_type.capitalize()} Scores") # noqa: T201 + print(f"Bootstrap Resamples: {self.details.boots}") # noqa: T201 + print(f"Confidence Level: {self.details.interval}") # noqa: T201 + print(f"Listwise Deletion: {self.details.listwise}") # noqa: T201 + print(f"Scale Displacements: {self.details.angles}") # noqa: T201 + print("\nResults:") # noqa: T201 + for _, row in self.results.iterrows(): + print(f"Profile[{row.Label}]:") # noqa: T201 + print( # noqa: T201 + f" Elevation: {round(row.e_est, 3)}, " + f"Lower CI: {round(row.e_lci, 3)}, " + f"Upper CI: {round(row.e_uci, 3)}" + ) + print( # noqa: T201 + f" X-Value: {round(row.x_est, 3)}, " + f"Lower CI: {round(row.x_lci, 3)}, " + f"Upper CI: {round(row.x_uci, 3)}" + ) + print( # noqa: T201 + f" Y-Value: {round(row.y_est, 3)}, " + f"Lower CI: {round(row.y_lci, 3)}, " + f"Upper CI: {round(row.y_uci, 3)}" + ) + print( # noqa: T201 + f" Amplitude: {round(row.a_est, 3)}, " + f"Lower CI: {round(row.a_lci, 3)}, " + f"Upper CI: {round(row.a_uci, 3)}" + ) + print(f" Displacement: {round(row.d_est, 3)}") # noqa: T201 + print(f" Model Fit: {round(row.fit_est, 3)}\n") # noqa: T201 + + def plot_circle(self, **kwargs: Any) -> Figure: + """Generate a circular SSM plot for the analysis results. + + Convenience method that passes SSM data to the plot_circle() function. + Automatically plots all profiles in the results. + + Parameters + ---------- + **kwargs + Additional plotting options passed to plot_circle(). See plot_circle() + documentation for available options (e.g., amax, angle_labels, colors, + fontsize, drop_lowfit, figsize, title). + + Returns + ------- + Matplotlib Figure object. + + Examples + -------- + >>> results = ssm_analyze(data, scales=list(range(8))) + >>> fig = results.plot_circle() + >>> fig.savefig('profile.png') + + >>> fig = results.plot_circle(colors="husl", fontsize=14) + + See Also + -------- + circumplex.visualization.plot_circle : Full function documentation + """ + return plot_circle( + results_df=self.results, + angles=self.details.angles, + **kwargs, + ) + + def plot_curve(self, **kwargs: Any) -> Figure: + """Generate SSM curve plots for the analysis results. + + Convenience method that passes SSM data to the plot_curve() function. + Creates faceted plots showing fitted curves overlaid on observed scores. + + Parameters + ---------- + **kwargs + Additional plotting options passed to plot_curve(). See plot_curve() + documentation for available options (e.g., angle_labels, colors, + base_size, drop_lowfit, figsize). + + Returns + ------- + Matplotlib Figure object. + + Examples + -------- + >>> results = ssm_analyze(data, scales=list(range(8))) + >>> fig = results.plot_curve() + >>> fig.savefig('curves.png') + + >>> fig = results.plot_curve(angle_labels=['PA', 'BC', 'DE', 'FG', + ... 'HI', 'JK', 'LM', 'NO']) + + See Also + -------- + circumplex.visualization.plot_curve : Full function documentation + """ + return plot_curve( + results_df=self.results, + scores_df=self.scores, + angles=self.details.angles, + **kwargs, + ) + + def plot_contrast(self, **kwargs: Any) -> Figure: + """Generate SSM parameter contrast plots for the analysis results. + + Convenience method that passes SSM data to the plot_contrast() function. + Only available for contrast analyses (when contrast=True in ssm_analyze). + + Parameters + ---------- + **kwargs + Additional plotting options passed to plot_contrast(). See + plot_contrast() documentation for available options (e.g., drop_xy, + sig_color, ns_color, linewidth, fontsize, figsize). + + Returns + ------- + Matplotlib Figure object. + + Raises + ------ + ValueError + If this SSM object does not contain contrast results. + + Examples + -------- + >>> results = ssm_analyze(data, scales=list(range(8)), + ... grouping='condition', contrast=True) + >>> fig = results.plot_contrast() + >>> fig.savefig('contrasts.png') + + >>> fig = results.plot_contrast(drop_xy=True) + + See Also + -------- + circumplex.visualization.plot_contrast : Full function documentation + """ + if not self.details.contrast: + msg = ( + "plot_contrast() requires contrast results. " + "Run ssm_analyze() with contrast=True." + ) + raise ValueError(msg) + + return plot_contrast( + results_df=self.results, + **kwargs, + ) From 2499f936ffad854442eb2dd461563d97034f2503 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:52:16 +0000 Subject: [PATCH 73/97] Refactor package initialization and exports --- src/circumplex/__init__.py | 81 ++++++++++++++++++++++++++++++++------ 1 file changed, 69 insertions(+), 12 deletions(-) diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index db21a41..15ab76a 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -1,16 +1,73 @@ -from circumplex import ssm_analysis, utils -from circumplex.instrument import Instrument, instruments -from circumplex.ssm_analysis import ssm_analyze -from circumplex.ssm_results import SSMResults -from circumplex.visualization import ssm_plot, ssm_profile_plot +"""Circumplex: Analysis and visualization of circular data in Python. + +This package provides tools for analyzing circular data using the Structural +Summary Method (SSM), particularly for interpersonal functioning, mood/affect, +and vocational preferences. + +Main functions: + +- ssm_analyze: Perform SSM analysis with bootstrap confidence intervals +- plot_circle: Plot SSM profiles on a circumplex circle +- plot_curve: Plot SSM fitted curves with observed scores +- plot_contrast: Plot SSM parameter contrasts between groups +- load_dataset: Load built-in example datasets +- OCTANTS, QUADRANTS, POLES: Standard angle sets + +Examples +-------- +>>> from circumplex import ssm_analyze, plot_circle +>>> from circumplex.data import load_dataset +>>> +>>> jz2017 = load_dataset('jz2017') +>>> results = ssm_analyze(jz2017, scales=['PA', 'BC', 'DE', 'FG', +... 'HI', 'JK', 'LM', 'NO']) +>>> print(results.results) +>>> fig = results.plot_circle() +>>> fig.savefig('profile.png') + +""" + +# Core analysis functions +from circumplex.analysis import ssm_analyze + +# Data loading +from circumplex.data import load_dataset + +# Utility functions +from circumplex.utils.angles import OCTANTS, POLES, QUADRANTS, Degree, Radian + +# Visualization functions +from circumplex.visualization import plot_circle, plot_contrast, plot_curve + +from ._version import __version__ # noqa: F401 +from .instruments import ( + csig, + get_instrument, + iipsc, + ipipipc, + register_instrument, + show_instruments, +) +from .utils.tidying_functions import ipsatize, norm_standardize, score __all__ = [ - "ssm_analysis", + "OCTANTS", + "POLES", + "QUADRANTS", + "Degree", + "Radian", + "csig", + "get_instrument", + "iipsc", + "ipipipc", + "ipsatize", + "load_dataset", + "norm_standardize", + "plot_circle", + "plot_contrast", + "plot_curve", + "register_instrument", + "score", + "show_instruments", "ssm_analyze", - "SSMResults", - "ssm_plot", - "ssm_profile_plot", - "Instrument", - "instruments", - "utils", ] From 905bd69b1905d2ce20f0608a43ae7a5fcd99231b Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 74/97] Add SSM analysis package structure and __init__ files --- src/circumplex/analysis/__init__.py | 5 +++++ src/circumplex/utils/__init__.py | 25 +++++++++++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 src/circumplex/analysis/__init__.py create mode 100644 src/circumplex/utils/__init__.py diff --git a/src/circumplex/analysis/__init__.py b/src/circumplex/analysis/__init__.py new file mode 100644 index 0000000..24c8caf --- /dev/null +++ b/src/circumplex/analysis/__init__.py @@ -0,0 +1,5 @@ +"""SSM analysis components.""" + +from circumplex.analysis.ssm_analyze import ssm_analyze + +__all__ = ["ssm_analyze"] diff --git a/src/circumplex/utils/__init__.py b/src/circumplex/utils/__init__.py new file mode 100644 index 0000000..cdf008b --- /dev/null +++ b/src/circumplex/utils/__init__.py @@ -0,0 +1,25 @@ +"""Utilities package.""" + +from .angles import ( + OCTANTS, + POLES, + QUADRANTS, + Degree, + Radian, + degrees_to_radians, + radians_to_degrees, +) +from .tidying_functions import ipsatize, norm_standardize, score + +__all__ = [ + "OCTANTS", + "POLES", + "QUADRANTS", + "Degree", + "Radian", + "degrees_to_radians", + "ipsatize", + "norm_standardize", + "radians_to_degrees", + "score", +] From c39ac594433598c43300b67a725ef4a05bc2c2ae Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 75/97] Add core SSM parameter calculation engine --- src/circumplex/core/parameters.py | 107 +++++++++++++ src/circumplex/core/scores.py | 251 ++++++++++++++++++++++++++++++ 2 files changed, 358 insertions(+) create mode 100644 src/circumplex/core/parameters.py create mode 100644 src/circumplex/core/scores.py diff --git a/src/circumplex/core/parameters.py b/src/circumplex/core/parameters.py new file mode 100644 index 0000000..719cc36 --- /dev/null +++ b/src/circumplex/core/parameters.py @@ -0,0 +1,107 @@ +"""SSM parameter calculation engine. + +This module implements the core Structural Summary Method parameter +calculations, ported from the C++ implementation in the R package. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +import numpy as np + +if TYPE_CHECKING: + from typing import Any + + from nptyping import NDArray, Shape + + +def ssm_parameters( + scores: NDArray[Shape[Any], float], + angles: NDArray[Shape[Any], float], +) -> dict[str, float]: + """Calculate SSM parameters for a profile of circumplex scores. + + Direct port of ssm_parameters_cpp from the R circumplex package. + Computes the six core SSM parameters: elevation, x-value, y-value, + amplitude, displacement, and model fit. + + Parameters + ---------- + scores + Array of circumplex scale scores (length n_scales) + angles + Angular positions in radians (length n_scales) + + Returns + ------- + Dictionary with keys: + + - elevation: Mean of all scale scores + - x_value: Projection onto x-axis (cosine component) + - y_value: Projection onto y-axis (sine component) + - amplitude: Vector length in 2D space + - displacement: Angular position in radians [0, 2π) + - fit: Model fit (R²), proportion of variance explained + + Examples + -------- + >>> import numpy as np + >>> from circumplex.utils.angles import OCTANTS, degrees_to_radians + >>> + >>> scores = np.array([0.374, -0.572, -0.520, 0.016, 0.688, 1.142, 1.578, 0.678]) + >>> angles = degrees_to_radians(OCTANTS) + >>> params = ssm_parameters(scores, angles) + >>> print(f"Elevation: {params['elevation']:.3f}") + Elevation: 0.423 + >>> print(f"Amplitude: {params['amplitude']:.3f}") + Amplitude: 0.981 + + Notes + ----- + This function implements the Structural Summary Method as described in + Zimmermann & Wright (2017). The displacement is returned in radians; + convert to degrees if needed. + + References + ---------- + Zimmermann, J., & Wright, A. G. C. (2017). Beyond description in + interpersonal construct validation: Methodological advances in the + circumplex Structural Summary Approach. Assessment, 24(1), 3-23. + + """ + n = len(scores) + + # Elevation: mean of scores + elevation: float = cast("float", np.mean(scores)) + + # X and Y values: projections onto axes + x_value: float = (2 / n) * np.dot(scores, np.cos(angles)) + y_value: float = (2 / n) * np.dot(scores, np.sin(angles)) + + # Amplitude: vector length + amplitude: float = np.sqrt(x_value**2 + y_value**2) + + # Displacement: angular position + # Use atan2 for proper quadrant, then modulo to ensure [0, 2π) + displacement: float = np.arctan2(y_value, x_value) % (2 * np.pi) + + # Model fit (R²) + # Predicted scores from cosine model + predicted: NDArray[Any, float] = elevation + amplitude * np.cos( + angles - displacement + ) + ss_residual: float = np.sum((scores - predicted) ** 2) + ss_total: float = cast("float", np.var(scores, ddof=1) * (n - 1)) + + # Avoid division by zero + fit: float = 1.0 if ss_total == 0 else 1 - ss_residual / ss_total + + return { + "elevation": elevation, + "x_value": x_value, + "y_value": y_value, + "amplitude": amplitude, + "displacement": displacement, + "fit": fit, + } diff --git a/src/circumplex/core/scores.py b/src/circumplex/core/scores.py new file mode 100644 index 0000000..de3f9e0 --- /dev/null +++ b/src/circumplex/core/scores.py @@ -0,0 +1,251 @@ +"""Score calculation functions for SSM analysis. + +This module implements the core score calculation functions for both mean-based +and correlation-based SSM analysis, ported from the C++ implementation in the +R circumplex package. +""" + +import numpy as np + +from circumplex.core.parameters import ssm_parameters + + +def mean_scores( + data: np.ndarray, + groups: np.ndarray | None = None, + *, + listwise: bool = True, +) -> np.ndarray: + """Calculate mean scale scores by group. + + Port of mean_scores() from R circumplex C++ implementation. Computes + mean values for each scale, optionally stratified by group, with + listwise or pairwise deletion of missing data. + + Parameters + ---------- + data + Array of circumplex scale scores, shape (n_obs, n_scales) + groups + Group indicators as integers (0-indexed), shape (n_obs,). + If None, treats all observations as a single group. + listwise + If True, use listwise deletion (remove any row with any NA). + If False, use pairwise deletion (compute mean per scale ignoring NAs). + + Returns + ------- + Array of mean scores, shape (n_groups, n_scales) + + Examples + -------- + >>> data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) + >>> mean_scores(data) + array([[4., 5., 6.]]) + + >>> groups = np.array([0, 0, 1]) + >>> mean_scores(data, groups) + array([[2.5, 3.5, 4.5], + [7. , 8. , 9. ]]) + + Notes + ----- + This function mirrors the behavior of mean_scores() in the R package's + C++ code (src/parameters.cpp lines 62-93). + + """ + # Handle single group case + if groups is None: + groups = np.zeros(len(data), dtype=int) + + # Get unique groups (sorted) + unique_groups = np.unique(groups) + n_groups = len(unique_groups) + n_scales = data.shape[1] + + # Initialize output + result = np.zeros((n_groups, n_scales)) + + for i, group_id in enumerate(unique_groups): + # Extract data for this group + group_mask = groups == group_id + group_data = data[group_mask] + + if listwise: + # Listwise deletion: remove rows with any NA + complete_rows = ~np.isnan(group_data).any(axis=1) + clean_data = group_data[complete_rows] + if len(clean_data) > 0: + result[i] = np.mean(clean_data, axis=0) + else: + result[i] = np.nan + else: + # Pairwise deletion: compute mean per column ignoring NAs + result[i] = np.nanmean(group_data, axis=0) + + return result + + +def corr_scores( + scales: np.ndarray, + measures: np.ndarray, + groups: np.ndarray | None = None, + *, + listwise: bool = True, +) -> np.ndarray: + """Calculate correlation scores between measures and scales by group. + + Port of corr_scores() from R circumplex C++ implementation. Computes + correlations between measure variables and circumplex scales, optionally + stratified by group, with listwise or pairwise deletion. + + Parameters + ---------- + scales + Array of circumplex scale scores, shape (n_obs, n_scales) + measures + Array of measure variables, shape (n_obs, n_measures) + groups + Group indicators as integers (0-indexed), shape (n_obs,). + If None, treats all observations as a single group. + listwise + If True, use listwise deletion (remove any row with any NA). + If False, use pairwise deletion (compute correlation per pair ignoring NAs). + + Returns + ------- + Array of correlation scores, shape (n_groups * n_measures, n_scales). + Rows are ordered by group, then by measure within each group. + + Examples + -------- + >>> scales = np.array([[1, 2], [3, 4], [5, 6]]) + >>> measures = np.array([[0], [1], [2]]) + >>> corr_scores(scales, measures) + array([[1., 1.]]) + + Notes + ----- + This function mirrors the behavior of corr_scores() in the R package's + C++ code (src/parameters.cpp lines 113-160). + + The output is organized as: + - Single group: [measure1_corrs, measure2_corrs, ...] + - Multiple groups: [g1_m1_corrs, g1_m2_corrs, ..., g2_m1_corrs, g2_m2_corrs, ...] + + """ + # Ensure measures is 2D + if measures.ndim == 1: + measures = measures.reshape(-1, 1) + + # Handle single group case + if groups is None: + groups = np.zeros(len(scales), dtype=int) + + # Get dimensions + unique_groups = np.unique(groups) + n_groups = len(unique_groups) + n_measures = measures.shape[1] + n_scales = scales.shape[1] + + # Initialize output: (n_groups * n_measures) x n_scales + result = np.zeros((n_groups * n_measures, n_scales)) + + for g_idx, group_id in enumerate(unique_groups): + # Extract data for this group + group_mask = groups == group_id + group_scales = scales[group_mask] + group_measures = measures[group_mask] + + if listwise: + # Listwise deletion: remove rows with any NA in scales or measures + all_data = np.column_stack([group_scales, group_measures]) + complete_rows = ~np.isnan(all_data).any(axis=1) + clean_scales = group_scales[complete_rows] + clean_measures = group_measures[complete_rows] + + # Compute correlations for all measure-scale pairs + for m_idx in range(n_measures): + row_idx = g_idx * n_measures + m_idx + if len(clean_scales) > 1: # Need at least 2 observations + for s_idx in range(n_scales): + result[row_idx, s_idx] = np.corrcoef( + clean_measures[:, m_idx], clean_scales[:, s_idx] + )[0, 1] + else: + result[row_idx] = np.nan + else: + # Pairwise deletion: compute correlation per pair ignoring NAs + for m_idx in range(n_measures): + row_idx = g_idx * n_measures + m_idx + for s_idx in range(n_scales): + # Get measure and scale vectors + m_vec = group_measures[:, m_idx] + s_vec = group_scales[:, s_idx] + + # Remove pairs where either is NA + valid_mask = ~(np.isnan(m_vec) | np.isnan(s_vec)) + m_clean = m_vec[valid_mask] + s_clean = s_vec[valid_mask] + + if len(m_clean) > 1: # Need at least 2 observations + result[row_idx, s_idx] = np.corrcoef(m_clean, s_clean)[0, 1] + else: + result[row_idx, s_idx] = np.nan + + return result + + +def group_parameters( + scores: np.ndarray, + angles: np.ndarray, +) -> np.ndarray: + """Calculate SSM parameters for multiple groups. + + Applies ssm_parameters() to each row of a score matrix, returning + a flat array of all parameters. + + Parameters + ---------- + scores + Array of scale scores, shape (n_groups, n_scales) + angles + Angular positions in radians, shape (n_scales,) + + Returns + ------- + Flat array of parameters, length (n_groups * 6). + Order: [e1, x1, y1, a1, d1, f1, e2, x2, y2, a2, d2, f2, ...] + + Examples + -------- + >>> from circumplex.core.parameters import ssm_parameters + >>> from circumplex.utils.angles import OCTANTS, degrees_to_radians + >>> scores = np.array([[1, 2, 3, 4, 5, 6, 7, 8], + ... [8, 7, 6, 5, 4, 3, 2, 1]]) + >>> angles = degrees_to_radians(OCTANTS) + >>> params = group_parameters(scores, angles) + >>> len(params) + 12 + + Notes + ----- + This function mirrors group_parameters() in the R package's C++ code + (src/parameters.cpp lines 37-45). + + """ + n_groups = scores.shape[0] + result = np.zeros(n_groups * 6) + + for i in range(n_groups): + params = ssm_parameters(scores[i], angles) + result[i * 6 : (i + 1) * 6] = [ + params["elevation"], + params["x_value"], + params["y_value"], + params["amplitude"], + params["displacement"], + params["fit"], + ] + + return result From c61cc94013476ac4dc046153591e43dd66a4cb9c Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 76/97] Add angle utilities and predefined angle sets --- src/circumplex/utils/angles.py | 141 +++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 src/circumplex/utils/angles.py diff --git a/src/circumplex/utils/angles.py b/src/circumplex/utils/angles.py new file mode 100644 index 0000000..227f17c --- /dev/null +++ b/src/circumplex/utils/angles.py @@ -0,0 +1,141 @@ +"""Angle utilities and predefined angle sets. + +This module provides tools for working with circular angles, including +conversion between degrees and radians, and standard angle sets for +circumplex models. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np + +if TYPE_CHECKING: + from nptyping import Float, NDArray, Shape + + +OCTANTS: NDArray[Shape["8"], Float] = np.array( + [90, 135, 180, 225, 270, 315, 360, 45], dtype=float +) +"""Standard octant angles in degrees. + +Returns the eight standard positions on a circumplex circle, +spaced 45 degrees apart, starting from 90 degrees (North). +""" + +QUADRANTS: NDArray[Shape["4"], Float] = np.array([90, 180, 270, 360], dtype=float) +"""Standard quadrant angles in degrees. + +Returns the four standard quadrant positions on a circumplex circle, +spaced 90 degrees apart. +""" + +POLES: NDArray[Shape["2"], Float] = np.array([90, 270], dtype=float) +"""Standard pole angles in degrees. + +Returns the two primary axis positions (vertical poles) +on a circumplex circle. +""" + + +class Degree(float): + """Angular measurement in degrees. + + A float subclass representing an angle in degrees, with + conversion methods to radians. + + Examples + -------- + >>> angle = Degree(90) + >>> angle.to_radians() + Radian(1.5707963267948966) + + """ + + def to_radians(self) -> "Radian": + """Convert to radians. + + Returns + ------- + Angle in radians + + """ + return Radian(np.radians(self)) + + def __repr__(self) -> str: + """Return a compact string representation, e.g., '90°'.""" + return f"{float(self):.0f}°" + + +class Radian(float): + """Angular measurement in radians. + + A float subclass representing an angle in radians, with + conversion methods to degrees. + + Examples + -------- + >>> angle = Radian(np.pi/2) + >>> angle.to_degrees() + Degree(90.0) + + """ + + def to_degrees(self) -> Degree: + """Convert to degrees. + + Returns + ------- + Angle in degrees + + """ + return Degree(np.degrees(self)) + + def __repr__(self) -> str: + """Return a compact string representation, e.g., '1.571 rad'.""" + return f"{float(self):.3f} rad" + + +def degrees_to_radians(degrees: float | np.ndarray) -> float | np.ndarray: + """Convert degrees to radians. + + Parameters + ---------- + degrees + Angle(s) in degrees + + Returns + ------- + Angle(s) in radians + + Examples + -------- + >>> degrees_to_radians(180) + 3.141592653589793 + >>> degrees_to_radians(OCTANTS) + array([1.57..., 2.35..., 3.14..., ...]) + + """ + return np.radians(degrees) + + +def radians_to_degrees(radians: float | np.ndarray) -> float | np.ndarray: + """Convert radians to degrees. + + Parameters + ---------- + radians + Angle(s) in radians + + Returns + ------- + Angle(s) in degrees + + Examples + -------- + >>> radians_to_degrees(np.pi) + 180.0 + + """ + return np.degrees(radians) From 1fc126e5ddcc1a365be424730e7f6a2132cc15a6 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 77/97] Add contrast and circular difference utilities --- src/circumplex/utils/contrast.py | 170 +++++++++++++++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 src/circumplex/utils/contrast.py diff --git a/src/circumplex/utils/contrast.py b/src/circumplex/utils/contrast.py new file mode 100644 index 0000000..06a80d4 --- /dev/null +++ b/src/circumplex/utils/contrast.py @@ -0,0 +1,170 @@ +"""Contrast and circular difference utilities for SSM analysis. + +This module provides functions for computing parameter differences and +circular distance calculations, particularly for contrast analyses. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np + +if TYPE_CHECKING: + from nptyping import Float, Int, NDArray, Shape + + +def angle_dist(angle1: float, angle2: float) -> float: + """Calculate circular distance between two angles. + + Computes the signed difference between two angles in radians, + returning a value in the range [-π, π]. This handles the circular + nature of angular data correctly. + + Parameters + ---------- + angle1 + First angle in radians + angle2 + Second angle in radians + + Returns + ------- + Signed difference (angle1 - angle2) in radians, range [-π, π] + + Examples + -------- + >>> angle_dist(0.1, 0.05) # Small positive difference + 0.05 + >>> angle_dist(0.1, 6.2) # Wraps around circle + 0.18318... + >>> angle_dist(np.pi, -np.pi) # Opposite sides of circle + 0.0 + + Notes + ----- + This function mirrors angle_dist() from the R package (R/utils.R lines 32-34). + The formula ((x - y + π) mod 2π) - π ensures the result is in [-π, π]. + + """ + diff = angle1 - angle2 + # Wrap to [-π, π] + return ((diff + np.pi) % (2 * np.pi)) - np.pi + + +def param_diff( + params1: dict[str, float], params2: dict[str, float] +) -> dict[str, float]: + """Calculate difference between two sets of SSM parameters. + + Computes element-wise differences between parameter sets, with special + handling for the displacement parameter (circular difference). + + Parameters + ---------- + params1 + First parameter set with keys: elevation, x_value, y_value, + amplitude, displacement, fit + params2 + Second parameter set with same keys + + Returns + ------- + Parameter differences (params1 - params2). The displacement difference + uses circular distance to handle angular wrapping correctly. + + Examples + -------- + >>> p1 = {'elevation': 1.0, 'x_value': 0.5, 'y_value': 0.3, + ... 'amplitude': 0.6, 'displacement': 0.1, 'fit': 0.9} + >>> p2 = {'elevation': 0.8, 'x_value': 0.4, 'y_value': 0.2, + ... 'amplitude': 0.5, 'displacement': 6.2, 'fit': 0.85} + >>> diff = param_diff(p1, p2) + >>> diff['elevation'] + 0.2 + >>> diff['displacement'] # Uses circular distance + 0.18318... + + Notes + ----- + This function mirrors param_diff() from the R package (R/utils.R lines 13-19). + For displacement, it uses angle_dist() instead of simple subtraction. + + """ + return { + "elevation": params1["elevation"] - params2["elevation"], + "x_value": params1["x_value"] - params2["x_value"], + "y_value": params1["y_value"] - params2["y_value"], + "amplitude": params1["amplitude"] - params2["amplitude"], + "displacement": angle_dist(params1["displacement"], params2["displacement"]), + "fit": params1["fit"] - params2["fit"], + } + + +def param_diff_array( + params: NDArray[Shape["12", Float | Int]], +) -> NDArray[Shape["6", Float | Int]]: + """Calculate parameter differences from a flat parameter array. + + Given a flat array containing parameters for two groups/measures, + computes the difference between them (first - second) with circular + handling for displacement. + + Parameters + ---------- + params + Flat array of parameters, length 12: + [e1, x1, y1, a1, d1, f1, e2, x2, y2, a2, d2, f2] + + Returns + ------- + Array of parameter differences, length 6: + [e_diff, x_diff, y_diff, a_diff, d_diff, f_diff] + + Examples + -------- + >>> params = np.array([1.0, 0.5, 0.3, 0.6, 0.1, 0.9, + ... 0.8, 0.4, 0.2, 0.5, 6.2, 0.85]) + >>> diff = param_diff_array(params) + >>> diff[0] # Elevation difference + 0.2 + + Notes + ----- + This is a convenience wrapper around param_diff() for use with + flat arrays returned by group_parameters(). + + """ + # Extract first set (indices 0-5) - first group + p1 = { + "elevation": params[0], + "x_value": params[1], + "y_value": params[2], + "amplitude": params[3], + "displacement": params[4], + "fit": params[5], + } + + # Extract second set (indices 6-11) - second group + p2 = { + "elevation": params[6], + "x_value": params[7], + "y_value": params[8], + "amplitude": params[9], + "displacement": params[10], + "fit": params[11], + } + + # Compute difference as second - first (matches R convention) + diff = param_diff(p2, p1) # type: ignore[invalid-argument-type] + + return np.array( + [ + diff["elevation"], + diff["x_value"], + diff["y_value"], + diff["amplitude"], + diff["displacement"], + diff["fit"], + ] + ) From 2eb9a0b2b63bc8afd0858ab2761457bae57f64d0 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 78/97] Add data tidying and instrument scoring functions --- src/circumplex/utils/tidying_functions.py | 227 ++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 src/circumplex/utils/tidying_functions.py diff --git a/src/circumplex/utils/tidying_functions.py b/src/circumplex/utils/tidying_functions.py new file mode 100644 index 0000000..81fa515 --- /dev/null +++ b/src/circumplex/utils/tidying_functions.py @@ -0,0 +1,227 @@ +"""Utility functions for data tidying and instrument scoring.""" + +from collections.abc import Iterable + +import numpy as np +import pandas as pd + +from circumplex.instruments import get_instrument +from circumplex.instruments.models import Instrument + + +def ipsatize( + data: pd.DataFrame, + items: Iterable[str | int], + prefix: str = "", + suffix: str = "_i", + *, + na_rm: bool = True, + append: bool = True, +) -> pd.DataFrame: + """Ipsatize item-level data by centering within individuals. + + Parameters + ---------- + data : pd.DataFrame + DataFrame containing item-level data. + items : tuple[str] + Tuple of column names corresponding to item-level data to ipsatize. + prefix : str, optional + Prefix to add to ipsatized column names, by default "". + suffix : str, optional + Suffix to add to ipsatized column names, by default "". + na_rm : bool, optional + Whether to remove NAs when computing individual means, by default True. + append : bool, optional + Whether to append ipsatized columns to the original DataFrame, + or return only the ipsatized columns, by default True. + + Returns + ------- + DataFrame with ipsatized item-level data. + + Raises + ------ + TypeError + If `data` is not a DataFrame or `items` is not a sequence. + ValueError + If any item in `items` is not a column in `data`. + """ + if not isinstance(data, pd.DataFrame): + msg = "Input 'data' must be a pandas DataFrame." + raise TypeError(msg) + if isinstance(items, str): + msg = "Input 'items' must be a sequence of column names." + raise TypeError(msg) + if not isinstance(items, Iterable): + msg = "Input 'items' must be a sequence of column names." + raise TypeError(msg) + + if all(isinstance(item, str) for item in items): + if all(item in data.columns for item in items): + item_data = data.loc[:, list(items)].copy() + else: + msg = "All items in 'items' must be valid column names in 'data'." + raise ValueError(msg) + elif all(isinstance(item, (int, np.integer, float, np.floating)) for item in items): + numeric_items = [int(item) for item in items] + if all(0 <= idx < data.shape[1] for idx in numeric_items): + item_data = data.iloc[:, numeric_items].copy() + else: + msg = "All items in 'items' must be valid indices in 'data'." + raise ValueError(msg) + else: + msg = "All items in 'items' must be either strings or integers." + raise TypeError(msg) + + rmean = item_data.mean(axis=1, skipna=na_rm) + scores = item_data.subtract(rmean, axis=0) + scores.columns = [f"{prefix}{item}{suffix}" for item in items] + + if append: + return pd.concat([data, scores], axis=1) + return scores + + +def score( + data: pd.DataFrame, + items: Iterable[str | int], + instrument: Instrument | str, + prefix: str = "", + suffix: str = "", + *, + na_rm: bool = True, + append: bool = True, +) -> pd.DataFrame: + """Score item-level data using a circumplex instrument. + + Parameters + ---------- + data + DataFrame containing at least circumplex scales. + items + The variable names or column numbers for the variables in `data` + that contain all the circumplex items from a single circumplex measure, + in ascending order from item 1 to item N. + instrument + An instrument object from the package. To see the available + prefix : str, optional + Prefix to add to scored column names, by default "". + suffix : str, optional + Suffix to add to scored column names, by default "". + na_rm : bool, optional + Whether to remove NAs when computing individual means, by default True. + append : bool, optional + Whether to append scored columns to the original DataFrame, + or return only the scored columns, by default True. + + Returns + ------- + DataFrame with scored scale-level data. + + Raises + ------ + TypeError + If `data` is not a DataFrame or `items` is not a sequence. + ValueError + If any item in `items` is not a column in `data`. + """ + # Validate inputs + # -- validate data and items first (before trying to get instrument) + if not isinstance(data, pd.DataFrame): + msg = "Input 'data' must be a pandas DataFrame." + raise TypeError(msg) + if isinstance(items, str): + msg = "Input 'items' must be a sequence of column names." + raise TypeError(msg) + if not isinstance(items, Iterable): + msg = "Input 'items' must be a sequence of column names or indices." + raise TypeError(msg) + + # -- get instrument if a string is provided + if isinstance(instrument, str): + instrument = get_instrument(instrument) + if not isinstance(instrument, Instrument): + msg = "Input 'instrument' must be an Instrument instance." + raise TypeError(msg) + + return instrument.score( + data, + items, + prefix=prefix, + suffix=suffix, + na_rm=na_rm, + append=append, + ) + + +def norm_standardize( + data: pd.DataFrame, + scales: Iterable[str | int], + instrument: Instrument | str, + sample_id: int, + prefix: str = "", + suffix: str = "_z", + *, + append: bool = True, +) -> pd.DataFrame: + """Standardize scale-level data using normative sample statistics. + + Parameters + ---------- + data : pd.DataFrame + DataFrame containing scale-level data. + scales : tuple[str | int] + Tuple of column names or indices corresponding to scale-level data + to standardize. + instrument : Instrument | str + An instrument object from the package. To see the available + instruments, use `show_instruments()`. + sample_id : int | str + The ID of the normative sample to use for standardization. + prefix : str, optional + Prefix to add to standardized column names, by default "". + suffix : str, optional + Suffix to add to standardized column names, by default "_z". + append : bool, optional + Whether to append standardized columns to the original DataFrame, + or return only the standardized columns, by default True. + + Returns + ------- + DataFrame with standardized scale-level data. + + Raises + ------ + TypeError + If `data` is not a DataFrame or `scales` is not a sequence. + ValueError + If any scale in `scales` is not a column in `data`. + """ + # Validate inputs + # -- validate data and scales first (before trying to get instrument) + if not isinstance(data, pd.DataFrame): + msg = "Input 'data' must be a pandas DataFrame." + raise TypeError(msg) + if isinstance(scales, str): + msg = "Input 'scales' must be a sequence of column names." + raise TypeError(msg) + if not isinstance(scales, Iterable): + msg = "Input 'scales' must be a sequence of column names or indices." + raise TypeError(msg) + + # -- get instrument if a string is provided + if isinstance(instrument, str): + instrument = get_instrument(instrument) + if not isinstance(instrument, Instrument): + msg = "Input 'instrument' must be an Instrument instance." + raise TypeError(msg) + + return instrument.norm_standardize( + data, + scales, + int(sample_id), + prefix=prefix, + suffix=suffix, + append=append, + ) From c346c0e8209c7ca2e1ab87dede388bdc59a7a1c8 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 79/97] Add bootstrap confidence interval calculation --- src/circumplex/analysis/bootstrap.py | 261 +++++++++++++++++++++++++++ 1 file changed, 261 insertions(+) create mode 100644 src/circumplex/analysis/bootstrap.py diff --git a/src/circumplex/analysis/bootstrap.py b/src/circumplex/analysis/bootstrap.py new file mode 100644 index 0000000..3a1cfb3 --- /dev/null +++ b/src/circumplex/analysis/bootstrap.py @@ -0,0 +1,261 @@ +"""Bootstrap confidence interval calculation for SSM analysis. + +This module implements bootstrap resampling with confidence interval +calculation, including special handling for circular displacement data. +""" + +from __future__ import annotations + +from collections.abc import Callable +from typing import TYPE_CHECKING, Any + +import numpy as np +import pandas as pd + +if TYPE_CHECKING: + from nptyping import Float, NDArray, Shape + + +def circular_quantile( + angles: NDArray[Any, Float], + probs: list[float] | NDArray[Shape[Any], Float], +) -> NDArray[Shape[Any], Float]: + """Calculate quantiles for circular data in radians. + + Implements a circular quantile method that accounts for the periodic + nature of angular data. Centers angles around their mean direction, + calculates linear quantiles, then transforms back. + + Parameters + ---------- + angles + Array of angles in radians, shape (n,) + probs + Probability points at which to calculate quantiles (e.g., [0.025, 0.975]) + + Returns + ------- + Quantiles at the requested probability points + + Examples + -------- + >>> angles = np.array([0.1, 0.2, 6.2, 6.3]) # Two near 0, two near 2π + >>> circular_quantile(angles, [0.25, 0.75]) + array([6.25..., 0.15...]) + + Notes + ----- + This function mirrors the quantile.circumplex_radian method from the + R package (R/ssm_bootstrap.R lines 72-82). It: + 1. Computes mean direction using atan2 + 2. Centers all angles around the mean + 3. Calculates linear quantiles on centered data + 4. Transforms back to [0, 2π) + + """ + # Calculate mean direction + mean_angle = np.arctan2(np.mean(np.sin(angles)), np.mean(np.cos(angles))) + + # Center angles around mean direction + angles_centered = (angles - mean_angle + np.pi) % (2 * np.pi) - np.pi + + # Calculate quantiles on centered data + quantiles_centered = np.quantile(angles_centered, probs) + + # Transform back + return (quantiles_centered + mean_angle) % (2 * np.pi) + + +def ssm_bootstrap( + data: pd.DataFrame, + bootstrap_fn: Callable[ + [pd.DataFrame, NDArray[Shape[Any], Float]], NDArray[Shape[Any], Float] + ], + boots: int = 2000, + grouping_col: str | None = None, + *, + seed: int | None = None, +) -> dict[str, Any]: + """Perform stratified bootstrap with confidence intervals. + + Executes bootstrap resampling with stratification by group (if specified), + calculates point estimates and and bootstrap replicats; + use `calculate_confidence_intervals()` to derive confidence intervals. + + Parameters + ---------- + data + DataFrame containing all data for bootstrap sampling + bootstrap_fn + Function that takes (data, resample_indices) and returns + flat array of parameters for all groups/measures + boots + Number of bootstrap resamples + grouping_col + Name of grouping column for stratified sampling. + If None, uses simple random sampling. + seed + Random seed for reproducibility + + Returns + ------- + Dictionary containing: + - 't0': Point estimates (observed parameters) + - 't': Bootstrap matrix (boots x n_params) + - 'n_params': Number of parameters per profile + - 'n_profiles': Number of profiles (groups/measures) + + Examples + -------- + >>> def simple_mean(df, indices): + ... return np.array([df.iloc[indices]['x'].mean()]) + >>> data = pd.DataFrame({'x': [1, 2, 3, 4, 5]}) + >>> result = ssm_bootstrap(data, simple_mean, boots=100, seed=123) + >>> result['t0'] # Observed mean + array([3.]) + + Notes + ----- + This function mirrors ssm_bootstrap() from the R package + (R/ssm_bootstrap.R lines 1-55). It uses stratified sampling + when a grouping variable is provided to ensure each bootstrap + sample maintains the original group proportions. + + """ + if seed is not None: + np.random.seed(seed) + + n_obs = len(data) + + # Calculate observed parameters (t0) + observed_indices = np.arange(n_obs) + t0 = bootstrap_fn(data, observed_indices) + + # Initialize bootstrap matrix + n_params_total = len(t0) + t_matrix = np.zeros((boots, n_params_total)) + + # Perform bootstrap resampling + for b in range(boots): + if grouping_col is not None: + # Stratified sampling: sample within each group + resample_indices = _stratified_resample(data, grouping_col) + else: + # Simple random sampling with replacement + resample_indices = np.random.choice(n_obs, size=n_obs, replace=True) + + # Calculate parameters for this resample + t_matrix[b] = bootstrap_fn(data, resample_indices) + + return { + "t0": t0, + "t": t_matrix, + "n_params": 6, # Always 6 SSM parameters per profile + "n_profiles": n_params_total // 6, + } + + +def _stratified_resample(data: pd.DataFrame, grouping_col: str) -> np.ndarray: + """Perform stratified resampling within groups. + + Parameters + ---------- + data + DataFrame with grouping column + grouping_col + Name of column containing group labels + + Returns + ------- + Array of resampled indices + + """ + indices = [] + groups = data[grouping_col].unique() + + for group in groups: + # Get indices for this group + group_mask = data[grouping_col] == group + group_indices = np.where(group_mask)[0] + + # Sample with replacement from this group + n_group = len(group_indices) + resampled = np.random.choice(group_indices, size=n_group, replace=True) + indices.extend(resampled) + + return np.array(indices) + + +def calculate_confidence_intervals( + bootstrap_results: dict[str, Any], + interval: float = 0.95, +) -> pd.DataFrame: + """Calculate confidence intervals from bootstrap results. + + Computes percentile confidence intervals for all parameters, with + special circular handling for displacement parameters. + + Parameters + ---------- + bootstrap_results + Dictionary from ssm_bootstrap() containing 't0' and 't' + interval + Confidence level (e.g., 0.95 for 95% CI) + + Returns + ------- + DataFrame with columns: + - e_est, x_est, y_est, a_est, d_est, fit_est (point estimates) + - e_lci, x_lci, y_lci, a_lci, d_lci (lower CI) + - e_uci, x_uci, y_uci, a_uci, d_uci (upper CI) + Note: fit has no confidence intervals + + Notes + ----- + This function mirrors the CI calculation in R's ssm_bootstrap() + (R/ssm_bootstrap.R lines 38-54). It uses percentile method for + linear parameters and circular_quantile() for displacement. + + """ + t0 = bootstrap_results["t0"] + t_matrix = bootstrap_results["t"] + n_params = bootstrap_results["n_params"] + n_profiles = bootstrap_results["n_profiles"] + + # Calculate probability points for CI + alpha = 1 - interval + lower_prob = alpha / 2 + upper_prob = 1 - alpha / 2 + + # Initialize results DataFrame + param_names = ["e", "x", "y", "a", "d", "fit"] + results = [] + + for profile_idx in range(n_profiles): + # Extract parameters for this profile + param_start = profile_idx * n_params + profile_params = {} + + for param_idx, param_name in enumerate(param_names): + obs_value = t0[param_start + param_idx] + boot_values = t_matrix[:, param_start + param_idx] + + # Point estimate + profile_params[f"{param_name}_est"] = obs_value + + # Confidence intervals (skip fit) + if param_name != "fit": + if param_name == "d": + # Use circular quantile for displacement + ci = circular_quantile(boot_values, [lower_prob, upper_prob]) + + else: + # Use regular quantile for other parameters + ci = np.quantile(boot_values, [lower_prob, upper_prob]) + + profile_params[f"{param_name}_lci"] = ci[0] # type: ignore[non-subscriptable] + profile_params[f"{param_name}_uci"] = ci[1] # type: ignore[non-subscriptable] + + results.append(profile_params) + + return pd.DataFrame(results) From 098294ded6eeb756767df2189930ca77be3f059c Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 80/97] Add mean-based SSM analysis implementation --- src/circumplex/analysis/mean_analysis.py | 222 +++++++++++++++++++++++ 1 file changed, 222 insertions(+) create mode 100644 src/circumplex/analysis/mean_analysis.py diff --git a/src/circumplex/analysis/mean_analysis.py b/src/circumplex/analysis/mean_analysis.py new file mode 100644 index 0000000..62b5d92 --- /dev/null +++ b/src/circumplex/analysis/mean_analysis.py @@ -0,0 +1,222 @@ +"""Mean-based SSM analysis. + +This module implements mean-based SSM analysis with bootstrap confidence +intervals, supporting single-group and multi-group designs with optional +contrast analysis. +""" + +from __future__ import annotations + +from typing import Any + +import numpy as np +import pandas as pd + +from circumplex.analysis.bootstrap import calculate_confidence_intervals, ssm_bootstrap +from circumplex.core.scores import group_parameters, mean_scores +from circumplex.utils.contrast import param_diff_array + + +def ssm_analyze_means( # noqa: PLR0915 + data: pd.DataFrame, + scales: list[str] | list[int], + angles: np.ndarray, + grouping: str | None = None, + boots: int = 2000, + interval: float = 0.95, + *, + contrast: bool = False, + listwise: bool = True, + seed: int | None = None, +) -> dict[str, Any]: + """Perform mean-based SSM analysis. + + Calculates SSM parameters from mean scale scores, optionally stratified + by group, with bootstrap confidence intervals. Supports contrast analysis + for comparing two groups. + + Parameters + ---------- + data + DataFrame containing circumplex scale scores + scales + Column names or indices for circumplex scales (length n_scales) + angles + Angular positions in radians (length n_scales) + grouping + Column name for grouping variable. If None, analyzes all data as one group. + contrast + If True, calculate difference between two groups (requires exactly 2 groups) + boots + Number of bootstrap resamples + interval + Confidence level (e.g., 0.95 for 95% CI) + listwise + If True, use listwise deletion. If False, use pairwise deletion. + seed + Random seed for reproducibility + + Returns + ------- + Dictionary with keys: + - 'results': DataFrame with parameters and confidence intervals + - 'scores': DataFrame with mean scale scores per group + - 'details': Dict with analysis metadata + - 'type': 'mean' + + Raises + ------ + ValueError + If contrast=True but number of groups is not 2 + + Examples + -------- + >>> from circumplex.data import load_dataset + >>> from circumplex.utils.angles import OCTANTS, degrees_to_radians + >>> data = load_dataset('jz2017') + >>> angles = degrees_to_radians(OCTANTS) + >>> results = ssm_analyze_means(data, scales=['PA', 'BC', 'DE', 'FG', + ... 'HI', 'JK', 'LM', 'NO'], + ... angles=angles, boots=2000, seed=12345) + + Notes + ----- + This function mirrors ssm_analyze_means() from the R package + (R/ssm_analysis.R lines 179-276). + + """ + # Convert scale indices to names if needed + if isinstance(scales[0], int): + scale_names = [data.columns[i] for i in scales] + else: + scale_names = scales + + # Handle grouping + if grouping is None: + # Create synthetic "All" group + group_labels = np.array(["All"] * len(data)) + group_col = "All" + n_groups = 1 + else: + group_col = data[grouping] + # Convert to categorical and get labels + if not isinstance(group_col.dtype, pd.CategoricalDtype): + group_col = pd.Categorical(group_col) + else: + group_col = group_col.astype("category") + + group_labels = np.array(group_col) + unique_groups = group_col.categories + n_groups = len(unique_groups) + + # Validate contrast + if contrast and n_groups != 2: + msg = "Contrast can only be TRUE when comparing exactly 2 groups" + raise ValueError(msg) + + # Prepare bootstrap input data + bs_input = data[scale_names].copy() + bs_input["__group__"] = group_labels + + # Apply listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() + + # Convert groups to integer codes for internal use + if grouping is None: + group_codes = np.zeros(len(bs_input), dtype=int) + else: + group_categories = pd.Categorical(bs_input["__group__"]) + group_codes = group_categories.codes + unique_groups = group_categories.categories + + # Calculate observed mean scores + observed_scores = mean_scores( + bs_input[scale_names].values, group_codes, listwise=listwise + ) + + # Add contrast row if requested + if contrast: + contrast_scores = observed_scores[1] - observed_scores[0] + observed_scores = np.vstack([observed_scores, contrast_scores]) + + # Define bootstrap function + def bootstrap_fn(df: pd.DataFrame, indices: np.ndarray) -> np.ndarray: + """Calculate SSM parameters for a bootstrap resample.""" + resampled = df.iloc[indices] + scale_vals = resampled[scale_names].to_numpy() + + # Get group codes for resample + if grouping is None: + grp_codes = np.zeros(len(resampled), dtype=int) + else: + grp_categories = pd.Categorical( + resampled["__group__"], categories=unique_groups + ) + grp_codes = grp_categories.codes + + # Calculate mean scores for this resample + scores_r = mean_scores(scale_vals, grp_codes, listwise=listwise) + + # Calculate SSM parameters + params = group_parameters(scores_r, angles) + + # Add contrast if requested + if contrast: + contrast_params = param_diff_array(params) + params = np.concatenate([params, contrast_params]) + + return params + + # Perform bootstrap + bs_results = ssm_bootstrap( + bs_input, + bootstrap_fn, + boots=boots, + grouping_col="__group__" if grouping is not None else None, + seed=seed, + ) + + # Calculate confidence intervals + results_df = calculate_confidence_intervals(bs_results) + + # Convert displacement from radians to degrees + results_df["d_est"] = np.degrees(results_df["d_est"]) + if "d_lci" in results_df.columns: + results_df["d_lci"] = np.degrees(results_df["d_lci"]) + results_df["d_uci"] = np.degrees(results_df["d_uci"]) + + # Add metadata columns + if grouping is None: + results_df.insert(0, "Label", ["All"]) + group_labels_list = ["All"] + else: + group_labels_list = list(unique_groups) + if contrast: + contrast_label = f"{group_labels_list[1]} - {group_labels_list[0]}" + group_labels_list.append(contrast_label) + results_df.insert(0, "Label", group_labels_list) + + results_df.insert(1, "Group", group_labels_list) + results_df.insert(2, "Measure", [None] * len(results_df)) + + # Create scores DataFrame + scores_df = pd.DataFrame(observed_scores, columns=scale_names) + scores_df.insert(0, "Label", group_labels_list) + + # Prepare details + details = { + "boots": boots, + "interval": interval, + "listwise": listwise, + "angles": np.degrees(angles).tolist(), + "contrast": contrast, + "score_type": "mean", + } + + return { + "results": results_df, + "scores": scores_df, + "details": details, + "type": "mean", + } From ab2b3926b564a25d7935013b13a69fbca140e150 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 81/97] Add correlation-based SSM analysis implementation --- src/circumplex/analysis/corr_analysis.py | 288 +++++++++++++++++++++++ 1 file changed, 288 insertions(+) create mode 100644 src/circumplex/analysis/corr_analysis.py diff --git a/src/circumplex/analysis/corr_analysis.py b/src/circumplex/analysis/corr_analysis.py new file mode 100644 index 0000000..6c1fdd1 --- /dev/null +++ b/src/circumplex/analysis/corr_analysis.py @@ -0,0 +1,288 @@ +"""Correlation-based SSM analysis. + +This module implements correlation-based SSM analysis with bootstrap confidence +intervals, supporting single/multi-group and single/multi-measure designs with +optional contrast analysis. +""" + +from typing import Any + +import numpy as np +import pandas as pd + +from circumplex.analysis.bootstrap import calculate_confidence_intervals, ssm_bootstrap +from circumplex.core.scores import corr_scores, group_parameters +from circumplex.utils.contrast import param_diff_array + + +def ssm_analyze_corrs( # noqa: C901, PLR0915 + data: pd.DataFrame, + scales: list[str] | list[int], + angles: np.ndarray, + measures: list[str] | str, + grouping: str | None = None, + boots: int = 2000, + interval: float = 0.95, + measures_labels: list[str] | None = None, + *, + contrast: bool = False, + listwise: bool = True, + seed: int | None = None, +) -> dict[str, Any]: + """Perform correlation-based SSM analysis. + + Calculates SSM parameters from correlations between measures and scales, + optionally stratified by group, with bootstrap confidence intervals. + Supports contrast analysis for comparing two groups or two measures. + + Parameters + ---------- + data + DataFrame containing circumplex scales and measures + scales + Column names or indices for circumplex scales (length n_scales) + angles + Angular positions in radians (length n_scales) + measures + Column name(s) for measure variable(s). Can be string or list. + grouping + Column name for grouping variable. If None, analyzes all data as one group. + boots + Number of bootstrap resamples + interval + Confidence level (e.g., 0.95 for 95% CI) + measures_labels + Optional custom labels for measures (same length as measures) + contrast + If True, calculate difference between two groups or two measures + (requires exactly 2 groups OR 2 measures, not both) + listwise + If True, use listwise deletion. If False, use pairwise deletion. + seed + Random seed for reproducibility + + Returns + ------- + Dictionary with keys: + - 'results': DataFrame with parameters and confidence intervals + - 'scores': DataFrame with correlation scores + - 'details': Dict with analysis metadata + - 'type': 'correlation' + + Raises + ------ + ValueError + If contrast=True but requirements not met (2 groups XOR 2 measures) + + Examples + -------- + >>> from circumplex.data import load_dataset + >>> from circumplex.utils.angles import OCTANTS, degrees_to_radians + >>> data = load_dataset('jz2017') + >>> angles = degrees_to_radians(OCTANTS) + >>> results = ssm_analyze_corrs(data, scales=['PA', 'BC', 'DE', 'FG', + ... 'HI', 'JK', 'LM', 'NO'], + ... angles=angles, measures='PARPD', + ... boots=2000, seed=12345) + + Notes + ----- + This function mirrors ssm_analyze_corrs() from the R package + (R/ssm_analysis.R lines 280-406). + + """ + # Convert measures to list if single string + if isinstance(measures, str): + measures = [measures] + + # Convert scale indices to names if needed + if isinstance(scales[0], int): + scale_names = [data.columns[i] for i in scales] + else: + scale_names = scales + + # Use custom labels or measure names + if measures_labels is None: + measures_labels = measures + + n_measures = len(measures) + + # Handle grouping + if grouping is None: + group_labels = np.array(["All"] * len(data)) + group_col = "All" + n_groups = 1 + else: + group_col = data[grouping] + if not isinstance(group_col.dtype, pd.CategoricalDtype): + group_col = pd.Categorical(group_col) + else: + group_col = group_col.astype("category") + + group_labels = np.array(group_col) + unique_groups = group_col.categories + n_groups = len(unique_groups) + + # Validate contrast + if contrast: + group_mean_contrast = n_measures == 0 and n_groups == 2 + group_corr_contrast = n_measures == 1 and n_groups == 2 + measure_corr_contrast = n_measures == 2 and n_groups == 1 + + if not (group_mean_contrast or group_corr_contrast or measure_corr_contrast): + msg = ( + "Contrast can only be TRUE when comparing exactly 2 groups " + "(with 1 measure) or exactly 2 measures (with 1 group)" + ) + raise ValueError(msg) + + # Prepare bootstrap input data + bs_input = data[scale_names + measures].copy() + bs_input["__group__"] = group_labels + + # Apply listwise deletion if requested + if listwise: + bs_input = bs_input.dropna() + + # Convert groups to integer codes + if grouping is None: + group_codes = np.zeros(len(bs_input), dtype=int) + unique_groups = ["All"] + else: + group_categories = pd.Categorical(bs_input["__group__"]) + group_codes = group_categories.codes + unique_groups = group_categories.categories + + # Calculate observed correlation scores + observed_scores = corr_scores( + bs_input[scale_names].values, + bs_input[measures].values, + group_codes, + listwise=listwise, + ) + + # Add contrast row if requested + if contrast: + if n_measures == 2 and n_groups == 1: + # Measure contrast: compare two measures within single group + contrast_scores = observed_scores[1] - observed_scores[0] + elif n_groups == 2: + # Group contrast: compare two groups for single measure + contrast_scores = observed_scores[1] - observed_scores[0] + observed_scores = np.vstack([observed_scores, contrast_scores]) + + # Define bootstrap function + def bootstrap_fn(df: pd.DataFrame, indices: np.ndarray) -> np.ndarray: + """Calculate SSM parameters for a bootstrap resample.""" + resampled = df.iloc[indices] + scale_vals = resampled[scale_names].to_numpy() + measure_vals = resampled[measures].to_numpy() + + # Get group codes for resample + if grouping is None: + grp_codes = np.zeros(len(resampled), dtype=int) + else: + grp_categories = pd.Categorical( + resampled["__group__"], categories=unique_groups + ) + grp_codes = grp_categories.codes + + # Calculate correlation scores for this resample + scores_r = corr_scores(scale_vals, measure_vals, grp_codes, listwise=listwise) + + # Calculate SSM parameters + params = group_parameters(scores_r, angles) + + # Add contrast if requested + if contrast: + contrast_params = param_diff_array(params) + params = np.concatenate([params, contrast_params]) + + return params + + # Perform bootstrap + bs_results = ssm_bootstrap( + bs_input, + bootstrap_fn, + boots=boots, + grouping_col="__group__" if grouping is not None else None, + seed=seed, + ) + + # Calculate confidence intervals + results_df = calculate_confidence_intervals(bs_results) + + # Convert displacement from radians to degrees + results_df["d_est"] = np.degrees(results_df["d_est"]) + if "d_lci" in results_df.columns: + results_df["d_lci"] = np.degrees(results_df["d_lci"]) + results_df["d_uci"] = np.degrees(results_df["d_uci"]) + + # Create labels combining measure and group information + labels = [] + profile_groups = [] + profile_measures = [] + + if n_groups == 1: + # Single group: labels are measure names + for m_label in measures_labels: + labels.append(m_label) + profile_groups.append(unique_groups[0]) + profile_measures.append(m_label) + + if contrast and n_measures == 2: + contrast_label = f"{measures_labels[1]} - {measures_labels[0]}" + labels.append(contrast_label) + profile_groups.append(unique_groups[0]) + profile_measures.append(contrast_label) + else: + # Multiple groups: labels combine measure and group + for group in unique_groups: + for m_label in measures_labels: + # Always use "MEASURE: GROUP" format for multi-group correlation + label = f"{m_label}: {group}" + labels.append(label) + profile_groups.append(group) + profile_measures.append(m_label) + + if contrast: + if n_measures == 1: + # Format: "MEASURE: GROUP1 - GROUP2" # noqa: ERA001 + contrast_label = ( + f"{measures_labels[0]}: {unique_groups[1]} - {unique_groups[0]}" + ) + else: + contrast_label = ( + f"{unique_groups[1]} - {unique_groups[0]}: {measures_labels[0]}" + ) + labels.append(contrast_label) + profile_groups.append(contrast_label) + profile_measures.append( + measures_labels[0] if n_measures == 1 else contrast_label + ) + + # Add metadata columns + results_df.insert(0, "Label", labels) + results_df.insert(1, "Group", profile_groups) + results_df.insert(2, "Measure", profile_measures) + + # Create scores DataFrame + scores_df = pd.DataFrame(observed_scores, columns=scale_names) + scores_df.insert(0, "Label", labels) + + # Prepare details + details = { + "boots": boots, + "interval": interval, + "listwise": listwise, + "angles": np.degrees(angles).tolist(), + "contrast": contrast, + "score_type": "correlation", + } + + return { + "results": results_df, + "scores": scores_df, + "details": details, + "type": "correlation", + } From 87fa028ddd806456386090f0d0d42db0fcf9ee64 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 82/97] Add main SSM analysis function and SSM class integration --- src/circumplex/analysis/ssm_analyze.py | 261 +++++++++++++++++++++++++ 1 file changed, 261 insertions(+) create mode 100644 src/circumplex/analysis/ssm_analyze.py diff --git a/src/circumplex/analysis/ssm_analyze.py b/src/circumplex/analysis/ssm_analyze.py new file mode 100644 index 0000000..8b9daba --- /dev/null +++ b/src/circumplex/analysis/ssm_analyze.py @@ -0,0 +1,261 @@ +"""Main SSM analysis function. + +This module provides the primary user-facing function for performing +Structural Summary Method (SSM) analysis on circumplex data. +""" + +from __future__ import annotations + +from typing import cast + +import numpy as np +import pandas as pd + +from circumplex.analysis.corr_analysis import ssm_analyze_corrs +from circumplex.analysis.mean_analysis import ssm_analyze_means +from circumplex.ssm import SSM +from circumplex.utils.angles import OCTANTS, degrees_to_radians + + +def ssm_analyze( + data: pd.DataFrame, + scales: list[str] | list[int], + angles: np.ndarray | list[float] | None = None, + measures: list[str] | str | None = None, + grouping: str | None = None, + boots: int = 2000, + interval: float = 0.95, + measures_labels: list[str] | None = None, + *, + contrast: bool = False, + listwise: bool = True, + seed: int | None = None, +) -> SSM: + """Perform Structural Summary Method (SSM) analysis on circumplex data. + + This is the main entry point for SSM analysis. It automatically determines + whether to perform mean-based or correlation-based analysis based on the + `measures` parameter, calculates SSM parameters, and computes bootstrap + confidence intervals. + + Parameters + ---------- + data + DataFrame containing circumplex scale scores (and optionally measures + and grouping variables) + scales + Column names or indices for circumplex scales. Must be ordered according + to their angular positions (matching the order in `angles`). + angles + Angular positions for the scales in degrees. If None, uses standard + octant angles [90, 135, 180, 225, 270, 315, 360, 45]. Length must + match the number of scales. + measures + Column name(s) for external measure variable(s) to correlate with scales. + - If None: Performs mean-based analysis (profile analysis) + - If string or list: Performs correlation-based analysis + grouping + Column name for grouping variable. If None, treats all data as a + single group. The variable will be converted to a categorical factor. + contrast + If True, calculates differences between groups or measures. + - Requires exactly 2 groups (with 0 or 1 measures), OR + - Requires exactly 2 measures (with 1 group) + Raises ValueError if requirements not met. + boots + Number of bootstrap resamples for confidence interval calculation. + Default: 2000. + interval + Confidence level for bootstrap intervals (e.g., 0.95 for 95% CI). + Default: 0.95. + listwise + Missing data handling: + - If True: Listwise deletion (remove rows with any missing value) + - If False: Pairwise deletion (use all available data for each calculation) + Default: True. + measures_labels + Optional custom labels for measures (same length as measures). + If None, uses the column names. + seed + Random seed for reproducibility of bootstrap results. If None, results + will vary across runs. + + Returns + ------- + dict + Dictionary containing: + + - **results** : pd.DataFrame + SSM parameters and confidence intervals with columns: + + - Label: Profile label (group/measure name or combination) + - Group: Group identifier + - Measure: Measure identifier (None for mean-based analysis) + - e_est, x_est, y_est, a_est, d_est, fit_est: Point estimates + - e_lci, x_lci, y_lci, a_lci, d_lci: Lower confidence intervals + - e_uci, x_uci, y_uci, a_uci, d_uci: Upper confidence intervals + + Note: Displacement (d) is in degrees. No CIs for fit parameter. + + - **scores** : pd.DataFrame + Mean scores (mean-based) or correlation scores (correlation-based) + for each scale, with Label column. + + - **details** : dict + Analysis metadata including boots, interval, listwise, angles, + contrast, and score_type. + + - **type** : str + Analysis type: 'mean' or 'correlation' + + Raises + ------ + ValueError + - If angles length doesn't match scales length + - If contrast=True but requirements not met + - If data contains no valid observations after missing data handling + + Examples + -------- + **Mean-based analysis (single group)** + + >>> from circumplex import ssm_analyze + >>> from circumplex.data import load_dataset + >>> aw2009 = load_dataset('aw2009') + >>> results = ssm_analyze(aw2009, scales=list(range(8)), seed=12345) + >>> print(results['results'][['Label', 'e_est', 'a_est', 'd_est']]) + Label e_est a_est d_est + 0 All 0.423 0.981 344.358 + + **Mean-based analysis (multiple groups with contrast)** + + >>> jz2017 = load_dataset('jz2017') + >>> results = ssm_analyze(jz2017, scales=list(range(1, 9)), + ... grouping='Gender', contrast=True, seed=12345) + >>> print(results['results'][['Label', 'e_est', 'a_est']]) + Label e_est a_est + 0 Female 0.635 0.158 + 1 Male 0.596 0.192 + 2 Male - Female -0.039 0.034 + + **Correlation-based analysis (single measure)** + + >>> results = ssm_analyze(jz2017, scales=list(range(1, 9)), + ... measures='PARPD', seed=12345) + >>> print(results['results'][['Label', 'e_est', 'a_est', 'd_est']]) + Label e_est a_est d_est + 0 PARPD 0.250 0.150 128.9 + + **Correlation-based analysis (measure contrast)** + + >>> results = ssm_analyze(jz2017, scales=list(range(1, 9)), + ... measures=['ASPD', 'NARPD'], + ... contrast=True, seed=12345) + >>> print(results['results'][['Label', 'e_est', 'a_est']]) + Label e_est a_est + 0 ASPD 0.253 0.055 + 1 NARPD 0.311 0.203 + 2 NARPD - ASPD 0.058 0.148 + + Notes + ----- + This function is a Python port of ssm_analyze() from the R circumplex + package (Zimmermann & Wright, 2017). It maintains numerical parity with + the R implementation to at least 3 decimal places. + + **SSM Parameters:** + + - **elevation (e)**: Mean of all scale scores + - **x_value (x)**: Projection onto x-axis (cosine component) + - **y_value (y)**: Projection onto y-axis (sine component) + - **amplitude (a)**: Vector length (prototypicality) + - **displacement (d)**: Angular position in degrees [0, 360) + - **fit**: Model fit (R²), proportion of variance explained + + **Bootstrap Confidence Intervals:** + + Uses percentile method with stratified sampling when groups are present. + Displacement CIs use circular statistics to handle angular wrapping. + + See Also + -------- + load_dataset : Load example datasets + OCTANTS : Standard octant angles for 8-scale circumplex + + References + ---------- + Zimmermann, J., & Wright, A. G. C. (2017). Beyond description in + interpersonal construct validation: Methodological advances in the + circumplex Structural Summary Approach. *Assessment, 24*(1), 3-23. + https://doi.org/10.1177/1073191115621795 + + Zimmermann, J., & Wright, A. G. C. (2017). The circumplex package + [Computer software]. https://cran.r-project.org/package=circumplex + + """ + # Validate and process scales + if isinstance(scales[0], int): + scale_names = [data.columns[i] for i in scales] + else: + scale_names = scales + + n_scales = len(scale_names) + + # Process angles + if angles is None: + # Use default octant angles + if n_scales != 8: + msg = ( + f"When angles=None, exactly 8 scales are required (got {n_scales}). " + "Please provide custom angles for non-octant circumplex models." + ) + raise ValueError(msg) + angles_deg = OCTANTS + else: + # Convert to numpy array if needed + angles_deg = np.array(angles, dtype=float) + + # Validate length + if len(angles_deg) != n_scales: + msg = ( + f"Length of angles ({len(angles_deg)}) must match " + f"number of scales ({n_scales})" + ) + raise ValueError(msg) + + # Convert angles to radians for internal use + # Ensure numpy array type for downstream functions + angles_rad = cast("np.ndarray", degrees_to_radians(angles_deg)) + + # Route to appropriate analysis function + if measures is None: + # Mean-based analysis + return SSM.from_dict( + ssm_analyze_means( + data=data, + scales=scale_names, + angles=angles_rad, + grouping=grouping, + contrast=contrast, + boots=boots, + interval=interval, + listwise=listwise, + seed=seed, + ) + ) + # Correlation-based analysis + return SSM.from_dict( + ssm_analyze_corrs( + data=data, + scales=scale_names, + angles=angles_rad, + measures=measures, + grouping=grouping, + contrast=contrast, + boots=boots, + interval=interval, + listwise=listwise, + measures_labels=measures_labels, + seed=seed, + ) + ) From 718cd58bb9b9c749284b18bfa4b8f2c45f85f017 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 83/97] Add visualization package with plotting utilities --- src/circumplex/visualization/__init__.py | 13 +++ src/circumplex/visualization/_utils.py | 104 +++++++++++++++++++++++ 2 files changed, 117 insertions(+) create mode 100644 src/circumplex/visualization/__init__.py create mode 100644 src/circumplex/visualization/_utils.py diff --git a/src/circumplex/visualization/__init__.py b/src/circumplex/visualization/__init__.py new file mode 100644 index 0000000..069ecf2 --- /dev/null +++ b/src/circumplex/visualization/__init__.py @@ -0,0 +1,13 @@ +"""Circumplex visualization module. + +This module provides functions for visualizing SSM analysis results using +matplotlib. Three main plot types are available: + +- plot_circle: Circular plot showing amplitude and displacement +- plot_curve: Faceted plot showing fitted cosine curves with observed scores +- plot_contrast: Faceted plots for parameter contrasts between groups +""" + +from circumplex.visualization.plots import plot_circle, plot_contrast, plot_curve + +__all__ = ["plot_circle", "plot_contrast", "plot_curve"] diff --git a/src/circumplex/visualization/_utils.py b/src/circumplex/visualization/_utils.py new file mode 100644 index 0000000..c9cd4ac --- /dev/null +++ b/src/circumplex/visualization/_utils.py @@ -0,0 +1,104 @@ +"""Helper utilities for circumplex visualization.""" + +import numpy as np + + +def ggrad(degrees: float | np.ndarray) -> float | np.ndarray: + """Convert degrees to ggplot2-style radians. + + ggplot2 uses a coordinate system where: + - 90° is at the top (North) + - Angles proceed clockwise + + This function converts standard circumplex degrees to this system. + + Parameters + ---------- + degrees + Angle(s) in degrees (0-360). + + Returns + ------- + Angle(s) in radians with ggplot2 orientation. + + Examples + -------- + >>> ggrad(90) # Top (North) + 0.0 + >>> ggrad(0) # Right (East) + 1.5707963267948966 + >>> ggrad(180) # Left (West) + -1.5707963267948966 + + """ + return (degrees - 90) * (-np.pi / 180) + + +def pretty_max(values: np.ndarray) -> float: + """Find a nice maximum value for amplitude scaling. + + Selects from a predefined set of "pretty" values that are slightly + larger than the maximum data value, providing appropriate buffer space. + + Parameters + ---------- + values + Array of amplitude values (typically upper CI bounds). + + Returns + ------- + A nice round number suitable for the amplitude scale maximum. + + Examples + -------- + >>> pretty_max(np.array([0.42, 0.38, 0.45])) + 0.75 + >>> pretty_max(np.array([1.2, 1.5, 1.3])) + 2.5 + + """ + amax = np.nanmax(values) + + options = np.array( + [ + -5.00, + -4.00, + -3.00, + -2.50, + -2.00, + -1.50, + -1.25, + -1.00, + -0.75, + -0.50, + -0.25, + -0.20, + -0.15, + -0.10, + -0.05, + 0.00, + 0.05, + 0.10, + 0.15, + 0.20, + 0.25, + 0.50, + 0.75, + 1.00, + 1.25, + 1.50, + 2.00, + 2.50, + 3.00, + 4.00, + 5.00, + ] + ) + + # If negative, use smaller buffer; if positive, use larger buffer + scalar = 0.5 if amax < 0 else 1.5 + + # Find the first option larger than amax * scalar + idx = np.searchsorted(options, amax * scalar) + + return options[min(idx, len(options) - 1)] From e5b814b7e45d355ff2309e870862b3f29cb6c13d Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 84/97] Add comprehensive matplotlib-based plotting functions --- src/circumplex/visualization/plots.py | 1104 +++++++++++++++++++++++++ 1 file changed, 1104 insertions(+) create mode 100644 src/circumplex/visualization/plots.py diff --git a/src/circumplex/visualization/plots.py b/src/circumplex/visualization/plots.py new file mode 100644 index 0000000..3c97751 --- /dev/null +++ b/src/circumplex/visualization/plots.py @@ -0,0 +1,1104 @@ +"""Matplotlib-based plotting functions for SSM results.""" + +from __future__ import annotations + +import warnings +from typing import Any, cast + +import matplotlib.patches as mpatches +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from matplotlib.colors import to_rgb +from matplotlib.figure import Figure +from matplotlib.patches import Patch + +from circumplex.visualization._utils import pretty_max + + +def _validate_results_df(results_df: pd.DataFrame) -> None: + """Validate that results DataFrame has required columns. + + Parameters + ---------- + results_df + DataFrame to validate. + + Raises + ------ + ValueError + If required columns are missing. + + """ + required_cols = ["Label", "e_est", "x_est", "y_est", "a_est", "d_est", "fit_est"] + missing = [col for col in required_cols if col not in results_df.columns] + if missing: + msg = f"results_df missing required columns: {missing}" + raise ValueError(msg) + + +def _prepare_plot_data( + results_df: pd.DataFrame, + profile_indices: list[int] | None, + *, + drop_lowfit: bool, +) -> pd.DataFrame: + """Extract and filter profiles to plot. + + Parameters + ---------- + results_df + Full results DataFrame. + profile_indices + Indices of profiles to plot, or None for all. + drop_lowfit + Whether to drop profiles with fit < 0.70. + + Returns + ------- + Filtered DataFrame ready for plotting. + + Raises + ------ + IndexError + If profile index is out of range. + ValueError + If no profiles remain after filtering. + + """ + # Determine which profiles to plot + if profile_indices is None: + profile_indices = list(range(len(results_df))) + + if len(profile_indices) == 0: + msg = "No profiles to plot" + raise ValueError(msg) + + # Validate indices + for idx in profile_indices: + if idx >= len(results_df): + msg = f"Profile index {idx} out of range (max: {len(results_df) - 1})" + raise IndexError(msg) + + # Extract profiles + plot_df = results_df.iloc[profile_indices].copy() + + # Handle low-fit profiles + if drop_lowfit: + low_fit_mask = plot_df["fit_est"] < 0.70 + if low_fit_mask.any(): + dropped = plot_df.loc[low_fit_mask, "Label"].tolist() + warnings.warn( + f"Dropping profiles with fit < 0.70: {dropped}", + stacklevel=3, + ) + plot_df = plot_df[~low_fit_mask] + if len(plot_df) == 0: + msg = "All profiles dropped due to low fit" + raise ValueError(msg) + + # Add line style column based on fit + plot_df["linestyle"] = plot_df["fit_est"].apply( + lambda fit: "solid" if fit >= 0.70 else "dashed" + ) + + return plot_df + + +def _setup_colors( + n_profiles: int, + colors: str | list[str] | None, +) -> tuple[list[tuple[float, float, float]], bool]: + """Set up colors and determine if legend should be shown. + + Parameters + ---------- + n_profiles + Number of profiles to plot. + colors + Color specification. Can be: + - None: single blue color, no legend + - str: seaborn palette name (e.g., "Set2", "husl") + - list: custom colors as names, hex codes, or RGB tuples + + Returns + ------- + tuple of (colors list, show_legend boolean) + + Raises + ------ + ValueError + If custom color list is provided but empty. + + """ + # No colors specified or single profile with default + if colors is None or (colors == "Set2" and n_profiles == 1): + return [(0.0, 0.45, 0.70)] * n_profiles, False + + # Palette name (string) + if isinstance(colors, str): + if n_profiles > 1: + color_list = sns.color_palette(colors, n_profiles) + return color_list, True + # Single profile with named palette + color_list = sns.color_palette(colors, 1) + return color_list, False + + # Custom color list + if len(colors) == 0: + msg = "colors list cannot be empty" + raise ValueError(msg) + + # Convert all colors to RGB tuples + color_list: list[tuple[float, float, float]] = [] + for color in colors: + try: + color_list.append(to_rgb(color)) + except ValueError as e: + msg = f"Invalid color specification: {color}" + raise ValueError(msg) from e + + # Cycle colors if not enough provided + if len(color_list) < n_profiles: + warnings.warn( + f"Only {len(color_list)} colors provided for {n_profiles} profiles. " + f"Colors will be cycled.", + stacklevel=4, + ) + # Repeat colors to cover all profiles + multiplier = (n_profiles // len(color_list)) + 1 + color_list = (color_list * multiplier)[:n_profiles] + + return color_list, n_profiles > 1 + + +def _get_contrast_row(results_df: pd.DataFrame) -> pd.Series: + """Get the contrast row (last row) from results_df.""" + if len(results_df) < 3: + msg = ( + "Contrast plot requires at least 3 rows in results_df " + "(two profiles + contrast)" + ) + raise ValueError(msg) + return results_df.iloc[-1] + + +def _build_contrast_plot_data( + contrast_row: pd.Series, *, drop_xy: bool +) -> list[dict[str, Any]]: + """Build per-parameter contrast plot data from a results row. + + Parameters + ---------- + contrast_row + The contrast row from results_df (typically last row). + drop_xy + Whether to omit X and Y parameters. + + Returns + ------- + List of dictionaries with keys: parameter, estimate, lci, uci, significant. + """ + param_names = ["e", "x", "y", "a", "d"] + param_labels = [ + "Δ Elevation", + "Δ X-Value", + "Δ Y-Value", + "Δ Amplitude", + "Δ Displacement", + ] + + plot_data: list[dict[str, Any]] = [] + for param, label in zip(param_names, param_labels, strict=False): + est_col = f"{param}_est" + lci_col = f"{param}_lci" + uci_col = f"{param}_uci" + + if est_col not in contrast_row: + msg = f"Missing required column: {est_col}" + raise ValueError(msg) + + lci = contrast_row[lci_col] + uci = contrast_row[uci_col] + significant = not (lci <= 0 <= uci) + + plot_data.append( + { + "parameter": label, + "estimate": contrast_row[est_col], + "lci": lci, + "uci": uci, + "significant": significant, + } + ) + + if drop_xy: + plot_data = [ + d for d in plot_data if d["parameter"] not in ["Δ X-Value", "Δ Y-Value"] + ] + + return plot_data + + +def _draw_contrast_subplot( + *, + ax: plt.Axes, + data: dict[str, Any], + sig_color: str, + ns_color: str, + linewidth: float, + fontsize: float, + is_leftmost: bool, +) -> None: + """Render a single contrast subplot.""" + # Draw horizontal line at zero + ax.axhline(0, color="darkgray", linewidth=linewidth * 0.8, zorder=1) + + # Determine color based on significance + color = sig_color if data["significant"] else ns_color + + # Draw error bar + lower_error = abs(data["estimate"] - data["lci"]) + upper_error = abs(data["uci"] - data["estimate"]) + ax.errorbar( + 0, + data["estimate"], + yerr=[[lower_error], [upper_error]], + fmt="none", + ecolor="black", + elinewidth=linewidth, + capsize=5, + capthick=linewidth, + zorder=2, + ) + + # Draw point + ax.scatter( + 0, + data["estimate"], + s=linewidth * 120, + c=[color], + edgecolors="black", + linewidths=linewidth, + zorder=3, + ) + + # Set title + ax.set_title(data["parameter"], fontsize=fontsize * 1.05, pad=10) + + # Remove x-axis + ax.set_xlim(-0.4, 0.4) + ax.set_xticks([]) + + # Style y-axis - only show ylabel on leftmost plot + if is_leftmost: + ax.set_ylabel("Difference", fontsize=fontsize, fontweight="bold") + ax.tick_params(axis="y", labelsize=fontsize * 0.9) + + # Apply seaborn style + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.spines["bottom"].set_visible(False) + ax.spines["left"].set_linewidth(1.2) + ax.grid(axis="y", alpha=0.25, linestyle="--", linewidth=0.8) + ax.set_axisbelow(True) + + +def _add_contrast_legend( + fig: Figure, sig_color: str, ns_color: str, fontsize: float +) -> None: + """Add a legend to the contrast plot.""" + legend_elements = [ + Patch( + facecolor=sig_color, + edgecolor="black", + linewidth=1.5, + label="Significant (p < .05)", + ), + Patch( + facecolor=ns_color, + edgecolor="black", + linewidth=1.5, + label="Not Significant", + ), + ] + legend = fig.legend( + handles=legend_elements, + loc="upper center", + bbox_to_anchor=(0.5, 1.0), + ncol=2, + frameon=True, + fontsize=fontsize * 0.95, + edgecolor="gray", + fancybox=False, + ) + legend.get_frame().set_linewidth(1.2) + + +def _draw_circle_base( + ax: plt.Axes, + angles: list[float] | np.ndarray, + amax: float, + fontsize: float = 12, + labels: list[str] | None = None, +) -> None: + """Draw the base circumplex circle with scales. + + Parameters + ---------- + ax + Matplotlib axes to draw on. + angles + Angular positions in degrees for displacement scale. + amax + Maximum amplitude value for scale. + fontsize + Font size for labels in points. + labels + Labels for each angle. If None, uses degree symbols (e.g., "90°"). + + """ + # Default labels: degree symbols + if labels is None: + labels = [f"{int(angle)}°" for angle in angles] + elif len(labels) != len(angles): + msg = f"labels must have same length as angles ({len(angles)})" + raise ValueError(msg) + + # Set up axes + ax.set_aspect("equal") + ax.set_xlim(-6.5, 6.5) + ax.set_ylim(-6.5, 6.5) + ax.axis("off") + + # Draw outer circle (radius 5) + outer_circle = mpatches.Circle( + (0, 0), + 5, + fill=True, + facecolor="white", + edgecolor="gray", + linewidth=1.5, + ) + ax.add_patch(outer_circle) + + # Draw radial segments for displacement scale + angles_rad = np.radians(angles) + for angle_rad in angles_rad: + x_end = 5 * np.cos(angle_rad) + y_end = 5 * np.sin(angle_rad) + ax.plot([0, x_end], [0, y_end], color="gray", linewidth=0.5, alpha=0.6) + + # Draw amplitude circles (radii 1-4) + for radius in range(1, 5): + circle = mpatches.Circle( + (0, 0), + radius, + fill=False, + edgecolor="gray", + linewidth=0.5, + alpha=0.6, + ) + ax.add_patch(circle) + + # Draw amplitude scale labels (at positions 2 and 4 on x-axis) + amp_values = np.linspace(0, amax, 6) + for radius, amp_val in zip([2, 4], [amp_values[2], amp_values[4]], strict=False): + ax.text( + radius, + 0, + f"{amp_val:.2f}", + ha="center", + va="center", + fontsize=fontsize * 0.8, + bbox={ + "boxstyle": "round,pad=0.3", + "facecolor": "white", + "edgecolor": "none", + }, + ) + + # Draw displacement scale labels (at radius 5.1) + for label, angle_rad in zip(labels, angles_rad, strict=False): + x_label = 5.1 * np.cos(angle_rad) + y_label = 5.1 * np.sin(angle_rad) + + # Determine alignment based on position + if np.abs(x_label) < 0.5: + ha = "center" + elif x_label > 0: + ha = "left" + else: + ha = "right" + + if np.abs(y_label) < 0.5: + va = "center" + elif y_label > 0: + va = "bottom" + else: + va = "top" + + ax.text( + x_label, + y_label, + label, + ha=ha, + va=va, + fontsize=fontsize * 0.8, + color="gray", + ) + + +def plot_circle( + results_df: pd.DataFrame, + angles: list[float] | np.ndarray, + *, + profile_indices: list[int] | None = None, + amax: float | None = None, + angle_labels: list[str] | None = None, + colors: str | list[str] | None = "Set2", + fontsize: float = 12, + drop_lowfit: bool = False, + figsize: tuple[float, float] = (8, 8), + title: str | None = None, +) -> Figure: + """Plot SSM profiles on a circumplex circle. + + Creates a circular plot showing amplitude and displacement of SSM profiles, + with arc bars representing confidence intervals. Automatically handles both + single and multiple profiles. + + Parameters + ---------- + results_df + DataFrame with SSM results. Must contain columns: + - Label: str, profile name + - e_est, x_est, y_est, a_est, d_est: float, parameter estimates + - e_lci, x_lci, ..., d_uci: float, confidence intervals + - fit_est: float, model fit (0-1) + angles + Angular positions of scales in degrees + (e.g., [90, 135, 180, 225, 270, 315, 360, 45]). + profile_indices + Which rows of results_df to plot. If None, plots all profiles. + amax + Maximum amplitude for scaling. If None, auto-computed using pretty_max(). + angle_labels + Labels for each angle. If None, shows degree symbols (e.g., "90°"). + Pass empty strings to hide labels. + colors + Colors for profiles. Can be: + - Seaborn palette name: "Set2", "husl", "deep", etc. + - List of color specifications: ['red', 'blue'] or ['#FF0000', '#0000FF'] + - None: single blue color with no legend + fontsize + Base font size in points. + drop_lowfit + If True, omit profiles with fit < 0.70. If False, show with dashed borders. + figsize + Figure size in inches (width, height). + title + Title for the plot. If None, no title is added. + + Returns + ------- + Matplotlib Figure object. + + Examples + -------- + Plot all profiles from an SSM analysis: + + >>> from circumplex import ssm_analyze + >>> results = ssm_analyze(data, scales=list(range(8))) + >>> fig = plot_circle(results.results, results.details.angles) + >>> fig.savefig('profiles.png') + + Plot specific profiles with custom styling: + + >>> fig = plot_circle( + ... results.results, + ... results.details.angles, + ... profile_indices=[0, 1], + ... colors="husl", + ... fontsize=14, + ... figsize=(10, 10), + ... ) + + Use custom colors: + + >>> fig = plot_circle( + ... results.results, + ... results.details.angles, + ... colors=['red', 'blue', 'green'], + ... ) + + See Also + -------- + plot_curve : Plot SSM fitted curves with observed scores + plot_contrast : Plot SSM parameter contrasts + + """ + # Validate and prepare data + _validate_results_df(results_df) + plot_df = _prepare_plot_data(results_df, profile_indices, drop_lowfit=drop_lowfit) + + # Determine amax + if amax is None: + if "a_uci" in plot_df.columns: + amax = pretty_max(plot_df["a_uci"].values) + else: + amax = pretty_max(plot_df["a_est"].values) + + # Create figure and draw base + fig, ax = plt.subplots(figsize=figsize) + _draw_circle_base(ax, angles, amax, fontsize, angle_labels) + + # Scale factor: radius 5 corresponds to amax + scale_factor = 5.0 / amax + + # Set up colors and legend + n_profiles = len(plot_df) + color_list, show_legend = _setup_colors(n_profiles, colors) + + # Plot each profile + for i, (_idx, row) in enumerate(plot_df.iterrows()): + color = color_list[i] + label = row["Label"] + + # Scale parameters to circle coordinates + x_plot = row["x_est"] * scale_factor + y_plot = row["y_est"] * scale_factor + + # Draw confidence interval arc if available + ci_cols = ["a_lci", "a_uci", "d_lci", "d_uci"] + has_ci = all(col in row and not pd.isna(row[col]) for col in ci_cols) + + if has_ci: + a_lci_plot = row["a_lci"] * scale_factor + a_uci_plot = row["a_uci"] * scale_factor + d_lci = row["d_lci"] + d_uci = row["d_uci"] + + # Handle displacement wrapping (CI crosses 0/360) + if d_uci < d_lci: + d_uci += 360 + + # Draw arc bar (wedge) + wedge = mpatches.Wedge( + center=(0, 0), + r=a_uci_plot, + theta1=d_lci, + theta2=d_uci, + width=a_uci_plot - a_lci_plot, + facecolor=color, + edgecolor=color, + alpha=0.4, + linestyle=row["linestyle"], + linewidth=1.0, + ) + ax.add_patch(wedge) + + # Draw point at (x, y) + ax.scatter( + x_plot, + y_plot, + s=100, + facecolor=color, + edgecolor="black", + linewidth=1.0, + zorder=10, + label=label if show_legend else None, + ) + + # Add legend if multiple profiles + if show_legend: + ax.legend( + title="Profile", + fontsize=fontsize * 0.9, + title_fontsize=fontsize, + loc="upper left", + bbox_to_anchor=(1.02, 1), + frameon=True, + ) + + # Add title if provided + if title is not None: + fig.suptitle(title, fontsize=fontsize * 1.2, fontweight="bold") + + plt.tight_layout() + + return fig + + +def _plot_single_curve( + ax: plt.Axes, + angles: np.ndarray, + angles_sorted: np.ndarray, + observed_scores: np.ndarray, + scores_sorted: np.ndarray, + result_row: pd.Series, + c_scores: str, + c_fit: str, + tick_labels: list[str], + xlabel: str, + base_size: float, + *, + incl_pred: bool, + incl_fit: bool, + incl_disp: bool, + incl_amp: bool, + incl_elev: bool, +) -> None: + """Plot a single SSM curve on an axes. + + Parameters + ---------- + ax + Matplotlib axes to plot on. + angles + Angular positions (original order). + angles_sorted + Angular positions (sorted order). + observed_scores + Observed scores (original order). + scores_sorted + Observed scores (sorted order). + result_row + Row from results DataFrame with SSM parameters. + color + RGB color tuple for the fitted curve. + tick_labels + Labels for x-axis ticks. + xlabel + Label for x-axis. + base_size + Base font size. + + """ + # Plot observed scores as points (at original positions) + ax.plot( + angles, + observed_scores, + "o", + color=c_scores, + # markersize=6, # noqa: ERA001 + # zorder=3, # noqa: ERA001 + label="Observed", + ) + + # Connect observed scores with lines (using sorted order) + ax.plot( + angles_sorted, + scores_sorted, + "-", + color=c_scores, + # linewidth=0.8, # noqa: ERA001 + # alpha=0.5, # noqa: ERA001 + zorder=2, + ) + + # Generate fitted curve + amplitude = result_row["a_est"] + displacement = result_row["d_est"] + elevation = result_row["e_est"] + r2 = result_row["fit_est"] + + if incl_pred: + angle_range = np.linspace(min(angles), max(angles), 100) + fitted_scores = elevation + amplitude * np.cos( + np.radians(angle_range - displacement) + ) + + # Determine line style based on fit + linestyle = "solid" if r2 >= 0.70 else "dashed" + + # Plot fitted curve + ax.plot( + angle_range, + fitted_scores, + linestyle=linestyle, + color=c_fit, + # linewidth=2.0, # noqa: ERA001 + # zorder=4, # noqa: ERA001 + label="Fitted", + ) + + # Annotate parameters + ymin, ymax = ax.get_ylim() + y_offset = (ymax - ymin) * 0.2 + curve_min = displacement - 180 if displacement >= 180 else displacement + 180 + + if incl_disp: + ax.axvline(displacement, color="gray", linestyle="--", linewidth=1.0, alpha=0.7) + ax.text( + displacement, + max(fitted_scores) - y_offset, + f"d = {int(displacement)}°", + horizontalalignment="center", + verticalalignment="center", + bbox={"facecolor": "white"}, + fontsize=base_size * 0.8, + ) + if incl_amp: + ax.axhline( + amplitude + elevation, + color="gray", + linestyle="--", + linewidth=1.0, + alpha=0.7, + ) + ax.text( + curve_min, + elevation + amplitude, + f"a = {amplitude:.2f}", + horizontalalignment="center", + verticalalignment="center", + bbox={"facecolor": "white"}, + fontsize=base_size * 0.8, + ) + if incl_fit: + ax.text( + curve_min, + elevation + (amplitude * 0.5), + f"R² = {r2:.2f}", + horizontalalignment="center", + verticalalignment="center", + bbox={"facecolor": "white"}, + fontsize=base_size * 0.8, + ) + if incl_elev: + ax.axhline(elevation, color="gray", linestyle="--", linewidth=1.0, alpha=0.7) + ax.text( + curve_min, + elevation, + f"e = {elevation:.2f}", + horizontalalignment="center", + verticalalignment="center", + bbox={"facecolor": "white"}, + fontsize=base_size * 0.8, + ) + + # Set x-axis ticks and labels + ax.set_xticks(angles) + ax.set_xticklabels(tick_labels, rotation=45, ha="right") + + # Add title with profile label + ax.set_title(result_row["Label"], fontsize=base_size * 1.1, fontweight="bold") + + # Add axis labels + ax.set_xlabel(xlabel, fontsize=base_size) + ax.set_ylabel("Score", fontsize=base_size) + + # Apply seaborn style + ax.grid(axis="x", alpha=0.5, linestyle="-", linewidth=0.5) + ax.grid(axis="y", alpha=0.5, linestyle="-", linewidth=0.5) + ax.set_axisbelow(True) + + +def plot_curve( + results_df: pd.DataFrame, + scores_df: pd.DataFrame, + angles: list[float] | np.ndarray, + *, + profile_indices: list[int] | None = None, + angle_labels: list[str] | None = None, + c_scores: str = "red", + c_fit: str = "black", + base_size: float = 11, + drop_lowfit: bool = False, + figsize: tuple[float, float] | None = None, + incl_pred: bool = True, + incl_fit: bool = False, + incl_disp: bool = False, + incl_amp: bool = False, + incl_elev: bool = False, +) -> Figure: + """Plot SSM fitted curves with observed scores. + + Creates a faceted plot showing the fitted cosine curve overlaid on the + observed circumplex scale scores. Each profile is shown in a separate subplot. + + Parameters + ---------- + results_df + DataFrame with SSM results. Must contain columns: + - Label: str, profile name + - e_est, a_est, d_est: float, parameter estimates + - fit_est: float, model fit (0-1) + scores_df + DataFrame with observed circumplex scores. Must have columns: + - Label: str, profile name (matching results_df) + - Scale columns: float, one column per circumplex scale + angles + Angular positions of scales in degrees, matching score column order. + profile_indices + Which rows to plot. If None, plots all profiles. + angle_labels + Labels for each angle on x-axis. If None, shows degree symbols (e.g., "90°"). + colors + Colors for profiles. Can be: + - Seaborn palette name: "Set2", "husl", "deep", etc. + - List of color specifications: ['red', 'blue'] or ['#FF0000', '#0000FF'] + - None: single blue color + base_size + Base font size in points for labels and text. + drop_lowfit + If True, omit profiles with fit < 0.70. If False, show with dashed curves. + figsize + Figure size in inches (width, height). If None, auto-computed based on + number of profiles. + + Returns + ------- + Matplotlib Figure object. + + Examples + -------- + Plot curves from an SSM analysis: + + >>> from circumplex import ssm_analyze + >>> results = ssm_analyze(data, scales=list(range(8))) + >>> fig = plot_curve(results.results, results.scores, results.details.angles) + >>> fig.savefig('curves.png') + + Use custom angle labels: + + >>> fig = plot_curve( + ... results.results, + ... results.scores, + ... results.details.angles, + ... angle_labels=['PA', 'BC', 'DE', 'FG', 'HI', 'JK', 'LM', 'NO'], + ... ) + + See Also + -------- + plot_circle : Plot SSM profiles on a circumplex circle + plot_contrast : Plot SSM parameter contrasts + + """ + # Validate results + _validate_results_df(results_df) + + # Prepare plot data (filter profiles, handle low fit) + plot_results = _prepare_plot_data( + results_df, profile_indices, drop_lowfit=drop_lowfit + ) + + # Filter scores to match plot_results + plot_scores = scores_df[scores_df["Label"].isin(plot_results["Label"])].copy() + + n_profiles = len(plot_results) + if n_profiles == 0: + msg = "No profiles to plot" + raise ValueError(msg) + + # Determine subplot layout + ncols = min(3, n_profiles) + nrows = (n_profiles + ncols - 1) // ncols + + # Auto-compute figure size if not provided + if figsize is None: + figsize = (ncols * 6, nrows * 4) + + # Set up colors + # color_list, _ = _setup_colors(n_profiles, colors) # noqa: ERA001 + + # Prepare angle labels for x-axis + if angle_labels is None: + xlabel = "Angle" + tick_labels = [f"{int(a)}°" for a in angles] + else: + xlabel = "Scale" + if len(angle_labels) != len(angles): + msg = f"angle_labels must have same length as angles ({len(angles)})" + raise ValueError(msg) + tick_labels = angle_labels + + # Create figure with subplots + fig, axes = plt.subplots(nrows, ncols, figsize=figsize, squeeze=False) + # Convert ndarray of Axes to a plain list with proper typing for type checkers + axes_flat: list[plt.Axes] = [cast("plt.Axes", a) for a in axes.flatten()] + + # Hide unused subplots + for idx in range(n_profiles, len(axes_flat)): + axes_flat[idx].set_visible(False) + + # Get scale column names (everything except Label, Model, Fit) + info_cols = {"Label", "Model", "Fit"} + scale_cols = [col for col in plot_scores.columns if col not in info_cols] + + if len(scale_cols) != len(angles): + msg = ( + f"Number of scale columns ({len(scale_cols)}) must match " + f"angles ({len(angles)})" + ) + raise ValueError(msg) + + # Prepare angles array for sorting + angles_array = np.array(angles) + + # Plot each profile + for idx, (_ridx, result_row) in enumerate(plot_results.iterrows()): + ax = axes_flat[idx] + label = result_row["Label"] + + # Get scores for this profile + score_row = plot_scores[plot_scores["Label"] == label].iloc[0] + observed_scores = score_row[scale_cols].to_numpy().astype(float) + + # Sort angles and scores together for proper line connection + sorted_indices = np.argsort(angles_array) + angles_sorted = angles_array[sorted_indices] + scores_sorted = observed_scores[sorted_indices] + + # Plot using helper function + _plot_single_curve( + ax, + angles_array, + angles_sorted, + observed_scores, + scores_sorted, + result_row, + c_scores, + c_fit, + tick_labels, + xlabel, + base_size, + incl_pred=incl_pred, + incl_fit=incl_fit, + incl_disp=incl_disp, + incl_amp=incl_amp, + incl_elev=incl_elev, + ) + + plt.tight_layout() + + return fig + + +def plot_contrast( + results_df: pd.DataFrame, + *, + drop_xy: bool = False, + sig_color: str = "#fc8d62", + ns_color: str = "white", + linewidth: float = 1.25, + fontsize: float = 12, + figsize: tuple[float, float] | None = None, +) -> Figure: + """Plot SSM parameter contrasts with confidence intervals. + + Creates a faceted plot showing the difference between two profiles for each + SSM parameter (elevation, x-value, y-value, amplitude, displacement). Points + are colored based on statistical significance (whether CI includes zero). + + This function requires results from a contrast analysis (e.g., comparing two + groups or measures). + + Parameters + ---------- + results_df + DataFrame with SSM contrast results. Must contain the contrast row + (typically the last row) with columns: + - Label: str, contrast label (e.g., "Group 1 - Group 2") + - e_est, x_est, y_est, a_est, d_est: float, parameter differences + - e_lci, x_lci, ..., d_uci: float, confidence intervals + drop_xy + Whether to omit x-value and y-value parameters from the plot. This can + simplify the plot when only interested in elevation, amplitude, and + displacement (default = False). + sig_color + Color for significant contrasts (CI excludes zero). + ns_color + Color for non-significant contrasts (CI includes zero). + linewidth + Width of error bars and point outlines in points. + fontsize + Base font size in points for labels and text. + figsize + Figure size in inches (width, height). If None, uses (10, 4) for all + parameters or (7, 4) if drop_xy=True. + + Returns + ------- + Matplotlib Figure object. + + Examples + -------- + Plot contrasts from an SSM analysis: + + >>> from circumplex import ssm_analyze + >>> results = ssm_analyze( + ... data, scales=list(range(8)), + ... grouping='condition', contrast=True + ... ) + >>> fig = plot_contrast(results.results) + >>> fig.savefig('contrasts.png') + + Drop x and y parameters for simpler plot: + + >>> fig = plot_contrast(results.results, drop_xy=True) + + Use custom colors: + + >>> fig = plot_contrast( + ... results.results, + ... sig_color='red', + ... ns_color='lightgray', + ... ) + + See Also + -------- + plot_circle : Plot SSM profiles on a circumplex circle + plot_curve : Plot SSM fitted curves with observed scores + + """ + # Build data + contrast_row = _get_contrast_row(results_df) + plot_data = _build_contrast_plot_data(contrast_row, drop_xy=drop_xy) + + n_params = len(plot_data) + + # Set figure size + if figsize is None: + figsize = (7, 4) if drop_xy else (10, 4) + + # Create figure with subplots + fig, axes = plt.subplots( + 1, n_params, figsize=figsize, sharey=False, constrained_layout=False + ) + + # Normalize axes into a list of Axes for consistent typing/iteration + if n_params == 1: + axes_list: list[plt.Axes] = [cast("plt.Axes", axes)] + else: + axes_list = [cast("plt.Axes", a) for a in cast("np.ndarray", axes)] + + # Plot each parameter + for i, (ax, data) in enumerate(zip(axes_list, plot_data, strict=False)): + _draw_contrast_subplot( + ax=ax, + data=data, + sig_color=sig_color, + ns_color=ns_color, + linewidth=linewidth, + fontsize=fontsize, + is_leftmost=(i == 0), + ) + + # Add legend with better positioning + _add_contrast_legend(fig, sig_color, ns_color, fontsize) + + # Add contrast label as suptitle + contrast_label = contrast_row["Label"] + fig.suptitle( + f"Contrast: {contrast_label}", + fontsize=fontsize * 1.15, + fontweight="bold", + y=0.88, + ) + + plt.tight_layout(rect=[0, 0, 1, 0.86]) + + return fig From 5b9c619b403d7601c5d8826e35047c5c31b3dc02 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:53:08 +0000 Subject: [PATCH 85/97] Update core package structure and remove obsolete instrument module --- src/circumplex/core/__init__.py | 12 ++-- src/circumplex/core/instrument.py | 116 ------------------------------ 2 files changed, 4 insertions(+), 124 deletions(-) delete mode 100644 src/circumplex/core/instrument.py diff --git a/src/circumplex/core/__init__.py b/src/circumplex/core/__init__.py index ed205cf..0d7740e 100644 --- a/src/circumplex/core/__init__.py +++ b/src/circumplex/core/__init__.py @@ -1,9 +1,5 @@ -from instrument import Instrument, instruments +"""Core circumplex analysis functions.""" -__all__ = [ - "ssm_analyze", - "SSMResults", - "ssm_plot", - "Instrument", - "instruments", -] +from circumplex.core.parameters import ssm_parameters + +__all__ = ["ssm_parameters"] diff --git a/src/circumplex/core/instrument.py b/src/circumplex/core/instrument.py deleted file mode 100644 index d901aab..0000000 --- a/src/circumplex/core/instrument.py +++ /dev/null @@ -1,116 +0,0 @@ -from typing import Any, Dict - -import pandas as pd - - -class Instrument: - def __init__( - self, - scales: pd.DataFrame, - anchors: pd.DataFrame, - items: pd.DataFrame, - norms: Dict[str, Any], - details: Dict[str, Any], - ): - self.scales = scales - self.anchors = anchors - self.items = items - self.norms = norms - self.details = details - - def __str__(self): - return ( - f"{self.details['Abbrev']}: {self.details['Name']}\n" - f"{self.details['Items']} items, {self.details['Scales']} scales, " - f"{len(self.norms[1])} normative data sets\n" - f"{self.details['Reference']}\n" - f"<{self.details['URL']}>" - ) - - def summary(self, scales=True, anchors=True, items=True, norms=True): - output = [str(self)] - if scales: - output.append("\n" + self.get_scales()) - if anchors: - output.append("\n" + self.get_anchors()) - if items: - output.append("\n" + self.get_items()) - if norms: - output.append("\n" + self.get_norms()) - return "\n".join(output) - - def get_scales(self, items=False): - output = [ - f"The {self.details['Abbrev']} contains {self.details['Scales']} circumplex scales." - ] - for _, scale in self.scales.iterrows(): - output.append( - f"{scale['Abbrev']}: {scale['Label']} ({scale['Angle']} degrees)" - ) - if items: - item_nums = [int(i) for i in scale["Items"].split(",")] - for num in item_nums: - item = self.items.loc[self.items["Number"] == num, "Text"].iloc[0] - output.append(f" {num}. {item}") - return "\n".join(output) - - def get_items(self): - output = [ - f"The {self.details['Abbrev']} contains {self.details['Items']} items ({self.details['Status']}):" - ] - for _, item in self.items.iterrows(): - if not pd.isna(item["Number"]): - output.append(f"{item['Number']}. {item['Text']}") - else: - output.append(item["Text"]) - return "\n".join(output) - - def get_anchors(self): - output = [ - f"The {self.details['Abbrev']} is rated using the following {len(self.anchors)}-point scale." - ] - for _, anchor in self.anchors.iterrows(): - output.append(f"{anchor['Value']}. {anchor['Label']}") - return "\n".join(output) - - def get_norms(self): - samples = self.norms[1] - n_norms = len(samples) - if n_norms == 0: - return f"The {self.details['Abbrev']} currently has no normative data sets." - - output = [ - f"The {self.details['Abbrev']} currently has {n_norms} normative data set(s):" - ] - for i, sample in samples.iterrows(): - output.extend( - [ - f"{sample['Sample']}. {sample['Size']} {sample['Population']}", - sample["Reference"], - f"<{sample['URL']}>", - ] - ) - return "\n".join(output) - - -def instruments(): - return """The circumplex package currently includes 13 instruments: -1. CSIE: Circumplex Scales of Interpersonal Efficacy (csie) -2. CSIG: Circumplex Scales of Intergroup Goals (csig) -3. CSIP: Circumplex Scales of Interpersonal Problems (csip) -4. CSIV: Circumplex Scales of Interpersonal Values (csiv) -5. IGI-CR: Interpersonal Goals Inventory for Children, Revised Version (igicr) -6. IIP-32: Inventory of Interpersonal Problems, Brief Version (iip32) -7. IIP-64: Inventory of Interpersonal Problems (iip64) -8. IIP-SC: Inventory of Interpersonal Problems, Short Circumplex (iipsc) -9. IIS-32: Inventory of Interpersonal Strengths, Brief Version (iis32) -10. IIS-64: Inventory of Interpersonal Strengths (iis64) -11. IIT-C: Inventory of Influence Tactics Circumplex (iitc) -12. IPIP-IPC: IPIP Interpersonal Circumplex (ipipipc) -13. ISC: Interpersonal Sensitivities Circumplex (isc)""" - - -def instrument(code: str): - # This function would load the instrument data from a file or database - # For now, we'll just return a placeholder - return f"Instrument data for {code}" From eedefaadbda9020209e644edb7d7143c8e648643 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:55:02 +0000 Subject: [PATCH 86/97] Remove legacy JSON instrument definitions --- src/circumplex/instruments/CSIP.json | 134 -------------------- src/circumplex/instruments/IIPSC.json | 151 ----------------------- src/circumplex/instruments/SATP-eng.json | 55 --------- src/circumplex/instruments/SSQP-eng.json | 55 --------- 4 files changed, 395 deletions(-) delete mode 100644 src/circumplex/instruments/CSIP.json delete mode 100644 src/circumplex/instruments/IIPSC.json delete mode 100644 src/circumplex/instruments/SATP-eng.json delete mode 100644 src/circumplex/instruments/SSQP-eng.json diff --git a/src/circumplex/instruments/CSIP.json b/src/circumplex/instruments/CSIP.json deleted file mode 100644 index 411d11b..0000000 --- a/src/circumplex/instruments/CSIP.json +++ /dev/null @@ -1,134 +0,0 @@ -{ - "details": { - "name": "Circumplex Scales of Interpersonal Problems", - "abbrev": "CSIP", - "inst_items": 64, - "scales": 8, - "prefix": "", - "suffix": "", - "status": "open-access", - "construct": "interpersonal problems", - "reference": "Boudreaux, Ozer, Oltmanns, & Wright (2018)", - "url": "https://doi.org/10.1037/pas0000505" - }, - "anchors": { - "0": "Not a problem", - "1": "Minor problem", - "2": "Moderate problem", - "3": "Serious problem" - }, - "scales": { - "PA": { - "label": "Domineering", - "angle": 90, - "inst_items": { - "1": "Bossing around other people too much", - "9": "Verbally or physically abusing others", - "17": "Starting arguments and conflicts with others", - "25": "Trying to influence or control other people too much", - "33": "Dominating or intimidating others", - "41": "Acting aggressively toward others", - "49": "Manipulating other people to get what I want", - "57": "Acting superior or condescending toward others" - } - }, - "BC": { - "label": "Self-Centered", - "angle": 135, - "inst_items": { - "2": "Acting rude and inconsiderate toward others", - "10": "Acting selfishly with others", - "18": "Being unable to feel guilt or remorse", - "26": "Lacking respect for other people's beliefs, attitudes, or opinions", - "34": "Having trouble getting along with others", - "42": "Being insensitive to the thoughts, feelings, and needs of others", - "50": "Disliking most people", - "58": "Having trouble giving emotional or moral support to others" - } - }, - "DE": { - "label": "Distant", - "angle": 180, - "inst_items": { - "3": "Pushing away from other people who get too close", - "11": "Difficulty showing love and affection to others", - "19": "Being unable to enjoy the company of others", - "27": "Feeling emotionally disconnected from others", - "35": "Difficulty developing close and lasting relationships", - "43": "Being unable to fully connect with others", - "51": "Difficulty opening up to others", - "59": "Feeling uncomfortable with being close or intimate with others" - } - }, - "FG": { - "label": "Socially Inhibited", - "angle": 225, - "inst_items": { - "4": "Difficulty making friends", - "12": "Having trouble fitting in with others", - "20": "Avoiding people or social situations", - "28": "Being unable to keep conversations going", - "36": "Feeling like an outsider in most social situations", - "44": "Being unable to be myself around others", - "52": "Feeling fearful or nervous in social situations", - "60": "Acting shy around others" - } - }, - "HI": { - "label": "Nonassertive", - "angle": 270, - "inst_items": { - "5": "Lacking self-confidence", - "13": "Getting easily embarrassed in front of others", - "21": "Difficulty taking the lead", - "29": "Having trouble asserting myself", - "37": "Feeling weak and insecure around dominant others", - "45": "Being unable to stand up to others", - "53": "Avoiding confrontation when problems arise", - "61": "Letting other people make decisions too often" - } - }, - "JK": { - "label": "Exploitable", - "angle": 315, - "inst_items": { - "6": "Letting other people boss me around too much", - "14": "Acting overly submissive with others", - "22": "Being unable to express anger toward others", - "30": "Being too concerned about what other people think", - "38": "Being easily taken advantage of", - "46": "Compromising with other people too much", - "54": "Being easily influenced by others", - "62": "Being unable to say 'no'" - } - }, - "LM": { - "label": "Self-Sacrificing", - "angle": 360, - "inst_items": { - "7": "Putting other people's needs before my own too much", - "15": "Giving too much to others", - "23": "Forgiving people too easily", - "31": "Being overly sentimental or tender-hearted", - "39": "Being easily affected by the pain and suffering of others", - "47": "Trusting people too easily", - "55": "Trying to solve other people's problems too much", - "63": "Getting too attached to others" - } - }, - "NO": { - "label": "Intrusive", - "angle": 45, - "inst_items": { - "8": "Being overly affectionate with others", - "16": "Difficulty keeping personal matters private from others", - "24": "Talking too much", - "32": "Flirting with other people too much", - "40": "Having trouble respecting other people's privacy", - "48": "Exaggerating so that other people will respect me", - "56": "Confronting people too quickly about problems", - "64": "Needing to be the center of attention" - } - } - } -} diff --git a/src/circumplex/instruments/IIPSC.json b/src/circumplex/instruments/IIPSC.json deleted file mode 100644 index dbc3e25..0000000 --- a/src/circumplex/instruments/IIPSC.json +++ /dev/null @@ -1,151 +0,0 @@ -{ - "details": { - "name": "Inventory of Interpersonal Problems Short Circumplex", - "abbrev": "IIP-SC", - "inst_items": 32, - "scales": 8, - "prefix": "", - "suffix": "", - "status": "partial text", - "construct": "interpersonal problems", - "reference": "Soldz, Budman, Demby, & Merry (1995)", - "url": "https://doi.org/10.1177/1073191195002001006" - }, - "anchors": { - "0": "Not at all", - "1": "Somewhat", - "2": "Moderately", - "3": "Very", - "4": "Extremely" - }, - "norms": { - "sample": [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2], - "scale": [ - "PA", - "BC", - "DE", - "FG", - "HI", - "JK", - "LM", - "NO", - "PA", - "BC", - "DE", - "FG", - "HI", - "JK", - "LM", - "NO" - ], - "angle": [ - 90, 135, 180, 225, 270, 315, 360, 45, 90, 135, 180, 225, 270, 315, 360, 45 - ], - "m": [ - 0.76, 0.7925, 0.9, 1.0475, 1.42, 1.385, 1.465, 1.025, 0.99, 0.97, 1.3, - 1.33, 1.81, 1.92, 2.14, 1.43 - ], - "sd": [ - 0.66, 0.69, 0.855, 0.9475, 0.915, 0.8525, 0.825, 0.8, 0.82, 0.85, 1.07, - 0.98, 0.89, 0.89, 0.9, 1.05 - ] - }, - "norms_src": { - "sample": [1, 2], - "size": [872, 106], - "population": [ - "American college students", - "American psychiatric outpatients" - ], - "reference": [ - "Hopwood, Pincus, DeMoor, & Koonce (2011)", - "Soldz, Budman, Demby, & Merry (1995)" - ], - "url": [ - "https://doi.org/10.1080/00223890802388665", - "https://doi.org/10.1177/1073191195002001006" - ] - }, - "scales": { - "PA": { - "label": "Domineering", - "angle": 90, - "inst_items": { - "1": "...point of view...", - "9": "...too aggressive toward...", - "17": " ...control other people...", - "25": " ...argue with other..." - } - }, - "BC": { - "label": "Vindictive", - "angle": 135, - "inst_items": { - "2": "...supportive of another...", - "10": "...another person's happiness...", - "18": "...too suspicious of...", - "26": "...revenge against people..." - } - }, - "DE": { - "label": "Cold", - "angle": 180, - "inst_items": { - "3": "...show affection to...", - "11": "...feeling of love...", - "19": "...feel close to...", - "27": "...at a distance..." - } - }, - "FG": { - "label": "Socially Avoidant", - "angle": 225, - "inst_items": { - "4": "...join in on...", - "12": "...introduce myself to...", - "20": "...socialize with other...", - "28": "...get together socially..." - } - }, - "HI": { - "label": "Nonassertive", - "angle": 270, - "inst_items": { - "5": "...stop bothering me...", - "13": "...confront people with...", - "21": "...assertive with another...", - "29": "...to be firm..." - } - }, - "JK": { - "label": "Exploitable", - "angle": 315, - "inst_items": { - "6": "...I am angry...", - "14": "...assertive without worrying...", - "22": "...too easily persuaded...", - "30": "...people take advantage..." - } - }, - "LM": { - "label": "Overly Nurturant", - "angle": 360, - "inst_items": { - "7": "...my own welfare...", - "15": "...please other people...", - "23": "...other people's needs...", - "31": "...another person's misery..." - } - }, - "NO": { - "label": "Intrusive", - "angle": 45, - "inst_items": { - "8": "...keep things private...", - "16": "...open up to...", - "24": "...noticed too much...", - "32": "...tell personal things..." - } - } - } -} diff --git a/src/circumplex/instruments/SATP-eng.json b/src/circumplex/instruments/SATP-eng.json deleted file mode 100644 index 370df98..0000000 --- a/src/circumplex/instruments/SATP-eng.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "details": { - "name": "Soundscape Attributes Translation Project - English Translation", - "abbrev": "SATP-eng", - "inst_items": 8, - "scales": 8, - "prefix": "For each of the 8 scales below, to what extent do you agree or disagree that the present surrounding sound environment is...", - "suffix": "", - "status": "open-access", - "construct": "soundscape circumplex", - "reference": "Aletta, Mitchell, et.al. (2024)", - "url": "" - }, - "anchors": { - "0": "Strongly disagree", - "25": "Somewhat disagree", - "50": "Neither agree nor disagree", - "75": "Somewhat agree", - "100": "Strongly agree" - }, - "scales": { - "PAQ1": { - "label": "pleasant", - "angle": 0 - }, - "PAQ2": { - "label": "vibrant", - "angle": 46 - }, - "PAQ3": { - "label": "eventful", - "angle": 93 - }, - "PAQ4": { - "label": "chaotic", - "angle": 138 - }, - "PAQ5": { - "label": "annoying", - "angle": 178 - }, - "PAQ6": { - "label": "monotonous", - "angle": 228 - }, - "PAQ7": { - "label": "uneventful", - "angle": 272 - }, - "PAQ8": { - "label": "calm", - "angle": 340 - } - } -} diff --git a/src/circumplex/instruments/SSQP-eng.json b/src/circumplex/instruments/SSQP-eng.json deleted file mode 100644 index 89b8d3c..0000000 --- a/src/circumplex/instruments/SSQP-eng.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "details": { - "name": "Swedish Soundscape Quality Protocol - English Translation", - "abbrev": "SSQP-eng", - "inst_items": 8, - "scales": 8, - "prefix": "For each of the 8 scales below, to what extent do you agree or disagree that the present surrounding sound environment is...", - "suffix": "", - "status": "open-access", - "construct": "soundscape circumplex", - "reference": "Axelsson, Nilsson, & Berglund (2012)", - "url": "https://doi.org/10.1121/1.4709112" - }, - "anchors": { - "1": "Strongly disagree", - "2": "Somewhat disagree", - "3": "Neither agree nor disagree", - "4": "Somewhat agree", - "5": "Strongly agree" - }, - "scales": { - "PAQ1": { - "label": "pleasant", - "angle": 0 - }, - "PAQ2": { - "label": "vibrant", - "angle": 46 - }, - "PAQ3": { - "label": "eventful", - "angle": 93 - }, - "PAQ4": { - "label": "chaotic", - "angle": 138 - }, - "PAQ5": { - "label": "annoying", - "angle": 178 - }, - "PAQ6": { - "label": "monotonous", - "angle": 228 - }, - "PAQ7": { - "label": "uneventful", - "angle": 272 - }, - "PAQ8": { - "label": "calm", - "angle": 340 - } - } -} From 8d6b82a55d1f8b866c5c21e2574177a001081bc0 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:55:02 +0000 Subject: [PATCH 87/97] Add instrument data models and registry system --- src/circumplex/instruments/models.py | 439 +++++++++++++++++++++++++++ 1 file changed, 439 insertions(+) create mode 100644 src/circumplex/instruments/models.py diff --git a/src/circumplex/instruments/models.py b/src/circumplex/instruments/models.py new file mode 100644 index 0000000..a99b2ac --- /dev/null +++ b/src/circumplex/instruments/models.py @@ -0,0 +1,439 @@ +"""Instrument data models.""" + +from __future__ import annotations + +from collections.abc import Iterable +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +from circumplex._utils import is_package_installed + +console = None # Will be set if rich is available +if is_package_installed("rich"): + from rich.console import Group + from rich.table import Table + from rich.text import Text + from rich.tree import Tree + + from circumplex import _utils + + console = getattr(_utils, "console", None) + + +@dataclass(frozen=True) +class InstrumentScale: + """Single scale within an instrument.""" + + abbrev: str + angle: float # degrees + items: tuple[int, ...] # immutable + label: str + + +@dataclass(frozen=True) +class ResponseAnchor: + """Response option for an instrument.""" + + value: int + label: str + + +@dataclass(frozen=True) +class ResponseItem: + """Single item within an instrument.""" + + item_id: int + text: str + + +@dataclass(frozen=True) +class NormativeSample: + """Normative sample metadata and statistics.""" + + sample_id: int + size: int + population: str + reference: str + url: str + statistics: pd.DataFrame # columns: scale, mean, sd, etc. + + +@dataclass(frozen=True) +class Instrument: + """Circumplex instrument definition.""" + + # Metadata + name: str + abbrev: str + construct: str + reference: str + url: str + status: str # "open-access" or "limited" + + # Structure + scales: tuple[InstrumentScale, ...] + anchors: tuple[ResponseAnchor, ...] + items: tuple[ResponseItem, ...] | None = None # Full item text (if available) + + # Normative data + norms: tuple[NormativeSample, ...] = () + + # Formatting + prefix: str = "" + suffix: str = "" + + @property + def n_scales(self) -> int: + """Number of scales in the instrument.""" + return len(self.scales) + + @property + def n_items(self) -> int: + """Number of items in the instrument.""" + return len(self.items) if self.items else 0 + + @property + def scale_labels(self) -> list[str]: + """Get names of all scales.""" + return [scale.label for scale in self.scales] + + @property + def scale_abbrevs(self) -> list[str]: + """Get abbreviations of all scales.""" + return [scale.abbrev for scale in self.scales] + + def get_angles(self) -> list[float]: + """Get angular positions for all scales.""" + return [scale.angle for scale in self.scales] + + def get_scale(self, abbrev: str) -> InstrumentScale: + """Get scale by abbreviation.""" + for scale in self.scales: + if scale.abbrev == abbrev: + return scale + msg = ( + f"Scale with abbreviation '{abbrev}' not found in instrument " + f"'{self.abbrev}'." + ) + raise ValueError(msg) + + def get_item(self, item_id: int) -> ResponseItem: + """Get item by item ID.""" + if self.items is None: + msg = f"Instrument '{self.abbrev}' does not have item text available." + raise ValueError(msg) + for item in self.items: + if item.item_id == item_id: + return item + msg = f"Item with ID '{item_id}' not found in instrument '{self.abbrev}'." + raise ValueError(msg) + + def __repr__(self) -> str: + """Return a human-readable multi-line summary of the instrument.""" + lines = [ + f"{self.abbrev}: {self.name}", + ( + f"{self.n_items} items, {self.n_scales} scales, " + f"{len(self.norms)} normative data sets" + ), + f"{self.reference}", + f"< {self.url} >", + ] + return "\n".join(lines) + + def __rich_repr__(self) -> Iterable[str]: + """Yield lines for rich-rendered representation.""" + yield f"{self.abbrev}: {self.name}" + yield ( + f"{self.n_items} items, {self.n_scales} scales, " + f"{len(self.norms)} normative data sets" + ) + yield f"{self.reference}" + yield f"< {self.url} >" + + def info( + self, + *, + scales: bool = True, + anchors: bool = True, + items: bool = False, + norms: bool = True, + rich_print: bool = True, + ) -> None: + """Print instrument information.""" + if is_package_installed("rich") and rich_print: + info_sections = [ + *self.__rich_repr__(), + ] + if scales: + info_sections.append("\n") + info_sections.append( + self.info_scales(items=items, rich_print=rich_print) + ) + if anchors: + info_sections.append("\n") + info_sections.append(self.info_anchors(rich_print=rich_print)) + if norms: + info_sections.append("\n") + info_sections.append(self.info_norms(rich_print=rich_print)) + info_group = Group(*info_sections) + if console is not None: + console.print(info_group) + else: + print(self) # noqa: T201 + print() # noqa: T201 + if scales: + print(self.info_scales(items=items, rich_print=rich_print)) # noqa: T201 + print() # noqa: T201 + if anchors: + print(self.info_anchors(rich_print=rich_print)) # noqa: T201 + print() # noqa: T201 + if norms: + print(self.info_norms(rich_print=rich_print)) # noqa: T201 + print() # noqa: T201 + + def info_scales( + self, *, items: bool = False, rich_print: bool = True + ) -> str | Tree: + """Return information about instrument scales, optionally with items.""" + if is_package_installed("rich") and rich_print: + tree = Tree( + f"[cyan]The {self.abbrev} contains {self.n_scales} scales:", + style="bold", + guide_style="dim", + ) + for scale in self.scales: + scale_branch = tree.add( + f"{scale.abbrev} ({scale.angle}°): {scale.label}" + ) + if items: + for item_id in scale.items: + scale_branch.add( + f"[dim]{item_id}. {self.items[item_id - 1].text}" + ) + return tree + + text = [f"The {self.abbrev} contains {self.n_scales} scales:"] + for scale in self.scales: + text.append(f" {scale.abbrev}: {scale.label} ({scale.angle}°)") + if items: + for item_id in scale.items: + text.append(f" {item_id}. {self.items[item_id - 1].text}") + return "\n".join(text) + + def info_anchors(self, *, rich_print: bool = True) -> str | Text: + """Return the response anchors for the instrument.""" + lines = [ + ( + f"The {self.abbrev} is rated using the following " + f"{len(self.anchors)}-point scale:" + ) + ] + for anchor in self.anchors: + lines.append(f" {anchor.value}. {anchor.label}") + if is_package_installed("rich") and rich_print: + text = Text() + for i, line in enumerate(lines): + if i == 0: + text.append(line + "\n", style="bold cyan") + else: + text.append(line + "\n") + return text + + return "\n".join(lines) + + def info_norms(self, *, rich_print: bool = True) -> str | Text: + """Return information about available normative samples.""" + lines = [ + ( + f"The {self.abbrev} currently has {len(self.norms)} " + "normative data set(s):\n" + ) + ] + for norm in self.norms: + lines.append(f"{norm.sample_id}. {norm.size} {norm.population}") + lines.append(f" {norm.reference}") + lines.append(f" {norm.url}") + if is_package_installed("rich") and rich_print: + text = Text() + for i, line in enumerate(lines): + if i == 0: + text.append(line + "\n", style="bold cyan") + else: + text.append(line + "\n") + return text + + return "\n".join(lines) + + def score( + self, + data: pd.DataFrame, + items: Iterable[str | int], + prefix: str = "", + suffix: str = "", + *, + na_rm: bool = True, + append: bool = True, + ) -> pd.DataFrame: + """Compute mean scale scores for the instrument. + + Parameters + ---------- + data + DataFrame containing item-level data. + items + Iterable of item names or integer indices in `data`. + prefix, suffix + String affixes to add to resulting scale column names. + na_rm + If True, ignore missing values when computing means. + append + If True, append scores to `data`; else return only scores. + """ + # Extract item data from the provided dataframe + if all( + isinstance(item, (int, np.integer, float, np.floating)) for item in items + ): + item_data = data.iloc[:, items].copy() + elif all(isinstance(item, str) for item in items): + item_data = data.loc[:, items].copy() + else: + msg = "All items in 'items' must be either strings or integers." + raise TypeError(msg) + + scores = pd.DataFrame(index=data.index, columns=self.scale_abbrevs, dtype=float) + for scale in self.scales: + scale_items = [self.get_item(i).item_id - 1 for i in scale.items] + scale_data = item_data.iloc[:, scale_items] + + scale_score = scale_data.mean(axis=1, skipna=na_rm) + scores.loc[:, scale.abbrev] = scale_score + + scores.columns = [f"{prefix}{col}{suffix}" for col in scores.columns] + + if append: + return pd.concat([data, scores], axis=1) + return scores + + def norm_standardize( + self, + data: pd.DataFrame, + scales: Iterable[str | int], + sample_id: int, + prefix: str = "", + suffix: str = "_z", + *, + append: bool = True, + ) -> pd.DataFrame: + """Standardize scale-level data using a normative sample. + + Parameters + ---------- + data + DataFrame containing at least circumplex scales. + scales + The variable names or column numbers for the scales in `data`. + sample_id + The ID of the normative sample to use for standardization. + prefix + Prefix to add to standardized scale names. + suffix + Suffix to add to standardized scale names. + append + If True, append standardized scales to `data`. If False, + return only standardized scales. + + Returns + ------- + DataFrame + DataFrame with standardized scale-level data. + + Raises + ------ + ValueError + If `sample_id` is not found in the instrument's normative samples. + """ + norm_sample = None + for norm in self.norms: + if norm.sample_id == sample_id: + norm_sample = norm + break + if norm_sample is None: + msg = ( + f"Normative sample with ID '{sample_id}' not found in instrument " + f"'{self.abbrev}'." + ) + raise ValueError(msg) + + scores = pd.DataFrame(index=data.index, columns=[], dtype=float) + for scale in scales: + if isinstance(scale, (int, np.integer, float, np.floating)): + scale_abbrev = self.scales[scale].abbrev + else: + scale_abbrev = scale + + scale_data = data.loc[:, scale_abbrev] + norm_stats = norm_sample.statistics + mean_row = norm_stats.loc[norm_stats["scale"] == scale_abbrev] + if mean_row.empty: + msg = ( + f"Normative statistics for scale '{scale_abbrev}' not found in " + f"sample ID '{sample_id}'." + ) + raise ValueError(msg) + mean = mean_row["mean"].to_numpy()[0] + sd = mean_row["sd"].to_numpy()[0] + + standardized_score = (scale_data - mean) / sd + scores[f"{prefix}{scale_abbrev}{suffix}"] = standardized_score + + if append: + return pd.concat([data, scores], axis=1) + return scores + + +# Global registry +_INSTRUMENTS: dict[str, Instrument] = {} + + +def register_instrument(abbrev: str, instrument: Instrument) -> None: + """Register an instrument in the global registry.""" + _INSTRUMENTS[abbrev.lower()] = instrument + + +def get_instrument(abbrev: str) -> Instrument: + """Retrieve an instrument by its abbreviation.""" + key = abbrev.lower() + if key not in _INSTRUMENTS: + available = ", ".join(_INSTRUMENTS.keys()) + msg = f"Instrument '{abbrev}' not found. Available instruments: {available}" + raise ValueError(msg) + return _INSTRUMENTS[key] + + +def show_instruments(*, rich_print: bool = True) -> None: + """List all registered instrument abbreviations.""" + if is_package_installed("rich") and rich_print: + table = Table( + title=( + "The circumplex package currently includes " + f"{len(_INSTRUMENTS)} instruments" + ) + ) + table.add_column("", no_wrap=True) + table.add_column("Abbreviation", style="cyan", no_wrap=True) + table.add_column("Name", style="magenta") + for index, (abbrev, inst) in enumerate(_INSTRUMENTS.items(), start=1): + table.add_row(str(index), abbrev.upper(), inst.name) + if console is not None: # safety if rich not actually available + console.print(table) + + else: + print( # noqa: T201 + "The circumplex package currently includes " + f"{len(_INSTRUMENTS)} instruments:" + ) + for index, (abbrev, inst) in enumerate(_INSTRUMENTS.items(), start=1): + print(f" {index}. {abbrev.upper()}: {inst.name}") # noqa: T201 From 82f425250daee61e98f209ae02f3a6038648b6da Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:55:02 +0000 Subject: [PATCH 88/97] Add instruments package initialization --- src/circumplex/instruments/__init__.py | 27 ++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/circumplex/instruments/__init__.py b/src/circumplex/instruments/__init__.py index e69de29..3c0dca2 100644 --- a/src/circumplex/instruments/__init__.py +++ b/src/circumplex/instruments/__init__.py @@ -0,0 +1,27 @@ +"""Circumplex instrument registry and management. + +This package provides classes and functions for managing circumplex instruments, +including their scales, normative samples, and response items. +""" + +from .models import ( + Instrument, + InstrumentScale, + NormativeSample, + ResponseAnchor, + ResponseItem, + get_instrument, + register_instrument, + show_instruments, +) + +__all__ = [ + "Instrument", + "InstrumentScale", + "NormativeSample", + "ResponseAnchor", + "ResponseItem", + "get_instrument", + "register_instrument", + "show_instruments", +] From d54cee970ca3c3ed2431be623103d756138a2048 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:55:02 +0000 Subject: [PATCH 89/97] Add Python-based instrument definitions --- src/circumplex/instruments/csig.py | 113 +++++++++++++++++++++++ src/circumplex/instruments/iipsc.py | 126 ++++++++++++++++++++++++++ src/circumplex/instruments/ipipipc.py | 109 ++++++++++++++++++++++ 3 files changed, 348 insertions(+) create mode 100644 src/circumplex/instruments/csig.py create mode 100644 src/circumplex/instruments/iipsc.py create mode 100644 src/circumplex/instruments/ipipipc.py diff --git a/src/circumplex/instruments/csig.py b/src/circumplex/instruments/csig.py new file mode 100644 index 0000000..2e24076 --- /dev/null +++ b/src/circumplex/instruments/csig.py @@ -0,0 +1,113 @@ +"""Circumplex Scales of Intergroup Goals (CSIG) instrument definition. + +Reference: + Lock, B. D. (2014). Circumplex scales of intergroup goals: An interpersonal circle + model of goals for interactions between groups. Personality and Social + Psychology Bulletin, 40(4), 433-449. https://kennethlocke.org/CSIG/CSIG.html +""" + +import pandas as pd + +from circumplex.instruments.models import ( + Instrument, + InstrumentScale, + NormativeSample, + ResponseAnchor, + ResponseItem, + register_instrument, +) + +# Define scales +SCALES = ( + InstrumentScale("PA", 90, items=(8, 16, 24, 32), label="Be authoritative"), + InstrumentScale("BC", 135, items=(5, 12, 21, 29), label="Be tough"), + InstrumentScale("DE", 180, items=(2, 10, 18, 26), label="Be self-protective"), + InstrumentScale("FG", 225, items=(7, 15, 23, 31), label="Be wary"), + InstrumentScale("HI", 270, items=(4, 12, 20, 28), label="Be conflict-avoidant"), + InstrumentScale("JK", 315, items=(1, 9, 17, 25), label="Be cooperative"), + InstrumentScale("LM", 360, items=(6, 14, 22, 30), label="Be understanding"), + InstrumentScale("NO", 45, items=(3, 11, 19, 27), label="Be respected"), +) + +ANCHORS = ( + ResponseAnchor(0, "It is not at all important that..."), + ResponseAnchor(1, "It is somewhat important that..."), + ResponseAnchor(2, "It is moderately important that..."), + ResponseAnchor(3, "It is very important that..."), + ResponseAnchor(4, "It is extremely important that..."), +) + +ITEMS = ( + ResponseItem(1, "We are friendly"), + ResponseItem(2, "We are the winners in any argument or dispute"), + ResponseItem(3, "They respect what we have to say"), + ResponseItem(4, "We avoid conflict"), + ResponseItem(5, "We show that we can be tough"), + ResponseItem(6, "We appreciate what they have to offer"), + ResponseItem(7, "We let them fend for themselves"), + ResponseItem(8, "We are assertive"), + ResponseItem(9, "We celebrate their achievements"), + ResponseItem(10, "We do whatever is in our best interest"), + ResponseItem(11, "We get the chance to express our views"), + ResponseItem(12, "They not get angry with us"), + ResponseItem(13, "We not appear vulnerable"), + ResponseItem(14, "We understand their point of view"), + ResponseItem(15, "They stay out of our business"), + ResponseItem(16, "We appear confident"), + ResponseItem(17, "They feel we are all on the same team"), + ResponseItem(18, "We are better than them"), + ResponseItem(19, "They listen to what we have to say"), + ResponseItem(20, "We not get into arguments"), + ResponseItem(21, "We are aggressive if necessary"), + ResponseItem(22, "We show concern for their welfare"), + ResponseItem(23, "We not trust them"), + ResponseItem(24, "We are decisive"), + ResponseItem(25, "We are cooperative"), + ResponseItem(26, "We keep our guard up"), + ResponseItem(27, "They see us as responsible"), + ResponseItem(28, "We not make them angry"), + ResponseItem(29, "We not show our weaknesses"), + ResponseItem(30, "We are able to compromise"), + ResponseItem(31, "We not get entangled in their affairs"), + ResponseItem(32, "They see us as capable"), +) + + +norm_stats = pd.DataFrame( + { + "scale": ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + "angle": [90, 135, 180, 225, 270, 315, 360, 45], + "mean": [2.96, 2.53, 2.02, 1.88, 2.24, 2.89, 2.97, 2.96], + "sd": [0.68, 0.86, 0.88, 0.74, 0.90, 0.76, 0.71, 0.68], + } +) + +NORMS = NormativeSample( + sample_id=1, + size=665, + population="MTurkers from US, Canada, and India about interactions between nations", + reference="Lock (2014)", + url="https://doi.org/10.1177/0146167213514280", + statistics=norm_stats, +) + +# Create Instrument +csig = Instrument( + name="Circumplex Scales of Interpersonal Goals", + abbrev="CSIG", + construct="interpersonal intergroup goals", + reference="Lock (2014)", + url="https://doi.org/10.1177/0146167213514280", + status="open-access", + scales=SCALES, + anchors=ANCHORS, + items=ITEMS, + norms=(NORMS,), + prefix=( + "In dealing with other groups, how important is it" + "that we act or appear or are treated this way?" + ), + suffix="", +) + +register_instrument("csig", csig) diff --git a/src/circumplex/instruments/iipsc.py b/src/circumplex/instruments/iipsc.py new file mode 100644 index 0000000..0897106 --- /dev/null +++ b/src/circumplex/instruments/iipsc.py @@ -0,0 +1,126 @@ +"""Inventory of Interpersonal Problems Short Circumplex (IIP-SC) instrument definition. + +Reference: + Soldz, S., Budman, S., Demby, A., & Merry, J. (1995). A short form of the Inventory + of Interpersonal Problems Circumplex Scales. Assessment, 2(1), 53-63. + https://doi.org/10.1080/00223890802388665 +""" + +import numpy as np +import pandas as pd + +from circumplex.instruments.models import ( + Instrument, + InstrumentScale, + NormativeSample, + ResponseAnchor, + ResponseItem, + register_instrument, +) + +SCALES = ( + InstrumentScale("PA", 90, items=(1, 9, 17, 25), label="Domineering"), + InstrumentScale("BC", 135, items=(2, 10, 18, 26), label="Vindictive"), + InstrumentScale("DE", 180, items=(3, 11, 19, 27), label="Cold"), + InstrumentScale("FG", 225, items=(4, 12, 20, 28), label="Socially avoidant"), + InstrumentScale("HI", 270, items=(5, 13, 21, 29), label="Nonassertive"), + InstrumentScale("JK", 315, items=(6, 14, 22, 30), label="Exploitable"), + InstrumentScale("LM", 360, items=(7, 15, 23, 31), label="Overly nurturant"), + InstrumentScale("NO", 45, items=(8, 16, 24, 32), label="Intrusive"), +) + +ANCHORS = ( + ResponseAnchor(0, "Not at all"), + ResponseAnchor(1, "Somewhat"), + ResponseAnchor(2, "Moderately"), + ResponseAnchor(3, "Very"), + ResponseAnchor(4, "Extremely"), +) + +ITEMS = ( + ResponseItem(1, "...point of view..."), + ResponseItem(2, "...supportive of another..."), + ResponseItem(3, "...show affection to..."), + ResponseItem(4, "...join in on..."), + ResponseItem(5, "...stop bothering me..."), + ResponseItem(6, "...I am angry..."), + ResponseItem(7, "...my own welfare..."), + ResponseItem(8, "...keep things private..."), + ResponseItem(9, "...too aggressive toward..."), + ResponseItem(10, "...another person's happiness..."), + ResponseItem(11, "...feeling of love..."), + ResponseItem(12, "...introduce myself to..."), + ResponseItem(13, "...confront people with..."), + ResponseItem(14, "...assertive without worrying..."), + ResponseItem(15, "...please other people..."), + ResponseItem(16, "...open up to..."), + ResponseItem(17, "...control other people..."), + ResponseItem(18, "...too suspicious of..."), + ResponseItem(19, "...feel close to..."), + ResponseItem(20, "...socialize with other..."), + ResponseItem(21, "...assertive with another..."), + ResponseItem(22, "...too easily persuaded..."), + ResponseItem(23, "...other people's needs..."), + ResponseItem(24, "...noticed too much..."), + ResponseItem(25, "...argue with other..."), + ResponseItem(26, "...revenge against people..."), + ResponseItem(27, "...at a distance..."), + ResponseItem(28, "...get together socially..."), + ResponseItem(29, "...to be firm..."), + ResponseItem(30, "...people take advantage..."), + ResponseItem(31, "...another person's misery..."), + ResponseItem(32, "...tell personal things..."), +) + +norm_1_stats = pd.DataFrame( + { + "scale": ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + "angles": [90, 135, 180, 225, 270, 315, 360, 45], + "mean": np.array([3.04, 3.17, 3.60, 4.19, 5.68, 5.54, 5.86, 4.10]) / 4, + "sd": np.array([2.64, 2.76, 3.42, 3.79, 3.66, 3.41, 3.30, 3.20]) / 4, + } +) + +NORM1 = NormativeSample( + sample_id=1, + size=872, + population="American college students", + reference="Hopwood, Pincus, DeMoor, & Koonce (2011)", + url="https://doi.org/10.1080/00223890802388665", + statistics=norm_1_stats, +) + +norm_2_stats = pd.DataFrame( + { + "scale": ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + "angles": [90, 135, 180, 225, 270, 315, 360, 45], + "mean": [0.99, 0.97, 1.30, 1.33, 1.81, 1.92, 2.14, 1.43], + "sd": [0.82, 0.85, 1.07, 0.98, 0.89, 0.89, 0.90, 1.05], + } +) + +NORM2 = NormativeSample( + sample_id=2, + size=106, + population="American psychiatric outpatients", + reference="Soldz, Budman, Demby, & Merry (1995)", + url="https://doi.org/10.1177/1073191195002001006", + statistics=norm_2_stats, +) + +iipsc = Instrument( + name="Inventory of Interpersonal Problems Short Circumplex", + abbrev="IIP-SC", + construct="interpersonal problems", + reference="Soldz, Budman, Demby, & Merry (1995)", + url="https://doi.org/10.1177/1073191195002001006", + status="partial text", + scales=SCALES, + anchors=ANCHORS, + items=ITEMS, + norms=(NORM1, NORM2), + prefix="", + suffix="", +) + +register_instrument("iipsc", iipsc) diff --git a/src/circumplex/instruments/ipipipc.py b/src/circumplex/instruments/ipipipc.py new file mode 100644 index 0000000..b758b23 --- /dev/null +++ b/src/circumplex/instruments/ipipipc.py @@ -0,0 +1,109 @@ +"""IPIP Interpersonal Circumplex (IPIP-IPC) instrument definition. + +Reference: + Markey, P. M., & Markey, C. N. (2009). A brief assessment of the + interpersonal circumplex: The IPIP-IPC. Assessment, 16(4), 352-361. + https://doi.org/10.1177/1073191109340382 +""" + +import pandas as pd + +from circumplex.instruments.models import ( + Instrument, + InstrumentScale, + NormativeSample, + ResponseAnchor, + ResponseItem, + register_instrument, +) + +# Define scales +SCALES = ( + InstrumentScale("PA", 90, (6, 14, 22, 30), "Assured-Dominant"), + InstrumentScale("BC", 135, (7, 15, 23, 31), "Arrogant-Calculating"), + InstrumentScale("DE", 180, (8, 16, 24, 32), "Cold-Hearted"), + InstrumentScale("FG", 225, (1, 9, 17, 25), "Aloof-Introverted"), + InstrumentScale("HI", 270, (2, 10, 18, 26), "Unassured-Submissive"), + InstrumentScale("JK", 315, (3, 11, 19, 27), "Unassuming-Ingenuous"), + InstrumentScale("LM", 360, (4, 12, 20, 28), "Warm-Agreeable"), + InstrumentScale("NO", 45, (5, 13, 21, 29), "Gregarious-Extraverted"), +) + +ANCHORS = ( + ResponseAnchor(1, "Very Inaccurate"), + ResponseAnchor(2, "Moderately Inaccurate"), + ResponseAnchor(3, "Neither Accurate nor Inaccurate"), + ResponseAnchor(4, "Moderately Accurate"), + ResponseAnchor(5, "Very Accurate"), +) + +ITEMS = ( + ResponseItem(1, "Am quiet around strangers"), + ResponseItem(2, "Speak softly"), + ResponseItem(3, "Tolerate a lot from others"), + ResponseItem(4, "Am interested in people"), + ResponseItem(5, "Feel comfortable around people"), + ResponseItem(6, "Demand to be the center of interest"), + ResponseItem(7, "Cut others to pieces"), + ResponseItem(8, "Believe people should fend for themselves"), + ResponseItem(9, "Am a very private person"), + ResponseItem(10, "Let others finish what they are saying"), + ResponseItem(11, "Take things as they come"), + ResponseItem(12, "Reassure others"), + ResponseItem(13, "Start conversations"), + ResponseItem(14, "Do most of the talking"), + ResponseItem(15, "Contradict others"), + ResponseItem(16, "Don't fall for sob-stories"), + ResponseItem(17, "Don't talk a lot"), + ResponseItem(18, "Seldom toot my own horn"), + ResponseItem(19, "Think of others first"), + ResponseItem(20, "Inquire about others' well-being"), + ResponseItem(21, "Talk to a lot of different people at parties"), + ResponseItem(22, "Speak loudly"), + ResponseItem(23, "Snap at people"), + ResponseItem(24, "Don't put a lot of thought into things"), + ResponseItem(25, "Have little to say"), + ResponseItem(26, "Dislike being the center of attention"), + ResponseItem(27, "Seldom stretch the truth"), + ResponseItem(28, "Get along well with others"), + ResponseItem(29, "Love large parties"), + ResponseItem(30, "Demand attention"), + ResponseItem(31, "Have a sharp tongue"), + ResponseItem(32, "Am not interested in other people's problems"), +) + +norm_stats = pd.DataFrame( + { + "scale": ["PA", "BC", "DE", "FG", "HI", "JK", "LM", "NO"], + "angle": [90, 135, 180, 225, 270, 315, 360, 45], + "mean": [2.66, 2.27, 2.46, 2.68, 3.20, 3.64, 4.37, 3.64], + "sd": [0.71, 0.69, 0.58, 0.79, 0.63, 0.58, 0.47, 0.78], + } +) + +NORMS = NormativeSample( + sample_id=1, + size=274, + population="American college students", + reference="Markey & Markey (2009)", + url="https://doi.org/10.1177/1073191109340382", + statistics=norm_stats, +) + +INSTRUMENT = Instrument( + name="IPIP Interpersonal Circumplex", + abbrev="IPIP-IPC", + construct="interpersonal traits", + reference="Markey & Markey (2009)", + url="https://doi.org/10.1177/1073191109340382", + status="open-access", + scales=SCALES, + anchors=ANCHORS, + items=ITEMS, + norms=(NORMS,), + prefix="", + suffix="", +) + + +register_instrument("ipipipc", INSTRUMENT) From d84f9ab269338fcfbdf21e4558164f7207f89e23 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 17:55:02 +0000 Subject: [PATCH 90/97] Add data loading utilities and example datasets --- src/circumplex/data/__init__.py | 96 +++++++++++++++++++++++++++++++++ src/circumplex/data/aw2009.csv | 6 +++ 2 files changed, 102 insertions(+) create mode 100644 src/circumplex/data/aw2009.csv diff --git a/src/circumplex/data/__init__.py b/src/circumplex/data/__init__.py index e69de29..1b4ba86 100644 --- a/src/circumplex/data/__init__.py +++ b/src/circumplex/data/__init__.py @@ -0,0 +1,96 @@ +"""Example datasets and data loading utilities. + +This module provides access to the built-in example datasets that +are used for testing and demonstration purposes. +""" + +from pathlib import Path +from typing import Literal + +import pandas as pd + +# Type for available datasets +DatasetName = Literal["jz2017", "aw2009"] + + +def load_dataset(name: DatasetName) -> pd.DataFrame: + """Load a built-in example dataset. + + Parameters + ---------- + name : str + Dataset name. Available datasets: + - 'jz2017': Interpersonal problems and personality disorder data + - 'aw2009': Standardized octant scores + + Returns + ------- + pd.DataFrame + The requested dataset + + Raises + ------ + ValueError + If dataset name is not recognized + + Examples + -------- + >>> from circumplex.data import load_dataset + >>> jz2017 = load_dataset('jz2017') + >>> print(jz2017.shape) + (1166, 19) + >>> print(jz2017.columns[:9].tolist()) + ['Gender', 'PA', 'BC', 'DE', 'FG', 'HI', 'JK', 'LM', 'NO'] + + Notes + ----- + The jz2017 dataset contains data from Zimmermann & Wright (2017): + - 1166 observations + - 8 IIP-SC octant scales (PA through NO) + - 10 PDQ-4+ personality disorder scales + - Gender grouping variable + + The aw2009 dataset contains data from Wright et al. (2009): + - 5 observations + - 8 standardized circumplex scales + + """ + valid_datasets = {"jz2017", "aw2009"} + + if name not in valid_datasets: + msg = ( + f"Unknown dataset '{name}'. Valid options are: {', '.join(valid_datasets)}" + ) + raise ValueError(msg) + + # Path to data files + data_dir = Path(__file__).parent + filepath = data_dir / f"{name}.csv" + + if not filepath.exists(): + msg = ( + f"Dataset file not found: {filepath}. " + f"This may indicate a corrupted package installation." + ) + raise FileNotFoundError(msg) + + return pd.read_csv(filepath) + + +def list_datasets() -> list[str]: + """List all available built-in datasets. + + Returns + ------- + list of str + Names of available datasets + + Examples + -------- + >>> from circumplex.data import list_datasets + >>> datasets = list_datasets() + >>> print(datasets) + ['aw2009', 'jz2017'] + + """ + return ["aw2009", "jz2017"] diff --git a/src/circumplex/data/aw2009.csv b/src/circumplex/data/aw2009.csv new file mode 100644 index 0000000..4dc4a74 --- /dev/null +++ b/src/circumplex/data/aw2009.csv @@ -0,0 +1,6 @@ +"PA","BC","DE","FG","HI","JK","LM","NO" +-1.09,-1.04,-0.97,0.61,1.41,2.49,1.78,0.27 +1.13,-1.04,-0.97,-0.79,-0.56,0.79,1.78,1.52 +0.91,-0.65,-0.8,-0.96,-0.23,-0.34,1.24,0.27 +0.47,-0.45,-0.29,0.26,1.57,1.36,1.6,0.48 +0.45,0.32,0.43,0.96,1.25,1.41,1.49,0.85 From 5fa64a957bb2e4a90b515fa085962f500d11fd27 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:06:17 +0000 Subject: [PATCH 91/97] Standardizes code formatting and adds JSON schema Removes trailing whitespace from license file and normalizes spacing in configuration files to improve consistency. Adds GitHub issue forms JSON schema to enable validation and autocomplete for issue template definitions. --- LICENSE.md | 2 +- docs/tutorials/Intro_to_SSM_Analysis.ipynb | 1201 +++++++--- docs/tutorials/Random_exs.ipynb | 1950 ++++++++++++---- docs/tutorials/using-instruments.ipynb | 1126 ++++------ pyproject.toml | 56 +- schemas/github-issue-forms.json | 2377 ++++++++++++++++++++ uv.lock | 187 +- 7 files changed, 5363 insertions(+), 1536 deletions(-) create mode 100644 schemas/github-issue-forms.json diff --git a/LICENSE.md b/LICENSE.md index a8fa8cc..64441c7 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,7 +1,7 @@ GNU General Public License ========================== -_Version 3, 29 June 2007_ +_Version 3, 29 June 2007_ _Copyright © 2007 Free Software Foundation, Inc. <>_ Everyone is permitted to copy and distribute verbatim copies of this license diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/docs/tutorials/Intro_to_SSM_Analysis.ipynb index 1cf9021..f97a954 100644 --- a/docs/tutorials/Intro_to_SSM_Analysis.ipynb +++ b/docs/tutorials/Intro_to_SSM_Analysis.ipynb @@ -27,10 +27,11 @@ }, "outputs": [], "source": [ - "import circumplex\n", - "import numpy as np\n", - "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import circumplex\n", + "from circumplex import OCTANTS, get_instrument, load_dataset, octants\n", "\n", "# %matplotlib inline\n", "degree_sign = \"\\N{DEGREE SIGN}\"" @@ -69,7 +70,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -79,18 +80,18 @@ } ], "source": [ - "angles = (90, 135, 180, 225, 270, 315, 0, 45)\n", + "angles = octants(3)\n", "alabel = (\"PA\", \"BC\", \"DE\", \"FG\", \"HI\", \"JK\", \"LM\", \"NO\")\n", "\n", "# Create plot ---------------------------------------------------------------\n", "\n", - "fig, ax = plt.subplots(figsize=(4, 4), subplot_kw=dict(polar=True))\n", + "fig, ax = plt.subplots(figsize=(4, 4), subplot_kw={\"polar\": True})\n", "\n", "ax.plot()\n", "ax.set_xticks(np.radians(angles), labels=alabel, fontsize=14)\n", "ax.set_yticks([])\n", - "ax.grid(True)\n", - "for i, angle in enumerate(angles):\n", + "ax.grid(visible=True)\n", + "for angle in angles:\n", " ax.text(\n", " np.radians(angle),\n", " 0.6,\n", @@ -128,7 +129,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAHWCAYAAABkNgFvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMhxJREFUeJzt3QuYVWW9P/AfIHfCGwlq5AU0RAUUAsnULEBNU0rPwSscNepkWIaXohS8lHgLsSIpjLTMI3pSy1KUKEyFoIN5ycwS9eAV0BQRCFDm/7xvZ89/BobhIsyexf58nmexZ6+91l5rv+zZ893v+q13NamqqqoKAAAooKbl3gEAANhUwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAlu1G2+8MZo0aRKtWrWKl156aa3HP/axj8V+++1X57rvvvtu7LLLLnn9e++9t85lLr744vx4aWrevHnsvvvu8aUvfSnefPPNtZZPj9VcfqeddopDDjkk7rzzzrX2q7RM06ZNo3379vGhD30oTjvttJg2bdpGtcHdd98dhx12WN5WmzZtYs8994x///d/j6lTp27U8wA0RsIsUBFWrFgRV1xxxUat89vf/jZeeeWVHEB/9rOf1bvs9ddfHz/96U/je9/7XvTt2ze++93vxjHHHFPnsr169crLpum8886Ll19+OT7zmc/ExIkTay33gQ98IC/zk5/8JK6++uo49thjY+bMmTFo0KAYMmRIrFq1ar2v4ZprrsnrpVA8atSouPbaa+P444+Pv//973HrrbduVHsANEpVAFuxH//4x1Xpo65Xr15VLVu2rHrppZdqPX7YYYdV7bvvvnWuO3To0KoDDzyw6rrrrqtq27Zt1dtvv73WMmPGjMnPv2jRolrzhwwZkufPnj271vzddtut6uijj64175VXXsnPv/fee693v955552qs846Kz/3BRdcUO9rX7VqVVX79u2rBg4cWOfjCxYsqGoo7777btXy5csbbHtA5dAzC1SEr3/967lsYEN7Z5cvX54P/Z944on5kHy6/4tf/GKDt5dKB5J58+atd9lOnTrFPvvsE88999x6l23WrFl85zvfie7du+de4MWLF69z2ddeey3eeuutOPjgg+t8PJUd1PTPf/4zl03svffeuSxj5513zj3GNV/D0qVL49xzz43OnTtHy5Ytc+lD6v2tqkr5+v9LPcEjRozIPdr77rtvXrZU1pDKPc4444zo2LFjnp8enzx58lr7l3q302OpNGL77bePPn36xC233LLeNgIqizALVIQ99tgjhg4dGpMmTcqH9dfnl7/8Zbz99ts5zKawmWpY11dqUNPzzz+fb1MIW59ULvDCCy/EjjvuuEHPnQLtSSedFMuWLYuHHnponculsNq6detcM/uPf/yj3udMQT+VRVxyySXRu3fv+Pa3vx1f/vKXc1j+85//nJdJgTWVLKRShSOPPDLGjRuXw+z5558fI0eOrLNM4ytf+UouibjuuutyucaCBQvioIMOit/85jc57Kb5Xbt2jTPPPDPGjx9fvW76f0p1xym0p/lpv1J5xuzZszeojYAKUu6uYYCGKDP44x//WDVv3ryqbbbZpupLX/rSeg/nH3PMMVUHH3xw9f0f/vCHed2FCxfWWWbw9NNP51KD559/vmry5MlVrVu3rnr/+99ftXTp0rXKDAYNGpSXTdNjjz1WdeKJJ+bnOPvss9e7XyV33nlnXieVQNRn9OjReblUxnDUUUdVfetb36qaO3fuWsulfU7LjRs3bq3HVq9enW/vuuuuvMw3v/nNWo+fcMIJVU2aNKl65plnquel5Zo2bVr15JNP1lr2zDPPrNp5552rXnvttVrzUxtsu+22VcuWLcv3jzvuuHpfP0CJnlmgYqSz+NNoAD/84Q/ziV3r8vrrr8d9992Xez9L0klT6dD5bbfdVuc6qYfy/e9/f+59TIfQU29jGgEhHSJf0/3335+XTVPPnj3j9ttvz/t15ZVXbvBradeuXb5dsmRJvculHs10aP6AAw7Ir+kb3/hG7nk98MAD46mnnqpe7uc//3l06NAhzj777LWeI73u5J577sm9wqnHtKZUdpDy65ojPqQRFFLPaklaJm3nU5/6VP45lUGUpiOOOCL3Aj/yyCN52e222y5efPHF+OMf/7jBbQJUJmEWqCgXXnhhvPPOO/XWzk6ZMiUf+k8B8JlnnslTOkzfr1+/dZYapJCWhsxKwTEdRl+4cGE+xF+X9Dxp2XSoPY1OkMJcGrFgXcvXJZVAJO973/vWu2wK5Q8++GC88cYbOUiffPLJ8ac//SmHylQnm6S62BTIt9lmm3U+z//+7//mocrW3Gaq9y09vmZpR02LFi3Kw5WlLxOlMF+aTj/99LxMarfkq1/9ag7saWSIvfbaK774xS/Gww8/vIGtA1SSdX9qAWylvbOnnnpqDlRf+9rX6lymFFjXdeLUs88+m5+npkMPPTT3bCYpJO6///5xyimnxNy5c/M4sTWl5QYMGPCeXkepjjX1AG+oNFbtwIED85TGw73ppptyDWrqQd0S1gznq1evzrep/YcNG1bnOj169KgOyE8//XT86le/yieOpS8L3//+92P06NG5txmgRJgFKrJ39uabb67zsH4aUSD1lqaTk9YMeSmMpXKA1PuanmNdUo/imDFjcm9jKktIJ5FtTulkrbQPqYThox/96CY9RxoZIIXZUrlFly5dcrBNPdIp6NZlt912y73JqbShZu/sX//61+rH65N6YNN6af83JMy3bds2nzyWppUrV+aRFb71rW/l8XLTaAsAiTIDoOKk4JZ6B3/wgx/Eq6++Wmev7AUXXBAnnHBCrSkN0ZUC7oaMapB6ZdNFDzamDnZDpCCYalZTvWu6Tb2t65JGO5g1a1adj5XqW1NpQakmOJU7pOG+1lQaduuTn/xk3v6ay6TRDVJd7VFHHVXvvqd627Sd1Mta6lleswyhZt1yTS1atMj1t2lfNuRiEUDl0DMLVKR0IlS6ulY6lJ3GMi1JQTUNAZXGUa1LGpoqnSSVTlRKJ1GtS+rdTENbpWGr0mHyNJTVxkonRKUe5FIwTbW7d9xxR65vTb29l112Wb3rp3U+8pGP5BretP30mlLN6l133ZVraAcPHpzrgpM0bFmq201DbM2ZMyePk5vGlE09sWeddVYcd9xxuXzi8MMPz22Xhh5LJ6+lGtw0/u4555yTvySsT6pV/t3vfpfrhocPH54DaqpHTu2ZtlUaQixd5SwNiZZKPdJ4tCm8pxB99NFHb1CdMFBBqsc1ANjKh+Za07Bhw/JjpSGg0pBV6f5FF120zudLQ2+lZb7yla/UewWwZPHixXm4qTTMVn1XAKtLWic9b2lq165d1V577VV16qmnVt1///0b9NrTFcAmTZpUNXjw4LzddAW0Nm3aVB1wwAFVV199ddWKFStqLZ+GxfrGN75Rtccee1Q1b968qlOnTnnYrTSkWcmSJUvya99ll13yMmmf0nOVhu8qSfv8xS9+cZ1XHkuPde7cuXo7n/jEJ/LwZyU/+MEPqg499NCqHXfcMe93ly5dqs4///zcpgA1NUn/lDtQAwDAplAzCwBAYQmzAAAUljALAEBhNYowO2HChHwJyDRuYDrDNZ1Juy433nhjHgKm5mS8QQCAylT2MJsuG5mGgkkDjKehWdJQL+ka3aVLGtYljauYBvouTWteQhEAgMpQ9jA7bty4PNZgulJOGm9w4sSJ+ao2kydPXuc6qTc2jT9YmtIYhAAAVJ6yXjQhXZ4wXbc8XZqwJF3DPF3mcF1XrUnefvvtfNnEdGnJNGj55ZdfXmvQ85pWrFiRp5K0ThqUe8cdd8yhGACAxiWNHJsunb3LLrvkbNhow2y6dGK6NOKaPavpfula32tKl15MvbY9evTIV8e55ppr8hVunnzyyXzpyDWNHTs2Lrnkki32GgAA2DJeeOGFOvNdoS9n279//zyVpCC7zz775Gus13Vpx9Trm2pyS1IA/uAHPxjPPffcVntJxHTd8nS5yHTZyXRJTdamjeqnfeqnfeqnfdZPG9VP+9SvEtpnyZIlsccee2xQVitrmO3QoUM0a9YsFixYUGt+up9qYTdE+k9M1xZP1yyvS8uWLfO0ph122CGfSLa1vslT3XEqpdha3+TvlTaqn/apn/apn/ZZP21UP+1Tv0pon+b/97o2pCS0rCeAtWjRInr37h3Tp0+vVdOa7tfsfa1PKlN44oknYuedd96CewoAQGNU9jKDVAIwbNiw6NOnT/Tt2zfGjx8fS5cuzaMbJEOHDo1dd901174ml156aRx00EHRtWvXePPNN+Pqq6/OQ3N99rOfLfMrAQCg4sLskCFDYtGiRTF69Oh49dVXo1evXjF16tTqk8Lmz59f6yy2N954Iw/llZbdfvvtc8/uzJkz87BeAABUlrKH2WTEiBF5qsuMGTNq3b/22mvzBAAAZb9oAgAAbCphFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBACgsYRYAgMJqFGF2woQJsfvuu0erVq2iX79+MWfOnA1a79Zbb40mTZrE4MGDt/g+AgDQ+JQ9zE6ZMiVGjhwZY8aMiUceeSR69uwZRxxxRCxcuLDe9Z5//vk477zz4pBDDmmwfQUAoHEpe5gdN25cDB8+PE4//fTo3r17TJw4Mdq0aROTJ09e5zrvvvtunHLKKXHJJZfEnnvu2aD7CwBA47FNOTe+cuXKmDt3bowaNap6XtOmTWPAgAExa9asda536aWXxk477RRnnnlmPPjgg/VuY8WKFXkqeeutt/LtqlWr8rQ1Kr2urfX1bQ7aqH7ap37ap37aZ/20Uf20T/0qoX1WbcRrK2uYfe2113Iva8eOHWvNT/f/+te/1rnOQw89FD/60Y/i0Ucf3aBtjB07Nvfgrun+++/PPcBbs2nTppV7Fxo9bVQ/7VM/7VM/7bN+2qh+2qdy22fZsmXFCLMba8mSJXHaaafFpEmTokOHDhu0Tur1TTW5NXtmO3fuHIMGDYr27dtHg9h222hIq1q3jmmTJ8fAM86I5suXN9yGFy+OIn3jSx8CAwcOjObNm5d7dxod7VM/7VM/7bN+2qh+2qd+ldA+b/3fkfRGH2ZTIG3WrFksWLCg1vx0v1OnTmstP2/evHzi16c+9anqeatXr86322yzTTz99NPRpUuXWuu0bNkyT2tK//kN9gZoyEBZQwqyDRpmC/gL1aDvgwLSPvXTPvXTPuunjeqnfSq3fZpvxOsq6wlgLVq0iN69e8f06dNrhdN0v3///mst361bt3jiiSdyiUFpOvbYY+Pwww/PP6ceVwAAKkfZywxSCcCwYcOiT58+0bdv3xg/fnwsXbo0j26QDB06NHbddddc+5rGod1vv/1qrb/ddtvl2zXnAwCw9St7mB0yZEgsWrQoRo8eHa+++mr06tUrpk6dWn1S2Pz58/MIBwAA0OjCbDJixIg81WXGjBn1rnvjjTduob0CAKCx0+UJAEBhCbMAABSWMAsAQGEJswAAFJYwS+PQpEnDTqWrsqXbhtwuALBZCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABRWowizEyZMiN133z1atWoV/fr1izlz5qxz2TvuuCP69OkT2223XbRt2zZ69eoVP/3pTxt0fwEAaBzKHmanTJkSI0eOjDFjxsQjjzwSPXv2jCOOOCIWLlxY5/I77LBDfOMb34hZs2bF448/Hqeffnqe7rvvvgbfdwAAKjzMjhs3LoYPH54Daffu3WPixInRpk2bmDx5cp3Lf+xjH4tPf/rTsc8++0SXLl3iy1/+cvTo0SMeeuihBt93AADKa5tybnzlypUxd+7cGDVqVPW8pk2bxoABA3LP6/pUVVXFb3/723j66afjyiuvrHOZFStW5KnkrbfeyrerVq3KU4No3Toa0qr/217ptuE2/B7aUxs1KqXfjQb7HSkY7VM/7bN+2qh+2qd+ldA+qzbitTWpSomwTF5++eXYddddY+bMmdG/f//q+RdccEE88MADMXv27DrXW7x4cV4vhdRmzZrF97///TjjjDPqXPbiiy+OSy65ZK35t9xyS+4BBgCgcVm2bFmcfPLJOfO1b9++8fbMbqr3ve998eijj8bbb78d06dPzzW3e+65Zy5BWFPq9U2P1+yZ7dy5cwwaNGi9jbPZbLttNKTU2zht8uQYeMYZ0Xz58obb8OLFm76uNmp034inTZsWAwcOjObNm5d7dxod7VM/7bN+2mgrax9/wza70pH0DVHWMNuhQ4fcs7pgwYJa89P9Tp06rXO9VIrQtWvX/HMazeCpp56KsWPH1hlmW7Zsmac1pV+OBvsFacg3Wg3pDd6gb/L30p7aqFFq0N+TAtI+9dM+66eNtpL28Tdss9uY//eyngDWokWL6N27d+5dLVm9enW+X7PsYH3SOjXrYgEAqAxlLzNIJQDDhg3LY8f27ds3xo8fH0uXLs2jGyRDhw7N9bGp5zVJt2nZNJJBCrD33HNPHmf2+uuvL/MrAQCg4sLskCFDYtGiRTF69Oh49dVXc9nA1KlTo2PHjvnx+fPn57KCkhR0zzrrrHjxxRejdevW0a1bt7j55pvz8wAAUFnKHmaTESNG5KkuM2bMqHX/m9/8Zp4AAKDsF00AAIBNJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFCZYXblypXx9NNPxzvvvLP59ggAALZkmF22bFmceeaZ0aZNm9h3331j/vz5ef7ZZ58dV1xxxaY8JQAANEyYHTVqVDz22GMxY8aMaNWqVfX8AQMGxJQpUzblKQEAYKNts/GrRNx11105tB500EHRpEmT6vmpl3bevHmb8pQAANAwPbOLFi2KnXbaaa35S5curRVuAQCg0YXZPn36xK9//evq+6UAe8MNN0T//v03394BAMDmLjO4/PLL46ijjoq//OUveSSD6667Lv88c+bMeOCBBzblKQEAoGF6Zj/60Y/mE8BSkN1///3j/vvvz2UHs2bNit69e2/KUwIAwJbvmV21alV8/vOfj4suuigmTZq08VsEAIBy9cw2b948fv7zn2+u7QMAQMOWGQwePDgPzwUAAIU7AWyvvfaKSy+9NB5++OFcI9u2bdtaj3/pS1/aXPsHAACbN8z+6Ec/iu222y7mzp2bp5rSMF3CLAAAjTbMPvfcc5t/TwAAoCFqZmuqqqrKEwAAFCbM/uQnP8ljzLZu3TpPPXr0iJ/+9Kebd+8AAGBzlxmMGzcujzM7YsSIOPjgg/O8hx56KP7zP/8zXnvttfjKV76yKU8LAABbPsx+97vfjeuvvz6GDh1aPe/YY4+NfffdNy6++GJhFgCAxltm8Morr8RHPvKRteaneekxAABotGG2a9eucdttt601f8qUKXkMWgAAaLRlBpdcckkMGTIkfv/731fXzKYLKEyfPr3OkAsAAI2mZ/b444+P2bNnR4cOHfJlbdOUfp4zZ058+tOf3vx7CQAAm6tnNkmXsb355ps3dXUAAChPz+w999wT991331rz07x77733ve8VAABsqTD7ta99Ld5999215qcrgaXHAACg0YbZv//979G9e/e15nfr1i2eeeaZzbFfAACwZcLstttuG88+++xa81OQbdu27aY8JQAANEyYPe644+Kcc86JefPm1Qqy5557br4SGAAANNowe9VVV+Ue2FRWsMcee+Qp/bzjjjvGNddcs/n3EgAANtfQXKnMYObMmTFt2rR47LHHonXr1tGzZ8845JBDNuXpgPVp0qRht9e6dcR//Vf6ZY9YvrzhtltV1XDbAqDyemZnzZoVv/rVr/LPTZo0iUGDBsVOO+2Ue2PThRQ+97nPxYoVK7bUvgIAwKaH2UsvvTSefPLJ6vtPPPFEDB8+PAYOHJiH5Lr77rtj7NixG/OUAADQMGH20UcfjU984hPV92+99dbo27dvTJo0KUaOHBnf+c534rbbbtv0vQEAgC0VZt94443o2LFj9f0HHnggjjrqqOr7H/7wh+OFF17YmKcEAICGCbMpyD733HP555UrV8YjjzwSBx10UPXjS5YsiebNm2/63gAAwJYKs5/85CdzbeyDDz4Yo0aNijZt2tQaweDxxx+PLl26bMxTAgBAwwzNddlll8VnPvOZOOyww6Jdu3Zx0003RYsWLaofnzx5ch7hAAAAGl2Y7dChQ/z+97+PxYsX5zDbrFmzWo/ffvvteT4AADTqiybUZYcddniv+wMAAFv2crYAANAYCLMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhNYowO2HChNh9992jVatW0a9fv5gzZ846l500aVIccsghsf322+dpwIAB9S4PAMDWq+xhdsqUKTFy5MgYM2ZMPPLII9GzZ8844ogjYuHChXUuP2PGjDjppJPid7/7XcyaNSs6d+4cgwYNipdeeqnB9x0AgAoPs+PGjYvhw4fH6aefHt27d4+JEydGmzZtYvLkyXUu/7Of/SzOOuus6NWrV3Tr1i1uuOGGWL16dUyfPr3B9x0AgPLappwbX7lyZcydOzdGjRpVPa9p06a5dCD1um6IZcuWxapVq2KHHXao8/EVK1bkqeStt97Kt2mdNDWI1q2jIa36v+2Vbhtuw++hPbVR/bRPo1L67Giwz5CC0T7rp422svbxGb3Zbcz/fZOqqqqqKJOXX345dt1115g5c2b079+/ev4FF1wQDzzwQMyePXu9z5F6ae+777548sknc83tmi6++OK45JJL1pp/yy235B5gAAAal9RZefLJJ8fixYujffv2jbdn9r264oor4tZbb811tHUF2ST1+qaa3Jo9s6U62/U1zmaz7bbRkNI3tWmTJ8fAM86I5suXN9yGFy/e9HW1Uf20T6OSegymTZsWAwcOjObNm5d7dxod7bN+2mgrax+f0Ztd6Uj6hihrmO3QoUM0a9YsFixYUGt+ut+pU6d6173mmmtymP3Nb34TPXr0WOdyLVu2zNOa0i9Hg/2CNOQbrYb0Bm/QN/l7aU9tVD/t0yg16OdIAWmf9dNGW0n7+Ize7Dbm/72sJ4C1aNEievfuXevkrdLJXDXLDtZ01VVXxWWXXRZTp06NPn36NNDeAgDQ2JS9zCCVAAwbNiyH0r59+8b48eNj6dKleXSDZOjQobmuduzYsfn+lVdeGaNHj841r2ls2ldffTXPb9euXZ4AAKgcZQ+zQ4YMiUWLFuWAmoJpGnIr9bh27NgxPz5//vw8wkHJ9ddfn0dBOOGEE2o9TxqnNp3sBQBA5Sh7mE1GjBiRp7qkk7tqev755xtorwAAaOzKftEEAADYVMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzALF16RJw07bbvuv7abbhtwuAGsRZgEAKKyyh9kJEybE7rvvHq1atYp+/frFnDlz1rnsk08+Gccff3xevkmTJjF+/PgG3VcAABqXsobZKVOmxMiRI2PMmDHxyCOPRM+ePeOII46IhQsX1rn8smXLYs8994wrrrgiOnXq1OD7CwBA41LWMDtu3LgYPnx4nH766dG9e/eYOHFitGnTJiZPnlzn8h/+8Ifj6quvjhNPPDFatmzZ4PsLAEDjsk25Nrxy5cqYO3dujBo1qnpe06ZNY8CAATFr1qzNtp0VK1bkqeStt97Kt6tWrcpTg2jdOhrSqv/bXum24Tb8HtpTG9VP+9RP+zQqpc/WBvuMLSBttJW1j8+gzW5j/u+bVFVVVUUZvPzyy7HrrrvGzJkzo3///tXzL7jggnjggQdi9uzZ9a6f6mbPOeecPNXn4osvjksuuWSt+bfcckvuBQYAoHFJpaUnn3xyLF68ONq3b984e2YbSur5TXW5NXtmO3fuHIMGDVpv42w2pWF8Gkj6pjZt8uQYeMYZ0Xz58obb8OLFm76uNqqf9qmf9mlUUo/KtGnTYuDAgdG8efNy706jpI22svbxGbTZlY6kb4iyhdkOHTpEs2bNYsGCBbXmp/ub8+SuVFtbV31t+uVosF+Qhnyj1ZDe4A36Jn8v7amN6qd96qd9GqUG/ZwtKG20lbSPz6DNbmP+38t2AliLFi2id+/eMX369Op5q1evzvdrlh0AAECjLDNIh/+HDRsWffr0ib59++ZxY5cuXZpHN0iGDh2a62rHjh1bfdLYX/7yl+qfX3rppXj00UejXbt20bVr13K+FAAAKi3MDhkyJBYtWhSjR4+OV199NXr16hVTp06Njh075sfnz5+fRzioedLYAQccUH3/mmuuydNhhx0WM2bMKMtrAACgfMp+AtiIESPyVJc1A2oawaBMgy8AANAIlf1ytgAAsKmEWQAACkuYBQCgsIRZAAAKS5gFAKCwhFkAoH5NmjTsVLo8bLptyO1SSMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCAFBYwiwAAIUlzAIAUFjCLAAAhSXMAgBQWMIsAACFJcwCQJMmDTttu+2/tptuG3K7sBUSZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBKoGTm4CtlDALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYQmzAAAUljALAEBhCbMAABSWMAsAQGEJswAAFJYwCwBAYTWKMDthwoTYfffdo1WrVtGvX7+YM2dOvcvffvvt0a1bt7z8/vvvH/fcc0+D7SsAAI1H2cPslClTYuTIkTFmzJh45JFHomfPnnHEEUfEwoUL61x+5syZcdJJJ8WZZ54Zf/rTn2Lw4MF5+vOf/9zg+w4AQIWH2XHjxsXw4cPj9NNPj+7du8fEiROjTZs2MXny5DqXv+666+LII4+M888/P/bZZ5+47LLL4sADD4zvfe97Db7vAACU1zbl3PjKlStj7ty5MWrUqOp5TZs2jQEDBsSsWbPqXCfNTz25NaWe3LvuuqvO5VesWJGnksWLF+fbf/zjH7Fq1apoEK1aRUNa1apVLFu2LF5v1SqaV1U13IZff33T19VG9dM+9dM+jaqNtM9W2Ebap37aZ7NbsmRJvq3akNdXVUYvvfRS2sOqmTNn1pp//vnnV/Xt27fOdZo3b151yy231Jo3YcKEqp122qnO5ceMGZO3YTKZTCaTyWSKQk0vvPDCevNkWXtmG0Lq9a3Zk7t69ercK7vjjjtGkyZNYmv01ltvRefOneOFF16I9u3bl3t3GiVtVD/tUz/tUz/ts37aqH7ap36V0D5VVVW5d3aXXXZZ77JlDbMdOnSIZs2axYIFC2rNT/c7depU5zpp/sYs37JlyzzVtN1220UlSG/wrfVNvrloo/ppn/ppn/ppn/XTRvXTPpXdPttuu23jPwGsRYsW0bt375g+fXqtntN0v3///nWuk+bXXD6ZNm3aOpcHAGDrVfYyg1QCMGzYsOjTp0/07ds3xo8fH0uXLs2jGyRDhw6NXXfdNcaOHZvvf/nLX47DDjssvv3tb8fRRx8dt956a/zP//xP/PCHPyzzKwEAoOLC7JAhQ2LRokUxevToePXVV6NXr14xderU6NixY358/vz5eYSDko985CNxyy23xIUXXhhf//rXY6+99sojGey3335lfBWNSyqrSOP2rllewf+njeqnfeqnfeqnfdZPG9VP+9RP+9TWJJ0FtsY8AAAohLJfNAEAADaVMAsAQGEJswAAFJYwCwBAYQmzBfYf//Ef+SpmaUpj9nbt2jUuvfTSeOedd6qXOeKII/KFKf74xz9GpbZNmtIV34488sh4/PHHq5dJ5z6mId369esX7dq1yxfTSEPEpeHh0jWvK6mNmjdvnkcQGThwYEyePDmP91yy++6712rL0nTFFVdEJb2HStMzzzyTH0+jr6ShAtPvXatWrXL7HXzwwXH99ddXxPtnzbYaPHjwWvNnzJiR2+zNN9+s9XOlqdk+dbXVf//3f+f3UBpystLfMzU/c9LQm2vad99982M33nhjVMLnz5qfs2n0pppXL3333Xfj2muvjf333z+/h7bffvs46qij4uGHH45KIswWXApor7zySvz973+Pc889Ny6++OK4+uqrq4c1mzlzZowYMSIHlEptmzSlC21ss802ccwxx1Q/ftppp8U555wTxx13XPzud7+LRx99NC666KL4xS9+Effff39UUhs9//zzce+998bhhx+eA1pqp5pfitKXpFJblqazzz47Kuk9VJr22GOPePbZZ+OAAw7I75PLL788/vSnP8WsWbPiggsuiF/96lfxm9/8pty7TkHccMMNccopp+QvQekznH9Jl2r98Y9/XGveH/7wh/wlsm3btlEJUji98sor44033qjz8dQhc+KJJ+bP5/S5/dRTT+UvjantPvaxj+XgWynKPs4s700aY650Kd8vfOELceedd8Yvf/nLGDVqVP4gSKEkzT/ooINi3Lhx0bp166jEtkm3X/va1+KQQw7J4xqn8Pqzn/0s/7KnMFuzR+DYY4/N172utDZKFyc58MAD83vlE5/4RO75+OxnP5sfe9/73rfOS0ZXSvvUdNZZZ+UvR+mCLTX/sO655575/WTEQzbEVVddlccKTT2Qn/70p8u9O41KCvipx/GFF17I4SxJnTJp/k9+8pOoBAMGDMhHgtJFo9J7ZU233XZb7tX/5S9/GZ/61Keq56cjjq+//nr+/E5H2yoh/OuZ3cqksLpy5cr8xzSF2VNPPTW6deuWD4WmN32levvtt+Pmm2/O7ZBKDlKQ/dCHPlQryJakQzgbej3ordHHP/7x6NmzZ9xxxx3l3pVGKf2RSD2yX/ziF9f5R6LmYUCoy1e/+tW47LLLck++ILu2VLaTyuRuuummfD+V7kyZMiXOOOOMqBSpRDAd+fnud78bL7744lqPpwtI7b333rWCbEnq5U+fVdOmTYtKIMxuJVJ4TYc277vvvhxG0s/plz99GCQp1P7oRz+KSpL+SKRa2DSlnsX07TV9GKYryqWyjBRmqVv6ApRKD2r+4S21ZWl68MEHo5LeQ2n6t3/7t9xTkn7f1nz/dOjQoXq51F6VZs22SlOq3WNtqaQn9bSlkqZ0FIS6peCajhCl37fUGdOlS5d8ldBKkr7opNecevDX9Le//S322WefOtcrzU/LVAJlBlvJH5BVq1blk3ZOPvnkXDebDi+kSwWnQ6HJSSedFOeff37MmzcvfyBUglT/merQklRz9P3vfz//cZ0zZ47DwOuR2qdm72J676QTEmpKZQmV9B5KUk9sqkWvS3pfpd/BdBh0xYoVUWnWbKtk9uzZ+Ys0tfXo0SNee+21HFD69u2bP8NZ29FHHx2f//zn4/e//30uMaikXtmaUt1s6qQ677zz1nrM37J/EWa3kj8gaTSDXXbZJYfXf/zjH7l2NgXcmn9c0lmP6QPhW9/6VlSCFDxSWUHNEy1S+cCkSZPyoZm//vWvZd2/xiydSJBOdKrZ61izLSvFmu+hJP2upaD/9NNP15qf6mWTSqpLX19b1XVolH99EUw9jenzO51kmHpq09Ejakt/z9KJuin0py9G6e9aJTr00EPzUdZ0LkzNToX0dyx9VtelND8tUwmUGWwlf0A++MEPVvfCpnrQD3zgA/HYY4/lM/RLUxr2JR2ySaG2EqUAkkoMli9fnnuw0+GXdJivrm+6ixcvjkr129/+Np544ok4/vjjy70rjVKquU4nVXzve9+LpUuXlnt3KKjddtstHnjggXx2fgq0S5YsKfcuNUqpNza1Uzq/IQ07VanSEF133313HjWlJI1kkErm7r777rWWT3/vS59VlUDP7FYo1caecMIJsd9++9Wan84ITd/spk6dmg/fbO3Sod70h6JUZpDCRzoRLBXLH3bYYflbfiq/uPDCC2PQoEHx/ve/P4e4dAZtGnZqXWMgbo1tlL7gLFiwIL830pmzaRSMoUOHVi+X/tCW2rKkTZs20b59+6hEqWQljSmbxiVOZT3psHH6opTGc049/r179y73LlIA6TM5DaWUemhTz1v6/auk36nUaZA6WmpKAWzN2s9UkpE+bypZGkc2lTB95zvfqRVmb7/99hg2bFgekjPVX6eReCZMmJDPEUmPVcJIBokwu5WZO3du7pFNh9LXlA6xpzd7CruVEGbTH4add945/5wO4aWTmtIvdxp/r3QmaBrCpFR6kXq299prrxziSifOVUobpdeeej3SKAbpwzJ9OKZwVjJ69Og81ZRq2SZOnBiVKNWdp7Fl05nG6QtiOpyehvHq3r17rmtLQ3dBSaqlLh05W1M6ilYz0KaTeCsl0KbXncZrrunMM89ca7k1A26lSuPJppOYax5tTMNzjR8/PnfCpM+dNDZt//79c9umL9yVokmV6mEA2GJSGUEqB0tHh4DNT80sAGwBqbwpjTiTesnSAPjAlqHMAAC20MlLqY46DWBf1wVagM1DmQEAAIWlzAAAgMISZgEAKCxhFgCAwhJmAQAoLGEWAIDCEmYBtnLpqnfnnHNOuXcDYIsQZgHKbNGiRfGFL3whPvjBD+bL4nbq1Clf2vThhx8u964BNHoumgBQZscff3ysXLkybrrppthzzz1jwYIFMX369Hj99dfLvWsAjZ6eWYAyevPNN+PBBx+MK6+8Mg4//PDYbbfdom/fvjFq1Kg49thjq5f5/Oc/Hx07doxWrVrFfvvtly+TmqTAe9JJJ8Wuu+4abdq0if333z/+67/+q95trlixIs4777y8Ttu2baNfv375kqsARaRnFqCM2rVrl6e77rorDjrooFxmUNPq1avjqKOOiiVLlsTNN98cXbp0ib/85S/RrFmz/Pg///nP6N27d3z1q1+N9u3bx69//es47bTT8nIpFNdlxIgR+TluvfXW2GWXXeLOO++MI488Mp544onYa6+9GuR1A2wuLmcLUGY///nPY/jw4bF8+fI48MAD47DDDosTTzwxevToEffff38Os0899VTsvffeG/R8xxxzTHTr1i2uueaa6hPAevXqFePHj4/58+fnUoZ0m4JsyYABA3L4vfzyy7fY6wTYEvTMAjSCmtmjjz46lxv84Q9/iHvvvTeuuuqquOGGG2LhwoXxgQ98YJ1B9t13380B9LbbbouXXnop196mMoJUclCX1Pua1lnz+dI6O+644xZ5fQBbkjAL0AikWtiBAwfm6aKLLorPfvazMWbMmFzbWp+rr746rrvuutzrmuplUw1sGoYrhdq6vP3227lEYe7cudWlCiWp3AGgaIRZgEaoe/fuuY42lRq8+OKL8be//a3O3tk0fNdxxx0Xp556anWNbVo2rV+XAw44IPfMph7fQw45ZIu/DoAtzWgGAGWURiP4+Mc/nk/uevzxx+O5556L22+/PZcZpJCa6mcPPfTQXIowbdq0/HgqQ5g6dWpeP52wlebPnDkz19WmUQ/S0F7rkgLxKaecEkOHDo077rgjP9+cOXNi7Nix+eQxgKLRMwtQRunQfhoa69prr4158+bFqlWronPnzvmEsK9//evVJ4ilcoM0BNfSpUuja9euccUVV+THLrzwwnj22WfzRRZSneznPve5GDx4cCxevHid2/zxj38c3/zmN+Pcc8/NdbYdOnTIIymkE8cAisZoBgAAFJYyAwAACkuYBQCgsIRZAAAKS5gFAKCwhFkAAApLmAUAoLCEWQAACkuYBQCgsIRZAAAKS5gFAKCwhFkAAKKo/h+MMHICV/fgswAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -138,20 +139,17 @@ } ], "source": [ - "from circumplex.datasets import JZ2017\n", - "import matplotlib.pyplot as plt\n", + "scales = [\"PA\", \"BC\", \"DE\", \"FG\", \"HI\", \"JK\", \"LM\", \"NO\"]\n", "\n", - "jz_data = JZ2017\n", - "r = circumplex.ssm_analyze(\n", - " jz_data.data, jz_data.scales.abbrev, angles=angles, measures=[\"NARPD\"]\n", - ")\n", + "jz_data = load_dataset(\"jz2017\")\n", + "r = circumplex.ssm_analyze(jz_data, scales, angles=OCTANTS, measures=[\"NARPD\"])\n", "plt.figure(figsize=(8, 5))\n", - "plt.bar(r.scales, r.scores[r.scales].values[0], color=\"red\")\n", + "plt.bar(scales, r.scores[scales].to_numpy()[0], color=\"red\")\n", "plt.ylim(0, 0.5)\n", "plt.ylabel(\"Score\")\n", "plt.xlabel(\"Scale\")\n", "plt.title(\"NARPD Scores\")\n", - "plt.grid(True)\n", + "plt.grid(visible=True)\n", "plt.show()" ] }, @@ -179,7 +177,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -189,16 +187,8 @@ } ], "source": [ - "fig, ax = r.profile_plot(\n", - " incl_amp=False,\n", - " incl_disp=False,\n", - " incl_pred=False,\n", - " incl_fit=False,\n", - " reorder_scales=True,\n", - ")\n", + "fig = r.plot_curve(incl_pred=False)\n", "\n", - "ax[0].grid(True)\n", - "plt.ylim(0, 0.5)\n", "plt.xlabel(\"Angle\")\n", "plt.title(\"Scores by Angle\")\n", "plt.show()" @@ -228,7 +218,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -238,11 +228,8 @@ } ], "source": [ - "fig, ax = r.profile_plot(\n", - " reorder_scales=True, incl_amp=False, incl_disp=False, incl_pred=True, incl_fit=False\n", - ")\n", - "ax[0].grid(True)\n", - "plt.ylim(0, 0.5)\n", + "fig = r.plot_curve()\n", + "\n", "plt.xlabel(\"Angle\")\n", "plt.title(\"Cosine curve estimated by SSM\")\n", "plt.show()" @@ -280,7 +267,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -290,18 +277,10 @@ } ], "source": [ - "from matplotlib import collections as mc\n", "import numpy as np\n", + "from matplotlib import collections as mc\n", "\n", - "fig, ax = r.profile_plot(\n", - " reorder_scales=True,\n", - " incl_amp=False,\n", - " incl_disp=False,\n", - " incl_pred=True,\n", - " incl_fit=False,\n", - " c_fit=\"black\",\n", - " c_scores=\"black\",\n", - ")\n", + "fig = r.plot_curve(c_fit=\"black\", c_scores=\"black\")\n", "thetas = np.linspace(0, 360, 1000)\n", "fit = circumplex.utils.cosine_form(\n", " np.deg2rad(thetas),\n", @@ -310,7 +289,7 @@ " r.results[\"e_est\"][0],\n", ")\n", "angles, scores = circumplex.utils.sort_angles(\n", - " r.details[\"angles\"], r.scores[r.scales].values[0]\n", + " np.array(r.details.angles), r.scores[scales].to_numpy()[0]\n", ")\n", "\n", "lines = []\n", @@ -321,10 +300,8 @@ " lines.append([(0, fit[0]), (0, scores[i])])\n", "\n", "lc = mc.LineCollection(lines, colors=\"red\", linewidths=10)\n", - "ax[0].add_collection(lc)\n", + "fig.axes[0].add_collection(lc)\n", "\n", - "ax[0].grid(True)\n", - "plt.ylim(0, 0.5)\n", "plt.xlabel(\"Angle\")\n", "plt.title(f\"Fit = {round(r.results.fit_est[0], 2)}\")\n", "plt.show()" @@ -344,19 +321,25 @@ "cell_type": "markdown", "id": "b8e0a65d8bf43c20", "metadata": {}, - "source": "The second SSM is amplitude or $a$, which is calculated as the difference between the highest point of the curve and the curve's mean. It is interpreted as the distinctiveness or differentiation of a profile: how much it is peaked versus flat. Similar to elevation, when using correlation based SSM, $a \\geq 0.15$ is considered \"marked\" and $a \\leq 0.15$ is considered \"modest\"." + "source": [ + "The second SSM is amplitude or $a$, which is calculated as the difference between the highest point of the curve and the curve's mean. It is interpreted as the distinctiveness or differentiation of a profile: how much it is peaked versus flat. Similar to elevation, when using correlation based SSM, $a \\geq 0.15$ is considered \"marked\" and $a \\leq 0.15$ is considered \"modest\"." + ] }, { "cell_type": "markdown", "id": "83f2230678d86f83", "metadata": {}, - "source": "The final SSM parameter is displacement or $d$, which is calculated as the angle at which the curve reaches its highest point. It is interpreted as the style of the profile. For instance, if $d = 90$ and we are using a circumplex scale that defines 90 degrees as \"domineering\", then the profile's style is domineering." + "source": [ + "The final SSM parameter is displacement or $d$, which is calculated as the angle at which the curve reaches its highest point. It is interpreted as the style of the profile. For instance, if $d = 90$ and we are using a circumplex scale that defines 90 degrees as \"domineering\", then the profile's style is domineering." + ] }, { "cell_type": "markdown", "id": "b1c952954bc8f60f", "metadata": {}, - "source": "By interpreting these three parameters, we can understand a profile much more parsimoniously than by trying to interpret all eight subscales individually. This approach also leverages the circumplex relationship (i.e. dependency) among subscales. It is also possible to transform the amplitude and displacement parameters into estimates of distance from the x-axis and y-axis, which will be shown in the output discussed below." + "source": [ + "By interpreting these three parameters, we can understand a profile much more parsimoniously than by trying to interpret all eight subscales individually. This approach also leverages the circumplex relationship (i.e. dependency) among subscales. It is also possible to transform the amplitude and displacement parameters into estimates of distance from the x-axis and y-axis, which will be shown in the output discussed below." + ] }, { "cell_type": "markdown", @@ -386,9 +369,9 @@ "data": { "text/plain": [ "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", - "32 Items, 8 Scales, 2 normative data sets\n", + "32 items, 8 scales, 2 normative data sets\n", "Soldz, Budman, Demby, & Merry (1995)\n", - "" + "< https://doi.org/10.1177/1073191195002001006 >" ] }, "execution_count": 7, @@ -397,10 +380,8 @@ } ], "source": [ - "from circumplex.datasets import _jz2017_path\n", - "\n", - "jz2017 = circumplex.instrument.load_instrument(\"IIPSC\")\n", - "jz2017.attach_data(pd.read_csv(_jz2017_path))" + "iipsc = get_instrument(\"iipsc\")\n", + "iipsc" ] }, { @@ -427,6 +408,227 @@ "outputs": [ { "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Gender", + "rawType": "object", + "type": "string" + }, + { + "name": "PA", + "rawType": "float64", + "type": "float" + }, + { + "name": "BC", + "rawType": "float64", + "type": "float" + }, + { + "name": "DE", + "rawType": "float64", + "type": "float" + }, + { + "name": "FG", + "rawType": "float64", + "type": "float" + }, + { + "name": "HI", + "rawType": "float64", + "type": "float" + }, + { + "name": "JK", + "rawType": "float64", + "type": "float" + }, + { + "name": "LM", + "rawType": "float64", + "type": "float" + }, + { + "name": "NO", + "rawType": "float64", + "type": "float" + }, + { + "name": "PARPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "SCZPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "SZTPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "ASPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "BORPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "HISPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "NARPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "AVPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "DPNPD", + "rawType": "int64", + "type": "integer" + }, + { + "name": "OCPD", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "2f1cd42a-748c-42a1-b036-f906a26f551e", + "rows": [ + [ + "0", + "Female", + "1.5", + "1.5", + "1.25", + "1.0", + "2.0", + "2.5", + "2.25", + "2.5", + "4", + "3", + "7", + "7", + "8", + "4", + "6", + "3", + "4", + "6" + ], + [ + "1", + "Female", + "0.0", + "0.25", + "0.0", + "0.25", + "1.25", + "1.75", + "2.25", + "2.25", + "1", + "0", + "2", + "0", + "1", + "2", + "3", + "0", + "1", + "0" + ], + [ + "2", + "Female", + "0.0", + "0.0", + "0.0", + "0.0", + "0.0", + "0.0", + "0.0", + "0.0", + "0", + "1", + "0", + "4", + "1", + "5", + "4", + "0", + "0", + "1" + ], + [ + "3", + "Male", + "2.0", + "1.75", + "1.75", + "2.5", + "2.0", + "1.75", + "2.0", + "2.5", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "4", + "Female", + "0.25", + "0.5", + "0.25", + "0.0", + "0.0", + "0.0", + "0.0", + "0.0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "1", + "0", + "0" + ] + ], + "shape": { + "columns": 19, + "rows": 5 + } + }, "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", + " \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", + "
LabelGroupMeasuree_este_lcie_ucix_estx_lcix_uciy_esty_lciy_ucia_esta_lcia_ucid_estd_lcid_ucifit_est
0loud: deudeuloud-0.030-0.043-0.017-0.649-0.682-0.6140.4210.3670.4710.7740.7440.804147.051143.049151.4000.978
1loud: engengloud0.002-0.0130.016-0.575-0.619-0.5250.3710.3180.4220.6840.6460.722147.187142.359152.0870.983
2loud: hrvhrvloud0.0620.0500.075-0.502-0.543-0.4590.4630.4150.5120.6840.6480.718137.315132.725141.7260.916
3loud: itaitaloud0.0330.0140.052-0.493-0.532-0.4500.3670.3150.4180.6150.5750.653143.332138.393148.4660.912
4loud: porporloud0.0820.0690.095-0.392-0.419-0.3620.5850.5540.6140.7040.6760.732123.804121.435126.1050.929
5loud: swesweloud0.0160.0020.029-0.630-0.666-0.5960.3820.3300.4350.7370.7080.766148.747144.483153.2200.956
6loud: turturloud-0.001-0.0190.016-0.494-0.527-0.4580.5670.5240.6090.7520.7190.785131.042127.857134.3360.947
\n", + "
" + ], + "text/plain": [ + " Label Group Measure e_est e_lci e_uci x_est x_lci x_uci y_est \\\n", + "0 loud: deu deu loud -0.030 -0.043 -0.017 -0.649 -0.682 -0.614 0.421 \n", + "1 loud: eng eng loud 0.002 -0.013 0.016 -0.575 -0.619 -0.525 0.371 \n", + "2 loud: hrv hrv loud 0.062 0.050 0.075 -0.502 -0.543 -0.459 0.463 \n", + "3 loud: ita ita loud 0.033 0.014 0.052 -0.493 -0.532 -0.450 0.367 \n", + "4 loud: por por loud 0.082 0.069 0.095 -0.392 -0.419 -0.362 0.585 \n", + "5 loud: swe swe loud 0.016 0.002 0.029 -0.630 -0.666 -0.596 0.382 \n", + "6 loud: tur tur loud -0.001 -0.019 0.016 -0.494 -0.527 -0.458 0.567 \n", + "\n", + " y_lci y_uci a_est a_lci a_uci d_est d_lci d_uci fit_est \n", + "0 0.367 0.471 0.774 0.744 0.804 147.051 143.049 151.400 0.978 \n", + "1 0.318 0.422 0.684 0.646 0.722 147.187 142.359 152.087 0.983 \n", + "2 0.415 0.512 0.684 0.648 0.718 137.315 132.725 141.726 0.916 \n", + "3 0.315 0.418 0.615 0.575 0.653 143.332 138.393 148.466 0.912 \n", + "4 0.554 0.614 0.704 0.676 0.732 123.804 121.435 126.105 0.929 \n", + "5 0.330 0.435 0.737 0.708 0.766 148.747 144.483 153.220 0.956 \n", + "6 0.524 0.609 0.752 0.719 0.785 131.042 127.857 134.336 0.947 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "test.results" + "test.results.round(3)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "8632928f988b2c91", "metadata": { "ExecuteTime": { @@ -126,16 +1003,26 @@ }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "fig, axes = plt.subplots(4, 2, figsize=(12, 16), sharey=True)\n", - "ssm_res.profile_plots(axes=axes)\n", + "ssm_res.plot_curve(figsize=(12, 12))\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "id": "99ab18f9960d34a2", "metadata": { "ExecuteTime": { @@ -144,14 +1031,504 @@ }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Label", + "rawType": "object", + "type": "string" + }, + { + "name": "Group", + "rawType": "object", + "type": "string" + }, + { + "name": "Measure", + "rawType": "object", + "type": "string" + }, + { + "name": "e_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "e_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "x_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "y_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "a_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_est", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_lci", + "rawType": "float64", + "type": "float" + }, + { + "name": "d_uci", + "rawType": "float64", + "type": "float" + }, + { + "name": "fit_est", + "rawType": "float64", + "type": "float" + } + ], + "ref": "4b219993-05f6-48de-ae79-8805f7ab0435", + "rows": [ + [ + "0", + "loud: deu", + "deu", + "loud", + "-0.03", + "-0.043", + "-0.018", + "-0.649", + "-0.683", + "-0.614", + "0.421", + "0.366", + "0.471", + "0.774", + "0.743", + "0.805", + "147.051", + "143.151", + "151.255", + "0.978" + ], + [ + "1", + "loud: eng", + "eng", + "loud", + "0.002", + "-0.012", + "0.016", + "-0.575", + "-0.619", + "-0.53", + "0.371", + "0.32", + "0.422", + "0.684", + "0.647", + "0.722", + "147.187", + "142.638", + "151.806", + "0.983" + ], + [ + "2", + "loud: hrv", + "hrv", + "loud", + "0.062", + "0.049", + "0.075", + "-0.502", + "-0.545", + "-0.459", + "0.463", + "0.417", + "0.508", + "0.684", + "0.647", + "0.718", + "137.315", + "132.946", + "141.561", + "0.916" + ], + [ + "3", + "loud: ita", + "ita", + "loud", + "0.033", + "0.014", + "0.053", + "-0.493", + "-0.533", + "-0.454", + "0.367", + "0.315", + "0.418", + "0.615", + "0.577", + "0.654", + "143.332", + "138.42", + "148.371", + "0.912" + ], + [ + "4", + "loud: por", + "por", + "loud", + "0.082", + "0.069", + "0.095", + "-0.392", + "-0.419", + "-0.365", + "0.585", + "0.557", + "0.614", + "0.704", + "0.676", + "0.732", + "123.804", + "121.532", + "126.017", + "0.929" + ], + [ + "5", + "loud: swe", + "swe", + "loud", + "0.016", + "0.003", + "0.03", + "-0.63", + "-0.664", + "-0.595", + "0.382", + "0.331", + "0.432", + "0.737", + "0.708", + "0.766", + "148.747", + "144.514", + "153.013", + "0.956" + ], + [ + "6", + "loud: tur", + "tur", + "loud", + "-0.001", + "-0.019", + "0.017", + "-0.494", + "-0.528", + "-0.458", + "0.567", + "0.523", + "0.609", + "0.752", + "0.72", + "0.784", + "131.042", + "127.782", + "134.461", + "0.947" + ] + ], + "shape": { + "columns": 19, + "rows": 7 + } + }, + "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", + " \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", + "
LabelGroupMeasuree_este_lcie_ucix_estx_lcix_uciy_esty_lciy_ucia_esta_lcia_ucid_estd_lcid_ucifit_est
0loud: deudeuloud-0.030-0.043-0.018-0.649-0.683-0.6140.4210.3660.4710.7740.7430.805147.051143.151151.2550.978
1loud: engengloud0.002-0.0120.016-0.575-0.619-0.5300.3710.3200.4220.6840.6470.722147.187142.638151.8060.983
2loud: hrvhrvloud0.0620.0490.075-0.502-0.545-0.4590.4630.4170.5080.6840.6470.718137.315132.946141.5610.916
3loud: itaitaloud0.0330.0140.053-0.493-0.533-0.4540.3670.3150.4180.6150.5770.654143.332138.420148.3710.912
4loud: porporloud0.0820.0690.095-0.392-0.419-0.3650.5850.5570.6140.7040.6760.732123.804121.532126.0170.929
5loud: swesweloud0.0160.0030.030-0.630-0.664-0.5950.3820.3310.4320.7370.7080.766148.747144.514153.0130.956
6loud: turturloud-0.001-0.0190.017-0.494-0.528-0.4580.5670.5230.6090.7520.7200.784131.042127.782134.4610.947
\n", + "
" + ], + "text/plain": [ + " Label Group Measure e_est e_lci e_uci x_est x_lci x_uci y_est \\\n", + "0 loud: deu deu loud -0.030 -0.043 -0.018 -0.649 -0.683 -0.614 0.421 \n", + "1 loud: eng eng loud 0.002 -0.012 0.016 -0.575 -0.619 -0.530 0.371 \n", + "2 loud: hrv hrv loud 0.062 0.049 0.075 -0.502 -0.545 -0.459 0.463 \n", + "3 loud: ita ita loud 0.033 0.014 0.053 -0.493 -0.533 -0.454 0.367 \n", + "4 loud: por por loud 0.082 0.069 0.095 -0.392 -0.419 -0.365 0.585 \n", + "5 loud: swe swe loud 0.016 0.003 0.030 -0.630 -0.664 -0.595 0.382 \n", + "6 loud: tur tur loud -0.001 -0.019 0.017 -0.494 -0.528 -0.458 0.567 \n", + "\n", + " y_lci y_uci a_est a_lci a_uci d_est d_lci d_uci fit_est \n", + "0 0.366 0.471 0.774 0.743 0.805 147.051 143.151 151.255 0.978 \n", + "1 0.320 0.422 0.684 0.647 0.722 147.187 142.638 151.806 0.983 \n", + "2 0.417 0.508 0.684 0.647 0.718 137.315 132.946 141.561 0.916 \n", + "3 0.315 0.418 0.615 0.577 0.654 143.332 138.420 148.371 0.912 \n", + "4 0.557 0.614 0.704 0.676 0.732 123.804 121.532 126.017 0.929 \n", + "5 0.331 0.432 0.737 0.708 0.766 148.747 144.514 153.013 0.956 \n", + "6 0.523 0.609 0.752 0.720 0.784 131.042 127.782 134.461 0.947 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "ssm_res.table" + "ssm_res.results.round(3)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "id": "a33ca93dde25b889", "metadata": { "ExecuteTime": { @@ -160,7 +1537,6 @@ }, "collapsed": false }, - "outputs": [], "source": [ "lang_angles = {\n", " \"arb\": (0, 65, 97, 131, 182, 255, 281, 335),\n", @@ -192,39 +1568,7 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "e5d424d89e2d808c", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:36.029078Z", - "start_time": "2023-11-25T18:35:35.101478Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "corr_res.profile_plots();" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c7583551aed48dd2", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:36.030018Z", - "start_time": "2023-11-25T18:35:35.899807Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "corr_res.table" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "id": "bf9f01e61ec25305", "metadata": { "ExecuteTime": { @@ -233,35 +1577,67 @@ }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Statistical Basis:   Mean Scores\n",
+       "Bootstrap Resamples: 2000\n",
+       "Confidence Level:    0.95\n",
+       "Listwise Deletion:   True\n",
+       "Scale Displacements: [0.0, 65.0, 97.0, 131.0, 182.0, 255.00000000000003, 281.0, 335.0]\n",
+       "\n",
+       "\n",
+       "                  Profile[All]                   \n",
+       "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n",
+       "┃               Estimate  Lower CI  Upper CI ┃\n",
+       "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n",
+       "│ Elevation    │ 45.041   │ 44.485   │ 45.596   │\n",
+       "│ X-Value      │ 26.004   │ 24.778   │ 27.186   │\n",
+       "│ Y-Value      │ 19.611   │ 18.378   │ 20.826   │\n",
+       "│ Amplitude    │ 32.57    │ 31.542   │ 33.661   │\n",
+       "│ Displacement │ 37.021   │ 34.702   │ 39.371   │\n",
+       "│ Model Fit    │ 0.934    │          │          │\n",
+       "└──────────────┴──────────┴──────────┴──────────┘\n",
+       "
\n" + ], + "text/plain": [ + "Statistical Basis: Mean Scores\n", + "Bootstrap Resamples: \u001b[1;36m2000\u001b[0m\n", + "Confidence Level: \u001b[1;36m0.95\u001b[0m\n", + "Listwise Deletion: \u001b[3;92mTrue\u001b[0m\n", + "Scale Displacements: \u001b[1m[\u001b[0m\u001b[1;36m0.0\u001b[0m, \u001b[1;36m65.0\u001b[0m, \u001b[1;36m97.0\u001b[0m, \u001b[1;36m131.0\u001b[0m, \u001b[1;36m182.0\u001b[0m, \u001b[1;36m255.00000000000003\u001b[0m, \u001b[1;36m281.0\u001b[0m, \u001b[1;36m335.0\u001b[0m\u001b[1m]\u001b[0m\n", + "\n", + "\n", + "\u001b[3m Profile[All] \u001b[0m\n", + "┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mEstimate\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mLower CI\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mUpper CI\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩\n", + "│ Elevation │ 45.041 │ 44.485 │ 45.596 │\n", + "│ X-Value │ 26.004 │ 24.778 │ 27.186 │\n", + "│ Y-Value │ 19.611 │ 18.378 │ 20.826 │\n", + "│ Amplitude │ 32.57 │ 31.542 │ 33.661 │\n", + "│ Displacement │ 37.021 │ 34.702 │ 39.371 │\n", + "│ Model Fit │ 0.934 │ │ │\n", + "└──────────────┴──────────┴──────────┴──────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "lang_data = data[data[\"Language\"] == \"deu\"]\n", "rec_data = data[data[\"Recording\"] == \"CG01\"]\n", "angles = [0, 65, 97, 131, 182, 255, 281, 335]\n", - "# angles = [360 - a for a in angles]\n", - "# angles[0] = 0\n", - "new_ang_results = circumplex.SSMParams(rec_data[scales].mean(), scales, angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "6c83db8be730d642", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:36.030297Z", - "start_time": "2023-11-25T18:35:35.913372Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "new_ang_results.angles" + "new_ang_results = circumplex.ssm_analyze(rec_data, scales, angles=angles)\n", + "\n", + "new_ang_results.summary()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "id": "c2b3a77b1350c969", "metadata": { "ExecuteTime": { @@ -270,14 +1646,26 @@ }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "new_ang_results.profile_plot()" + "new_ang_results.plot_curve()\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 21, "id": "64f3cd8bb92fe5b9", "metadata": { "ExecuteTime": { @@ -286,14 +1674,51 @@ }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "d_est", + "rawType": "float64", + "type": "float" + } + ], + "ref": "d2c90f5e-356c-43d3-bea7-700f82507e66", + "rows": [ + [ + "0", + "37.02" + ] + ], + "shape": { + "columns": 1, + "rows": 1 + } + }, + "text/plain": [ + "0 37.02\n", + "Name: d_est, dtype: float64" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "new_ang_results.displacement" + "new_ang_results.results[\"d_est\"].round(2)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 22, "id": "a00685d5a11367bb", "metadata": { "ExecuteTime": { @@ -302,325 +1727,66 @@ }, "collapsed": false }, - "outputs": [], - "source": [ - "new_ang_results.elevation" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1a75672166b1fd02", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.135583Z", - "start_time": "2023-11-25T18:35:36.036804Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "import soundscapy as sspy\n", - "\n", - "ss_data = sspy.isd.load()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "9f0b5e4a63535199", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.153649Z", - "start_time": "2023-11-25T18:35:37.134917Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "ss_data.query(\"LocationID == 'MonumentoGaribaldi'\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "ce971cc7b2f46236", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.312644Z", - "start_time": "2023-11-25T18:35:37.151777Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "ss_data, excl_data = sspy.isd.validate(ss_data)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "74e7aa3c27c484e8", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.313899Z", - "start_time": "2023-11-25T18:35:37.273277Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "excl_data" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "e165d5b1f2aa841e", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.314125Z", - "start_time": "2023-11-25T18:35:37.286480Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "ss_data.dropna(subset=[\"Appropriate\"], inplace=True)\n", - "ss_data.dropna(subset=[\"LocationID\"], inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "575b5a5e7851ae08", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.558409Z", - "start_time": "2023-11-25T18:35:37.290756Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "%autoreload\n", - "ss_res = circumplex.ssm_analyse(\n", - " ss_data, scales, measures=[\"Appropriate\"], grouping=[\"LocationID\"]\n", - ")\n", - "ss_res.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "a08facba2975a1f0", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:37.573844Z", - "start_time": "2023-11-25T18:35:37.562415Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "ss_res.table" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "a35ed5883bae593d", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:38.957240Z", - "start_time": "2023-11-25T18:35:37.579464Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "ss_res.profile_plots();" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "9a081d5c6031399b", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:39.462712Z", - "start_time": "2023-11-25T18:35:38.956960Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "circumplex.profile_plot(\n", - " 0.22,\n", - " 332.3,\n", - " 0,\n", - " 0.777,\n", - " ss_res.query_label(\"RegentsParkJapan_Appropriate\").angles,\n", - " ss_res.query_label(\"RegentsParkJapan_Appropriate\").scores,\n", - " \"Appropriate\",\n", - ")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "e614fdebb98c3cad", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:39.463289Z", - "start_time": "2023-11-25T18:35:39.110359Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "sspy.plotting.scatter(ss_res.table, x=\"xval\", y=\"yval\")" - ] - }, - { - "cell_type": "markdown", - "id": "82e8807763eff74f", - "metadata": { - "collapsed": false - }, - "source": [ - "## Instruments" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "bbcca11c33dfca66", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:43.674594Z", - "start_time": "2023-11-25T18:35:41.803575Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "from circumplex.datasets import SATP_ENG\n", - "\n", - "satp_eng = SATP_ENG\n", - "satp_eng.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "da11116471121fef", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:48.047926Z", - "start_time": "2023-11-25T18:35:47.955539Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "# Updated to use ssm_analyze instead of ssm_analyse\n", - "satp_eng_res = satp_eng.ssm_analyze(measures=[\"loud\"])\n", - "print(satp_eng_res)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "4c7f315bfc5df6d4", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-25T18:35:58.920878Z", - "start_time": "2023-11-25T18:35:58.891366Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "satp_eng_res = satp_eng.ssm_analyse(measures=[\"loud\"])\n", - "print(satp_eng_res)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6431fbd8bb17bac", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-16T15:56:02.454078Z", - "start_time": "2023-11-16T15:56:02.124062Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "satp_eng_res.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bb2fc8e49a953a75", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-16T15:56:26.744168Z", - "start_time": "2023-11-16T15:56:26.539583Z" - }, - "collapsed": false - }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "e_est", + "rawType": "float64", + "type": "float" + } + ], + "ref": "34ed3860-7251-4670-95f7-fabc854cff8f", + "rows": [ + [ + "0", + "45.04" + ] + ], + "shape": { + "columns": 1, + "rows": 1 + } + }, + "text/plain": [ + "0 45.04\n", + "Name: e_est, dtype: float64" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "satp_eng_res.results[0].profile_plot();" + "new_ang_results.results[\"e_est\"].round(2)" ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8a4a01ca2ed0058c", - "metadata": { - "ExecuteTime": { - "end_time": "2023-11-16T15:56:27.051707Z", - "start_time": "2023-11-16T15:56:27.020638Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a99ea4bcc555038", - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "circumplex (3.12.5)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.5" } }, "nbformat": 4, diff --git a/docs/tutorials/using-instruments.ipynb b/docs/tutorials/using-instruments.ipynb index 7e7b31c..3588042 100644 --- a/docs/tutorials/using-instruments.ipynb +++ b/docs/tutorials/using-instruments.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "initial_id", "metadata": { "ExecuteTime": { @@ -23,19 +23,9 @@ }, "collapsed": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "import circumplex\n", - "import pandas as pd\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -73,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "id": "afc9791b88c08ae9", "metadata": { "ExecuteTime": { @@ -84,19 +74,35 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "The circumplex package currently includes 4 instruments:\n", - "1. CSIP: Circumplex Scales of Interpersonal Problems (CSIP)\n", - "2. IIPSC: Inventory of Interpersonal Problems Short Circumplex (IIP-SC)\n", - "3. SSQP-eng: Swedish Soundscape Quality Protocol - English Translation (SSQP-eng)\n", - "4. SATP-eng: Soundscape Attributes Translation Project - English Translation (SATP-eng)\n" - ] + "data": { + "text/html": [ + "
          The circumplex package currently includes 3 instruments          \n",
+       "┏━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃    Abbreviation  Name                                                 ┃\n",
+       "┡━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ 1 │ CSIG          Circumplex Scales of Interpersonal Goals             │\n",
+       "│ 2 │ IIPSC         Inventory of Interpersonal Problems Short Circumplex │\n",
+       "│ 3 │ IPIPIPC       IPIP Interpersonal Circumplex                        │\n",
+       "└───┴──────────────┴──────────────────────────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m The circumplex package currently includes 3 instruments \u001b[0m\n", + "┏━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mAbbreviation\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mName \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ 1 │\u001b[36m \u001b[0m\u001b[36mCSIG \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mCircumplex Scales of Interpersonal Goals \u001b[0m\u001b[35m \u001b[0m│\n", + "│ 2 │\u001b[36m \u001b[0m\u001b[36mIIPSC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mInventory of Interpersonal Problems Short Circumplex\u001b[0m\u001b[35m \u001b[0m│\n", + "│ 3 │\u001b[36m \u001b[0m\u001b[36mIPIPIPC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35mIPIP Interpersonal Circumplex \u001b[0m\u001b[35m \u001b[0m│\n", + "└───┴──────────────┴──────────────────────────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "circumplex.instrument.instruments()" + "circumplex.show_instruments()" ] }, { @@ -113,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "8ff381ed31a876fa", "metadata": { "ExecuteTime": { @@ -127,16 +133,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "CSIP: Circumplex Scales of Interpersonal Problems\n", - "64 Items, 8 Scales\n", - "Boudreaux, Ozer, Oltmanns, & Wright (2018)\n", - "\n" + "CSIG: Circumplex Scales of Interpersonal Goals\n", + "32 items, 8 scales, 1 normative data sets\n", + "Lock (2014)\n", + "< https://doi.org/10.1177/0146167213514280 >\n" ] } ], "source": [ - "csip = circumplex.instrument.load_instrument(\"CSIP\")\n", - "print(csip)" + "csig = circumplex.get_instrument(\"csig\")\n", + "print(csig)" ] }, { @@ -153,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "id": "a98b0bc63b71e63b", "metadata": { "ExecuteTime": { @@ -163,113 +169,96 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CSIP: Circumplex Scales of Interpersonal Problems\n", - "64 Items, 8 Scales\n", - "Boudreaux, Ozer, Oltmanns, & Wright (2018)\n", - "\n", - "\n", - "The CSIP contains 8 circumplex scales.\n", - "PA: Domineering (90°)\n", - "BC: Self-Centered (135°)\n", - "DE: Distant (180°)\n", - "FG: Socially Inhibited (225°)\n", - "HI: Nonassertive (270°)\n", - "JK: Exploitable (315°)\n", - "LM: Self-Sacrificing (360°)\n", - "NO: Intrusive (45°)\n", - "\n", - "The CSIP is rated using the following 4-point scale.\n", - "0. Not a problem\n", - "1. Minor problem\n", - "2. Moderate problem\n", - "3. Serious problem\n", - "\n", - "The CSIP contains 64 items (open-access).\n", - "1. Bossing around other people too much\n", - "2. Acting rude and inconsiderate toward others\n", - "3. Pushing away from other people who get too close\n", - "4. Difficulty making friends\n", - "5. Lacking self-confidence\n", - "6. Letting other people boss me around too much\n", - "7. Putting other people's needs before my own too much\n", - "8. Being overly affectionate with others\n", - "9. Verbally or physically abusing others\n", - "10. Acting selfishly with others\n", - "11. Difficulty showing love and affection to others\n", - "12. Having trouble fitting in with others\n", - "13. Getting easily embarrassed in front of others\n", - "14. Acting overly submissive with others\n", - "15. Giving too much to others\n", - "16. Difficulty keeping personal matters private from others\n", - "17. Starting arguments and conflicts with others\n", - "18. Being unable to feel guilt or remorse\n", - "19. Being unable to enjoy the company of others\n", - "20. Avoiding people or social situations\n", - "21. Difficulty taking the lead\n", - "22. Being unable to express anger toward others\n", - "23. Forgiving people too easily\n", - "24. Talking too much\n", - "25. Trying to influence or control other people too much\n", - "26. Lacking respect for other people's beliefs, attitudes, or opinions\n", - "27. Feeling emotionally disconnected from others\n", - "28. Being unable to keep conversations going\n", - "29. Having trouble asserting myself\n", - "30. Being too concerned about what other people think\n", - "31. Being overly sentimental or tender-hearted\n", - "32. Flirting with other people too much\n", - "33. Dominating or intimidating others\n", - "34. Having trouble getting along with others\n", - "35. Difficulty developing close and lasting relationships\n", - "36. Feeling like an outsider in most social situations\n", - "37. Feeling weak and insecure around dominant others\n", - "38. Being easily taken advantage of\n", - "39. Being easily affected by the pain and suffering of others\n", - "40. Having trouble respecting other people's privacy\n", - "41. Acting aggressively toward others\n", - "42. Being insensitive to the thoughts, feelings, and needs of others\n", - "43. Being unable to fully connect with others\n", - "44. Being unable to be myself around others\n", - "45. Being unable to stand up to others\n", - "46. Compromising with other people too much\n", - "47. Trusting people too easily\n", - "48. Exaggerating so that other people will respect me\n", - "49. Manipulating other people to get what I want\n", - "50. Disliking most people\n", - "51. Difficulty opening up to others\n", - "52. Feeling fearful or nervous in social situations\n", - "53. Avoiding confrontation when problems arise\n", - "54. Being easily influenced by others\n", - "55. Trying to solve other people's problems too much\n", - "56. Confronting people too quickly about problems\n", - "57. Acting superior or condescending toward others\n", - "58. Having trouble giving emotional or moral support to others\n", - "59. Feeling uncomfortable with being close or intimate with others\n", - "60. Acting shy around others\n", - "61. Letting other people make decisions too often\n", - "62. Being unable to say 'no'\n", - "63. Getting too attached to others\n", - "64. Needing to be the center of attention\n", - "\n", - "No data has been loaded for this instrument. Use attach_data() to load data.\n" - ] + "data": { + "text/html": [ + "
CSIG: Circumplex Scales of Interpersonal Goals\n",
+       "32 items, 8 scales, 1 normative data sets\n",
+       "Lock (2014)\n",
+       "< https://doi.org/10.1177/0146167213514280 >\n",
+       "\n",
+       "\n",
+       "The CSIG contains 8 scales:\n",
+       "├── PA (90°): Be authoritative\n",
+       "├── BC (135°): Be tough\n",
+       "├── DE (180°): Be self-protective\n",
+       "├── FG (225°): Be wary\n",
+       "├── HI (270°): Be conflict-avoidant\n",
+       "├── JK (315°): Be cooperative\n",
+       "├── LM (360°): Be understanding\n",
+       "└── NO (45°): Be respected\n",
+       "\n",
+       "\n",
+       "The CSIG is rated using the following 5-point scale:\n",
+       "  0. It is not at all important that...\n",
+       "  1. It is somewhat important that...\n",
+       "  2. It is moderately important that...\n",
+       "  3. It is very important that...\n",
+       "  4. It is extremely important that...\n",
+       "\n",
+       "\n",
+       "\n",
+       "The CSIG currently has 1 normative data set(s):\n",
+       "\n",
+       "1. 665 MTurkers from US, Canada, and India about interactions between nations\n",
+       "   Lock (2014)\n",
+       "   https://doi.org/10.1177/0146167213514280\n",
+       "\n",
+       "
\n" + ], + "text/plain": [ + "CSIG: Circumplex Scales of Interpersonal Goals\n", + "\u001b[1;36m32\u001b[0m items, \u001b[1;36m8\u001b[0m scales, \u001b[1;36m1\u001b[0m normative data sets\n", + "Lock \u001b[1m(\u001b[0m\u001b[1;36m2014\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m<\u001b[0m\u001b[39m \u001b[0m\u001b[4;94mhttps://doi.org/10.1177/0146167213514280\u001b[0m\u001b[39m \u001b[0m\u001b[1m>\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Be authoritative\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Be tough\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Be self-protective\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Be wary\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Be conflict-avoidant\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Be cooperative\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Be understanding\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Be respected\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG is rated using the following 5-point scale:\u001b[0m\n", + " 0. It is not at all important that...\n", + " 1. It is somewhat important that...\n", + " 2. It is moderately important that...\n", + " 3. It is very important that...\n", + " 4. It is extremely important that...\n", + "\n", + "\n", + "\n", + "\u001b[1;36mThe CSIG currently has 1 normative data set(s):\u001b[0m\n", + "\n", + "1. 665 MTurkers from US, Canada, and India about interactions between nations\n", + " Lock (2014)\n", + " https://doi.org/10.1177/0146167213514280\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "csip.summary()" + "csig.info()" ] }, { "cell_type": "markdown", "id": "5478d2bce6a5a2dc", "metadata": {}, - "source": "Specific subsections of this output can be returned individually by printing the `scales`, `anchors`, `items`, and `norms` attributes of the instrument object. These functions are especially useful when you need to know a specific bit of information about an instrument and don't want the console to be flooded with unneeded information. " + "source": [ + "Specific subsections of this output can be returned individually by printing the `scales`, `anchors`, `items`, and `norms` attributes of the instrument object. These functions are especially useful when you need to know a specific bit of information about an instrument and don't want the console to be flooded with unneeded information. " + ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "id": "feca079741ba597c", "metadata": { "ExecuteTime": { @@ -279,58 +268,47 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "0. Not a problem\n", - "1. Minor problem\n", - "2. Moderate problem\n", - "3. Serious problem\n" - ] + "data": { + "text/html": [ + "
The CSIG is rated using the following 5-point scale:\n",
+       "  0. It is not at all important that...\n",
+       "  1. It is somewhat important that...\n",
+       "  2. It is moderately important that...\n",
+       "  3. It is very important that...\n",
+       "  4. It is extremely important that...\n",
+       "\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;36mThe CSIG is rated using the following 5-point scale:\u001b[0m\n", + " 0. It is not at all important that...\n", + " 1. It is somewhat important that...\n", + " 2. It is moderately important that...\n", + " 3. It is very important that...\n", + " 4. It is extremely important that...\n", + "\n" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "csip.anchors.show()" + "csig.info_anchors()" ] }, { "cell_type": "markdown", "id": "87ccb43033467e56", "metadata": {}, - "source": "Some of these attributes also have additional methods to customize their output. For instance, the `scales` attribute has a `.show()` method which includes the option to display the items for each scale." - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "b58a3bb64fb04fd7", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-11T14:46:10.278642Z", - "start_time": "2024-07-11T14:46:10.258908Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1. Bossing around other people too much\n", - "2. Acting rude and inconsiderate toward others\n", - "3. Pushing away from other people who get too close\n", - "4. Difficulty making friends\n", - "5. Lacking self-confidence\n", - "\n", - "...and 59 more items.\n" - ] - } - ], "source": [ - "csip.inst_items.show(n=5)" + "Some of these attributes also have additional methods to customize their output. For instance, the `scales` attribute has a `.show()` method which includes the option to display the items for each scale." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "id": "abbc4313ebd35297", "metadata": { "ExecuteTime": { @@ -340,86 +318,102 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "PA: Domineering (90°)\n", - "\t1: Bossing around other people too much\n", - "\t9: Verbally or physically abusing others\n", - "\t17: Starting arguments and conflicts with others\n", - "\t25: Trying to influence or control other people too much\n", - "\t33: Dominating or intimidating others\n", - "\t41: Acting aggressively toward others\n", - "\t49: Manipulating other people to get what I want\n", - "\t57: Acting superior or condescending toward others\n", - "BC: Self-Centered (135°)\n", - "\t2: Acting rude and inconsiderate toward others\n", - "\t10: Acting selfishly with others\n", - "\t18: Being unable to feel guilt or remorse\n", - "\t26: Lacking respect for other people's beliefs, attitudes, or opinions\n", - "\t34: Having trouble getting along with others\n", - "\t42: Being insensitive to the thoughts, feelings, and needs of others\n", - "\t50: Disliking most people\n", - "\t58: Having trouble giving emotional or moral support to others\n", - "DE: Distant (180°)\n", - "\t3: Pushing away from other people who get too close\n", - "\t11: Difficulty showing love and affection to others\n", - "\t19: Being unable to enjoy the company of others\n", - "\t27: Feeling emotionally disconnected from others\n", - "\t35: Difficulty developing close and lasting relationships\n", - "\t43: Being unable to fully connect with others\n", - "\t51: Difficulty opening up to others\n", - "\t59: Feeling uncomfortable with being close or intimate with others\n", - "FG: Socially Inhibited (225°)\n", - "\t4: Difficulty making friends\n", - "\t12: Having trouble fitting in with others\n", - "\t20: Avoiding people or social situations\n", - "\t28: Being unable to keep conversations going\n", - "\t36: Feeling like an outsider in most social situations\n", - "\t44: Being unable to be myself around others\n", - "\t52: Feeling fearful or nervous in social situations\n", - "\t60: Acting shy around others\n", - "HI: Nonassertive (270°)\n", - "\t5: Lacking self-confidence\n", - "\t13: Getting easily embarrassed in front of others\n", - "\t21: Difficulty taking the lead\n", - "\t29: Having trouble asserting myself\n", - "\t37: Feeling weak and insecure around dominant others\n", - "\t45: Being unable to stand up to others\n", - "\t53: Avoiding confrontation when problems arise\n", - "\t61: Letting other people make decisions too often\n", - "JK: Exploitable (315°)\n", - "\t6: Letting other people boss me around too much\n", - "\t14: Acting overly submissive with others\n", - "\t22: Being unable to express anger toward others\n", - "\t30: Being too concerned about what other people think\n", - "\t38: Being easily taken advantage of\n", - "\t46: Compromising with other people too much\n", - "\t54: Being easily influenced by others\n", - "\t62: Being unable to say 'no'\n", - "LM: Self-Sacrificing (360°)\n", - "\t7: Putting other people's needs before my own too much\n", - "\t15: Giving too much to others\n", - "\t23: Forgiving people too easily\n", - "\t31: Being overly sentimental or tender-hearted\n", - "\t39: Being easily affected by the pain and suffering of others\n", - "\t47: Trusting people too easily\n", - "\t55: Trying to solve other people's problems too much\n", - "\t63: Getting too attached to others\n", - "NO: Intrusive (45°)\n", - "\t8: Being overly affectionate with others\n", - "\t16: Difficulty keeping personal matters private from others\n", - "\t24: Talking too much\n", - "\t32: Flirting with other people too much\n", - "\t40: Having trouble respecting other people's privacy\n", - "\t48: Exaggerating so that other people will respect me\n", - "\t56: Confronting people too quickly about problems\n", - "\t64: Needing to be the center of attention\n" - ] + "data": { + "text/html": [ + "
The CSIG contains 8 scales:\n",
+       "├── PA (90°): Be authoritative\n",
+       "│   ├── 8. We are assertive\n",
+       "│   ├── 16. We appear confident\n",
+       "│   ├── 24. We are decisive\n",
+       "│   └── 32. They see us as capable\n",
+       "├── BC (135°): Be tough\n",
+       "│   ├── 5. We show that we can be tough\n",
+       "│   ├── 12. They not get angry with us\n",
+       "│   ├── 21. We are aggressive if necessary\n",
+       "│   └── 29. We not show our weaknesses\n",
+       "├── DE (180°): Be self-protective\n",
+       "│   ├── 2. We are the winners in any argument or dispute\n",
+       "│   ├── 10. We do whatever is in our best interest\n",
+       "│   ├── 18. We are better than them\n",
+       "│   └── 26. We keep our guard up\n",
+       "├── FG (225°): Be wary\n",
+       "│   ├── 7. We let them fend for themselves\n",
+       "│   ├── 15. They stay out of our business\n",
+       "│   ├── 23. We not trust them\n",
+       "│   └── 31. We not get entangled in their affairs\n",
+       "├── HI (270°): Be conflict-avoidant\n",
+       "│   ├── 4. We avoid conflict\n",
+       "│   ├── 12. They not get angry with us\n",
+       "│   ├── 20. We not get into arguments\n",
+       "│   └── 28. We not make them angry\n",
+       "├── JK (315°): Be cooperative\n",
+       "│   ├── 1. We are friendly\n",
+       "│   ├── 9. We celebrate their achievements\n",
+       "│   ├── 17. They feel we are all on the same team\n",
+       "│   └── 25. We are cooperative\n",
+       "├── LM (360°): Be understanding\n",
+       "│   ├── 6. We appreciate what they have to offer\n",
+       "│   ├── 14. We understand their point of view\n",
+       "│   ├── 22. We show concern for their welfare\n",
+       "│   └── 30. We are able to compromise\n",
+       "└── NO (45°): Be respected\n",
+       "    ├── 3. They respect what we have to say\n",
+       "    ├── 11. We get the chance to express our views\n",
+       "    ├── 19. They listen to what we have to say\n",
+       "    └── 27. They see us as responsible\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;36mThe CSIG contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Be authoritative\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m8. We are assertive\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m16. We appear confident\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m24. We are decisive\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m32. They see us as capable\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Be tough\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m5. We show that we can be tough\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m12. They not get angry with us\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m21. We are aggressive if necessary\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m29. We not show our weaknesses\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Be self-protective\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m2. We are the winners in any argument or dispute\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m10. We do whatever is in our best interest\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m18. We are better than them\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m26. We keep our guard up\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Be wary\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m7. We let them fend for themselves\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m15. They stay out of our business\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m23. We not trust them\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m31. We not get entangled in their affairs\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Be conflict-avoidant\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m4. We avoid conflict\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m12. They not get angry with us\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m20. We not get into arguments\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m28. We not make them angry\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Be cooperative\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m1. We are friendly\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m9. We celebrate their achievements\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m17. They feel we are all on the same team\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m25. We are cooperative\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Be understanding\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m6. We appreciate what they have to offer\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m14. We understand their point of view\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m22. We show concern for their welfare\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m30. We are able to compromise\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Be respected\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m3. They respect what we have to say\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m11. We get the chance to express our views\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m19. They listen to what we have to say\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m27. They see us as responsible\u001b[0m\n" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "csip.scales.show(inst_items=True)" + "csig.info_scales(items=True)" ] }, { @@ -438,7 +432,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "id": "66641d626662906c", "metadata": { "ExecuteTime": { @@ -451,34 +445,32 @@ "name": "stdout", "output_type": "stream", "text": [ - " IIP01 IIP02 IIP03 IIP04 IIP05 IIP06 IIP07 IIP08 IIP09 IIP10 ... \\\n", - "0 0 0 0 0.0 1 0 1 0 2 1 ... \n", - "1 1 1 0 0.0 3 2 2 1 0 1 ... \n", - "2 1 0 1 0.0 1 1 1 3 0 1 ... \n", - "3 3 2 3 NaN 2 3 2 3 2 3 ... \n", - "4 0 0 0 1.0 0 0 1 1 0 1 ... \n", - "\n", - " IIP23 IIP24 IIP25 IIP26 IIP27 IIP28 IIP29 IIP30 IIP31 IIP32 \n", - "0 0 0 3 3 3 0 0 0 1 0 \n", - "1 0 0 0 0 0 1 0 0 0 2 \n", - "2 3 1 1 1 1 0 3 2 3 2 \n", - "3 3 2 1 2 3 2 3 2 3 2 \n", - "4 1 1 2 1 0 0 0 0 0 0 \n", + " Gender PA BC DE FG HI JK LM NO PARPD SCZPD \\\n", + "0 Female 1.50 1.50 1.25 1.00 2.00 2.50 2.25 2.50 4 3 \n", + "1 Female 0.00 0.25 0.00 0.25 1.25 1.75 2.25 2.25 1 0 \n", + "2 Female 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0 1 \n", + "3 Male 2.00 1.75 1.75 2.50 2.00 1.75 2.00 2.50 1 0 \n", + "4 Female 0.25 0.50 0.25 0.00 0.00 0.00 0.00 0.00 0 0 \n", "\n", - "[5 rows x 32 columns]\n" + " SZTPD ASPD BORPD HISPD NARPD AVPD DPNPD OCPD \n", + "0 7 7 8 4 6 3 4 6 \n", + "1 2 0 1 2 3 0 1 0 \n", + "2 0 4 1 5 4 0 0 1 \n", + "3 0 0 1 0 0 0 0 0 \n", + "4 0 0 1 0 0 1 0 0 \n" ] } ], "source": [ - "from circumplex.datasets import _raw_iipsc_path\n", + "from circumplex import load_dataset\n", "\n", - "raw_iipsc = pd.read_csv(_raw_iipsc_path)\n", - "print(raw_iipsc.head())" + "raw_jz2017 = load_dataset(\"jz2017\")\n", + "print(raw_jz2017.head())" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "6e68baa5510c4f4b", "metadata": { "ExecuteTime": { @@ -486,486 +478,156 @@ "start_time": "2024-07-11T14:46:15.053171Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", - "32 Items, 8 Scales\n", - "Soldz, Budman, Demby, & Merry (1995)\n", - "\n", - "\n", - "The IIP-SC contains 8 circumplex scales.\n", - "PA: Domineering (90°)\n", - "BC: Vindictive (135°)\n", - "DE: Cold (180°)\n", - "FG: Socially Avoidant (225°)\n", - "HI: Nonassertive (270°)\n", - "JK: Exploitable (315°)\n", - "LM: Overly Nurturant (360°)\n", - "NO: Intrusive (45°)\n", - "\n", - "The IIP-SC is rated using the following 5-point scale.\n", - "0. Not at all\n", - "1. Somewhat\n", - "2. Moderately\n", - "3. Very\n", - "4. Extremely\n", - "\n", - "The IIP-SC contains 32 items (partial text).\n", - "1. ...point of view...\n", - "2. ...supportive of another...\n", - "3. ...show affection to...\n", - "4. ...join in on...\n", - "5. ...stop bothering me...\n", - "6. ...I am angry...\n", - "7. ...my own welfare...\n", - "8. ...keep things private...\n", - "9. ...too aggressive toward...\n", - "10. ...another person's happiness...\n", - "11. ...feeling of love...\n", - "12. ...introduce myself to...\n", - "13. ...confront people with...\n", - "14. ...assertive without worrying...\n", - "15. ...please other people...\n", - "16. ...open up to...\n", - "17. ...control other people...\n", - "18. ...too suspicious of...\n", - "19. ...feel close to...\n", - "20. ...socialize with other...\n", - "21. ...assertive with another...\n", - "22. ...too easily persuaded...\n", - "23. ...other people's needs...\n", - "24. ...noticed too much...\n", - "25. ...argue with other...\n", - "26. ...revenge against people...\n", - "27. ...at a distance...\n", - "28. ...get together socially...\n", - "29. ...to be firm...\n", - "30. ...people take advantage...\n", - "31. ...another person's misery...\n", - "32. ...tell personal things...\n", - "\n", - "No data has been loaded for this instrument. Use attach_data() to load data.\n" - ] - } - ], - "source": [ - "iipsc = circumplex.instrument.load_instrument(\"IIPSC\")\n", - "iipsc.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5926c67e18f9c763", - "metadata": { - "ExecuteTime": { - "end_time": "2024-07-11T13:55:47.032197Z", - "start_time": "2024-07-11T13:55:47.016643Z" - } - }, - "outputs": [], - "source": [ - "def score(data, instrument, na_rm=True, prorate=True):\n", - " \"\"\"Score item-level data using an instrument object.\n", - "\n", - " Args:\n", - " data (pandas.DataFrame): A data frame where each row corresponds to one observation\n", - " (e.g. participant, organization, timepoint) and each column corresponds to one variable\n", - " describing these observations (e.g. item responses, demographic characteristics, scale scores).\n", - " instrument (circumplex.instrument.Instrument): An instrument object loaded using the load_instrument() function.\n", - " impute (bool): Whether to impute missing values before scoring.\n", - " prorate (bool): Whether to prorate scale scores when missing values are present.\n", - "\n", - " Returns:\n", - " pandas.DataFrame: A data frame where each row corresponds to one observation and each column\n", - " corresponds to one variable describing these observations (e.g. item responses, demographic characteristics, scale scores).\n", - " \"\"\"\n", - " # Step 1: Impute missing values\n", - " # if impute:\n", - " # data = circumplex.impute(data)\n", - "\n", - " # assert set(data.columns).issubset(instrument.inst_items.keys()), \"Invalid item(s) selected.\"\n", - "\n", - " for i, scale in enumerate(instrument.scales.abbrev):\n", - " items = list(instrument.scales.inst_items[i].keys())\n", - " data[scale] = data.loc[:, items].mean(axis=1)\n", - "\n", - " return data" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "aadb417f8d90a221", - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-22T14:36:35.017729Z", - "start_time": "2024-06-22T14:36:34.991573Z" - } - }, "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", - " \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", - " \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", - "
12345678910...3132PABCDEFGHIJKLMNO
00000.0101021...101.752.001.250.0000000.500.2500001.500.75
11100.0322101...020.250.500.250.5000002.001.7500001.251.00
21010.0111301...321.000.750.750.0000002.252.0000002.502.00
3323NaN232323...321.752.252.502.3333332.502.0000002.502.50
40001.0001101...000.500.750.001.0000000.500.2500001.250.75
50000.0001100...010.250.000.000.0000000.000.0000001.001.00
61000.0211010...001.000.000.000.0000001.001.0000000.750.25
71010.0112110...211.000.250.750.0000000.500.6666671.751.00
80022.0013010...300.750.501.500.7500000.001.0000002.750.50
90000.0002000...000.000.000.000.0000000.000.5000001.000.25
\n", - "

10 rows × 40 columns

\n", - "
" + "
IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n",
+       "32 items, 8 scales, 2 normative data sets\n",
+       "Soldz, Budman, Demby, & Merry (1995)\n",
+       "< https://doi.org/10.1177/1073191195002001006 >\n",
+       "\n",
+       "\n",
+       "The IIP-SC contains 8 scales:\n",
+       "├── PA (90°): Domineering\n",
+       "│   ├── 1. ...point of view...\n",
+       "│   ├── 9. ...too aggressive toward...\n",
+       "│   ├── 17. ...control other people...\n",
+       "│   └── 25. ...argue with other...\n",
+       "├── BC (135°): Vindictive\n",
+       "│   ├── 2. ...supportive of another...\n",
+       "│   ├── 10. ...another person's happiness...\n",
+       "│   ├── 18. ...too suspicious of...\n",
+       "│   └── 26. ...revenge against people...\n",
+       "├── DE (180°): Cold\n",
+       "│   ├── 3. ...show affection to...\n",
+       "│   ├── 11. ...feeling of love...\n",
+       "│   ├── 19. ...feel close to...\n",
+       "│   └── 27. ...at a distance...\n",
+       "├── FG (225°): Socially avoidant\n",
+       "│   ├── 4. ...join in on...\n",
+       "│   ├── 12. ...introduce myself to...\n",
+       "│   ├── 20. ...socialize with other...\n",
+       "│   └── 28. ...get together socially...\n",
+       "├── HI (270°): Nonassertive\n",
+       "│   ├── 5. ...stop bothering me...\n",
+       "│   ├── 13. ...confront people with...\n",
+       "│   ├── 21. ...assertive with another...\n",
+       "│   └── 29. ...to be firm...\n",
+       "├── JK (315°): Exploitable\n",
+       "│   ├── 6. ...I am angry...\n",
+       "│   ├── 14. ...assertive without worrying...\n",
+       "│   ├── 22. ...too easily persuaded...\n",
+       "│   └── 30. ...people take advantage...\n",
+       "├── LM (360°): Overly nurturant\n",
+       "│   ├── 7. ...my own welfare...\n",
+       "│   ├── 15. ...please other people...\n",
+       "│   ├── 23. ...other people's needs...\n",
+       "│   └── 31. ...another person's misery...\n",
+       "└── NO (45°): Intrusive\n",
+       "    ├── 8. ...keep things private...\n",
+       "    ├── 16. ...open up to...\n",
+       "    ├── 24. ...noticed too much...\n",
+       "    └── 32. ...tell personal things...\n",
+       "\n",
+       "\n",
+       "The IIP-SC is rated using the following 5-point scale:\n",
+       "  0. Not at all\n",
+       "  1. Somewhat\n",
+       "  2. Moderately\n",
+       "  3. Very\n",
+       "  4. Extremely\n",
+       "\n",
+       "\n",
+       "\n",
+       "The IIP-SC currently has 2 normative data set(s):\n",
+       "\n",
+       "1. 872 American college students\n",
+       "   Hopwood, Pincus, DeMoor, & Koonce (2011)\n",
+       "   https://doi.org/10.1080/00223890802388665\n",
+       "2. 106 American psychiatric outpatients\n",
+       "   Soldz, Budman, Demby, & Merry (1995)\n",
+       "   https://doi.org/10.1177/1073191195002001006\n",
+       "\n",
+       "
\n" ], "text/plain": [ - " 1 2 3 4 5 6 7 8 9 10 ... 31 32 PA BC DE FG \\\n", - "0 0 0 0 0.0 1 0 1 0 2 1 ... 1 0 1.75 2.00 1.25 0.000000 \n", - "1 1 1 0 0.0 3 2 2 1 0 1 ... 0 2 0.25 0.50 0.25 0.500000 \n", - "2 1 0 1 0.0 1 1 1 3 0 1 ... 3 2 1.00 0.75 0.75 0.000000 \n", - "3 3 2 3 NaN 2 3 2 3 2 3 ... 3 2 1.75 2.25 2.50 2.333333 \n", - "4 0 0 0 1.0 0 0 1 1 0 1 ... 0 0 0.50 0.75 0.00 1.000000 \n", - "5 0 0 0 0.0 0 0 1 1 0 0 ... 0 1 0.25 0.00 0.00 0.000000 \n", - "6 1 0 0 0.0 2 1 1 0 1 0 ... 0 0 1.00 0.00 0.00 0.000000 \n", - "7 1 0 1 0.0 1 1 2 1 1 0 ... 2 1 1.00 0.25 0.75 0.000000 \n", - "8 0 0 2 2.0 0 1 3 0 1 0 ... 3 0 0.75 0.50 1.50 0.750000 \n", - "9 0 0 0 0.0 0 0 2 0 0 0 ... 0 0 0.00 0.00 0.00 0.000000 \n", - "\n", - " HI JK LM NO \n", - "0 0.50 0.250000 1.50 0.75 \n", - "1 2.00 1.750000 1.25 1.00 \n", - "2 2.25 2.000000 2.50 2.00 \n", - "3 2.50 2.000000 2.50 2.50 \n", - "4 0.50 0.250000 1.25 0.75 \n", - "5 0.00 0.000000 1.00 1.00 \n", - "6 1.00 1.000000 0.75 0.25 \n", - "7 0.50 0.666667 1.75 1.00 \n", - "8 0.00 1.000000 2.75 0.50 \n", - "9 0.00 0.500000 1.00 0.25 \n", - "\n", - "[10 rows x 40 columns]" + "IIP-SC: Inventory of Interpersonal Problems Short Circumplex\n", + "\u001b[1;36m32\u001b[0m items, \u001b[1;36m8\u001b[0m scales, \u001b[1;36m2\u001b[0m normative data sets\n", + "Soldz, Budman, Demby, & Merry \u001b[1m(\u001b[0m\u001b[1;36m1995\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m<\u001b[0m\u001b[39m \u001b[0m\u001b[4;94mhttps://doi.org/10.1177/1073191195002001006\u001b[0m\u001b[39m \u001b[0m\u001b[1m>\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC contains 8 scales:\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mPA (90°): Domineering\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m1. ...point of view...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m9. ...too aggressive toward...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m17. ...control other people...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m25. ...argue with other...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mBC (135°): Vindictive\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m2. ...supportive of another...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m10. ...another person's happiness...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m18. ...too suspicious of...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m26. ...revenge against people...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mDE (180°): Cold\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m3. ...show affection to...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m11. ...feeling of love...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m19. ...feel close to...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m27. ...at a distance...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mFG (225°): Socially avoidant\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m4. ...join in on...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m12. ...introduce myself to...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m20. ...socialize with other...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m28. ...get together socially...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mHI (270°): Nonassertive\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m5. ...stop bothering me...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m13. ...confront people with...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m21. ...assertive with another...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m29. ...to be firm...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mJK (315°): Exploitable\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m6. ...I am angry...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m14. ...assertive without worrying...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m22. ...too easily persuaded...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m30. ...people take advantage...\u001b[0m\n", + "\u001b[2m├── \u001b[0m\u001b[1mLM (360°): Overly nurturant\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m7. ...my own welfare...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m15. ...please other people...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m23. ...other people's needs...\u001b[0m\n", + "\u001b[2m│ \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m31. ...another person's misery...\u001b[0m\n", + "\u001b[2m└── \u001b[0m\u001b[1mNO (45°): Intrusive\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m8. ...keep things private...\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m16. ...open up to...\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m├── \u001b[0m\u001b[1;2m24. ...noticed too much...\u001b[0m\n", + "\u001b[2m \u001b[0m\u001b[2m└── \u001b[0m\u001b[1;2m32. ...tell personal things...\u001b[0m\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC is rated using the following 5-point scale:\u001b[0m\n", + " 0. Not at all\n", + " 1. Somewhat\n", + " 2. Moderately\n", + " 3. Very\n", + " 4. Extremely\n", + "\n", + "\n", + "\n", + "\u001b[1;36mThe IIP-SC currently has 2 normative data set(s):\u001b[0m\n", + "\n", + "1. 872 American college students\n", + " Hopwood, Pincus, DeMoor, & Koonce (2011)\n", + " https://doi.org/10.1080/00223890802388665\n", + "2. 106 American psychiatric outpatients\n", + " Soldz, Budman, Demby, & Merry (1995)\n", + " https://doi.org/10.1177/1073191195002001006\n", + "\n" ] }, - "execution_count": 13, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "\n", - "raw_iipsc.columns = np.arange(1, len(raw_iipsc.columns) + 1).astype(str)\n", - "\n", - "score(raw_iipsc, iipsc)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a3415037988572aa", - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-22T14:34:19.353285Z", - "start_time": "2024-06-22T14:34:19.088690Z" - } - }, - "outputs": [ - { - "ename": "KeyError", - "evalue": "\"None of [Index(['1', '9', '17', '25'], dtype='object')] are in the [columns]\"", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mraw_iipsc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m9\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m17\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m25\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\n", - "File \u001b[0;32m~/Documents/GitHub/circumplex/.venv/lib/python3.11/site-packages/pandas/core/frame.py:3902\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3900\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_iterator(key):\n\u001b[1;32m 3901\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(key)\n\u001b[0;32m-> 3902\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_indexer_strict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcolumns\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m[\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 3904\u001b[0m \u001b[38;5;66;03m# take() does not accept boolean indexers\u001b[39;00m\n\u001b[1;32m 3905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(indexer, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdtype\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mbool\u001b[39m:\n", - "File \u001b[0;32m~/Documents/GitHub/circumplex/.venv/lib/python3.11/site-packages/pandas/core/indexes/base.py:6114\u001b[0m, in \u001b[0;36mIndex._get_indexer_strict\u001b[0;34m(self, key, axis_name)\u001b[0m\n\u001b[1;32m 6111\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 6112\u001b[0m keyarr, indexer, new_indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reindex_non_unique(keyarr)\n\u001b[0;32m-> 6114\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_raise_if_missing\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkeyarr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6116\u001b[0m keyarr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtake(indexer)\n\u001b[1;32m 6117\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(key, Index):\n\u001b[1;32m 6118\u001b[0m \u001b[38;5;66;03m# GH 42790 - Preserve name from an Index\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/GitHub/circumplex/.venv/lib/python3.11/site-packages/pandas/core/indexes/base.py:6175\u001b[0m, in \u001b[0;36mIndex._raise_if_missing\u001b[0;34m(self, key, indexer, axis_name)\u001b[0m\n\u001b[1;32m 6173\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_interval_msg:\n\u001b[1;32m 6174\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(key)\n\u001b[0;32m-> 6175\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNone of [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m] are in the [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 6177\u001b[0m not_found \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(ensure_index(key)[missing_mask\u001b[38;5;241m.\u001b[39mnonzero()[\u001b[38;5;241m0\u001b[39m]]\u001b[38;5;241m.\u001b[39munique())\n\u001b[1;32m 6178\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnot_found\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not in index\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mKeyError\u001b[0m: \"None of [Index(['1', '9', '17', '25'], dtype='object')] are in the [columns]\"" - ] + "output_type": "display_data" } ], "source": [ - "raw_iipsc[[\"1\", \"9\", \"17\", \"25\"]]" + "iipsc = circumplex.get_instrument(\"iipsc\")\n", + "iipsc.info(items=True)" ] }, { @@ -979,21 +641,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "circumplex (3.12.5)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.5" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 0cba273..661924e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,8 +10,8 @@ dev = [ "tox>=4.30.3", "twine>=6.2.0", "ty>=0.0.1a21", - { include-group = "docs" }, - { include-group = "test" }, + {include-group = "docs"}, + {include-group = "test"}, ] docs = [ "mike>=2.1.3", @@ -35,7 +35,7 @@ test = [ [project] authors = [ - { email = "andrew.mitchell.research@gmail.com", name = "Andrew Mitchell" }, + {email = "andrew.mitchell.research@gmail.com", name = "Andrew Mitchell"}, ] classifiers = [ "Operating System :: POSIX", @@ -50,7 +50,7 @@ dependencies = [ "matplotlib>=3.10.7", "nptyping>=2.0.1", "numpy>=2.3.3", - "pandas>=2.3.3", + "pandas[excel]>=2.3.3", "scipy>=1.16.2", "seaborn>=0.13.2", ] @@ -77,7 +77,7 @@ repository = "https://github.com/MitchellAcoustics/circumplex" [tool.coverage] omit = ["*/__pycache__/*", "*/tests/*"] -run = { branch = true, parallel = true, source = ["circumplex"] } +run = {branch = true, parallel = true, source = ["circumplex"]} paths.source = ["src", ".tox*/*/lib/python*/site-packages"] [tool.coverage.report] @@ -115,35 +115,35 @@ testpaths = ["tests"] fix = true force-exclude = true lint.ignore = [ - "ANN401", # Dynamically typed expressions (typing.Any) are disallowed in `**kwargs` - "COM812", # trailing commas (ruff-format recommended) - "D417", # argument description in docstring (unreliable) - "ISC001", # simplify implicit str concatenation (ruff-format recommended) - "NPY002", # legacy np.random (required for R parity) + "ANN401", # Dynamically typed expressions (typing.Any) are disallowed in `**kwargs` + "COM812", # trailing commas (ruff-format recommended) + "D417", # argument description in docstring (unreliable) + "ISC001", # simplify implicit str concatenation (ruff-format recommended) + "NPY002", # legacy np.random (required for R parity) "PERF401", # list.extend suggestion (readability over micro-optimization) "PLR0912", # too many branches (acceptable for RTHOR algorithm complexity) "PLR0913", # too many arguments (acceptable for algorithm functions) "PLR2004", # magic value comparison (acceptable for algorithm constants) - "TC002", # type checking blocks (would break runtime imports) - "TC003", # type checking blocks (would break runtime imports) - "UP037", # Remove quotes from type annotation + "TC002", # type checking blocks (would break runtime imports) + "TC003", # type checking blocks (would break runtime imports) + "UP037", # Remove quotes from type annotation ] -lint.per-file-ignores = { "*.ipynb" = [ +lint.per-file-ignores = {"*.ipynb" = [ "T201", # print statement found ], "*demo.py" = [ - "E501", # line-too-long + "E501", # line-too-long "INP001", # File is part of an implicit namespace package. - "T201", # print statement found + "T201", # print statement found ], "tests*" = [ - "ANN001", # missing type annotation for function (test code) - "ANN201", # missing type annotation for self in methods (test code) - "D100", # missing docstring in public module (test code) - "D103", # missing docstring in public function (test code) - "ERA001", # assertRaises(Exception) (test code) - "INP001", # File is part of an implicit namespace package. + "ANN001", # missing type annotation for function (test code) + "ANN201", # missing type annotation for self in methods (test code) + "D100", # missing docstring in public module (test code) + "D103", # missing docstring in public function (test code) + "ERA001", # assertRaises(Exception) (test code) + "INP001", # File is part of an implicit namespace package. "PLR2004", # magic value comparison (test code) - "S101", # Use of `assert` detected -] } + "S101", # Use of `assert` detected +]} lint.select = ["ALL"] lint.isort.known-first-party = ["circumplex"] lint.mccabe.max-complexity = 18 @@ -165,7 +165,7 @@ overrides."tool.tox.env_run_base.commands".inline_arrays = false [tool.tox] env_list = ["py311", "py312", "py313"] -env_run_base = { commands = [ +env_run_base = {commands = [ [ "pytest", "--cov", @@ -173,8 +173,8 @@ env_run_base = { commands = [ ], ], dependency_groups = [ "test", -] } -env.docs = { commands = [ +]} +env.docs = {commands = [ [ "mkdocs", "build", @@ -182,7 +182,7 @@ env.docs = { commands = [ ], ], dependency_groups = [ "docs", -] } +]} gh.python."3.11" = ["py311"] gh.python."3.12" = ["py312"] gh.python."3.13" = ["py313"] diff --git a/schemas/github-issue-forms.json b/schemas/github-issue-forms.json new file mode 100644 index 0000000..b890ff1 --- /dev/null +++ b/schemas/github-issue-forms.json @@ -0,0 +1,2377 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + + "$id": "https://json.schemastore.org/github-issue-forms.json", + + "$comment": "https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms", + + "additionalProperties": false, + + "definitions": { + "type": { + "description": "A form item type\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#keys", + + "type": "string", + + "enum": ["checkboxes", "dropdown", "input", "markdown", "textarea"] + }, + + "id": { + "type": "string", + + "pattern": "^[a-zA-Z0-9_-]+$", + + "examples": ["SampleId"] + }, + + "validations": { + "title": "validation options", + + "type": "object", + + "properties": { + "required": { + "description": "Specify whether require a form item", + + "type": "boolean", + + "default": false + } + }, + + "additionalProperties": false + }, + + "assignee": { + "type": "string", + + "maxLength": 39, + + "pattern": "^[a-zA-Z0-9](-?[a-zA-Z0-9])*$", + + "examples": ["SampleAssignee"] + }, + + "label": { + "type": "string", + + "minLength": 1, + + "examples": ["Sample label"] + }, + + "description": { + "type": "string", + + "default": "", + + "examples": ["Sample description"] + }, + + "placeholder": { + "type": "string", + + "default": "", + + "examples": ["Sample placeholder"] + }, + + "value": { + "type": "string", + + "minLength": 1, + + "examples": ["Sample value"] + }, + + "form_item": { + "title": "form item", + + "description": "A form item\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#about-githubs-form-schema", + + "type": "object", + + "required": ["type"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + } + }, + + "allOf": [ + { + "if": { + "properties": { + "type": { + "const": "markdown" + } + } + }, + + "then": { + "$comment": "For `additionalProperties` to work `type` must also be present here.", + + "title": "markdown", + + "description": "Markdown\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#markdown", + + "type": "object", + + "required": ["type", "attributes"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + }, + + "attributes": { + "title": "markdown attributes", + + "description": "Markdown attributes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes", + + "type": "object", + + "required": ["value"], + + "properties": { + "value": { + "description": "A markdown code\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes", + + "type": "string", + + "minLength": 1, + + "examples": ["Sample code"] + } + }, + + "additionalProperties": false + } + }, + + "additionalProperties": false + } + }, + + { + "if": { + "properties": { + "type": { + "const": "textarea" + } + } + }, + + "then": { + "$comment": "For `additionalProperties` to work `type` must also be present here.", + + "title": "textarea", + + "description": "Textarea\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#textarea", + + "type": "object", + + "required": ["type", "attributes"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + }, + + "id": { + "$ref": "#/definitions/id", + + "description": "A textarea id\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#keys" + }, + + "attributes": { + "title": "textarea attributes", + + "description": "Textarea attributes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1", + + "type": "object", + + "required": ["label"], + + "properties": { + "label": { + "$ref": "#/definitions/label", + + "description": "A short textarea description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1" + }, + + "description": { + "$ref": "#/definitions/description", + + "description": "A long textarea description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1" + }, + + "placeholder": { + "$ref": "#/definitions/placeholder", + + "description": "A textarea placeholder\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1" + }, + + "value": { + "$ref": "#/definitions/value", + + "description": "A textarea value\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1" + }, + + "render": { + "description": "A textarea syntax highlighting mode\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-1", + + "type": "string", + + "enum": [ + "1C Enterprise", + + "4D", + + "ABAP CDS", + + "ABAP", + + "ABNF", + + "AFDKO", + + "AGS Script", + + "AIDL", + + "AL", + + "AMPL", + + "ANTLR", + + "API Blueprint", + + "APL", + + "ASL", + + "ASN.1", + + "ASP.NET", + + "ATS", + + "ActionScript", + + "Ada", + + "Alloy", + + "Alpine Abuild", + + "Altium Designer", + + "AngelScript", + + "Ant Build System", + + "ApacheConf", + + "Apex", + + "Apollo Guidance Computer", + + "AppleScript", + + "Arc", + + "AsciiDoc", + + "AspectJ", + + "Assembly", + + "Astro", + + "Asymptote", + + "Augeas", + + "AutoHotkey", + + "AutoIt", + + "AutoIt3", + + "AutoItScript", + + "Avro IDL", + + "Awk", + + "BASIC", + + "Ballerina", + + "Batchfile", + + "Beef", + + "Befunge", + + "BibTeX", + + "Bicep", + + "Bison", + + "BitBake", + + "Blade", + + "BlitzBasic", + + "BlitzMax", + + "Boo", + + "Boogie", + + "Brainfuck", + + "Brightscript", + + "Browserslist", + + "C", + + "C#", + + "C++", + + "C-ObjDump", + + "C2hs Haskell", + + "CIL", + + "CLIPS", + + "CMake", + + "COBOL", + + "CODEOWNERS", + + "COLLADA", + + "CSON", + + "CSS", + + "CSV", + + "CUE", + + "CWeb", + + "Cabal Config", + + "Cabal", + + "Cap'n Proto", + + "Carto", + + "CartoCSS", + + "Ceylon", + + "Chapel", + + "Charity", + + "ChucK", + + "Cirru", + + "Clarion", + + "Classic ASP", + + "Clean", + + "Click", + + "Clojure", + + "Closure Templates", + + "Cloud Firestore Security Rules", + + "CoNLL", + + "CoNLL-U", + + "CoNLL-X", + + "ColdFusion CFC", + + "ColdFusion", + + "Common Lisp", + + "Common Workflow Language", + + "Component Pascal", + + "Containerfile", + + "Cool", + + "Coq", + + "Cpp-ObjDump", + + "Crystal", + + "Csound Document", + + "Csound Score", + + "Csound", + + "Cuda", + + "Cue Sheet", + + "Cycript", + + "Cython", + + "D-ObjDump", + + "DIGITAL Command Language", + + "DM", + + "DTrace", + + "Dafny", + + "Darcs Patch", + + "Dart", + + "DataWeave", + + "Dhall", + + "Diff", + + "Dlang", + + "Dockerfile", + + "Dogescript", + + "Dylan", + + "E", + + "E-mail", + + "EBNF", + + "ECL", + + "ECLiPSe", + + "EJS", + + "EQ", + + "Eagle", + + "Earthly", + + "Easybuild", + + "Ecere Projects", + + "EditorConfig", + + "Eiffel", + + "Elixir", + + "Elm", + + "Emacs Lisp", + + "EmberScript", + + "Erlang", + + "F#", + + "F*", + + "FIGfont", + + "FIGlet Font", + + "FLUX", + + "Factor", + + "Fancy", + + "Fantom", + + "Faust", + + "Fennel", + + "Filebench WML", + + "Filterscript", + + "Fluent", + + "Formatted", + + "Forth", + + "Fortran Free Form", + + "Fortran", + + "FreeBasic", + + "Frege", + + "Futhark", + + "G-code", + + "GAML", + + "GAMS", + + "GAP", + + "GCC Machine Description", + + "GDB", + + "GDScript", + + "GEDCOM", + + "GLSL", + + "GN", + + "Game Maker Language", + + "Gemfile.lock", + + "Genie", + + "Genshi", + + "Gentoo Eclass", + + "Gerber Image", + + "Gettext Catalog", + + "Gherkin", + + "Git Config", + + "Glyph Bitmap Distribution Format", + + "Glyph", + + "Gnuplot", + + "Go Checksums", + + "Go Module", + + "Go", + + "Golo", + + "Gosu", + + "Grace", + + "Gradle", + + "Grammatical Framework", + + "Graph Modeling Language", + + "GraphQL", + + "Graphviz (DOT)", + + "Groovy Server Pages", + + "Groovy", + + "HAProxy", + + "HCL", + + "HTML", + + "HTML+ECR", + + "HTML+EEX", + + "HTML+ERB", + + "HTML+PHP", + + "HTML+Razor", + + "HTTP", + + "HXML", + + "Hack", + + "Haml", + + "Handlebars", + + "Harbour", + + "HashiCorp Configuration Language", + + "Haskell", + + "Haxe", + + "HiveQL", + + "HolyC", + + "Hy", + + "IDL", + + "IGOR Pro", + + "IPython Notebook", + + "Idris", + + "Ignore List", + + "ImageJ Macro", + + "Inform 7", + + "Io", + + "Ioke", + + "Isabelle ROOT", + + "Isabelle", + + "J", + + "JAR Manifest", + + "JFlex", + + "JSON with Comments", + + "JSON", + + "JSON5", + + "JSONLD", + + "JSONiq", + + "Jasmin", + + "Java Properties", + + "Java Server Pages", + + "Java", + + "JavaScript", + + "JavaScript+ERB", + + "Jest Snapshot", + + "Jinja", + + "Jison Lex", + + "Jison", + + "Jolie", + + "Jsonnet", + + "Julia", + + "Jupyter Notebook", + + "Kaitai Struct", + + "KakouneScript", + + "KiCad Layout", + + "KiCad Legacy Layout", + + "KiCad Schematic", + + "Kit", + + "Kotlin", + + "Kusto", + + "LFE", + + "LLVM", + + "LOLCODE", + + "LSL", + + "LTspice Symbol", + + "LabVIEW", + + "Lark", + + "Lasso", + + "Lean", + + "Less", + + "Lex", + + "LilyPond", + + "Limbo", + + "Linker Script", + + "Linux Kernel Module", + + "Liquid", + + "Literate Agda", + + "Literate CoffeeScript", + + "Literate Haskell", + + "LiveScript", + + "Logos", + + "Logtalk", + + "LookML", + + "LoomScript", + + "Lua", + + "M", + + "M4", + + "M4Sugar", + + "MATLAB", + + "MAXScript", + + "MLIR", + + "MQL4", + + "MQL5", + + "MTML", + + "MUF", + + "Macaulay2", + + "Makefile", + + "Mako", + + "Markdown", + + "Marko", + + "Mathematica", + + "Max", + + "Mercury", + + "Meson", + + "Metal", + + "Microsoft Developer Studio Project", + + "Microsoft Visual Studio Solution", + + "MiniD", + + "Mirah", + + "Modelica", + + "Modula-2", + + "Modula-3", + + "Module Management System", + + "Monkey", + + "Moocode", + + "MoonScript", + + "Motoko", + + "Motorola 68K Assembly", + + "Muse", + + "Myghty", + + "NASL", + + "NCL", + + "NEON", + + "NPM Config", + + "NSIS", + + "NWScript", + + "Nearley", + + "Nemerle", + + "NeoSnippet", + + "NetLinx", + + "NetLinx+ERB", + + "NetLogo", + + "NewLisp", + + "Nextflow", + + "Nginx", + + "Ninja", + + "Nit", + + "Nix", + + "NumPy", + + "Nunjucks", + + "ObjDump", + + "Object Data Instance Notation", + + "ObjectScript", + + "Objective-C", + + "Objective-C++", + + "Objective-J", + + "Odin", + + "Omgrofl", + + "Opa", + + "Opal", + + "Open Policy Agent", + + "OpenCL", + + "OpenEdge ABL", + + "OpenQASM", + + "OpenRC runscript", + + "OpenSCAD", + + "OpenStep Property List", + + "OpenType Feature File", + + "Org", + + "Ox", + + "Oxygene", + + "Oz", + + "P4", + + "PEG.js", + + "PHP", + + "PLpgSQL", + + "POV-Ray SDL", + + "Pan", + + "Papyrus", + + "Parrot Assembly", + + "Parrot Internal Representation", + + "Parrot", + + "Pascal", + + "Pawn", + + "Pep8", + + "Perl", + + "Pickle", + + "PicoLisp", + + "PigLatin", + + "Pike", + + "PlantUML", + + "Pod 6", + + "Pod", + + "PogoScript", + + "Pony", + + "PostCSS", + + "PostScript", + + "PowerShell", + + "Prisma", + + "Processing", + + "Proguard", + + "Prolog", + + "Promela", + + "Propeller Spin", + + "Protocol Buffer", + + "Protocol Buffers", + + "Public Key", + + "Pug", + + "Puppet", + + "Pure Data", + + "PureBasic", + + "PureScript", + + "Python", + + "Q#", + + "QMake", + + "Qt Script", + + "Quake", + + "R", + + "RAML", + + "RDoc", + + "REALbasic", + + "REXX", + + "RMarkdown", + + "RPC", + + "RPM Spec", + + "Racket", + + "Ragel", + + "Raw token data", + + "ReScript", + + "Readline Config", + + "Reason", + + "Rebol", + + "Record Jar", + + "Red", + + "Redirect Rules", + + "Regular Expression", + + "RenderScript", + + "Rich Text Format", + + "Ring", + + "Riot", + + "RobotFramework", + + "Roff", + + "Rouge", + + "Rscript", + + "Ruby", + + "Rust", + + "SAS", + + "SCSS", + + "SELinux Kernel Policy Language", + + "SELinux Policy", + + "SMT", + + "SPARQL", + + "SQF", + + "SQL", + + "SQLPL", + + "SRecode Template", + + "SSH Config", + + "STON", + + "SVG", + + "SWIG", + + "Sage", + + "SaltStack", + + "Sass", + + "Scala", + + "Scaml", + + "Scheme", + + "Scilab", + + "Self", + + "ShaderLab", + + "Shell", + + "ShellCheck Config", + + "Sieve", + + "Singularity", + + "Slash", + + "Slice", + + "Slim", + + "SmPL", + + "Smalltalk", + + "SnipMate", + + "Solidity", + + "Soong", + + "SourcePawn", + + "Spline Font Database", + + "Squirrel", + + "Stan", + + "Standard ML", + + "Starlark", + + "StringTemplate", + + "Stylus", + + "SubRip Text", + + "SugarSS", + + "SuperCollider", + + "Svelte", + + "Swift", + + "SystemVerilog", + + "TI Program", + + "TLA", + + "TOML", + + "TSQL", + + "TSV", + + "TSX", + + "TXL", + + "Tcl", + + "Tcsh", + + "TeX", + + "Tea", + + "Terra", + + "Texinfo", + + "Text", + + "TextMate Properties", + + "Textile", + + "Thrift", + + "Turing", + + "Turtle", + + "Twig", + + "Type Language", + + "TypeScript", + + "UltiSnip", + + "UltiSnips", + + "Unified Parallel C", + + "Unity3D Asset", + + "Unix Assembly", + + "Uno", + + "UnrealScript", + + "Ur", + + "Ur/Web", + + "UrWeb", + + "V", + + "VBA", + + "VCL", + + "VHDL", + + "Vala", + + "Valve Data Format", + + "Verilog", + + "Vim Help File", + + "Vim Script", + + "Vim Snippet", + + "Visual Basic .NET", + + "Vue", + + "Wavefront Material", + + "Wavefront Object", + + "Web Ontology Language", + + "WebAssembly", + + "WebVTT", + + "Wget Config", + + "Wikitext", + + "Windows Registry Entries", + + "Wollok", + + "World of Warcraft Addon Data", + + "X BitMap", + + "X Font Directory Index", + + "X PixMap", + + "X10", + + "XC", + + "XCompose", + + "XML Property List", + + "XML", + + "XPages", + + "XProc", + + "XQuery", + + "XS", + + "XSLT", + + "Xojo", + + "Xonsh", + + "Xtend", + + "YAML", + + "YANG", + + "YARA", + + "YASnippet", + + "Yacc", + + "ZAP", + + "ZIL", + + "Zeek", + + "ZenScript", + + "Zephir", + + "Zig", + + "Zimpl", + + "abl", + + "abuild", + + "acfm", + + "aconf", + + "actionscript 3", + + "actionscript3", + + "ada2005", + + "ada95", + + "adobe composite font metrics", + + "adobe multiple font metrics", + + "advpl", + + "ags", + + "ahk", + + "altium", + + "amfm", + + "amusewiki", + + "apache", + + "apkbuild", + + "arexx", + + "as3", + + "asm", + + "asp", + + "aspx", + + "aspx-vb", + + "ats2", + + "au3", + + "autoconf", + + "b3d", + + "bash session", + + "bash", + + "bat", + + "batch", + + "bazel", + + "blitz3d", + + "blitzplus", + + "bmax", + + "bplus", + + "bro", + + "bsdmake", + + "byond", + + "bzl", + + "c++-objdump", + + "c2hs", + + "cURL Config", + + "cake", + + "cakescript", + + "cfc", + + "cfm", + + "cfml", + + "chpl", + + "clipper", + + "coccinelle", + + "coffee", + + "coffee-script", + + "coldfusion html", + + "console", + + "cperl", + + "cpp", + + "csharp", + + "csound-csd", + + "csound-orc", + + "csound-sco", + + "cucumber", + + "curlrc", + + "cwl", + + "dcl", + + "delphi", + + "desktop", + + "dircolors", + + "django", + + "dosbatch", + + "dosini", + + "dpatch", + + "dtrace-script", + + "eC", + + "ecr", + + "editor-config", + + "edn", + + "eeschema schematic", + + "eex", + + "elisp", + + "emacs muse", + + "emacs", + + "email", + + "eml", + + "erb", + + "fb", + + "fish", + + "flex", + + "foxpro", + + "fsharp", + + "fstar", + + "ftl", + + "fundamental", + + "gf", + + "git-ignore", + + "gitattributes", + + "gitconfig", + + "gitignore", + + "gitmodules", + + "go mod", + + "go sum", + + "go.mod", + + "go.sum", + + "golang", + + "groff", + + "gsp", + + "hbs", + + "heex", + + "help", + + "html+django", + + "html+jinja", + + "html+ruby", + + "htmlbars", + + "htmldjango", + + "hylang", + + "i7", + + "ignore", + + "igor", + + "igorpro", + + "ijm", + + "inc", + + "inform7", + + "inputrc", + + "irc logs", + + "irc", + + "java server page", + + "jq", + + "jruby", + + "js", + + "jsonc", + + "jsp", + + "kak", + + "kakscript", + + "keyvalues", + + "ksy", + + "lassoscript", + + "latex", + + "leex", + + "lhaskell", + + "lhs", + + "lisp", + + "litcoffee", + + "live-script", + + "ls", + + "m2", + + "m68k", + + "mIRC Script", + + "macruby", + + "mail", + + "make", + + "man page", + + "man", + + "man-page", + + "manpage", + + "markojs", + + "max/msp", + + "maxmsp", + + "mbox", + + "mcfunction", + + "mdoc", + + "mediawiki", + + "mf", + + "mma", + + "mumps", + + "mupad", + + "nanorc", + + "nasm", + + "ne-on", + + "nesC", + + "nette object notation", + + "nginx configuration file", + + "nixos", + + "njk", + + "node", + + "npmrc", + + "nroff", + + "nush", + + "nvim", + + "obj-c", + + "obj-c++", + + "obj-j", + + "objc", + + "objc++", + + "objectivec", + + "objectivec++", + + "objectivej", + + "objectpascal", + + "objj", + + "octave", + + "odin-lang", + + "odinlang", + + "oncrpc", + + "ooc", + + "openedge", + + "openrc", + + "osascript", + + "pandoc", + + "pasm", + + "pcbnew", + + "perl-6", + + "perl6", + + "pir", + + "plain text", + + "posh", + + "postscr", + + "pot", + + "pov-ray", + + "povray", + + "progress", + + "protobuf", + + "pwsh", + + "pycon", + + "pyrex", + + "python3", + + "q", + + "ql", + + "qsharp", + + "ragel-rb", + + "ragel-ruby", + + "rake", + + "raw", + + "razor", + + "rb", + + "rbx", + + "reStructuredText", + + "readline", + + "red/system", + + "redirects", + + "regex", + + "regexp", + + "renpy", + + "rhtml", + + "robots txt", + + "robots", + + "robots.txt", + + "rpcgen", + + "rs", + + "rs-274x", + + "rss", + + "rst", + + "rusthon", + + "salt", + + "saltstate", + + "sed", + + "sepolicy", + + "sh", + + "shell-script", + + "shellcheckrc", + + "sml", + + "snippet", + + "sourcemod", + + "soy", + + "specfile", + + "splus", + + "squeak", + + "terraform", + + "tl", + + "tm-properties", + + "troff", + + "ts", + + "udiff", + + "vb .net", + + "vb.net", + + "vb6", + + "vbnet", + + "vdf", + + "vim", + + "vimhelp", + + "viml", + + "visual basic 6", + + "visual basic for applications", + + "visual basic", + + "vlang", + + "wasm", + + "wast", + + "wdl", + + "wgetrc", + + "wiki", + + "winbatch", + + "wisp", + + "wl", + + "wolfram lang", + + "wolfram language", + + "wolfram", + + "wsdl", + + "xBase", + + "xbm", + + "xdr", + + "xhtml", + + "xml+genshi", + + "xml+kid", + + "xpm", + + "xsd", + + "xsl", + + "xten", + + "yas", + + "yml", + + "zsh" + ] + } + }, + + "additionalProperties": false + }, + + "validations": { + "$ref": "#/definitions/validations", + + "title": "textarea validations", + + "description": "Textarea validations\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#validations" + } + }, + + "additionalProperties": false + } + }, + + { + "if": { + "properties": { + "type": { + "const": "input" + } + } + }, + + "then": { + "$comment": "For `additionalProperties` to work `type` must also be present here.", + + "title": "input", + + "description": "Input\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#input", + + "type": "object", + + "required": ["type", "attributes"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + }, + + "id": { + "$ref": "#/definitions/id", + + "description": "An input id\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#keys" + }, + + "attributes": { + "title": "input attributes", + + "description": "Input attributes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-2", + + "type": "object", + + "required": ["label"], + + "properties": { + "label": { + "$ref": "#/definitions/label", + + "description": "A short input description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-2" + }, + + "description": { + "$ref": "#/definitions/description", + + "description": "A long input description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-2" + }, + + "placeholder": { + "$ref": "#/definitions/placeholder", + + "description": "An input placeholder\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-2" + }, + + "value": { + "$ref": "#/definitions/value", + + "description": "An input value\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-2" + } + }, + + "additionalProperties": false + }, + + "validations": { + "$ref": "#/definitions/validations", + + "title": "input validations", + + "description": "Input validations\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#validations-1" + } + }, + + "additionalProperties": false + } + }, + + { + "if": { + "properties": { + "type": { + "const": "dropdown" + } + } + }, + + "then": { + "$comment": "For `additionalProperties` to work `type` must also be present here.", + + "title": "dropdown", + + "description": "dropdown\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#dropdown", + + "type": "object", + + "required": ["type", "attributes"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + }, + + "id": { + "$ref": "#/definitions/id", + + "description": "A dropdown id\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#keys" + }, + + "attributes": { + "title": "dropdown attributes", + + "description": "Dropdown attributes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3", + + "type": "object", + + "required": ["label", "options"], + + "properties": { + "label": { + "$ref": "#/definitions/label", + + "description": "A short dropdown description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3" + }, + + "description": { + "$ref": "#/definitions/description", + + "description": "A long dropdown description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3" + }, + + "multiple": { + "description": "Specify whether allow a multiple choices\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3", + + "type": "boolean", + + "default": false + }, + + "options": { + "description": "Dropdown choices\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3", + + "type": "array", + + "minItems": 1, + + "uniqueItems": true, + + "items": { + "type": "string", + + "minLength": 1, + + "examples": ["Sample choice"] + } + }, + + "default": { + "description": "Index of the default option\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-3", + + "type": "integer", + + "examples": [0] + } + }, + + "additionalProperties": false + }, + + "validations": { + "$ref": "#/definitions/validations", + + "title": "dropdown validations", + + "description": "Dropdown validations\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#validations-2" + } + }, + + "additionalProperties": false + } + }, + + { + "if": { + "properties": { + "type": { + "const": "checkboxes" + } + } + }, + + "then": { + "$comment": "For `additionalProperties` to work `type` must also be present here.", + + "title": "checkboxes", + + "description": "Checkboxes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#checkboxes", + + "type": "object", + + "required": ["type", "attributes"], + + "properties": { + "type": { + "$ref": "#/definitions/type" + }, + + "id": { + "$ref": "#/definitions/id", + + "description": "Checkbox list id\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#keys" + }, + + "attributes": { + "title": "checkbox list attributes", + + "description": "Checkbox list attributes\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4", + + "type": "object", + + "required": ["label", "options"], + + "properties": { + "label": { + "$ref": "#/definitions/label", + + "description": "A short checkbox list description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4" + }, + + "description": { + "$ref": "#/definitions/description", + + "description": "A long checkbox list description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4" + }, + + "options": { + "description": "Checkbox list choices\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4", + + "type": "array", + + "minItems": 1, + + "items": { + "title": "checkbox list choice", + + "description": "Checkbox list choice\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4", + + "type": "object", + + "required": ["label"], + + "properties": { + "label": { + "description": "A short checkbox list choice description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4", + + "type": "string", + + "minLength": 1, + + "examples": ["Sample label"] + }, + + "required": { + "description": "Specify whether a choice is required\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema#attributes-4", + + "type": "boolean", + + "default": false + } + }, + + "additionalProperties": false + } + } + }, + + "additionalProperties": false + } + }, + + "additionalProperties": false + } + } + ] + } + }, + + "properties": { + "name": { + "description": "An issue template name\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "type": "string", + + "minLength": 1, + + "examples": ["Sample name"] + }, + + "description": { + "description": "An issue template description\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "type": "string", + + "minLength": 1, + + "examples": ["Sample description"] + }, + + "body": { + "description": "An issue template body\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "type": "array", + + "minItems": 1, + + "items": { + "$ref": "#/definitions/form_item" + } + }, + + "assignees": { + "description": "An issue template assignees\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "oneOf": [ + { + "$ref": "#/definitions/assignee" + }, + + { + "type": "array", + + "minItems": 1, + + "uniqueItems": true, + + "items": { + "$ref": "#/definitions/assignee" + } + } + ] + }, + + "labels": { + "description": "An issue template labels\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "type": "array", + + "minItems": 1, + + "uniqueItems": true, + + "items": { + "type": "string", + + "minLength": 1, + + "examples": [ + "Sample label", + + "bug", + + "documentation", + + "duplicate", + + "enhancement", + + "good first issue", + + "help wanted", + + "invalid", + + "question", + + "wontfix" + ] + } + }, + + "title": { + "description": "An issue template title\nhttps://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-issue-forms#top-level-syntax", + + "type": "string", + + "minLength": 1, + + "examples": ["Sample title", "Bug: ", "Feature: "] + } + }, + + "required": ["name", "description", "body"], + + "title": "GitHub issue forms config file schema", + + "type": "object" +} diff --git a/uv.lock b/uv.lock index 890a0e9..2581e4c 100644 --- a/uv.lock +++ b/uv.lock @@ -275,7 +275,7 @@ dependencies = [ { name = "matplotlib" }, { name = "nptyping" }, { name = "numpy" }, - { name = "pandas" }, + { name = "pandas", extra = ["excel"] }, { name = "scipy" }, { name = "seaborn" }, ] @@ -286,7 +286,6 @@ dev = [ { name = "hypothesis" }, { name = "mike" }, { name = "mkdocs" }, - { name = "mkdocs-api-autonav" }, { name = "mkdocs-bibtex" }, { name = "mkdocs-git-authors-plugin" }, { name = "mkdocs-git-revision-date-localized-plugin" }, @@ -308,7 +307,6 @@ dev = [ docs = [ { name = "mike" }, { name = "mkdocs" }, - { name = "mkdocs-api-autonav" }, { name = "mkdocs-bibtex" }, { name = "mkdocs-git-authors-plugin" }, { name = "mkdocs-git-revision-date-localized-plugin" }, @@ -331,7 +329,7 @@ requires-dist = [ { name = "matplotlib", specifier = ">=3.10.7" }, { name = "nptyping", specifier = ">=2.0.1" }, { name = "numpy", specifier = ">=2.3.3" }, - { name = "pandas", specifier = ">=2.3.3" }, + { name = "pandas", extras = ["excel"], specifier = ">=2.3.3" }, { name = "scipy", specifier = ">=1.16.2" }, { name = "seaborn", specifier = ">=0.13.2" }, ] @@ -342,7 +340,6 @@ dev = [ { name = "hypothesis", specifier = ">=6.140.3" }, { name = "mike", specifier = ">=2.1.3" }, { name = "mkdocs", specifier = ">=1.6.1" }, - { name = "mkdocs-api-autonav", specifier = ">=0.4.0" }, { name = "mkdocs-bibtex", specifier = ">=4.4.0" }, { name = "mkdocs-git-authors-plugin", specifier = ">=0.10.0" }, { name = "mkdocs-git-revision-date-localized-plugin", specifier = ">=1.4.7" }, @@ -364,7 +361,6 @@ dev = [ docs = [ { name = "mike", specifier = ">=2.1.3" }, { name = "mkdocs", specifier = ">=1.6.1" }, - { name = "mkdocs-api-autonav", specifier = ">=0.4.0" }, { name = "mkdocs-bibtex", specifier = ">=4.4.0" }, { name = "mkdocs-git-authors-plugin", specifier = ">=0.10.0" }, { name = "mkdocs-git-revision-date-localized-plugin", specifier = ">=1.4.7" }, @@ -704,6 +700,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/66/dd/f95350e853a4468ec37478414fc04ae2d61dad7a947b3015c3dcc51a09b9/docutils-0.22.2-py3-none-any.whl", hash = "sha256:b0e98d679283fc3bb0ead8a5da7f501baa632654e7056e9c5846842213d674d8", size = 632667, upload-time = "2025-09-20T17:55:43.052Z" }, ] +[[package]] +name = "et-xmlfile" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" }, +] + [[package]] name = "executing" version = "2.2.1" @@ -1471,20 +1476,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" }, ] -[[package]] -name = "mkdocs-api-autonav" -version = "0.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mkdocs" }, - { name = "mkdocstrings-python" }, - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6d/b0/20960ee733a419a349877d09712d02e8ec2bda031672e5f0d0a15fc020b3/mkdocs_api_autonav-0.4.0.tar.gz", hash = "sha256:3527b0e5cf1b682bd374a3ce699ac12d6288f5fcaf93877f34a6b14c79740637", size = 17987, upload-time = "2025-09-09T12:42:02.216Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f0/37/e1413281aec69994a0ecb8baaff523b7b7da3119ae7d495b7dc659e630b0/mkdocs_api_autonav-0.4.0-py3-none-any.whl", hash = "sha256:87474e7919664fca75648a05e79de238dd5b39a0f711910d3638626b016acfe3", size = 13130, upload-time = "2025-09-09T12:42:00.731Z" }, -] - [[package]] name = "mkdocs-autorefs" version = "1.4.3" @@ -1853,6 +1844,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/af/11/0cc63f9f321ccf63886ac203336777140011fb669e739da36d8db3c53b98/numpy-2.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2e267c7da5bf7309670523896df97f93f6e469fb931161f483cd6882b3b1a5dc", size = 12971844, upload-time = "2025-09-09T15:58:57.359Z" }, ] +[[package]] +name = "odfpy" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "defusedxml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/97/73/8ade73f6749177003f7ce3304f524774adda96e6aaab30ea79fd8fda7934/odfpy-1.4.1.tar.gz", hash = "sha256:db766a6e59c5103212f3cc92ec8dd50a0f3a02790233ed0b52148b70d3c438ec", size = 717045, upload-time = "2020-01-18T16:55:48.852Z" } + +[[package]] +name = "openpyxl" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "et-xmlfile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" }, +] + [[package]] name = "packaging" version = "25.0" @@ -1925,6 +1937,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, ] +[package.optional-dependencies] +excel = [ + { name = "odfpy" }, + { name = "openpyxl" }, + { name = "python-calamine" }, + { name = "pyxlsb" }, + { name = "xlrd" }, + { name = "xlsxwriter" }, +] + [[package]] name = "pandocfilters" version = "1.5.1" @@ -2251,6 +2273,104 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" }, ] +[[package]] +name = "python-calamine" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/1a/ff59788a7e8bfeded91a501abdd068dc7e2f5865ee1a55432133b0f7f08c/python_calamine-0.5.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:944bcc072aca29d346456b4e42675c4831c52c25641db3e976c6013cdd07d4cd", size = 854308, upload-time = "2025-10-21T07:10:55.17Z" }, + { url = "https://files.pythonhosted.org/packages/24/7d/33fc441a70b771093d10fa5086831be289766535cbcb2b443ff1d5e549d8/python_calamine-0.5.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e637382e50cabc263a37eda7a3cd33f054271e4391a304f68cecb2e490827533", size = 830841, upload-time = "2025-10-21T07:10:57.353Z" }, + { url = "https://files.pythonhosted.org/packages/0f/38/b5b25e6ce0a983c9751fb026bd8c5d77eb81a775948cc3d9ce2b18b2fc91/python_calamine-0.5.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b2a31d1e711c5661b4f04efd89975d311788bd9a43a111beff74d7c4c8f8d7a", size = 898287, upload-time = "2025-10-21T07:10:58.977Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e9/ab288cd489999f962f791d6c8544803c29dcf24e9b6dde24634c41ec09dd/python_calamine-0.5.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2078ede35cbd26cf7186673405ff13321caacd9e45a5e57b54ce7b3ef0eec2ff", size = 886960, upload-time = "2025-10-21T07:11:00.462Z" }, + { url = "https://files.pythonhosted.org/packages/f0/4d/2a261f2ccde7128a683cdb20733f9bc030ab37a90803d8de836bf6113e5b/python_calamine-0.5.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:faab9f59bb9cedba2b35c6e1f5dc72461d8f2837e8f6ab24fafff0d054ddc4b5", size = 1044123, upload-time = "2025-10-21T07:11:02.153Z" }, + { url = "https://files.pythonhosted.org/packages/20/dc/a84c5a5a2c38816570bcc96ae4c9c89d35054e59c4199d3caef9c60b65cf/python_calamine-0.5.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:300d8d5e6c63bdecf79268d3b6d2a84078cda39cb3394ed09c5c00a61ce9ff32", size = 941997, upload-time = "2025-10-21T07:11:03.537Z" }, + { url = "https://files.pythonhosted.org/packages/dd/92/b970d8316c54f274d9060e7c804b79dbfa250edeb6390cd94f5fcfeb5f87/python_calamine-0.5.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0019a74f1c0b1cbf08fee9ece114d310522837cdf63660a46fe46d3688f215ea", size = 905881, upload-time = "2025-10-21T07:11:05.228Z" }, + { url = "https://files.pythonhosted.org/packages/ac/88/9186ac8d3241fc6f90995cc7539bdbd75b770d2dab20978a702c36fbce5f/python_calamine-0.5.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:30b40ffb374f7fb9ce20ca87f43a609288f568e41872f8a72e5af313a9e20af0", size = 947224, upload-time = "2025-10-21T07:11:06.618Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ec/6ac1882dc6b6fa829e2d1d94ffa58bd0c67df3dba074b2e2f3134d7f573a/python_calamine-0.5.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:206242690a5a5dff73a193fb1a1ca3c7a8aed95e2f9f10c875dece5a22068801", size = 1078351, upload-time = "2025-10-21T07:11:08.368Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f1/07aff6966b04b7452c41a802b37199d9e9ac656d66d6092b83ab0937e212/python_calamine-0.5.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:88628e1a17a6f352d6433b0abf6edc4cb2295b8fbb3451392390f3a6a7a8cada", size = 1150148, upload-time = "2025-10-21T07:11:10.18Z" }, + { url = "https://files.pythonhosted.org/packages/4e/be/90aedeb0b77ea592a698a20db09014a5217ce46a55b699121849e239c8e7/python_calamine-0.5.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:22524cfb7720d15894a02392bbd49f8e7a8c173493f0628a45814d78e4243fff", size = 1080101, upload-time = "2025-10-21T07:11:11.489Z" }, + { url = "https://files.pythonhosted.org/packages/30/89/1fadd511d132d5ea9326c003c8753b6d234d61d9a72775fb1632cc94beb9/python_calamine-0.5.4-cp311-cp311-win32.whl", hash = "sha256:d159e98ef3475965555b67354f687257648f5c3686ed08e7faa34d54cc9274e1", size = 679593, upload-time = "2025-10-21T07:11:12.758Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ba/d7324400a02491549ef30e0e480561a3a841aa073ac7c096313bc2cea555/python_calamine-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:0d019b082f9a114cf1e130dc52b77f9f881325ab13dc31485d7b4563ad9e0812", size = 721570, upload-time = "2025-10-21T07:11:14.336Z" }, + { url = "https://files.pythonhosted.org/packages/4f/15/8c7895e603b4ae63ff279aae4aa6120658a15f805750ccdb5d8b311df616/python_calamine-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:bb20875776e5b4c85134c2bf49fea12288e64448ed49f1d89a3a83f5bb16bd59", size = 685789, upload-time = "2025-10-21T07:11:15.646Z" }, + { url = "https://files.pythonhosted.org/packages/ff/60/b1ace7a0fd636581b3bb27f1011cb7b2fe4d507b58401c4d328cfcb5c849/python_calamine-0.5.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4d711f91283d28f19feb111ed666764de69e6d2a0201df8f84e81a238f68d193", size = 850087, upload-time = "2025-10-21T07:11:17.002Z" }, + { url = "https://files.pythonhosted.org/packages/7f/32/32ca71ce50f9b7c7d6e7ec5fcc579a97ddd8b8ce314fe143ba2a19441dc7/python_calamine-0.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed67afd3adedb5bcfb428cf1f2d7dfd936dea9fe979ab631194495ab092973ba", size = 825659, upload-time = "2025-10-21T07:11:18.248Z" }, + { url = "https://files.pythonhosted.org/packages/63/c5/27ba71a9da2a09be9ff2f0dac522769956c8c89d6516565b21c9c78bfae6/python_calamine-0.5.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13662895dac487315ccce25ea272a1ea7e7ac05d899cde4e33d59d6c43274c54", size = 897332, upload-time = "2025-10-21T07:11:19.89Z" }, + { url = "https://files.pythonhosted.org/packages/5a/e7/c4be6ff8e8899ace98cacc9604a2dd1abc4901839b733addfb6ef32c22ba/python_calamine-0.5.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:23e354755583cfaa824ddcbe8b099c5c7ac19bf5179320426e7a88eea2f14bc5", size = 886885, upload-time = "2025-10-21T07:11:21.912Z" }, + { url = "https://files.pythonhosted.org/packages/38/24/80258fb041435021efa10d0b528df6842e442585e48cbf130e73fed2529b/python_calamine-0.5.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4e1bc3f22107dcbdeb32d4d3c5c1e8831d3c85d4b004a8606dd779721b29843d", size = 1043907, upload-time = "2025-10-21T07:11:23.3Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/157340787d03ef6113a967fd8f84218e867ba4c2f7fc58cc645d8665a61a/python_calamine-0.5.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:182b314117e47dbd952adaa2b19c515555083a48d6f9146f46faaabd9dab2f81", size = 942376, upload-time = "2025-10-21T07:11:24.866Z" }, + { url = "https://files.pythonhosted.org/packages/98/f5/aec030f567ee14c60b6fc9028a78767687f484071cb080f7cfa328d6496e/python_calamine-0.5.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8f882e092ab23f72ea07e2e48f5f2efb1885c1836fb949f22fd4540ae11742e", size = 906455, upload-time = "2025-10-21T07:11:26.203Z" }, + { url = "https://files.pythonhosted.org/packages/29/58/4affc0d1389f837439ad45f400f3792e48030b75868ec757e88cb35d7626/python_calamine-0.5.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:62a9b4b7b9bd99d03373e58884dfb60d5a1c292c8e04e11f8b7420b77a46813e", size = 948132, upload-time = "2025-10-21T07:11:27.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/2e/70ed04f39e682a9116730f56b7fbb54453244ccc1c3dae0662d4819f1c1d/python_calamine-0.5.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:98bb011d33c0e2d183ff30ab3d96792c3493f56f67a7aa2fcadad9a03539e79b", size = 1077436, upload-time = "2025-10-21T07:11:28.801Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ce/806f8ce06b5bb9db33007f85045c304cda410970e7aa07d08f6eaee67913/python_calamine-0.5.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:6b218a95489ff2f1cc1de0bba2a16fcc82981254bbb23f31d41d29191282b9ad", size = 1150570, upload-time = "2025-10-21T07:11:30.237Z" }, + { url = "https://files.pythonhosted.org/packages/18/da/61f13c8d107783128c1063cf52ca9cacdc064c58d58d3cf49c1728ce8296/python_calamine-0.5.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e8296a4872dbe834205d25d26dd6cfcb33ee9da721668d81b21adc25a07c07e4", size = 1080286, upload-time = "2025-10-21T07:11:31.564Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c5612a63292eb7d0648b17c5ff32ad5d6c6f3e1d78825f01af5c765f4d3f/python_calamine-0.5.4-cp312-cp312-win32.whl", hash = "sha256:cebb9c88983ae676c60c8c02aa29a9fe13563f240579e66de5c71b969ace5fd9", size = 676617, upload-time = "2025-10-21T07:11:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/bb/18/5a037942de8a8df0c805224b2fba06df6d25c1be3c9484ba9db1ca4f3ee6/python_calamine-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:15abd7aff98fde36d7df91ac051e86e66e5d5326a7fa98d54697afe95a613501", size = 721464, upload-time = "2025-10-21T07:11:34.383Z" }, + { url = "https://files.pythonhosted.org/packages/d1/8b/89ca17b44bcd8be5d0e8378d87b880ae17a837573553bd2147cceca7e759/python_calamine-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:1cef0d0fc936974020a24acf1509ed2a285b30a4e1adf346c057112072e84251", size = 687268, upload-time = "2025-10-21T07:11:36.324Z" }, + { url = "https://files.pythonhosted.org/packages/60/82/0a6581f05916e2c09a418b5624661cb51dc0b8bd10dd0e8613b90bf785ad/python_calamine-0.5.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:46b258594314f89b9b92c6919865eabf501391d000794e70dc7a6b24e7bda9c6", size = 849926, upload-time = "2025-10-21T07:11:37.835Z" }, + { url = "https://files.pythonhosted.org/packages/25/ca/1d4698b2de6e5d9efc712bd4c018125021eaf9a0f20559a35654b17f1e7f/python_calamine-0.5.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:feea9a85683e66b4e87b381812086210e90521914d6960c45f30bedb9e186ffe", size = 825321, upload-time = "2025-10-21T07:11:39.299Z" }, + { url = "https://files.pythonhosted.org/packages/13/dd/09bd18c8ad6327bc03de2e3ce7c2150d0e605f8aa538615a6fc8b25b2f52/python_calamine-0.5.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd64ab500d7c1eb415776d722c4cda7d60fd373642f159946b5f03ae55dd246a", size = 897213, upload-time = "2025-10-21T07:11:40.801Z" }, + { url = "https://files.pythonhosted.org/packages/67/80/6cd2f358b96451dbfe40ff88e50ed875264e366cea01d1ec51aa46afc55a/python_calamine-0.5.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c15a09a24e8c2de4adc0f039c05dc37b85e8a3fd0befa8b8fcb8a61f13837965", size = 887237, upload-time = "2025-10-21T07:11:42.149Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1f/5abdf618c402c586c7d8e02664b2a4d85619e3b67c75f63c535fd819eb42/python_calamine-0.5.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3d956ab6a36afe3fabe0f3aeac86b4e6c16f8c1bc0e3fa0b57d0eb3e66e40c91", size = 1044372, upload-time = "2025-10-21T07:11:43.566Z" }, + { url = "https://files.pythonhosted.org/packages/82/10/164fed6f46c469f6e3a5c17f2864c8b028109f6d5da928f6aa34e0fbd396/python_calamine-0.5.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94840783be59659e367ae4f1c59fffcc54ad7f7f6935cbfbaa6879e6633c5a52", size = 942187, upload-time = "2025-10-21T07:11:45.347Z" }, + { url = "https://files.pythonhosted.org/packages/43/4f/a5f167a95ef57c3e37fe8ae0a41745061442f44e4c0c4395d70c8740e453/python_calamine-0.5.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8304fc19322f05dc0af78851ca47255a088a9c0cc3874648b42038e7f27ff2f", size = 905766, upload-time = "2025-10-21T07:11:46.972Z" }, + { url = "https://files.pythonhosted.org/packages/07/5c/2804120184a0b4b1510e6274e7c29f461bd80bae1935ad26ea68f4c31a6c/python_calamine-0.5.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0ee4a18b1341600111d756c6d5d30546729b8961e0c552b4d63fc40dcd609d7", size = 948683, upload-time = "2025-10-21T07:11:48.846Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7a/a0ec3339be0e0c4288fac04bf754c3a9c7d3c863e167359764384031469c/python_calamine-0.5.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:b5d81afbad55fd78146bad8bc31d55793fe3fdff5e49afab00c704f5f567d330", size = 1077564, upload-time = "2025-10-21T07:11:50.333Z" }, + { url = "https://files.pythonhosted.org/packages/8d/9c/78dd74b3cb2614c556014c205d63966043d62fe2e0a4570ccbf5a926bf18/python_calamine-0.5.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:c71c51211ce24db640099c60bccc2c93d58639664e8fb69db48a35ed3b272f8e", size = 1150587, upload-time = "2025-10-21T07:11:52.133Z" }, + { url = "https://files.pythonhosted.org/packages/c9/82/24bca60640366251fb5eb6ffa0199ad05aa638d7d228dc4ba338e9dd9835/python_calamine-0.5.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c64dec92cb1f094298e601ad10ceb6bc15668f5ae24a7e852589f8c0fdb346d2", size = 1080031, upload-time = "2025-10-21T07:11:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/20/97/7696c0d36f99fc6ab9770632655dd67389953b4d94e3394c280520db5e23/python_calamine-0.5.4-cp313-cp313-win32.whl", hash = "sha256:5f64e3f2166001a98c3f4218eac96fa24f96f9f9badad4b8a86d9a77e81284ad", size = 676927, upload-time = "2025-10-21T07:11:55.131Z" }, + { url = "https://files.pythonhosted.org/packages/4a/de/e9a1c650ba446f46e880f1bf07744c3dbc709b8f0285cf6db091bbe7f30d/python_calamine-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:b0858c907ac3e4000ab7f4422899559e412fe4a71dba3d7c96f9ecb1cf03a9ce", size = 721241, upload-time = "2025-10-21T07:11:56.597Z" }, + { url = "https://files.pythonhosted.org/packages/d7/58/0a6483cfc5bffd3df8a76c4041aa6396566cd0dddf180055064074fc6e77/python_calamine-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:2df6c552546f36702ae2a78f9ffeab5ecf638f27eece2737735c3fd4080d2809", size = 687761, upload-time = "2025-10-21T07:11:57.885Z" }, + { url = "https://files.pythonhosted.org/packages/df/c6/cbfb8050adb339fd604f9465aa67824f6da63ee74adb88bbad907f17397c/python_calamine-0.5.4-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7bf110052f62dcb16c507b741b5ab637b9b2e89b25406cb1bd795b2f1207439d", size = 848476, upload-time = "2025-10-21T07:11:59.651Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ab/888592578ee23cf7377009db7a396b73f011df5cd6e7627667cdc862a813/python_calamine-0.5.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:800763dcb01d3752450a6ee204bc22e661a20221e40490f85fff1c98ad96c2e9", size = 823829, upload-time = "2025-10-21T07:12:01.03Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/5dbbb506462f8ce9e7445905fa0efba73a25341d2bdd7f0da0b9c8c5cd99/python_calamine-0.5.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f40f2596f2ec8085343e67e73ad5321f18e36e6c2f7b15980201aec03666cf4c", size = 895812, upload-time = "2025-10-21T07:12:02.466Z" }, + { url = "https://files.pythonhosted.org/packages/23/b9/f839641ebe781cf7e82d2b58d0c3a609686f83516a946298627f20f5fc9f/python_calamine-0.5.4-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:859b1e8586cf9944edfa32ba1679be2b40407d67c8c071a97429ea4a79adcd08", size = 886707, upload-time = "2025-10-21T07:12:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/98/cf/d74743dc72128248ce598aa9eb2e82457166c380b48493f46ca001d429cf/python_calamine-0.5.4-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3221b145e52d708597b74832ff517adf9153b959aa17d05d2e7fc259855c6c25", size = 1042868, upload-time = "2025-10-21T07:12:05.362Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d6/55b061c7cf7e6c06279af4abf83aef01168f2a902446c79393cfecfc1a06/python_calamine-0.5.4-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0294d8e677f85a178c74a5952da668a35dd0522e7852f5a398aae01a9577fd0d", size = 941310, upload-time = "2025-10-21T07:12:06.866Z" }, + { url = "https://files.pythonhosted.org/packages/28/d7/457adac7eae82584ce36860ba9073e4e9492195fee6f4b41397733a92604/python_calamine-0.5.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:713df8fd08d71030bf7677712f4764e306e379e06c05f7656fed42e7cd256602", size = 904649, upload-time = "2025-10-21T07:12:08.851Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ad/0dbb38d992245a71630c93d928d3e1b5581c98e92d214d1ec80da0036c65/python_calamine-0.5.4-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:adc83cd98e58fecdedce7209bad98452b2702cc3cecb8e9066e0db198b939bb5", size = 944747, upload-time = "2025-10-21T07:12:10.288Z" }, + { url = "https://files.pythonhosted.org/packages/69/99/dcb7f5a7149afefcdfb5c1d2d0fb9b086df5dc228d54e693875b0797c680/python_calamine-0.5.4-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:c70ed54297ca49bb449df00a5e6f317df1162e042a65dd3fbeb9c9a6d85cb354", size = 1075868, upload-time = "2025-10-21T07:12:11.817Z" }, + { url = "https://files.pythonhosted.org/packages/33/19/c2145b5912fadf495d66ae96bb2735340fea1183844843fe975837c315a6/python_calamine-0.5.4-cp313-cp313t-musllinux_1_1_armv7l.whl", hash = "sha256:78baabfc04a918efcc44e61385526143fd773317fc263ee59a5aa8909854bae3", size = 1149999, upload-time = "2025-10-21T07:12:13.381Z" }, + { url = "https://files.pythonhosted.org/packages/33/e5/6787068c97978212ae7b71d6d6e4785474ac0c496f01c50d04866b66d72e/python_calamine-0.5.4-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:a12aa39963eaae84a1ae70fbd49171bcd901fff87c93095bd80760cb0107220c", size = 1078902, upload-time = "2025-10-21T07:12:15.202Z" }, + { url = "https://files.pythonhosted.org/packages/30/99/21c377f9173af146553569f672ef8989017f1dafa80ec912930ccbaaab0c/python_calamine-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:7c46c472299781bf51bcf550d81fe812363e3ca13535023bd2764145fbc52823", size = 722243, upload-time = "2025-10-21T07:12:16.62Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/a7d2eb4b5f34d34b6ed8d217dee91b1d5224d15905ca8870cf62858d2b25/python_calamine-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:e6b1a6f969207e3729366ee2ff1b5143a9b201e59af0d2708e51a39ef702652f", size = 684569, upload-time = "2025-10-21T07:12:18.401Z" }, + { url = "https://files.pythonhosted.org/packages/d1/89/0b9dc4dc7ebadd088b9558bd8e09a02ac0a11edd772b77f47c4c66dd2a22/python_calamine-0.5.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:79c493cc53ca4d728a758600291ceefdec6b705a199ce75f946c8f8858102d51", size = 850140, upload-time = "2025-10-21T07:12:19.853Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c2/379f43ad7944b8d200045c0a9c2783b3e6aac1015ad0a490996754ebf855/python_calamine-0.5.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a6001164afb03ec12725c5c8e975b73c6b6491381b03f28e5a88226e2e7473d7", size = 824651, upload-time = "2025-10-21T07:12:21.404Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4f/c484f6f0d99d14631de9e065bdf7932fe573f7b6f0bf79d6b3c0219595d7/python_calamine-0.5.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:656cb61bd306687486a45947f632cd5afef63beb78da2c73ac59ab66aa455f7e", size = 897554, upload-time = "2025-10-21T07:12:23.733Z" }, + { url = "https://files.pythonhosted.org/packages/e5/eb/1966d0fde74ca7023678eacd128a14a4c136dc287a9f1ec21ed2236f43d4/python_calamine-0.5.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aa79ff3770fc88732b35f00c4f3ac884bc2b5289e7893484a8d8d4790e67c7a", size = 887612, upload-time = "2025-10-21T07:12:25.25Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/50a4d29139ef6f67cc29b7bb2d821253f032bdbfa451faba986fc3ce1bf8/python_calamine-0.5.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2908be3d273ff2756893840b5bfeb07a444c193f55a2f2343d55870df5d228dc", size = 1046417, upload-time = "2025-10-21T07:12:26.747Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3f/4130952e2646867f6a8c3f0cda8a7834a95b720fd557115ce722d96250c9/python_calamine-0.5.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbcda9f0c195584bede0518597380e9431dcacd298c5f6b627bae1a38510ff25", size = 944118, upload-time = "2025-10-21T07:12:28.494Z" }, + { url = "https://files.pythonhosted.org/packages/27/f8/64fc1688c833ed5e79f3d657908f616909c03a4936eed8320519c6d5ffc2/python_calamine-0.5.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78f0c8853ce544b640e9a6994690c434be7a3e9189b4f49536669d220180a63", size = 906103, upload-time = "2025-10-21T07:12:30.201Z" }, + { url = "https://files.pythonhosted.org/packages/b0/13/9ef73a559f492651e3588e6ecbeaf82cb91cdb084eb05b9a70f50ab857b7/python_calamine-0.5.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba6f1181dcad2f6ec7da0ea6272bf68b59ce2135800db06374b083cac599780e", size = 947955, upload-time = "2025-10-21T07:12:32.035Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8d/e303b70fe8c6fa64179633445a5bf424a23153459ddcaff861300e5c2221/python_calamine-0.5.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:eea735f76e5a06efc91fe8907bca03741e71febcadd8621c6ea48df7b4a64be3", size = 1077823, upload-time = "2025-10-21T07:12:33.568Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ce/8e9b85b7488488a7c3c673ae727ba6eb4c73f97d81acb250048f8e223196/python_calamine-0.5.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:2d138e5a960ae7a8fc91674252cf2d7387a5cef2892ebdccf3eea2756e1ced0c", size = 1150733, upload-time = "2025-10-21T07:12:35.097Z" }, + { url = "https://files.pythonhosted.org/packages/37/e0/ca4ad49b693d165b87de068ad78c9aca35a8657a5695cbcb212426e29bd9/python_calamine-0.5.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8ad42673f5c0bb2d30b17b2ec3de5e8eae6dde4097650332c507b4146c63bb9c", size = 1080697, upload-time = "2025-10-21T07:12:36.679Z" }, + { url = "https://files.pythonhosted.org/packages/2a/62/1065dbf7c554bd80ba976d60278525750c0ff0feb56812f76b6531b67f21/python_calamine-0.5.4-cp314-cp314-win32.whl", hash = "sha256:36918496befbeeddc653e1499c090923dcf803d2633eb8bd473a9d21bdd06e79", size = 677184, upload-time = "2025-10-21T07:12:38.295Z" }, + { url = "https://files.pythonhosted.org/packages/e0/2f/f21bffb13712434168f7125f733fb728f723d79262a5acb90328a13fbf11/python_calamine-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:bc01a7c03d302d11721a0ca00f67b71ebec125abab414f604bb03749b8c3557e", size = 722692, upload-time = "2025-10-21T07:12:39.764Z" }, + { url = "https://files.pythonhosted.org/packages/e9/b5/7214e8105b5165653cf49c9edec17db9d2551645be1a332bf09013908bc2/python_calamine-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:8ab116aa7aea8bb3823f7a00c95bea08940db995556d287b6c1e51f3e83b3570", size = 686400, upload-time = "2025-10-21T07:12:41.371Z" }, + { url = "https://files.pythonhosted.org/packages/47/91/6815256d05940608c92e4d9467db04b9eab6124d8a9bd37f5c967157ead6/python_calamine-0.5.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:bc004d1da2779aea2b6782d18d977f8e1121e3a245c331db545f69fc2ae5cad0", size = 848400, upload-time = "2025-10-21T07:12:43.22Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2c/fee8ffaac4a2385e9522c0f0febb690499a00fb99c0c953e7cd4bcdc6695/python_calamine-0.5.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5fb8c85acf5ccfe961023de01ce3a36839e310b5d9dc9aac9db01f350fbd3cec", size = 825000, upload-time = "2025-10-21T07:12:45.008Z" }, + { url = "https://files.pythonhosted.org/packages/a0/4d/61eeddde208958518cbf9ab76f387c379bd56019c029ea5fcc6cf3b96044/python_calamine-0.5.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9dd48379eabc27c2bb73356fd5d1df48a46caf94433d4f60bdd38ad416a6f46", size = 896022, upload-time = "2025-10-21T07:12:46.503Z" }, + { url = "https://files.pythonhosted.org/packages/90/87/9ae23a3c2a7d2891c04436d0d7ed9984cb0f7145c96f6f8b36a345c7cc95/python_calamine-0.5.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da3c2aa81de7cb20834b5326f326ba91a58123f10845864c3911e9dd819b9271", size = 887206, upload-time = "2025-10-21T07:12:48.446Z" }, + { url = "https://files.pythonhosted.org/packages/13/23/9289c350b8d7976295d01474f17a22fb9a42695dc403aa0f735a4e008791/python_calamine-0.5.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9c09cd413e69f3366bdb73fc525c02963f29ca01da5a2ef9abed5486bba0e6a", size = 1042372, upload-time = "2025-10-21T07:12:50.04Z" }, + { url = "https://files.pythonhosted.org/packages/da/66/cd2c8ec4090d1cfd0875e7a45a7a7d55a9670b18daaad45845360d4def2c/python_calamine-0.5.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b678e11378b991e551d1260e21099cd9c5cffa4c83f816cba0aa05e9023d0f06", size = 941589, upload-time = "2025-10-21T07:12:51.635Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d5/6a8199af0efe83945beb3df5a0556d658108cbf71b2cc449f3b5106afaef/python_calamine-0.5.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c7397781c4aedf70c5e4adcd31e2209035f4eb78fcb8ed887d252965e924530", size = 904284, upload-time = "2025-10-21T07:12:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/93/0d/a419be4b036207ca61e5bbd15225f9637348a7c5c353d009ee0af5d38e90/python_calamine-0.5.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9062677c5c1ca9f16dd0d29875a9ffa841fe6b230a7c03b3ed92146fc42572fd", size = 945532, upload-time = "2025-10-21T07:12:54.692Z" }, + { url = "https://files.pythonhosted.org/packages/a1/eb/4b39fc8d42a13578b4cc695d0e1e84bd5d87087444c27f667e1d7e756f4f/python_calamine-0.5.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cd2881eadb30fddb84abe4fccb1544c6ba15aec45fe833a5691f5b0c8eeaec1", size = 1075965, upload-time = "2025-10-21T07:12:56.247Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a5/d9d286986a192afd35056cbb53ca6979c09a584ca8ae9c2ab818141a9dde/python_calamine-0.5.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:6d077520c78530ad610fc1dc94463e618df8600d071409d8aa1bc195b9759f6f", size = 1150192, upload-time = "2025-10-21T07:12:58.236Z" }, + { url = "https://files.pythonhosted.org/packages/d9/2c/37612d97cf969adf39dbad04c14e8c35aedc8e6476b8e97cb5a5c2ed2b76/python_calamine-0.5.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:1ba09027e12a495b4e3eda4a7c59bb38d058e1941382bb2cc2e3a2a7bd12d3ba", size = 1078532, upload-time = "2025-10-21T07:13:00.123Z" }, + { url = "https://files.pythonhosted.org/packages/b1/2b/f6913d5cfc35c7d9c76df9fbabf00cbc5ddc525abc1e1dc55d5a57a059aa/python_calamine-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a45f72a0ae0184c6ae99deefba735fdf82f858bcbf25caeb14366d45b18f23ea", size = 722451, upload-time = "2025-10-21T07:13:01.902Z" }, + { url = "https://files.pythonhosted.org/packages/88/0c/b6bf7a7033b0f0143e1494f0f6803f63ec8755dc30f054775434fe06d310/python_calamine-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:1ec345f20f0ea6e525e8d5a6dbb68065d374bc1feaf5bb479a93e2ed1d4db9ae", size = 684875, upload-time = "2025-10-21T07:13:03.308Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a8/0e05992489f8ca99eadfb52e858a7653b01b27a7c66d040abddeb4bdf799/python_calamine-0.5.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:8d4be45952555f129584e0ca6ddb442bed5cb97b8d7cd0fd5ae463237b98eb15", size = 856420, upload-time = "2025-10-21T07:13:20.962Z" }, + { url = "https://files.pythonhosted.org/packages/f0/b0/5bbe52c97161acb94066e7020c2fed7eafbca4bf6852a4b02ed80bf0b24b/python_calamine-0.5.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b387d12cb8cae98c8e0c061c5400f80bad1f43f26fafcf95ff5934df995f50b", size = 833240, upload-time = "2025-10-21T07:13:22.801Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b9/44fa30f6bf479072d9042856d3fab8bdd1532d2d901e479e199bc1de0e6c/python_calamine-0.5.4-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2103714954b7dbed72a0b0eff178b08e854bba130be283e3ae3d7c95521e8f69", size = 899470, upload-time = "2025-10-21T07:13:25.176Z" }, + { url = "https://files.pythonhosted.org/packages/0e/f2/acbb2c1d6acba1eaf6b1efb6485c98995050bddedfb6b93ce05be2753a85/python_calamine-0.5.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c09fdebe23a5045d09e12b3366ff8fd45165b6fb56f55e9a12342a5daddbd11a", size = 906108, upload-time = "2025-10-21T07:13:26.709Z" }, + { url = "https://files.pythonhosted.org/packages/77/28/ff007e689539d6924223565995db876ac044466b8859bade371696294659/python_calamine-0.5.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fa992d72fbd38f09107430100b7688c03046d8c1994e4cff9bbbd2a825811796", size = 948580, upload-time = "2025-10-21T07:13:30.816Z" }, + { url = "https://files.pythonhosted.org/packages/a4/06/b423655446fb27e22bfc1ca5e5b11f3449e0350fe8fefa0ebd68675f7e85/python_calamine-0.5.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:88e608c7589412d3159be40d270a90994e38c9eafc125bf8ad5a9c92deffd6dd", size = 1079516, upload-time = "2025-10-21T07:13:32.288Z" }, + { url = "https://files.pythonhosted.org/packages/76/f5/c7132088978b712a5eddf1ca6bf64ae81335fbca9443ed486330519954c3/python_calamine-0.5.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:51a007801aef12f6bc93a545040a36df48e9af920a7da9ded915584ad9a002b1", size = 1152379, upload-time = "2025-10-21T07:13:33.739Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c8/37a8d80b7e55e7cfbe649f7a92a7e838defc746aac12dca751aad5dd06a6/python_calamine-0.5.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b056db205e45ab9381990a5c15d869f1021c1262d065740c9cd296fc5d3fb248", size = 1080420, upload-time = "2025-10-21T07:13:35.33Z" }, + { url = "https://files.pythonhosted.org/packages/10/52/9a96d06e75862d356dc80a4a465ad88fba544a19823568b4ff484e7a12f2/python_calamine-0.5.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:dd8f4123b2403fc22c92ec4f5e51c495427cf3739c5cb614b9829745a80922db", size = 722350, upload-time = "2025-10-21T07:13:37.074Z" }, +] + [[package]] name = "python-dateutil" version = "2.9.0.post0" @@ -2300,6 +2420,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, ] +[[package]] +name = "pyxlsb" +version = "1.0.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/13/eebaeb7a40b062d1c6f7f91d09e73d30a69e33e4baa7cbe4b7658548b1cd/pyxlsb-1.0.10.tar.gz", hash = "sha256:8062d1ea8626d3f1980e8b1cfe91a4483747449242ecb61013bc2df85435f685", size = 22424, upload-time = "2022-10-14T19:17:47.308Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/92/345823838ae367c59b63e03aef9c331f485370f9df6d049256a61a28f06d/pyxlsb-1.0.10-py2.py3-none-any.whl", hash = "sha256:87c122a9a622e35ca5e741d2e541201d28af00fb46bec492cfa9586890b120b4", size = 23849, upload-time = "2022-10-14T19:17:46.079Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -3095,6 +3224,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a7/75/35c17f21153190386af9fb36aab5f76d9f865c69d2f13afdfeb0b3109481/xdoctest-1.3.0-py3-none-any.whl", hash = "sha256:b546accaecae2fd0a14e8d8e125550832f3f11981629324519d057e218dd348f", size = 152543, upload-time = "2025-09-08T15:02:43.245Z" }, ] +[[package]] +name = "xlrd" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/07/5a/377161c2d3538d1990d7af382c79f3b2372e880b65de21b01b1a2b78691e/xlrd-2.0.2.tar.gz", hash = "sha256:08b5e25de58f21ce71dc7db3b3b8106c1fa776f3024c54e45b45b374e89234c9", size = 100167, upload-time = "2025-06-14T08:46:39.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/62/c8d562e7766786ba6587d09c5a8ba9f718ed3fa8af7f4553e8f91c36f302/xlrd-2.0.2-py2.py3-none-any.whl", hash = "sha256:ea762c3d29f4cca48d82df517b6d89fbce4db3107f9d78713e48cd321d5c9aa9", size = 96555, upload-time = "2025-06-14T08:46:37.766Z" }, +] + +[[package]] +name = "xlsxwriter" +version = "3.2.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", hash = "sha256:254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c", size = 215940, upload-time = "2025-09-16T00:16:21.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", hash = "sha256:9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3", size = 175315, upload-time = "2025-09-16T00:16:20.108Z" }, +] + [[package]] name = "zipp" version = "3.23.0" From 669db4875b9cd542c124fd05dd3eb1412e0a599e Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:07:01 +0000 Subject: [PATCH 92/97] Improves API flexibility and adds utility functions Makes scales parameter optional in normalization functions, defaulting to all instrument scales when not specified. Adds new angle utility functions for octant positioning and cosine modeling. Reorganizes imports to improve module structure and accessibility. --- src/circumplex/__init__.py | 8 ++- src/circumplex/data/SATP Dataset v1.4.xlsx | Bin 3215288 -> 0 bytes src/circumplex/instruments/models.py | 9 ++- src/circumplex/utils/__init__.py | 6 ++ src/circumplex/utils/angles.py | 80 ++++++++++++++++++++- src/circumplex/utils/tidying_functions.py | 6 +- tests/test_tidying_functions.py | 24 +++++-- 7 files changed, 116 insertions(+), 17 deletions(-) delete mode 100644 src/circumplex/data/SATP Dataset v1.4.xlsx diff --git a/src/circumplex/__init__.py b/src/circumplex/__init__.py index 15ab76a..3b17255 100644 --- a/src/circumplex/__init__.py +++ b/src/circumplex/__init__.py @@ -28,13 +28,13 @@ """ # Core analysis functions +# Utility functions +from circumplex import utils from circumplex.analysis import ssm_analyze # Data loading from circumplex.data import load_dataset - -# Utility functions -from circumplex.utils.angles import OCTANTS, POLES, QUADRANTS, Degree, Radian +from circumplex.utils.angles import OCTANTS, POLES, QUADRANTS, Degree, Radian, octants # Visualization functions from circumplex.visualization import plot_circle, plot_contrast, plot_curve @@ -63,6 +63,7 @@ "ipsatize", "load_dataset", "norm_standardize", + "octants", "plot_circle", "plot_contrast", "plot_curve", @@ -70,4 +71,5 @@ "score", "show_instruments", "ssm_analyze", + "utils", ] diff --git a/src/circumplex/data/SATP Dataset v1.4.xlsx b/src/circumplex/data/SATP Dataset v1.4.xlsx deleted file mode 100644 index cffd75fc4b51230b3d186b035a1f8b7a9f791629..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3215288 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

oNMuzEQQc# zP+p0ac4&P%GW*$_nZ!=muu=KJNg?boZ!Uz3?G$l%j-9Rlcy*Rlb!8w;_sHzSKep%r zrdf@7c4>zbEu(^eEjL^aw!VXFk!+>S8_q0|^ZrXVw{yLva^Ifv>jO$v-OH{NL`pft z*H6ka4g%=$N5VCQg>97H5vgu)I%Oc4=gr$NI`!~{X_f|Yw*C2nTX1C85~n#C3;kyp zkGGl<`9^7)oVKZ16R{Z@I{zwl&in|~-&tRUprS&5cuSXL2259i2HD?)xm>^ofY~ez7saa#A3Qt+86Diz9XEZqU&A5Qqhjnks*C2 zDylAXBtw^sB_Z{ zwF*m*{G&04YbnRbr#u*sFQ0!)_pE+`1hx^QHM*dBu#nMT*wxM5K_peOLVmco4>9$x zWQzXzd32zEU&a4r-XF>2$d^zCBkw>W{Sj<*`_Ht;}@7g&I8DCD+rg=`<}qIRZ7%8JHCV>pdTRJYN5X;wBAVxIc0 z?X!)MvgMk$k*&E+&N(lUgIFXYrmSeGNIKHUuJ|TCe?W{mue{)#8QO(aGQ6EM-d>Xn z9FXy^Q2r_N**l1yNY=s+7Ur$YB=@5FDdI8=$x@L&eekj1?@HHhEFhIsek)y|*_+7N zPKz{aX?sg8VzApechmG{ehoW#Z6`!d)Wn!(ZP8AMEx-qQ8A3Ssw$ z!h7*(=|ZzTb8!`D+J7pGN+#}tr~Jn+XD}W_;s8H1K>(?k%F$p_-cND-%L5^(LQ`*G z3bUPXbIk7R;W}v;_H}~p6YyQpkM<)!7A(v21 z%cK?A?A{k7$>*Nz{JrP_HZIvi<84E&RF$d=0Hjw*T7F6nV{t6e`?_Tn^!VMDhG8|1 z8gIvi|9Kx6%Q^Mjwp5^{%jl~t>F9|t91%B-{i!HooV*KGa;hx*ldBsD&U93TQESJ!&~(pt%rU3r3D;Nr&F&n}yDl8+E()g+!{J;Q!7q&dX6c0qFq zkjj>%2vA@U0j0B@K{Oi1eJMl*zTuOdZt;gKp)Uz+#usx@^dJJ)y)@FSOj6NO=s|n` zH2(erui2K_&Y0USMn=)r@Thnu^UkKDe5tpq7p22?&j=4I*8D5*!0%bi$~-ZoU~s#? zW_!W~jaM<&8bOszjSuUeQEd!7LuPFZoW_GZ>V@T2*V9G48bMEO=pkBm@Q?U_=+_@q zzIaklIozyN9-g;A#%dC2fX!rS+Ct60-t8$BeRc5yQuZ-(q+m^(>?2h3iFbu${DeeJ zA1UT1vjnd%OaQ!uX}9siIexV2iEK5-h%D}?pO(qIo}`T)yjHf7{+6jd^lLBlMl~}5 z?a#`p>Y*9_*OQ@Un^4*_Wm~#XEn+r1Dz%Fr-p`DyRbPfBXXbBL-%|p+i%uGNnA zK2rZZ=LZ#mx`A48y00r?1CDkt6V0R|I&_}X{Bz++$x$-xB=bwNq<&?VG&>osDw3yb zVTB}WM(qbXok#>mB0Lq>SJLBkGursqmxPd8ZK2w3DhCnQm0mR@|kDr=A`VjynD2c!9kJgaB9Y+1Y#onI``sjUqHw}EGJDo{? znmhaQ3N#X~;8ssK%{SzScbKAOu&aYbh9+zDAV40J0Fpo?*k-a@wz7WPNZuK28J@-! zWp)wjLIj{*F*J8BzlZ4Ic9Em30Qe7Pf`U#B`ZttKtfz=D)K3ecuX<^()J4t;O9)=#oZPS>9EhBNvjooF;N?^ViA zPS0^wLpbfIG{e9$Mk;pfXw!1mRI?({o-DH2Ko=gGV`wo}gLVXnXuUCn_&-1WG?#C4X^*Q>1y)`_jk<36N}H{VTJBy+zkz)+{@(R)MJGM#irwPs_F2aSRgL4)T@j|l3mGgTe z*KN|&+;*&I&a6m@C%0@7&ysos{FH$woi zy}+qyy%zhcscb++hq;>M@{M^dW(iPtWg;b!WI7i_M>!(ymU2!QBy6sNv3b~UTLKUn z^OOXHUbn7=^4CO4Gon4p!r-LyDcO8AYL zP#b_WEI|t?Nh~%^lfpEa<5W} zGwYk;Fe{2U&Er(pOu>;-7qf?n!|HqC>t3dT0_~$?4wI&r&%8#qb>9GhcEW&4s`QGK z1cH{QY0UVJZj?vyd*uu{ov7?Q!iXDiYWRD@H42o0iqt7otPCr*m(;4BxE)q<$ro#n z;2wtF{Fu$55yd%7$=POfrpTD_w&!zRbnquRYELw|tY|3-c|Bx$FIpl}7-`GHf_Zh3 zXFY{#8>$gpZ?z?a6|G=Spoy!Pu_CSbg^@GVF8J7uzJ^-4MQsEZXfoBXsO+hg^wCHY zr4)dY{TP`zwQUPHwTVUY13?%X05;rYmc-AqFi*Z=dL)+yXG>~>H_mhamHK07IaRdziYiNek6zv3RnfU@ zyvSCh+fwWlYy!@OHb&}uAIt$pu8l&<@>v8FwmmC;d0?_L_xDCH*yMcjn9K7MuHku*PwodJ(lsf+z?z>vL}v94lv5=CYh|db{}tGLB1@1$<#k|PfVX5btwRGNM z_?;4GYblv#ysVjPun7V*O8sov@hm1J=E8_X5v{ZFXnS0+;8lrwejM$^>EzjoP~2Gp zHeDS~a4V+x%49x9<%b!u!@?kZt%7ikt}d4|R;wJGmK0hHuqSC8_}G`T+cy;qp}c)# zI5`+!M0iRZ<|5%*1(-@Yfa$g*@owi~t zZ)j_7GAF_0aZJurnjP3v;`E^<{cDc0Mj8#~)>JahXc=vsmev$4B7-eE>O_jm5Mw{Y z?(Qchg>6rLNpQxa^%822lLoHvQhrt9lH;_A)VW9 zhnZaRsoKN1yP-Ew4Axu4%C8kr$O*F*G1dMsFEv583&ptG8JV~q*_(u8cMIz+-^4Py zpC;p(lqO?*DzuBlZ9+>>|H${&mo%~*PJ-35?XSkQs$Do`JCf%{a;{tAG#&$}vA~e( zo4DDX8cGiqLi@wj*lbQnq6U0xOemSd*jJYE9euaW8J)JAR~-~8v^yGGsAu*)E{CR5 zsA2|Fz8tdSoiieA{WY?duY-#?`nkt}E-!H+0{D3*qkri(7_ zluLYF!!$M`U92cEOhZZ12$hs_&3$ZCbDM>VTq?wjTyx2oyN#M~-qY`Q&iSJr9v&X= zy*{tc>-u~?-v}+&vnR}tF)kU2{kqV;z0MKMs8_QZb5$ykt-dey%;J#$u3bxGUFSvJ zCHk+jBIJWV(ul!h;gbPK(yxQdjki_IuAJozDI^md9}j`5VtS|GRE6&0-VEhP1$BU;!qBX3%RXKRC6SR=#le%vGvv13JT~Zi(~PHAbjsvUKObkBDyHO6|?; zkC~_p3EXTAa&$GP?1dCf{fnyzpYHTfejcc(EhKHWUy0RP7`1`W7{f$}! z=T~j`edy@29goJ#gl?-T`N@eXSdrLboVnnh2^3`^b8?JuCv$1$@+i7E$bJ5@6JsKc zyrI3QSU@+3ivU;FVRo_fYvDfD~l zjoiMWgUO3yoyT`-+UB++;yq{2V2x8+Nfp-iXPW0sF-s z;h-cRAAkzoReoQ)&F;_}M#^~S=ijHwPhesqK#Lt+)0(=_ZT*DtR_e8@d*13>^)>Bb z_dUX+CU&J^8tXrpZ{5Sn>-LuQ(h6+?ejO%9we2tg6XOo+Yoq_atKs41FdoV z>dXhZd)tW4g(QW$!dJ63pDiRHy?aW7syTEz0RVZRTFMuBNb_bj`nX!79+N&wRW2~4(xsn1|h|K(y& ze$P9cJWar5S>BUbD>^MY0nd5n{?{6DZ8Bw=eI9@K5RLg(3h#BDI@F$@A={6o&JSkw z8c-u_T>{1jH@xc~(`&ZrC`AdBnLg-&Y(BIo|U*z#g zq1(!F(KiKsp!?1~I`iFY;6n;u3%=r{$gaOqMTZHcw6(L{Beb6BINquE5l6S?FtVfn zU2LQg8BJHW4fu6oftQ#!)v4$Wy&;S$U(e<%9{WywYJHz|Gw6W!z|H&7NA2^#Tl8*Gb(jx0bEu8!=fVvTH;4I& z`UfK7Z@vG%<*qQbK2g1S(2IUCSq|!au;hPQ&;Cw-geNy2mCZy5i+V* z{tUI2#^w1RU)}?z(Fjdff3U`m?P$WdV2{EEl!|Nn76X&uDel>$8;<%{I;{7AeYsj7 z{1hxFdc*&a%*n4G7%{b>eVuesE#acYtazkL?&{|h%j+YVUMKud#bsQYx;$K>JB16F z==r2~;$@gP*sbcMY=--}kjj7`ZL6^)G2%4m8zVa!s#2_2^}7D5;)XLRh-m7@jYE3; z-PZSl@yOFVEY;m5KAK8bnhg}{j&PPk{nM&M2##%EbMBW`nAq=YUPUbPa}uD8>a-k3 z&D{)HNze}SrJMsmAE}Zhi{Fv2azdAht{}>H2jIQ)J6_+3JkmPa(-D1ns7mt0-pUTe z00=G7)ZN4f>d&Ln-}lwIo`_KbnR5s2t+akA!wiJ>9sH%Qy^Y&(6m{y0&oclnEm8x` z!%RW{%`Q;j_5V1y8N0qR*8~8kX=KXYU8dvKx*R>X?I6x?I7?M894w4Z-Z3np+gr>i z?q(GCx-xLwo^P#MQOpY-T`s}~-i%pZktM?0-pGtr-dlI_D^c$8Fq_La(7ePi5)Niwh;eF* z=Yb>8wIsYirBE|}%omq=Sd{x&j}ZU73#>2XXTM_jwJPn_a{pY2pk`H`6PpaBTYswA zXZS_1a{Ow9LD^tir-Y6G*?&{~PQ1IV;IOucSaK(cgWi{!T{?+vXbEuDL@Q z^AO^vu-C5g=C55>DkM{HWEJ!n-Q0K@eBKbn+R)kg{VH*c;<6w6oZg)_Tf8$uW^qSs zd#69I-}O!1nd^4B)Y8gn%!0<#Tj^rLzlAxF|BS9fbkHk5hZ~RMq7Y|ahWO<Ze7Q(-7Ax8x77aft_&Nmf@M*gz6(xFDg zP5(VeSca_>pWOM*fS$A6@CzDKj?6e94uAcPKI;YV;}NG{qqjFTXk!!&qmlgA8YQD} z9u_8+@-sOGFnKR1sYj(7@`FZTV^z8P(9{<*}&;Dh|Dag466v8 zX%^YKow|{H!Fx|k1oFOok8brPN@_MqZlR`Eh($L1)p(U;oX#8Q7_b_aoT~CsDA0D~ zV!ttukc$Zs(PcS3I+g@iO~R-54|(6JwnCy~j1phh9VSX*FPPdBaog9=?!oHc)!RAV z^@baXqL}mhu@&L_vAp>mZwJr8Uw2pvy52g$`{JRD;hLYjC--I!AA&X2X1;5d(c0rC7xX+qTmM+Q24 zTpM#J0MU#j?@5eHmj9-$F{l0d$kXeaI#2!JUhr8S%uR**TXg=1zI4RvEpMQ~!OxJe zwPTzM5$jD?WY$j&t>=OGc!QrsJ88kUHh=190{vZ|@t;xzkrxLqba~atxB1h%?vm*lg2wBJRk#&9f`iz3Vy-WCF}W zl$qwSXY9JIy`UQW93#I%u=>jUc#euTq*<58_`A8uDb`T~)}(L*(yRp;Vvfolaj5R#vGN^{vzJat>n6UwD%RJp*7)UahR50&PHOJ#k4ZT!v=`{$YM+qlyWsgKB8-=gBo4~-a7b0*S=QBilRh8Bg0=a3Z+fUtRDEA7PVCC5# zjhw0f^Z=48m_!&l0RaWN+2^Y+&tMCLtll)aGvyE3ZdaM0T^QT|u7`{Ph!`QAA;gU{jM-Pr>{w3QK8T#_6NFQJZ- z3M(?wvNM5lMtb<2{kBz3e>2s__`jqtzB0H)%TB89kpXst>h!vO2>*p_|2ncoh6>G9 z*w#ukHwB)U$w6qH{v&Ms(m^Z7$ddAw@J^6YSn{$%5kG{Ee8LsyI1TG562LHfo6wL+o!yF_HWez*YwG^F< zvfA9Z@hBt`oS6#Fq`y}4nknwDi)S93cyJ{Z$`1JHRfHF*n11+({GHzZ;3A1uhZtY2 z6O&Y#o*VvP3dKdX^WBs_m?^z%B0~|MnE=(=kZUdpm>USpMc*>4HF$57@I8g&UZ@}f zLdLxMMFtZOCh@o-dR}X42$NQbO~N!23QHiHUCM2>`rsa1jRA2um=bxtbB%Jj+y5|a2 zab2e>pPodK5}3Mx>cY=1edbJ=2->5Zhl0=BhufpNKc%C{>KlgG3KzrhBojqA6$Iv z**|9#ZaG7(yY4{tdvz=0ooD9ss7CVkiKMa2anD1P!ef&Sf)qcOeJ}7)4~wpys3ufw zV&leM;N^aQvg#XDvuI^zQ2Zb>X;BgJiD5T+^)!7@C8zg?(BLrxWFxyw!S9oeWamt3 zxanwcrZZ^p6WX4bBIi1yRbpuHT-t2S0|Cl`k!r%V&u{Q|4uu3e;ZB~U2Yc4?Lj=75?20`n_?li>G$4OE?I^A`pa=MDDrJnICGjx&tw*3yPv5M_)_To}#)- z=5k-A#>|2I?+tyrat0x~PPk8t1C1u%h}cyyLrl+C6M7bsDSkiYW=1hl?eV%03=Pst zHnIoi_K}}Wzg@kHT+8Lalc#6TWnIV;q)7eC!8CH+k>gH=e5WWfMHwp`C*ErOk4jvr zSQPkYvOn~&YxY@(#>(jEoxfOVBHw}MF)7%3u9<@0FE{-^Ypok)*WO3&EgYbw=EMfu zYFD)F_VGR>`KR4h|A58z`QwM*41UYKA8im&tAnw|4MgAj@X1PaZI3!cGfX1A|FaB_ zm4YHP1$*IOGud@|`6PB4p~?Pm*War6{TIDW+wh6r*dQ_?;yHZgA%4f1|Kq}m#3xfM z>532EMoXPiLo4IZ;k|iXnO{lOc@&eQLxTcS+x8YDlABSITU1j9+>xNOyOA z18340v40ewEsXoTGuA7&Zdt!2A@r$Om2-uDlwpPFYIqck)IOW?U`Lj_2@m72OcFk% z^d%i?lIor=*sFW`e2l5w!MNXvBQ+zfWwS6pR)pPvYUdbqu18?1ecM?EHnb9i_ZKwQ zQ5`N#z6qiF#TorD4A2$Fo!rC9iS-aaLg%0HfJ5|HS#(y?{>{O6%E2_~jzC>;>Z2!5 zG!tG=67wubo#BDA-x-y$C7tePIdAV27vj!xE})(eIvF1updMt4;a;DHMiCX9VhET= zC(1{PB}0<%@);CHwjMn6`9o~jzEK`5Ep-R>=9AL~I!Avc2VzwRZqc1`=?p_ECXUsA z+Q^nvca61iEr~%cIlEF@t{~i2tJMVvGxE|;AZAt zbi#XK{y>@x?j5sVJrEkQ%XxAdl7z>n9Q{* zPq3`3>=SH~QLk57KUBX5i2gC4zL!%DDYB|7vEDLSjGnkxRcr>%B3fB8)JeMbi-_=~ zHzzc5Gj@$%q%VJ56f2;hGEd;vf9rffN9Z2Go&5csu=5_vrH$3OF@9?-sAFo|-yFp` zQo{bG%aS{%(7YG}B}k@hLG-h;RQ|`5rh#T+Bj0%I*!Z}0ReOR>3b23tM;@?0=R2iW zRb#zId;J0Y3A%#0JJN4oQf(`!$y!~O6in23i2XIkWrb=W19V|K5(Uu^T!= zq2-Cz-*et}B>DZ^2>MfU!A9xT&7pUjRUV1gwYPao2GoSF4e~^$eH+%cZ%6I*eID;F zeZpV0w^2K8=oUKDDzaI;R5E|~zA5&Chg818FWt&Z6v_O6eP9T=MVNsM6z2sb;R}{h z4rRfkqrBMCzcb|)G$Ajgq+5u4tpozF6TGVU*Q> zYG|+#B(^QAqCYJ|B%{Xq>!wW?4?}m>F!(D*>xOWkSW>WPmAQ$9&_E6YwhHlI{B=>@ ze9l|_G6+ZH%*O*3(%?%OD|=Min-i0c?{iEuYgZ1kV@tZ-Z*s2hZHC9U<8Fe40b3n{ zq`42YZzs)3+GU zWe-NQg(`+SKCXl|LH;ACIh54)R!<>W3*)+S|IPYougr(-eKu}A#;8V@cJJ8186evi z8DGpBde{~4(d1EZdWQViQH!6gu^`j&v-#a!4J|I#8_%U>^FVa_y%OP+TJS%{TqItd zUsi%OKXuk~yUKZx3+Z8zM-#)!hm;|eOFChr)>XIATHQ9R4EMEroYT)DJ#7mWw&et+ zbAGU7zo7kTPAdgBZuqD08dcGR*w-Sv)2vfP3~qk4%BZX=@IsskO7^^eSkq2$(DY-; zNuHDfQ*Din{2;Lodwmn4>=9g3x(E6NDhC9#T9?9`6?EQI|=gHslJIE7fIPq&c#t^xwjIH5JP;6@ARPFHnJFgPmx%-Gpd)49t`h<=!pk7m#}OkMT0pbgHn4K|OIQd#A-*&bv7qZC>&1)%cM8iLw$t zgMz)mr}NsY-hwR$_z1b?%=J;}@%7_7?;-I&K*72MZ46FTwx-Fo5FDra{N3ZPRpwZW zS*>0-Az{ZLEqIw45<|_a?o(*B8 z8a2rTv1#Q;U*q|M_AeW1yG;5e5qer9w`INQBSA#$v{9wAo}X_$-XnlndtJzmB>{VHO_w?_23H?!xpRtaA-4HTlEiCR7~h z@J{FHX+l?k4(S}!7waC}*)aZ~X5A*pi=h3(y@7b6OvxXt>Tg5?7rkfGlcPXq)D@g& zV*bMi3tD*$yju8_^0}pjEH%}o1MM13S6Z*I&sF$E_k7XfQaAiEPAoN{A;XNcpERbQxN7*7&Kz3io;X?^8h zVK>t%p*#qq@f&W!Wmu3Ae45Z+)rBslfj~yBz2j)v)Vt)Lq#-Cw7o(M8~!Lmi`3rSL09YhYDb5(3o*^vEgqb zttNlIYwpSgSwhp?l_t*audpWoSKGj(byZ-r>BaIs=Es%L+o3X>L7GCpbSZ_1w(HTz zyp@epKMcck5r$*xaXLo>SL>g^cPWNB4uxPA58Ot2#`044woWys^9l=KY4TR66Q4No z`qUn8>Y4c`bffZ!HkmS7AxLx~6kdk?u{IytAM-v7ey}wfmEhKnu}5{GF7NNa-+7pV z106@AJX3cqL}#!iKbFLlC1k~X$D7)y+*H$q=qgLB94(Q~Xp!};T)V7R$Qq@wJy;?>RXy^#r+@aq>}nK`OD zE#T>XHl(Tp?pU$17v=tfluM!+lva#`X5!;>=+YjwRi)qwh9P;Si2b>w3lYQZkbj8g zAo@_}0PI;0V9%Pg)9iPv-88x4g6N>XhD7IcGWm@hr{rpDTlu%6*H%9uJIVHVcB9fw z8l*Y+bZL9lWNGjp*|?!6=uAZ9Q)TwjzA}c)A`yyAoVUZpZN>HJKZk#uILDkC8TaeP z{?M=XOORb2<^Ky2;aQ7eFD(49?yQ_Ftyvxxv%c(fQG3oWbh;P@Wz}TUE)PtRd!|*f zV8unOAHG_TdJTfwn)KdctLwg9ct4|*6{x}YC++>a&+kt5r$}VMad+if@M^si_B<_k z>l%B!Zq!U;f`BJRY+=S+a(KM^7g(QV{cugT$yPTG>;3{mFmQ&YBa>_e9PFGN8iqS* z@cPx>h;VBG*mF87=hECcpRkCHWkv{pAebnrN4{a;Dtnuu>~uH#Sfwz>#?^5b%^52c zS@1EKgfI8#icLd8~kHV8CrulT`g`^%gWSWw?+yb6g!~{ehR$DG=qs;Ao7*@g+Epj81C$ZM zRvEd_teckQRJn``dH1| zk+$*F$?)^Pd>~PBO|YRAvw*j6UAepDAo&+TuRA-}*!{ec7aK7v!Ax}8YiP(iohzFq{c3saQbl*5^_A*4fplPtL#z;Q4lTbZS$vCa4{a3D@O?-IfujLJQ zx>|@mN}O6iHzIEwK3g9v*uPz7n^G8cpIv#PmMl!+IQKn13?L;0l>ygosOpu?NXogd z_(jc&wOq2$>kY7viH6>P9s3m@yp}1HixsNU&3p`(`|@#I!ly|qShZ@TCtdP}{OUpW z$G;pes$7K8XG)!$;TJrdnkd^(bu;9#M}BPq?Vt$n&X3`bHA${#%mVLWbpzCyEtuld>v{p6<6kW<-v7?%8P*Vm>rhmS82$ z^k#$6(p-3epZ4SDGNbaTO7C0|`UgeDH1;lv{5g?*my~hxGQhw`?0xQ%OS$ zfWhxnB@ie*32!LXPwX+ClVHaF(XAXWZYVV?@$4=JJ9O#X6+=0LU|nzA^~7!${D2z( z*xNL9;pEy@mUErlpst-sBQql*9~?lk>~c3__a^HSJ=UdWrWV@z6fzg zFm%1CT9BC;t+*Q+g{*a5G+FXiU%RGk_NNAq`(1;N>Ht51YmVlnE?J$TiqExi$ZoLC za4ZODh2<73%oU(b^Vo<8!}6Vv22@beHVJZV*oW*DTc6peU|_tZ;^1~~$`FKMUXIe1 zWEH#I1~Uz3J1^GODN~M*kryp zaA~0@KFai1ssW}0Z`h_F!f3SORSc&&>Aj)zJ6l_>C@G%eW2HsGsG%WdN@Zx?3P~02 zI?CNVw0dk<$3qN(bHJpBex3gKB#3Jdz&ci|Na6;1=O(6wpQj-zBjZdCoINIYdxv1@ z<^q+HtH9IyCIk6=$fa`AfAsIwAHy}8>-tel(<7IB2cD;R*}IEVFZURwZydCFhboEK zn|q=uxEvtAU%anE^&`*e-yZ7Kwio;2=QmP@r0MBsid5`SHYwf4Q#oyR%os-12UuKb z&EA$vjWu#J8e>r&VXt0!2!l0h9F@eh%ig$}=>RajI>9%pbS@z?y|p1#io}7E}qXN3ja>L@EO=wPKJ#?=NA2lWRbAP2E_U4$`#;fGo12>+2OQ!l?VM~W#OGSa7x5hHHQ*N;K zpPLrpGdTSF3)aW26;glLT(AKCnnst4Le11yNDKd-Zx!#j8`_NO?u;?d zg8D{EV=t0~AMibf#)Pa7#Lw373smQSd{V|YUX$H@d7uSAbD&ca0T_HvDvFz$y92jE z@Bp;mwx}Tb3E}DA@;Se!*ow6SK75KHv>JWDEXiS$2-^T}*AF09NHzEpOoAQE`_7p+ z3+RYq&}679XW91WAuECGk0zgpF4bI@mP z=%z5<_l1+T&1VF$i+%zS>VYg(H}Jg*2^HlDO%ebl2kpbD zjM!(+?)Q|j5v)CS+!{B?bE)a7XBlBzz4pV2Bbj%Q{4+CNkRxxbP+g}Z1B7OjynMr6 zwh2%|hx0KlCZ{Mp<~JUPHxU2h(t%GoYL3&hSEhB6?7z7RFfSM}dCR;;$Kn3|1K@>WTL@PEO9W@=eSjcCfF$+JPB7 z*loPE6Oo_!nXR8fZJ;nNW!xgA9zjue+&*uGN^oe$(4G3qVN5Vu>sg_k7p^Njh(e2Z zHK=B11A`m@@&lCa0D|h-ZzWkzxNfQN~oPz}}ZZVG=lwt?n2-KCl;TN7nct$q` z*`V#f7v<6Q(fHYQgNT^ejiBy%$joosTjT&_ZXKW79KSCJFJh!J7mSo(W==R$OKa}m zX+`3yv2OJ7>33MYlhrb%?*V5yt-J&f!KWI{9{d-_O|`er@c!Lt(w4?OTms&=F&S8X zT^PARR?AxzAu{_Fg#s$KDHR{{bjOWjR z9rleEm$?No04Nc&8iN#jSuQ?r4a)I=d3XUFa#t}-SBPQWFfgUdvst*InY*dhg(V+1E$j)qqs1IN-(K<6`A-&5cU8QlR)RE)~&;r(^8c-Mz%%;|--- zaEkjDoH7956k{8VYTP9r*-S@ ze2T&&wkC{ID0#JCjTQx$DP4e4q)v;J0m5RgYn1<(do+?uRAeXB_}!GN#=qpRi5c|J z`ekmhu93u`m)iBi03dgEfatR3i)W_Q#s0@GT?Gk7Z;a-X#$f6J&WYIu*_V_wD4XE zpt9ZhziTyJNj2dzg{{M|C|ql^gQYP0sKK>9b3u1-dDH5^ABj8fq&E5|=5m=JLo|w{ z!F8J67FBMBJejgTzrnT!1+$yzk_QUrc#d5FU?c5_76k>=JmQr~ISXE5mxM#Z)aRai zyw#x+D|ym9m*HV%^5bc<#9&>+D322t!9rZ!a|A5JEdVt!j{7e_9}tIjn9|m6E|eaO zeWJ|p3OqCT=u4x?vuf+J`{MA}I?W;gZKRZ&5c`Nbsyq`u&gaXGYv`Md0*IqjRs+{` zy(MKtDPZvY?_cli^FYCQk|X)f;4>v{&*%0dqlL>K|Ekq|kKOf4m)z_BxrQ+kh99l* zM|BM?yK0q0yJvr&w0gcrEz9yieTm&`wXCUa-G0Y7oL?qdbLW8uh6kX61ye`o!qB)h zu=s?bGc6(?cd-H~^8gn_d@BBrJ6PO1tzh}QbIuoVht)C(fIA$TK8Dr%-R}*`&(Ws= zD2av2#wy`V$+pit7#bYp37;2zSF+LAHzL^z3|N?1i7ETD>srO#qI|w!7v}1L7Jpa4 zs)Y)ZT21oJ%Yc9cXCzmI=6xS-TOU~)6Q%uKN7ISADqz?c%0-M(17DJiPj}!&J5bPN ztLmh*o0-ydJ>cXivVDPZoZUQLn>MxI;!tt7GRhXVy~pUNlhz4P3*3SZC#jP9{1N=K zJ219_@EXPia<(aH%IOd{H3&qz0=2A0AMlNz0$R&fk}QNmf&Ezv#`{}q$ldnO^}4=;1X6Dw(qex&tyo_QC7})mw;;7`ETs`xyu`w| z3t`R*6%6$P$|EnOUrn-lxF(#x2a_dEwMVT5ah@<(?@Q<(PQd0}gTY*Q2^w=X(&t(b zcH2^QdFRyC`4-K40jBlDZ4KY?xZY0UH-Q~%Q=@-DJisvfZy7Ke36G%%K)-j$yqPIW zH~Z&^LgTYPW!IVkU-*NTS`-`n74U@$w1Nb#CMrE+<^57l#hf=Z{CIjsat88jy1eC@ zTeQ4J`Ca#}({#V*GQtdbAAPculgCA-eN9-!1({HvTnajXtReIZ2))Bh7S(o=O z>s-K``J)ljh9s}kwe%{+&FkxYRI-e9HkHk;V}9pPjnNxVZ)2}c6svS+LWuVl>o(i# zHikEG6o>`M!0G)$Yt;mif9(V4cdQ=;-E}GgRfSH*JIAlli@5=Ub!@1lTj;qh0eQf+ zYn9`TD^ITTnSs)a6}64T6;biG-p8xO%kj=Fhb6d9hqNn^XKy&2!!9=5jc2$ z{g-d1lkt~S-|6#axyV5F zU_mM7_rSYoWOud8;|C|xvfszV(%Tf-EoxpMCbo+pwUJ!w2kFCy%(9Akz#g?h$n1>0 z_o4f_CE$W?fbp_)t05J!VdwMMdhCyi2gM6Q2zpyR$*{km$)c3RcL$Y#XvdJwDTo}A zA69-`$mT}uoJxtG) zIPTW|^qvQM4X|Q}$Dv`B8sHtKA-j8L-J5>!fb=W5OsP9+7Y+pg64I!u(nxl08ShB&5hMW9dWWF9ecddQ{@VlRzNiY>z)2Kjdx#AoTRw=f^DRW zzy-Q&NJn-*299})Y21xOMX`VW=)ik+8u?#a)noJjXJ6W1cSi9wJm}g>Q``1o ziVf%H)CY`=bgK%9gNU?Ll&DQZLecA>Vj^Rz^ z;KNU~n8FNvJ;_GBdWQ;kt-%LUFG^p8VV~z{Y#lw-ht{Hlp)P#(3Dfhf1Cu-*Yubux zpLZp5-y?n&fLnmnb6WlUrMH=VEu;k>wIRd9XjEpsiRY#E#>hPp63vu3Sl9ME8pU4% zbl+y!4!r!5iOwl5$zCe3HjcVT(id2xIXpddA@4Z`;JY97b)m?M_ZL&x{{q3M{oCT?XD*uO{${3kX;Q!At zFLt-&%qX>mtQ2CK<)9i$f4?xz!rouvy?F$nRb&)cUW3=uvFl7DDhNjW*6;|hD&?>~ z`~79OTP}A4Ya&7|1TVv{CXSo?4hXoQlHcN!XL9*Zw`gpi@rE8h-19@6jk% zZI2t6u5}I%IWUg`Y_AmH1lqxJ3Ya4HwssZP z?mJiRA-wWA_E0y141^@ssOx0T1>{@&Xq5))=g3SkVdU6~7c`N;tkHz51&xWHRcnHX zXq@%%w*xri=wKX>yzuC&-K_RVQPE4R(*xefLuC$v#khd3pn#bICNtBoAw#}~=7f?b zroq%ev>=KCM`+Pctat%6E?6Ll z2hoVW<3Sd5qVvD<@YT<6)Z5+M7=9!0=1UVu5^DrcR!$f;!Yy-+X>WCdN&tXe! zBtD%edcKfue&B$G*!2E9qgC)S0j;ooX{p;NCVG;HDB}8|n4y6Y@bWyi&5JDv%YKDq zWB3>@Xn^$^-uBCNnr9Wy^Ra+#2hYiK${fT8r!I^P6UH`w(>MRlN3N@F$TkW+5~V!l zy#2$ju_4N^obu#7)7k7Tu2SA7wN9gh;5=k(N#TB+=$g0VusS%cJ zLz-kvR??zSVDU$M6r{d+KF2~>v-?1&0I1U9g;eLr<8`j*kV#2;Cz*HI++iM6K_2RX zk@dJNhFwj2a7l39Susq_fSeT8a!%{>)9 zwEc?O=a1aE%CpPnP21WS5Uxlv0Zs#}aBt+?(7|>#yn*vSo?lmf)P)xz)g;Ktb2PvW zjZ!w}DC8&jqib~AnYpwLkD7|2!*g~h{*8>-pMJ06J;L_cKDH`*V&m2U_%r9oW|>l# z5@Qj*(x2?zpD95kHoyj3%ys*@%2SU7SNrfTARefzl8286B#51@l>X>*^c45k|~+ynp)Yi3-7()7+P1gv_HUYCb!ir_8>SyCLzqekCV1TGDz5z(u6JwmM6vEZHR z)E!7QxSC{>i&YoL=deHCPO_2z_W4R>4x0z8l0_MEC#&8-}Z+L?gkZ?g}?)T)e|h0OwqHvE5+>37Zm-bi%1Br zqHOV4Eez;D(^^g5=fh?X!+O;ElPN;a)2vNm>(f*g zEna(r?-w-E?a47DE`1YZ@VTu((DMg)ku?CHo(R|uOGt3_tn|5b?H#tFuD1{T$=GpR zqE)f8*QMM?L{A@2h_oKiHGV(U!*(75xRN%uSwS)os_-<|vyvlgm#pV9YE`&2wBPzOX9Nimxo_JlycFm`sD-2b zXl1!;6E1)!5qX6o|J{Y9)vrQ4QnF&Fih}i<8&9tvKPukgIk6!jPb@eN^qqqp(?|WQ zH5&w~=enmW0qvzzmmxjNSpFYt6~@Jhx8pIu;HXLBFE2y=8-XAe4^^9L&&fYOAQlCt z+UF__7|rNg)q?%P53P6s5r%N5oq+VF2wFS!8{Z9|Mkth|GH}x%P67hUhWKe0ZbZ^J z%3Co~`L><>aq_@!C#WcapdxmwhrWyx%h0JSu6jy%Da(em`XD+Q?+vorl@g+W3 zXRDT=&u>$sKwFr0)QJ89I`^i4?`-HaFgO^v7m$?FKc>u0BuRR^87@D78e#aeh@fXE zZ5qHC?1qp9JnrQI(|UX36Oi970k9}k@MIQT9;}uhfX;^fPiKQ&f9B#vaOb*}zU5Z+ z;I$8gPA1bN3;vq^7HKcz<3BFh*DfI7ZQQ*#id1_^{i-ELqrbd3bN0RTnR<42)Box$ zpKQ%hK#$SQ(Zbiek~dE7oZCw2z^|C~T{ZRzeEDFtyi9@BPW#L#!i%U}p^oyc!wz=& zRvxu{T2A6o#rsF3lwT;Cj$90c@)$;o_)lC2^j95#vcd3>vpVpjfEI9`rzfC!NFnyl zt9e9s30D)Teye{qp3GN8y8?Cvf7@`aOdhoT|N zN@T3Qk@~+qgoQwZLIlc1X~Ywmlll1~d_}|L!t;^$!fZ))go5b0qsI{dul9w~0{XA0 zI2@WTh?RN^hW6nRAfpHx-pv|qtWk0FlmuJ*+I}kJFXL_e(=IgbjZrm}z|n8yT;Iw& zRbhS3?MERYo!n5se#OX1e~C{(fSl_C@|0_l&+4!jVXec6fg_M=AAr-k$;DME5uCmU zB@DP|&MU%kw#~>rixU%q=X~VV)aV=!0JAp-PgZlrwi2%H$dCPTw`wUiJqlbYQxOA5 znOeXN!vA~~y8v_c-eTWyQ+_lrcZuxeG3G1NHKde%k)-aVZ06IxahrZ^-TPyQ>X*<9a4hr?XvG#bY)3}N1!R{_Padz+kNu(Ba9lj2H5NZ zfBC0}M-g0O2wX&5_g2Yz^*eY`N0%(jRx`Nmof{jm4e~!6HcI+QxG71W{6BUp*pq_+ zlQ^im70EQohHNn7{1b8(Mzm#WG0aO*ST2brzLU`yy#(}w02GjD$%5)vUY~)Cm)}Ko zjrCQO%R*Q+`+K-L2Lw0wR=Bc{w^nFy>c^3dG%&@3eXsN`ci+pK-preVu+mmmY%W6u z|AcR&f;h~Al3a+wEF~{Z5@VpEoNu?(9aOEy`9UfYayC7SzN_45%#OtV36iA?o#__& z^dtK~k0_s*s?h zUiDUo0xdV7_5Z&tM%cqDqaP(jBJlamYd&SFDUtM$zt@D)H!@P zeWuDSb6na; zT~tt#J|EQ&a?~eGwAmvl=_MaUsM%IABp7SRGnmN_Xzh*n8lXnE_K|zI@(iLr8-yU( zB0b->u>j6P!Gp{J;LZ`s>~V05#AW)oTbM4^u%Fr?&I7w~)}(TGy*B2;Wg%gPs3~}P zf(-KuL*_K$UeU7H*mb8dNKcO62P7MjNlazTcK@!jF9-O3aq7VpKq#h`ZVjs8eOO)# z(v1#SG`O~CSz+9V+0C=Yv$Eiz`pXi6KyO@zSiY3)i@o%1IF<0YuGkn_KO{RAIC1B% zoV*RzcYu-N)&5Ur^L67em_#Zf_7+alz}WyG)|jmTda<{JgE8m8eY*6E_E}zVDjtGa zEUQ%|Rh{bJz1^f~&&;UH3x;IWTRhxX6DFecE}a=(Zrne z{+eM48Wa3*>w=y)_kvy*%DxD|y_nsx@~B2UXo0WM`kB@yCvKW(TmKc`UWA8hW)JZ$ zyl`x4X-R471jQsZ57TK*1 zsQkr!u*mKz4R@~A&$$msRe^v`ruuz_<+S(bl?%J?L^F%dY!CeE#ued#GcT*DYU3sw zm7VA;hnQ^u!+1WFA~@a9M>axa4(z~8P@{~3XU{Pe-tx`_Gh^>Ckc1kp(YpN#*N;9B z0W4Z6X%^gdKGY`pU;NIC-hO8u-#POu$HV`nDbI5iQMNga z0P;!E8A21o6ao;fjM@!j-^s@lCm$VSma?V<#)V@Fle`z~-z=?v8#0^ES~afP){rHu zb2Rpoo^D{s$(Gz0zP~~>HK!x(cG2*#?X_56!SP0@06>YzwLl ztx!75-zBr?$D=_qpTyp~9F`o^w(EE3ID~`}Ahs|5AD+HFp6Tz8pAe-c6;qg7w-4DW z$^Di@sp!IrZ7NB%-0znerBowSqMLhBW0Sj?Q5vF}`&=5iGj}$ZF@9&hzu)h_>e1uu zywCf*Ua#lt`Fy_5iGzMCRS=r1x2&NMEN9qlifg};w9L?_CP;AoZGkZbetts@;gpRL z*$y6L&5DsXb;~I=PL$ebl?t7MVGn@|Z_#LLq2!5hDy6!z=a9l7j9P+%D3<&loMcix?pisHWo@&}XSQLL$i26>hWa09 zn){tgx9NE5Q~JJZeQx&>LwY%%cBkaSPKAH5F=Av_s>z9+;UV1mTMBIivMe=twvj{* zybuTVsz4$zMY_u5&|+JpzbQJvlRr_S)A`aMXF}=kb$nOUxZ{!|%EMiB*fIVKdPN2XTrbz6PTueV&8#D+fsT*Y$Re8O%DBn7=DcIZJe1kus<8|I0ns^Ig&Ah9Wow`j zJ$Qq=kp5MyZZo+d-OcEGL8-)e%o)${Ty}wC0^w*!0OhJi9d)qhV! zSAx{@F1qww$^6QRledI|X5FGHw!ScMslzUG=VQI2y0phrUo(vz@Ne~U!yc}!b!^%l zRAHQw%)@)fuNTf7Ms&HwLd63o)r*;0Jy_@>u{)n2vP$gyK8r&=w27WQFZ#n`fz&O2 zw}g)#*m)n%T&jJkmf_9nbTC<|@Xjr1w_b2?Sh>nSQ{3KQXXcP!w05C4I8x{C(+9?d z$A3@Z#>YJG%H)LY%de+buxr@0d-hDFR~!6@xqM7H9s%j94_ACdI5KT%Y zLmF!wF3%Tf)5v=8zhT?3zuEgkG|9M}wc{%P8cS$m=ZHK%unr*jeB{p$2_+)GvG+{R zv1e%pe%m~QW{Vym$-f3w$XnZ6(wyF#V}e8nEuJBm+k;%FQbDW;Zb9!*5x9N00=&7a z_?=fhaNzmfXTHC?Z>XyCUj5#;FSLx?PQmeCSInJ-$KTW)tliYEg?abiKw5lvw?&-t zPFC9FdE1I74If{aV+@OJo>T92o9IH|pOwkRCrfHhVhqvO=FBkxSNRi*KfV6{-1k*@ z4t~kYhuW`)29?}F#g3w=cM?t1f5k}SoyY7_gS#pMxq%)ihVYtouLbLx?GS47J^He1FJiQX(#g_6Q-*becEnDTVc2#1w`M z1nWl!Ho4O^YVmr{MH&>>^cDWFEf47ZSnQVYT9t#a#%Je;^FA_lH9|Zy2k3b}JmqHJ zPQUV)d&{?{9w^y`_+P5Szd7W22i3bNG7t?JnOyR{x86xOEm-#c?uTmP9nBiuCQ5fp z*xLO#yt>iapjDJ+MZO~YS)fvXe^FWKQjHm7Y*Fs!%HH*Du^#y3=__$e--Efq=c^x5 zVfUlv^JAGMGcMyiEUng&sYd;2-8$E2RbB#82od?U%(ylqm>anM^uGT68!407Xrp+u zr}v{u1Jl2xIeipo*Z))MSAW5GOD@ql`>Y%PW15bwD8uA4=~yKaKK?g%E|v$P@c^64 znezNG#luuk11;(ye$q_BgfS!vO5ViOiieU*RbZE$3-KBgJCI+$8h5L}lU;Wp`yxuW zO10VrrjnLVmr>fw$Fus<{EbS>*Ibmodh|8?;W9&G14x#EB(%)e5g{^K>?>n78*LbV z*hQJV1QDKN`=`hOLHTrYoRL+Jbx9bt50hp|!R`>&=|`0uc_yM5PCe^;i)Nt-%GPF)S42R&7j3GDD>*~KPa;v3XZQf_ix5q;OOF6}>7Ylf*L zv&9N;8CV@LoojdOT=aadH|~6xQ!Cl4;ue`(B*m=!wWGt4St8W;nb^*iVDMB+iaqwu z3yl)1xP>eE#M-E?HboNoPAx^F>tcDjBD??T<1WF%et*cOH_W{8qFp4BeonJNZH+g} zCE*I!EcW)vU2qf5r(@g7V13unGPxr{fV(@DjS<0_+8%tlZ}Yqf5@cb}N|%&is~g%P7bER(M@89hJzf#9b0M=E z06>;JZ|uGReM&AX7xEqMHW z;a$`EG)FGjWcJ7@eGxypFhBuqG6QKOtL94C1&>FH{m+8JcKhEU3e8oXWlT4Vc*%4M z_UpCDxBP_;-Li)i*e&kJMq+T>NDLIgY8H0qCyP-1Wpa#_gxEK!zoUHvC!e`)4Fdnr ztwM&as}F5r*F&CY7^G_IpOTMjSF{CX$TQarylqLQu`ND%OKwT7hwz-q+4 zYK9F2|L%WuVNBW9ODR%9LDG5Fj~-BOs%8_Fxt$OYODU)&b-^M(|PrPslQYJl^bjBPuOp+Th7@B*#3MXrSNt`I6E~N41 zf8i@`;3Ri+6y3WD#w5G5W$=%f;5)J>b=g z1j#r9m=T%+oet+MpQcdSQ!%$}iCCp<6UHjjpuI$>^Ka4U)!5O)B=^PV+#n%)v{;rP z)fn{{9F7srKl_*xc$U{xQ+K>OjRYfuGtv%SM=+j3!j=NfuQS;5g_xX7tEd*Lx3!_2mU3P--@ zFCAF@Gw~|#G8<_)i6wV{d&pYQjDmu?M|@?+iL6!f+g^;`r$;5X^a z8QH_9IpAN&Dm!VVyQASz%v`=sua+U)zixu9>JYF~`i()WOsA17S}Y@r<#eREZ(sU# zjvlPPKLU+n^(pSF*)RI!>}kaMUR$W5@qayLoOztDSFUtLcIs}Xi&8qsz!*UWUi@Mi zcoNoHGx!?HX?*XnvMDxo`p(Xk4%Pq#mkFKu(SszCvX0FNU_LqKl}i) zqAc==*rBzab#}Ac#=;gA-R8WgXm2+@4XPTay@V)sXw1PEJi9EktVENdTV;hT#v3=g zms9R6D!FD>%c47 zoJ3qC01gIi0^sl& za;V-`sY|uBM2sK$E*a$rnyi+Y)LikBW+$+WvTOd9iK_&f31`H5hoY&?D)rk?NsPH%Zs>G3lPc{UsCC@&417O%&#v z`7LtSpBUGgWB64!Fo$;-i7%yV)U20&h%?b#5MB$R8=g#pu1NGE>ZE)Ac+<|O`JOLn zDk|Fizm+z{zv-MNM37`tyBv;xwhU~S{aNw1KGqU4(`>hcry%9#LWyZ^Q#95%ZLk$8 zHPLcYA)L}S*<()iOm&YjuRCg6s(u==_;Z9lW=ttbsB(vH5 z2HqWV;{^Vl^G^_5cd_0fLoX(ZiWiRZn0xr_`SulO$sNsp*L<@Di@IEF2ZwmN$$)v< zm)%)>8V`9VSD@IXzR(ma(%?MEI9la7Ms61Ilj$B(Ay3UBO}(@3v$R*xn2l5x1X3A! z)7Vgs3gQumymVIN-Dam`r`gJiiqnCwp(>PF2}qs=t~kS&J~{357=49Pl$YU6pPaKr zevJXejs#mD4qIJxT3@Nen>&Idbm(!iipArPpA)P^9*slNQ~1T{DSy*Ee+!bPIftzE zp1Z)&G+prd0G%9@PEN2WU+u)7vi>zLgg`YxT;jRinH`g9o)(3WyA}qScFMd^mpJ>U zqZ(2_?2ZXCJ?n0u7AU0^im*YhaweW7KIXX8t(_RriZ#9)I3KE4aX(RHEs?l1@?_=! z;$l_^0Y5Q?Y(Ind2K_4+-! zKg8(hlrx9?eH8ceV{{lR1-9%x)ISxFB1drJoEz*{FK*K6(b?AAC-~C{0IeOTO)eb2 zL+m&#<(1G4R%Fo6RcT|an6ZtnE@{p0dwH4(PBQNCSwwA<&Chp!DxlUU^;oHkFa5ZB zJ-8-h5}=6$)z=)cPYnN75_oQx(AX}!8@z6b_!EP6-oe4E`x`?u6f*yWA(?MmKnsdq z(d838gRwTfn|v=b(~Us4PkF-R2Yvkqrbs9LvQurgTMa~>2m+@uJX+&o)@#B5?S`D5{L07RCF-_4x|XH&Ks!1jhv zp=5WazyBeSuiQqze#tT?$qf+=IKq234M;eJ_(c_4)>3E&g&}$zI$r9c@N101jmj`( zoq8sB{JBocOdcu4#r88cq)UuV?jx>ojC!m2V~&9@n0bzPUY~83_Jl*lvn50|i8Vo! zeM*yAn5N6D$}ME9EqwFL&cknya*NGY0D;%^$Eoc639V;N8qA3kZg&?P9Lr7l3&$gZ zJucw4@8~JIbD{TpL9xUP_l?)KMnB|@b;Ah<%44+B9!c=(gA6kh^l&%UgA8mO+Y*y| zKZ^IO3mLZ-^_)Y50h7#BDyf#ox^Gji%hwKVdq*1yDb>MAda!qX4VCjBKX0OdDVuZW zslpO8=KKVSi*hUrF>wfGgh|<}OunhZ_oN<*E#*6ow!c%C$<)s9{kfzx8`9@6^^rN@ z*9RWFYc^`N0k;!p~6Q4Z#t~rQu)5~J%;Wm#HA89<~eTUo?0KDWwTfz2s01;>R zJ}i*aCd{^fG-fUJL%a7Nl$qcC+t9EzxAq8sp-{5LsTzqJ3!z1=fKUJcO6Q!(=0H|` z677j4i#_YGKb17qSWEv7@pG}l8|2YwG_-dTRPvn3<3m1GIZ2kLC@rf1FHM~mM)ku| zST(1+1%3{{-HH2gdihq%bygznk*imH`pOFpXP&CGIx;${v~&xLiQ3Z=E4)+6%jKL? z$3=?zS*Kvz@@GeFK}SiwZ95Ghqw!I=S;cMg!5VaGSjgL1a?z*C%@SwOg@Px>u);V` zk3IzB4JMfJf0HV2pHRS*AInynwG6sh-CAee$l}nYXA0$Fg}m&NXdF}2JkHw-v}28k zqhL&Wkz|X9&AfZ?xHWj&ag%;ba?guRd*`PF)Jk@yNLLAa;K!yCQrT2y2#6|~ImJ&u| z+!*3^gz+ZtLO)eLChu)o43*LmJUV(`r}xX*UrAsC3U-dtLdI%adN5be>sfN2`Dbf% zsgT_9ZM|_7=m;*gY`Yiin~vyQ$>Vx$XJ2Of&SvnEieZtQC|n%v5xJ|`gBdDS^3kL3 zyyIN#{EZH7-|B#;oRy2}L(a00(`lGvt5#2D!elSO(8PV@^V#KV!C~8Dr!Z@1$nxdj zHH^oPcLpwVZ>KZQN5AYI+OL1;U`@3#2%X+~>pwic|8JcJY?I*q2l8=bBPBN`wjlDHoKhEf*j`%6A{ z<&VFe?xS(!L4vwd;$kEoIIFIUGZt#KKncvEw-iB>kZRn0vEruTAYG(k`y-L)2Ur%^$0>sZ-=!m)p#6<8K|N{8v<5>f+NV3XVsq5~TrxQ0M#=g2nfhCYFag&=De2!} z^Wd13>--y!tJ>d(VTHe!%l-yA)E-&l=)*f&)h452+-g@9+%<`{J3OJL6-C|ZU~=rt z`iv?Vw!`2x<`KyJLAW7sg6a$an>>ekK=zLV2HgY@99=CQnx@6TQZ(l1`x*=w!n-N- zTEO;;SN*j@A+QG78khXD0p-#8{ByjVlgVu5hr3C8gD&I`Mp2Ti*Ru2S5J!xE_=&eO z!tnP{)nH@-Rw>6sA_w~0d1!w*TdD!V)uev54tXL~?g!59d&oUEcrHDh8(mo!pGFd{ z`DnrST&hnN2_0)wtEuainN(@bA0Afu+nQuvUX0&l+V>bBZ+aT zmFoZ*T2oJPY!gpZcJ^rMw}QZhAM%yjh^-`_gTt=eT3zE8K^^P7CgWoUgYf^Z!rZTs!~vpt%wp-xR~rs{%L zEE%+7S3xUwF4L)Y&$TFCUtUoBn;h>Lts+HT->ZyoUZNkLG}>1_NzI*VOqqLBJe3Mw zW|u=Ttx14F(|E3Tan1yQ>r06fHkB&+SfVNbSzYQ@xaXFA&&U$Wxe^_fGXAZ(aONe;W6MXI?#B0ZKf~(Yn%#VtB@F1}k42jW^l`hf?fPLyc99Xkeba6~!TtcS z)~q78RJZE-sbV}#JnuJJtp|zXEahB{1C4{9fWs4@47LDefV~#S>-0Es(>v^C&` zf27BXV#eP`i{0A2tBM1A(B&8S2cHd{Sa11WKzmZ==Bh5x5(Lu)h=>w=dUme@It4m5 z6ZBOoaQ10@R347|YxjW~D@XVR$1A@EL~CAmXnbhVx}B{PspIyu z5?E79Hgk2NeC_x8s{yW*5p9_FH~0?G;0MG_=2h~7ZD~>+6R?<4<~smq^jhs)G)sCb zXbbblAsH#t83gR_(UB&bqEgUGjJ)AHMDcRPvP;<@Zh$m2gPHnOd$dXtv^YURP|y|= zh~WU{6{wP{TrHC0k)+T&PY94RVqWn*@}qmzPy#F)ssx0g(`5BS`mG*}6*&+r<-;%D zJ=RV<#%n3}VS!IrT)m`28(hp$@n!hE{$!L`hARx)t-W*k1?`}>mxaLr`kmSrVN{X0 zbB*>Jgz+%_`@^TRf1ZQIm~%J*cAVd2m-twU>r#mS-n6)|&a^Odnm`W<5EWlia~2-k zGhL+N<8dxJJ{O#9CDZw-9Z9 ze=R}Z;CR-998Ow>P1(jevFh0AEPYUqKfxh+{n|UvX!XR8T!a4`_q;lLQ&j^~sIhL2HM!{%2Hxb6FLE8A&9c`RZMLb%vJg0xIB`SYsXp$(*E zFsMTtNNtF&k6-W#BGfRM6?Tvi6B%1#&m9nglOMFt3oUdck+-!GM`p=;#;p3)Z{V~y zvne7#DMgaG#bDPG1=+a1IJo+=rfK$%vZ*VTDj*x5;@s${5QB)9Qnp@Y1R{~Q=aLl4 ztJ`EIlN5YZuOMh10(JKfTkm^0q*?kNGE7Oxi**C!271wLkQ-zLRr9^_Oy5tM4pvy5 zM7hj=42tniAE#i8S8I3o%{{_JuX_`81``+(8sxxFJD_`LO!xy|bBuy?k8{heR=SR4 z4fUCTRsvEW?j}m0K7)zonrzKoe3aPCb0PA!FXvNAp*;sryCaYej8i1|f&53fl8{|n z4$L*%HS)Z!BcY7eHVezZ`xCGa$G?&oS6~gn&*S<<{8-<>M6t}h%#BvblkfGt3J^e* zSt<>@`ErXao@{cP1o$R3jZ$vhPY3EF%Y~T_)UNOox_1fyMiXw1Nl!DjdVEx>4f8+ z*XC=$_7HhHJCHEYfh{D6gKuLdTq_wd*z5mmy%uWsbc`RAnl6z|Z5;Ov)#I!WiW5K~ zhEC2QAGy}l4Sk(a4>X#@P?t`cUWsH|L`lei1r>coUaA*JF?_ZtufOPL3M5Wc>*vpt z=yUrUP_3j@hNv5>^9q1Y{<%QQKok{CRtum=`RR~7zP}d(Q-UKcy_%+Q?6D*NEXvzR z3hOQz=z}D3wO8JWoeDRo#!7v)R+%0OVUVaW2_DgVm8N&!M?E$-#AmHo+8VsET+j3F zS?G;@;81zK(D?Wl58;#L_A!7Bqgy=lh>cdb-T){SYLj~c!CwQ_x#l+Lb=RU;3a|&S z?9u^a;3ng|_6n9g{)Yr=#7C^RxSvsnkZX4>8}J6d9~N_$fuM1kE3wgmb=+Az&Gii& zQ!j2C34BF@O&?BxIQqG)0O287ZazYVoPKw^I&yKTrnMiXLNY#CY5%x5GLz8|zy73G zgBk1yfPV46`zyL23$CbS#J6H;*BqnN7TT0jE-cw(E-@a@B|cb>z=64XM`s-96{gFTvn%Td)h41l{&h9tsLJoqX$_$s}oKGbcV$79x0V!ENTnO>%5`4vI$xfxt_Ny71+;(AGZj#>KuSDNX%mCJgaA#`p2c{c+vcjC9GaNK zxPvwk=se(m;TTEc*Zb_^g1h+fUsL;&CX?iy4LN|BL7rg)?!+!Sf=aP;I+q^! z^Wcu+|0_Z;CtPN`qS!j%OIpNN$MA`12QDCpUn3u}^{P_#IIHd^Z)$5H+3dAtruOsn z)D(?%PDe_C_9g762+l9cSiV2)tI%8=@+rIa;zYytvdfr?cD~1_KH)Ql9qYHdEy0#^ z+;`($ihvQc7pNQOnrAz%rV1pqU@8)E()~>+An0ZikcAn6^j!}qs^6kY<&^9Jre?E~ z39WL1w^jDyFX+&Hl|Z~*1l#Q%FnN3d4bYoNxA@ZG5UQim_jjd(J$SH_-MPMU=YKCS z)Z(9Ff2>fFVV42Htz?h%ksmN! z4O;EyK*0GWP?KS-s}f#YY?*+SC>g2wsrZAdOfvajW{5H?=1{;)odm{_J0%IAQ(IQ| z1f3dapqz5Z`$3Jo=_&wb{aeoTMN-dVY+`8-A}LRXCeIJZsklmdvHC#H1p&dtF609p zikr1ZB&3ojd&G{E7=R#z0d2BBoz)fK6;2>_Ac4N+#SNTB+C&kELJI>z3nIbQDgh8S z`wjdO;)qtW%H9X1qj`^*rCS}_8gO%Wy8$HU;-$r^TtHM`wJArGsoq>a zF(>!DE=W0dQ(Nr(qIgaHL&`=z12PeK{x(n?!HW_U$G6gXB_Jt2D7ViAlWYS7`j=!8 z6gs}o94$u7LVF!iM+$?2lK^OOOw;pvyLfR5uRQ;**LJpc$md*K>e{~4o`sLaLY=B! zl=sEfz1+j=`s?>4Jo@vExrHGq!TQ@;TijPJ`56ANaG0_o#Fv|cb@e*hM9nc9>QB&P zvmtcxMtkG^cL-|tABrlj?X+@#iN&5D%j&yfw66ToWHLh_4}1hNwdT{S0UM%2ALZo} zE7rwQ)x)(pS8ahkBwkmMmW()rdmdH1*(b#!ieixuw+t@^E->fA3fYc9qQgIyPm~oO zsAT49XEG=3SizkFnmPZBU?-esOT&tQLF;o?HM?EzNbgUE<8#oW9V9v~N7G`2#sB-- z>jBaGsMPi(r8;eOnd!Myd?oqSVqs==$;bMbV}8HGE;9!g>OXc``%Q{)5L$1!2e_K1 zN0F>dplzXkuuqqP2F-3}SwYHcwrY;S^V3bv_4fL4n?V@ZacsaG&6hjat#1`Y>v&Az zNoZzOYSgCmH5Tx?6&jc(f_>p0mLV8gjf2Qf>uE=6npQgJbhoPM6N#HR3jf&ZLg29} zfkMvGzNMw5!gx~5#>Vw4?*Tf=)XcE7@2EIAPIj64epeh%cfB#Er)~< zj$$7evxgjwjDZ?mxcmA~yMN2~L4+9El&>A%cKb)@*+Y(zGnnFhkuHk)h-+nHuJ#9z z!aKVxN1Set5=%C_SdXrLSmS^IWBX6rFoa3D5B`h<-XYeexS2o|*Zl4q+x>bPzi#fx zg6lvotHvIV6>F4LJhrK;-#=(&E?D7vu@Bh6|9Mr!hV6y1U&pOqa$MDBl@(GVn(F$mFLXUA;9kC=G9V)I#CELC7O^UKY$xT)7z72A2F;~^-*TvVoADU zGkYQLHKPvJoL=3-+x=Nt^Tr58{^mk?VfzR7<01d$;%=?EoTl}>1y#3K{{zHkDTuL9 zX~^Xls2ExUbHVm+!fQ!a)B(ksE3f<$1@8)j(Daod6P zRPJkpE@rmOuKF5wGj^#N5(%C?_kbmmvQ?K6NJJMJM5R`@*-a!fW=)E{(kU*IZ1qJ( zONP?NRhYng#6|TaVcda}g%VF9X}{ZmOJA1@@`6^Dvc&2xknEfV?!WjC-LNY_I71d^ z_#cgLBWGzm@C*v)V7T%Nf{>RA&MNitKz0 zr@818XMXf;bIRgHpsFvl75&Biitd`Y&DvPiOwQ>`dR4A951O@l+S&#Z)J)ORB*63n zIAaQ+S?MwF+MGHK2_oq`@CLzJNe1u37Ro8@@4>bz!YXB%NMStSruuwf8WZi(K z*=9kVij5Y_a#aPEwk)OD9>fEfQ=8=s;Ijqb7D2lxQAC^pY5`D=D?P&h=gqu4@V0GZ zEwA#g1+zL9S2az8kgNoO-=Pqk!BQI|up4D3&tl5urjKYF*iuLHrtzbV+WH4-jr%*H zm~;CVcXNpbm_c7)UIFLAfn4r!eDJj1w1ZCho5$j+Dju8E{m=_vd9t(#Ydq-8oIqz5 z1Uj>^u{=AYNqegIYNDIM)#RZ{NYp;wi3#t2)79=&EGlA>nr5!^bbap|U#-UJzDCw2 zyt~?<98jjul;5tjBmJE0YM%I5yb#Z85DheU1b(2x|Ls=CeM_eSY(5J>XV0CIW{Yy8 zBexAQ0WWrc{o;>xg@u`&cTf?Ca&;i=n&Lrw1_$j~1L>z?EBAWJy9VP+Ks$FE6Ch>l z*qKjo>4vBne-CS$C?qKfn98h-CP^e=dQr8q_~^FCX1nXYhjKzV)=E~<2lrcA&I03P zkw#Y<{J@LP(Eb-;rzmDO7edAyrZW;JTtZqKjBUZ-IKkl4VDQ862f-IvwVF~(S2|Qk zHV-yLGr_y#K#cnMAl^nD_bPk@(T5cljZmNk5PFKp}o+yjD!kEmI; zI9-CJ1u^~wH6?&>b(F~(5oB%PG`i|dhl*YWVpB2%T>@etl1!O14!A==j&wb96?5|| z|6%U9d|w3~lybBG?JB0U9XJS>kFZJ~D}QmA@0v@(pEi@i%B!w<@!yV99ddm#fSk{M8cn?81dLT!HnmSnC=U|Jcfk-H}uhei|qL4BP2A~2=A&^T~%NPP!j zFUpqwRJqcpBnoauFw#KC`dQ?}UOT$+-bw>SYk|}^*Hz^1qs1D|OUCE@{_Uca3ZTbr z4lqLLfT_wNOU7Tzw32j%iipYp!~l92PWn}Mk&-X+k!bM8`(aw{l&=1%{bh;4B5w4T z4~o+jyKbt!lO1{~PIScTo3I9zbH&G2$Bp&D7RwzK>|YDuZEVk7?l-w#7@`5}#HqJe zM&j!->47iXbyd<%_qsowU@>&_Uoe!~ELIgDA(ws~c|r8<(t5){UL=n%Es5QgzFMZ*VZqcucYwe*#qBCiilHqTB2m!Q@}TVWw-Nm5|zR{--=6!?s6v zwOt;Ah-VWZ-5y#HxQ+~)t@Z=rCF4ueJ@{nfC*UOQ55SICy3n+Y{6?b<@6^XVFi}(-0pICh ztjHW&?NziH#`jQa7RwrnxIo$q93~%bs*ntxfErY~5fl9&CY)SPO`}HvVKMCBn`Y_T zZeKFa=ami#2ciy3fL3~}Kf(g|w93sB&jNVc?v)7Pql4}cV;d6`3+Y5HH|Y|F|878f zYJ&oOZ4O3HmOWT$qDdN~-XbRy#r~<>`T_c_65##NYsG9cfEqN%&1}jSQ?sf^4JR+C zZq+yGuedKAxblK%a3Uz2o@3>XP*cvGDy@?MuzhvpX01sS3igAJKZq65Su=`eG<-N_ zELfNE?I0BaRn&N0zn~MTr&(wHj+N65c60+_u=B>LQ_a~Zv6L*9%DrzRd#1M~1oj+- zN-4k*fnIsb=(S7L9;!nCZ%M!|@Fk^0!fA|G=S&RY)h_S!{f*W-V z+zA{YO1!?tEeWZVOOm~uJ(*xj0f_NcYJsoBH{^WJpeJ*!UuS{)qjzF)_S z9w4*>FseFy?yzmMwnDL;r!K~&`2mG@v~|`;7sF}m_k5y&ms&CVBimn(*sV;`&V*JH zu$}DF1U{Xn-n0%TWu!XBKol$Qm2yW3DMpc+_d@|!B9 zEF0~W(inz~vIqzF|J0dP{QPtTX;atD1N)_e-}yT11|7i9QSFf2Ty*prXWz<*%X!Y) zUga(aP8zTZpd#BS!+S+uo!Sj9S9sGTRZbd}G$@n__+su5s&n0%1f0-xRHJ=~Mk??l zXr_lHw(o6hKwp6zEw6sR)UmMK(gHUX7&+3Wfq-HTEE0uv3_mDa?w_BA2=K4?5yaz` z#UEiOte8;dM{%Bd&2`Km_sp?64b=bvU#NNe6yBf^K00*4C}_yRJvAjtJm}1>5B(W* zFz_k-c6|9e>$OhXGSMcoV-t|y$?hfg9A^+LYGClWo76;7G~;49rFvnjJw&jTqfP=1 z%-8YMji}FqI_0MM=9P`eYmL&^sqR8fgUD5KoI9 zF}{A9!WGf*^1tts{e^khr7ut%W6=|_LHUQn*Z(Nh3XxH78lkhc(7s}#My0&zkZM|h zY?C6-0mkmvyXMi_*90>F?#UgAAnecsJMv}hJYF#f)>bA`QuFDY#{Wj>=s57+(C&k9 zXUr9=%8Aopl__&Qp4l2F16o0^EgP@G*NjD!TeVmC$I}TSMZj+kPreKc_rQ(re=Zsj zCl&@)KZ3<8mMXk8w*a~j3>gVCa2=j}a6$D|W5$Xj>p5+xp(`C-Vi7I8R+zK}+)8xP zWP<1TW1BL+?}7>MvSgelnh?g(1btv0swCsNaB;S)>Q_9x|6;iSWASON za-MnGe7DHIJf#wqG=J%T-4u-!*?Y*IvrZlB7?0|1y_&Otkac5evxaRcFsvnBe*%zD ztCMH2BlXE1Yu;W>&jl)I6TD<@K%*Dm6DVG-v)lf}}gjCQ33`djtpY__Z$+mKCx)KBl z{N_PI$o7Bif^b^TpE`Tauic;MJDYr-_>EA|k5E7%vytT0Lq-W6@`IsiWbWzU*>c)z z`7w|n$hcQ)NBW#RPUG(he<4%$;3OHm{xwf0-=?&E2~R`MC=DFdJUs(G`lMi)tpb=R!VN*gwLRlRh6#H9 zccqg*g=(ybNuCwCY{Qeh3^ZqAcafv!CySl#yO4!|UOcrxm5b2*(KgBJ+T33cIXour zv#5>i`}QK)bqGs(&;k{)Ee9x)WRL`;_%R28RGvt}C9NHq?W}&edhO=DR(l-)<^(S@ z3A2`+N_sM2BIBP8+!N?G9_E<3}Z6Abv8^}Qmsm&tt;u65Z2-DrU7viNnAX6WtX!s`%PU|%_d-fVsfN$=9s}n z?~`#z1tAb_Tan*J3lzVr3xsI<4X@{!4X>vr5f{CtjCL=4v@=Y`-%^m;iL&6L#>g)+ z7Y)DIM~vPDN0koHBfeNfg|#^8r4o%#nwUoAQ3i4ypTwBDipKfBS6{_hL zTAV~=5z@ij|4R6=%s`hyY!8NmMkg@9FlM~E(())~g z{I6N!E%FcuLK7QsAzV`mzyjr^qo+VVqSj4Kdc})uv%Ix3;sxABw`Og@3Rs5iPw%aj z7}s3S;H*+VB;=0H_u-*gVt#h=V1j8oj+?{zlpY)hSbgn85n<l6 zmw{bO57@N^iRO~>W9<@b2o{B>T+);l8Jd})XW#IQ)5RYSqW@Vn>Tdra#?MeUZdB##k&|U2@ zYpt6O1ZkH4-)iU%sv#r#sPv%Sb>PN|f_k`SN*-<{2{++xq|EAzzE<3Eb#ST?lokwi zo8Ixk1Sbts%=`!MpjUCY`W6EH5y4BBpjNvO$;rUSdw& z)M%2o7{P86e?J&ziZ;wQym0gOVA&rr89=AvQXduvN~{>ZhOi7b`^{=bM2Az7>XRaS zz}Nj*@?$;&ds{a&aZ`Rlqtkz?N%AtSPCc5z;3sn6{jMvIk4jZhG!8tVY_+v14-?w% z#}(GUdlKy{clIN=>2|QqG8=pt`}5fYP~ry;1<20<*qfw+fSJ3CK1(b-a4hJ&fP4}d zlrcaOE%2>4n%cGLmMb&;Ab$%mfC@VA6nSUWI$%&P9Cz3}#}-*ra&dY+QAhewEE5Iw zWVtqas@}(QCWEF*#1K`|YqJa6pQRq&WObH0+mG9K?5Dbn{?APXb9WG%!P!yd==Tn5 z|Ak}TJF1$JPZE_b*I^HI(90%wKM9A=UT3bRhTeVe*&CEQ6uhV6HZvKue%QMLCHo?= zj=K~+JG0=gOAFB-2><>kuP?bX!TOI$@vOPf3uGFzW$LY{l;}R02=uF8xub8wW&51( z4z|Lx{r}N9!KbZizy*l?1|11x*)jrhyv!Q*YKXLD@o&-V@kg8Ymtz(NdBZfeHNG@@ z(bI`H+*7A&@&}lMXdICvMhPNsP$>tOE}fs@>PJkE>%FSf+1W_oAFav%OBcF)xq!dO zMdr8Kp_+ReoJ;KvB%tPfj(eZan`S=}(=J>1!ArdMvF%IgV$|@FisQ7^f;;DW|7w*{ z&`y6$WCb74fqRRD$|x)@eAA~2yu3=!!ebSRegq1))9v=0kI)}d;1wZ%i;r_<8C9QexneMCM{5J9dY;lWL)h?t;+sKxx+$pknjTNe_ zS+VtIr2kiiaGLW22SZ5QM`)|6@-mMp15Orm_Ac|tBOv#eiE}7wZH&?^aOo)`gZUY2 z^93)xy#ur7-9up6bZk-jmpo=su03%xyhY>QS_)x{DS2v|94&gGJr65%z-mX}S0jF@ z{h95l$P`qYVIvr^B)G}u;3RG{Et?R$++MfiMHc+r8%a>l}aXU}ADca1JgM*2?L+Jnod4^~~p}YLx3v-!nCb@|BpW(##NE6n3@-7#V zE)>GvnG5qqvfjhSa{kH6+*ye`D*i9wYaF}4p2tWx z!})l8ww7;|D%Z|d3O~bDsJjeyOp8+qG8Jm)Ri>3mf{Z>Ct$9e{~v-@B^(8-=u!3FZtM+&CqRaWqO{8`)a zis48p?|nwUc*d%$AL6Bpk3GjG;I~%RSc!L5@oAgBKQLjIJ&MK4AF-1jr(tVi(7Ps9 z;2Vj?eqCKP@4ubD&BVwQGb5^2S$1A`a|B6zLiO8r75+1JKD z5f)s#eWj1&YIJ`+ENcPOVD9#ayusHnp6|Rg1>nTFAw60u9NHEoujh8Pvgp_<_{9MS!@zGhv zmK@IQ4kNdi;DDePb&g^WezZv+L>4|oH9e=wOe!;zg4W)|l`Lrm^-waJ7>uU*c883V zjPag*now z7uPA^{`1A|={%eXLY2R3%^qevVwf^>Fs~;;SLbrRR4X{5&fP_+%dK%HQ}ih#>jMJbGd$MYfXKiA;Gh! z%%+4n{jId=e%pEN2(;mrBMG$9L;J|Ev^_H5FlK9Xz%7t2^vm0i@f9jMf+l}*$jwMP zB;xHuD>U%{*OOtbHfgW;O$hIN>nPXxnIbPk`^sczS-7zC!J5s8jmwTGxD4oFl zfD{iMNN5YpBZ{n5JT^R(#=txLJO6eju?E~*nUQEcaKq-4$5aE1n>ah1{IJ#{Hn`N% zziG-ya9u<`fBwd{;{{Uo;K=q1*jGjBpO0)aGQQi;FdMxyKA@%79J1LBC>Z1{?(uHp=1XoO$5S`Wfn`+vzUXPaWNK&_{f58;oo~U0DjcLJxdkmgzy1)JMyN8D` z8>_%cxApM*yzR(E)o$>@z%>T$i-;3)J7^us{Y7Ze`vVD+*O9xyT`jN^5;9>@rec^l zg7h4DJIIumOa_Xl-~Nj$9~LBfaH}rB1NA4< zbe`wj_kG>hb?!^_UQl4&EXVaEbf6U9Qj)G##hN{sSD5t)OU2@ALYrYiGGAiV7=Otb zuQbCt*u04o#}nlCBJ67=HSS7|hCkDkGIaoVdvE)X_C{DxoJ>D^E?43ecbix}BDYl9 zXMU9Y;&^ykWhOo}E%0N^ft%>_p@Htp4b@ggn`A$asdfJ^7{Ue&*LZD%A&czcxGk_wCxFy%Il2R>-n>q%$; zvSA9ht4r9J1m=Xfs|mFt-Sg~$cC@gNUmv^epN6V>;A@_=9hqn_--vt2jL)h7X9swc z9vq*Q(@L_5U#*C6VSQj@-S-W5QY>I?CSl+hp;Rh9*oK*&upGU)@rpcI&bu%(Yqz4l z_+qn-@&>-Hao4?jOJzX|>}qn>AB97}`^98wCfS_r?OH~-^iGys_0A|>agP4Wf|1al zJjHybh^+1^Q|oX60>)Ifnq}D3$$WX~_j8YCN<~`{_?hjWdlAu_y`SpT9=em} zrk0q7uCHo4ov47Dw>S1;1i@TWrzo-0|2y$EhMdqmE(*r58vkK9~p z`qDhUa}f^!%jq*eW>gyW@^kAS;FgOsB< ztHZy;6DTN5N~^_XR~;=4se^^>ss)Ssx{L0+&?WJOu;J_Is5NntD%<<4&B~N~aq88( z`Q7bRIk@9nx4>z7g#fn9CdR?DmLozQxA}mbOD_1f-oR19=Gw8h;)zS?>}B@LSwoHj zO*(Z8vU)m2eW}M5V|r{@(qx0b`X974M%r!47Ru~iSe%G=u@G#jUvmkU#7zK7$dbNh9>Q-Ks4IBus> z2Py%#r8#ob9m?j_%{JZ0ZUfrhb~7LMb>lG0mt$viGYFMb6gl0DXXFHyG#d3H=<6Je z9Hg6KOr2C)=PX$g{D zPWtyB*ah8WYE>>RXF^lv98%UiMtDh3aK3*TTpzq`li4{Fri0VV$)(6F8qCi_hEwm+ z^?D_sLqnl-?-(>tZp&}L2$adJ&nupoJ3Y+R+0ev9#L(7#FbM@!ywv7p`VmB@8PYnQ zpzY9zKS!!DfC3hLqcFawcCe;0xTi=xp9_l!RtM6~R8o~`mbREo7v306pLMOz7 zkvcch66;uYDloU3Jt4m4|5dJ^q2Ky;Y)R3O9CkBDR7HXA&9z5n_Xh3wK!M`)=)Iv* zHM0LUZ3i3BcCdZ-4}!UY2qlVPX*dguKA!)N8gTO7pdd9ht1d3u?6n;+Nc3Vw!GmW@ z^Is`87yqm*z-*UJF|Wrw2sUfM2~;L~g@1ruLbc(b@2FQ!lnsBZQ@dFdyC4E$-J-K= zb7>klX!Rbm@2L_8)wRM{2%a@lYao=Dde=sXc`;^7JCfr0)%1EpmGW4H ztjSoIJ^N>JE;PBWS}CyGu`#gL5PY-Bhn2UW44OVXvH(a8&QphFlF`0=%wPG>n$rJl z2|tWSJX1CnRynI5W?$e=VB86;Z7`~XMf!><+1l}q=eXJ^Abwkerv4`HM%+M5#|R@NvUQzc|g zv!g&wzXT7`AC))dCucoZqATTV9hyqjQJSB%4!W#p+$jibeUz_HwuT z%}4hL!P-$CSwBK*97nydj@J%*Vn@!43jD;k^r`1Ez^?`Xzy6(nw7nNiPe<4@3TZUb z(f&$D@Fr-K@+r0aDQ+72cS8c=c~-XppVRW{5)lF3xsqLdksxBZU>fKa>{B0%xKa*) zj>AB?n+5y!O{F(6`{TBG0I6+nM%tN%dOp0~us;$jK)yvc2c}B*uyKMKOJo#;%*EO) zVL1t_AOV*DCG9_jNL_F?a&gcSs-$bbwb_VJb{PVcNW<^!hH#?3!J3nFwU>D9g14F~ zuqL}Qb$&G6#j?>2o1LQK|I>xe{J+W+t-)? zKHMD$4^YzppTMc@Z>2KEP<6RNb+D5YTl>FvEDHlqA`4UeOd%~di8{rrTsRbpHU*yT4M7)7;N+K4uSk6&7itEw$BcaBHx|lb_=%?0tW7H``7Y|59Iv zA3pg0HGHMi+0h3&dv9ayyIjb>%WLutMo#lMy5 zrybXh5apJ%!0ZCupDpPP)g&bhwdro{RN4}TWkX?QYb;Tq1Ljm{gn-`2ifPi;Ni z6+PscoJaF%vI7LL&5Bhf9gL`R1Xn~D`_5UHoG8ofllPomU{8FAX=YkG$lcccAKic-4EF|MoitQvhpd_sZ2yda=04w)n^OmfrDjT6r|<-&`=OJH zaTAMz21{5xE8`6pLtsHGpJBtS2_|685(VyahQVs39QjwG$r};mLEv0JGh2iF8DN?X zV1*Qb6(XMCxcpX}AMic)lg?4#M55My1Z-%;%97r5y?u8eTJ;2-$7ZGp{oR2c$Ow{{ zc5ONaxOzLvRS|s{3Ko)@CKtwQupzAM?-q0;skOO(RkmHD_FDZbS1=1~n@>CkOQqV& zv|Bgyrek6>F4G$NxTvIme>4uSS=B={xcc!w}4@JbHRN{pcF`ruTDnyf zC}u!!t(@cJs!gNbCxGcA274$!DlnG_U(Pkd^k4E>+#TuRP~iSnCwF4U2p(yczI2zb zsMi?Vv@#R^^FuhTTO~JPm&YggdJ#3iH4iePJ}o2C4tgoZcg4(%O>^8usJH{VBxN%t=7=?+(l!TmYu)cOo zwLHdq&zb%Srs-70Qqs)5z@xK=1U0`D32SmFrA{c%^<-NYnD`8(l`=9qX+q!VUP+V+ zzr!%xnV$Czs55dHS~ix2v_2fQ7Gmvg5m)cDKDlGnmspXdotMmhCZTefyQ{s*y;@3j zvM_+w(~+eN$hV_>_NK*@VFlCVC+*!?Lv;+!=oy8Uo|=!j^)m{40}J8|S2BY&xasnE z&iR>P&TU{TSYK*^G7_Z6%2I!JkD-p)2ZLR`HA&!auP)E+sK0)WaNx1R-lm&2ET7u- zgWz=oyBc-%w?T}`ODx(4<6Q0~=eF1P#LIccnptmn9(`ya#+H*M(40J@Gc4#*<4e^C zq2D<3fzBxJrf=Zwd(VuyM|q2^c20P#seV&&5YU;=^7mYcAx;8+jZZ3v41B{m2iJwm5XjL9 z5ChDc#R-geU4L&wP(%6I>0ZFvDe?b3@YeWBmqx&Wt$;yxD7^9$EnoLM=rR`=m2)}U z*)=lPLxC9zb1|ZlWuY!dVTZ)u+S{m?`vAQ_o;XH{T#GZ&);692Wg+NbZ7ftmKh#x^ z%#*ix{<_vy7joA1$_IA+fNo$oE9)=tszaIAdrJP!&8;}zjSr)*e;&QO;9~eQZYuHB zfOH?DW*{*vfuNdj1B9~&B;j`t1IW}4Wdo3_ z44MHvvQP@JDcgP%CT93_RGtnlaNJg3m0s6ii9_jBwE$*iF1Qv96Kp9Z@vdPc>5``Gt^Pw(&`-vZDy3Z;v_I?PVll47?pT>PZY(>)3 zQr?%XY4wPFGD+>3f_4mk9}LT=!QD1$qy`Hc`N0|f+EMG*Grnl*J!ykoevC?q1NrVo zu6AA8Qh2GlkmwF8Z!ue?Zi>9-e4z=m43qelur?HqQTndvIOMMoV00yrm(10oE)eMv}}~ zaMY*9k7BFdOp#l{)xF%0Z_XO4rN^|u2=%HrV}6#Z1^a-=XjbIx#<7}TEa5ffz2~%D z%VR+Hj6B@_9`}W(Nw-&UbEQs-m!--|Ow7jc3*wn(t`2Ta4K-~iyV(++>R=Bniar=M ztgq_gGP+4ib7_H6HksY=bnOmz@|6w}t840eve_D_oD)dNc86e@!fN_&EdI+auO$4C zV)C(!cuwi3p`AmPWg|5^_ORu3*rb%|4sbbWmD95%) zGjFc^T(9Uz8)tDy?n%@OTXtohmB#jiz<_nn#St0{(-`IqsJ7nY;F) zH$8l~BO&ISK8cM*r)EiIsf7t*Tdu^F4AW+`QedZ#Ma5(G|Q!c_sAY z3@~6L{{l@diH1tJmzZRcd=ERmN0VLbF~PQH*}h1=+c9@_khpOi0_cX>1_OhXZV9`Y*UlA`FSTO_8Ic_g zWIEtS6E3f(J~lPQ50h8io@?{0Zm;uuuv=d7YHROkR{n;qdPXA{pYBO>pv(2>L+4Ss zwEZy&rY5EY$^>Xn=cop%X!n2e*RtIn!r^H?*|y+&WT&aKTnYLB}1&|RRfC#uut zI#>;yUmJVNZBp#OnF&T_UuYh%={`?m7c;5;fL&zUq_JJT109zeKp&tRu!}h3d{M}H zyTD>hxMp8+YyUUJ;fUJ6a2WTnyHhROxtmM`e(~*7D5Q>KVM6WlL%@mrLKOC#V4t5X z&+XA}vm;#X4+(wD)?ZezOj~5aLlO=qLBmdm?LBaw;z=l=C-9%GWgw{Eg^nq*J6B)D_3X{*MlEjIuB1(LVeLi+J-?>pgNiV_ zhV~0Sfl~u3z+Xdm0b+3jJb%jb4v&r!TXy;{wuY;lCs%Vy*e3@RjW@TxgZ4m6pG27y z%b>VeJ*P!VnM`Rg=^22mH#YUc)saiU$Nj6N=h9q!n=alLOxFN=ns-SG;J#`eWm*U5 zv#9Tg-zMFw8vfDl7^*GbN8v{W1IXNGWyz52LgP=;8TS~=mz&9#m%9N7{vHNW{w2yQ zOE-l1e2H3gXZgchU^U8ZWtR(_&vyBUjdb!|f>PM6`wSZLiE^oz>3aWzCpet1>VW|I zg`3?Q`7;s+*?CjIe_}ByUR2(z&;U@1@-dfBx%n==Ae(+QDsqH7wVxA*zQ)z41#kQT zn*(9u$T%8Y@^^NF(UvRUV?Y4d7sRcpM|f7NzNX9I^EBaP@aB_XqysI=jbg_D;hb@;9pUBRaro<}p^(r6w5At(K zTjZwc3_Y76kh^Do8w?F>Ih?$Z2`-AoAAj6#5PFN#mM6dfK)=<;7JLwp!6XN~c^JYR zs?|jRc!kSz+8m>$!`EZ!)StA_8b~*WW-&IP1HmhoEOQ*q}(%rF(inxFOCp!Q*^N+QT z3%>+)61JvSkRk-DSJYa0L~f&0pkY1*%sZPL4F!8^)&m>sc!DrT(CM zV3XPLAoL674u|12B?IJpxD!SDABchB83ugfgFevlv}|(Rd#SMCN!XiG-RV)X2$(S2pac?lzTy z^Wz<1D|pqf|A`@yVzn3UgU_o1@fb=3=cgJ#`D8|e(7lNbEKr(wZo^9ToJMjkLA9;~ z25ukhtuOzjrd?*SZdAM+IG>dSu%HKE4F`{~;7!xR1_idsv^_S}>MY@Ex&FkOb;i+N zx}X6ovAZ^5Xt>|gBh~{63f06Kka=eApd5~O2#E$Y+bVz{JI!do@mI7C0wF=?uryXxquFpvZosb^aNpToE|v?-N$l{rz;1o?4KV(<*jQT{pQ-z4goYBg&$mRfhg zH}vpW8iaaki~rX@1BD?!c&*g!bE>aR*if4+h0%?5atzI|T`ip=4HSh&nxY7+8J|d4 z_@Q`D|JI98A2U=BVLqP5vZ*fbE7Hs6d5evZ3`4)fYMwsrECHC=ZJ5B0mN>aV@Lz%9 z>^x>Mnf(N4?LX`gm<3%EId-5J$}dRwaug(?z+o@oR0>3af{BL^G?9aXQr(7kmxj1x z7R7+5J`NfG3I6u*(KH*RXasv~{Hv#J{fVz3(0^iF&anWxHwmg8M>BA?@4oS^2)Q6c|NF^mrv(&aEI^wzsEM zPX0A*C@Gvd_e(({VCo~&UkquImT!cZP-~wh>B%jE+Ox^Pv$N)7Uwc&-qOh;M;{O;d6P{;&@M55So!twu^oGt%svpEUJe~fVltYrx z0J$j=?wAScfh_`iLLt1Av1pGyK`A5u7o|#Z>3;^l5wu%D7!MYCx+zFniQ51k=>jXE5txOw|_?9Y4+Nq9l zW$B9r860;tl<2q2|GxdFwIRBFKO73-83}!fv3N1JO;@`#T6Jn6^)tJ%oaKW-ZxSPZ zQrVDHy?`{ufsWu}=|o1WzsjQCJJM&Xqh{j-Z~|m_JVWzqDI55M0Y~OIh(@x9!8h-| zlZ)T*+1Z!YonRx=K?cXopNWSa8-F=QRuicHH1jYYaYQvS{8>0E01+&O2fIKmM3^5N zZa(L*`{anxTP=#uh6x_zFMwKrUC~?K!4bp&ETNUA?8(B2OHa3c~YZVVu6RXwl zIx{X|tFwyZk%`+_ppdxyM)gR2Bv^&ba)&{CPO23XP7VwSvasYdLChLh8W1MTLw;Cb- zuTa2Z%C4smU<&Pp5V$R zbgwD(CqtFu?xN|%_>_MABL)_C6In_kU;){V48_~T@li=>1DNZp&bl1_efzvU)ncV5}#5i>Tk+# z3Uh3I2)zhOvHdqqFDH8-heFZlUVpSBt=`xM`jELu7UX(=*Btv-tp(V8T0~Hrzr$1T z;Ay_4UOWc!r$}bU<&peTRR88N9i?N<>~WKzpODN%U@^)fcD{w&D`K0i^Z+~p`KB;= z9zCyZx;%!o|EJ;Ueg01N|k}Jp0#c z3&G&Eix}?^;=LSiH|vHiM=@)k|1|t@vhD5)o+TdE0>u1 zz)E0B4H&&iRWbr6$f=0=;1%UDlOp7;|D{{&(6lNf4rj>I^XK-@P@&HK>P*VVSnhWzhH8~D#^^A#346n__okZLFy#`gCN1@#O z5g2&A_v1@>6aAMdwyu#E*K!(4rXi6a5>xkAoLyxoJ+|p{+_Dzb+V<|!MsH} z3h+cpM@hir+4Q*_o8eWmrjChud3lUHZJQ!v0nQi^AnAcEJ>82n3q74VENcNipj*W} zScz+j3%9}TN3fywpi9`wydA{1%M^xcnc!BVW_#gcH&j0?ZuIx1)6G3$I*KOlQ-5Mv z-1v&FPwR}=d<1=Sz7wrBhF%8Wj-@)G>d#DWC21?&*Crh7yeTA~WY%)r zZytlEi?b&_gzQ8KL#@0AUxd#^J+dz-~EMPoXx%e@31w|w@_qHoo?ywp*x+alu>Nv z(?{8`_5JpX2~yLJHVxqEM!wBPI<1R`6`5}=D6wY%QtYvG(!E8C(5k>fEDumX{Z=ZU zqx`0Mfi>x0nm~(O_lr7ey}gZkK(A6ynldG$?e8QUYSGyX2xK_6hdU%&I68ELBTm5z zj9JVdysy=AZv5b|FsyQfKrJZdpXb~MdW0+&J_BKl#;XF0d4bVM+1EgR=xx5sYb@q9 zB^#I^$J<2fz`FFg8=8hr39Va;HrFpJ;WkZ?h0XSUmS9u36+1B82tz8Vc8)VewG@g6ec7*r2&0Dw{!eVnaeJc3AWf+hl4!I>V%#b*9bO;Y5{pTyG||o zFVgl32+Q~RmaGMUV$@0A61BJgrfxq<0Xp?WgI@6R{t1`(CpmKcB?|zIPiBoO);3~8 z-m@Elj%iLuJG<;84hf}ji}WdXW!xh@qA7-sawRASm&E2y#wo;g!;cy+Ud#yhX8MGwI`qgbq@ak z{~iHuAjks!#vJgB@Ht%$9Cwb`SGVyuwfv)G*?Xux`*p#Iolc{l1rjW_>n&TNO~4{> zF(d@``=odBEzjtkx{wevZ0&u}t9mmRdF)7o^{Sb?bw~QLyIv$Zc}zB=sUC&;h-6@nsQCNt{^@Awit;lw3Oq;%ASw7 zPm2$k)GKmj!Woi9fM%VRK^w6ncRDF*Ql6ht$HH1QGX0Ydvp@eTXo+HucmLfw1#NPlQj@S!_R zmRl9vYM>Ko$#&0~4+MPgjy;l>0kw&JJxAP=XsNFlnD+3ey6^} z%LHaux1X{5pQ{wJ(?254ZQ!r*NWLC4hGs6FgG%-}4PLRfx| zmg1dM{Ihsw?55n=fyhglG_IaYjW z+Jz|riPlA+TZ6pbRLMo9r;N_ zvJY9@2k5k=AE8_vw^f*}YUcltSO0Wp!PYmMBp5WkXhdN!iReNnz|uXBwicK0;wbjq zXBN|DvH*=1JWExaF~m`kFCWA4ogUowsBLCv0#65$c1Li%9JENiZ-)-Qq6yP3AJOoD z)&!_;<)&%FYsG#AAJ;?RXjIPkg9H&;JT2omzs+&?<=of9_65eR@2d1)1O}_D3$mp% z=C(c4T=F~Gt6YH$)XFOkcbOD$bfD|VK&Y{D1JpqZZrh;YPIm+Lk17C_tHEV@|6KLs zNsjg-oW0xX3>-9XrwMv}u-iwz6#W6`FThYPPhYsmPp;|Oy5FdPy!9l56yfgqCr}*F zD!!j+n&Ahuw%l=hEulx-f5?oQNFE}n?eh^VBO8~m%{yPmYfgAFnDw9a+hl=uLhAi> z?ux$Sd39KGP4(OQRJfz?-%5+W2wZN8=pvAUZrPE#0AG>pW%^0`29$8Xwi4gwBpYw* zmrFxuuBfpgpj%-9b8Zp|wr@TEfx%%VX!so-W`h59EP?d{7J?;YX;<+q)kneRPPh^2 zE+B9@e)kJqL4#fr$LzXy)SgRu37Xr`;kRJB-ATULPG{;6c@s!Ks%Di=(7z>qM2-?keDXuxs#=*N zT>{0d2^`QM0lg14@fRQ0SblO;Ia=f%sr0$dA) z$j;AZK+$<#LPFEefG9dSzXha*vyP&W>gfq?=_5(2{xZreM|&lohDSzRjX@9N4j60- zo(+UjotHrq$_pr5XgoqZ{|UOumSk|8naQ4L+D)eszcuG`r<`w(Kzh7%i`e{0X&0jo z^O6E0mFkk^0XdT%`t+^o51C9h%O6?4N#K@(8VSH#rUNtXBe+!XqFUt$sUtL-`vC z@>YGf@V`3t|ET8=%8f?xVOW7RF(L3~Re;yK)n;12{zZ2Z!(B-lWY6>28&6 zd+$45KV56zITS2|5H;y+&tE{pfpKL6XU(<%Gr_ob{TKi!PcRQytyNS%J@J@g0rYIe z0&rxO+dDkJ7@9`eQYEhU#-_!ne+#o?k0E=~4raZ=^>Qc)R7ua)cFF5xl*i$#$(OY} zCx#M%iu4o|(rzDVlrBwIp7&*-lEV0OiJ=_zOeuyT0ioAFF0|!!SalqdP~|@$Wq8^@ zv6Trg(+LFlB;mxPqRC)Stwzf^XyE@+8r8fOP^+(se)AU2jbSeXXjq7Wm=wtjyWElg z57m#{i2dEeaL|5%m&2Ajf4h|n+!pu(G~$?Y?Kdj8-kNOART$~5e#q&+M^`pXiUw8_ zfFg5#Wa~BU)(v42r&C1e1#3gj8kz^}9vPI=nvhbPZFX{&tp}h}-!Ca~$7g=g3P*nu z`itRPAdkDZPTC3vRM)M{qyIoqZ9JQGswSW<2r~!F!Zs|>f->->0|l-=7I&o4@=aNq zWjkH2P4__}fi)lN%LlH^mCN!rX(iD&!-ZG57QG6=Rm;_2K)~`bI6Yc~3|l=4F>$)B z4Ku$Og>g>+X{Q}y(49%>PU%}BQXW%ltHCH}lf&FshB$SO z(*{dFSt9{3Tm7Zs=TWyv5tk?fNBl$&%b4a>n0sxtrgKj!C`DkssaV>K!iIYQ{JoU9 zw|6m2TCulgfMcS{@}1xd%=Ty?ioRDZoTHa5&UeIn3PE438sWgzj5Gv#AFvLoU>zRN z)OGG}9uSm+efl2W0@^yo-ekOpu8y|zq>c%0HXhJ2XOZR@KX0&!F}L3uY2$vS7{sjA zDf%`{MQf_`C9|_M90?dT@Vz}CA;!RR{p@8aM9NmMxz(N)HV+onwQ!s$W;zpbAVICH zmIm?}3xU4$nR{~ zz7Lb+0415(RRi@c8R%$EeEcuPnKU=_=4Pl@JrCaUrNlOu1r|2QDkHHJ9;+I&eFekxRa}NpsU#XJ8*g)Tt1Na9y7v~~-1Er~>9kg6%atj_v9(@s zE%p^=yvC#E8rqm6lCn{ZaQ)e%*nZ+&LHlDujV#?e4C(U>hT$(1I6YYb5m3=fprREj{{s!VhtW+Mq~awqD1Og5zKuLoDY|4*%0sRB1e2s9S8U&b!2cX*DodKhwMh1)qG-cnaHl!5;W*7Fuv46np4`zhye3>csg ztJ1IBSQ5-9Y=WO%jnau^=p28vC$lK}W4Y6qy-nZl;KE}od7)68&6vlb_zG2Y+|Rx3 zJRv%xw^uMnn&UGZ77S%^ z#mp=M(4r~^rpe5Jv4t-Uhm4mJdKrvFDHUU^%h`_&PIY(MMUbOd9u_Jby(lo|@}c?V z=8IknPboZ*0d@$b$q}9p<+Kmu&Ly^UJ=QjjlEWzds@Mql-abyyy)*afq>Nl>{{J2d zFaOju>qUE_s9!m4uUjn+4GYBv#{V zcmDfU=`hy>K_<@QYg8khEUV4xrc!-ttKp6I0@r(qGwQ>Sqm+Tid>mct z&D`4|;NNyW_&4^;OT=sH>3>DazyM39ufy~VIDcR`-P&{Wcfd+f1{hhm zOX~UsAPp^Q*H1RfNzW$mjXdK6b4TNu5fUSjP)0%hfX&Y`1c&oQ@Gh(hX+gCB-Y)!U zgbnc;Y+)OvB~nilUR(6y(oNdA#~*YTX=CV;%RM%(l)R& zxo-0>wa#D$3|7ZFUjBB&CTvzOi2d!i&l2D+li|Jk=I6aM}0mxP-C_@m+2gb%IVStqrI1OyY?8wkQm7P=XQ zYUy75+rY0XvjV6x3We{YauyoG&Q-yx{??uBGFyz6h^kvsB1 zGQ+#WNk<%>7a`w&SOwn>g&7q&Y;=KfTbzEvB%RbMH@bw|Wb&sF2awhPVQa;l<`#W9Z^_5EX(|A+9+^$6H$FpxMc6jE@Yit#q=6 zDB1a3QxeR}DQ}#O=lEl11Kg4{N0RFzD~D=jSUSaDZ=EZ-OWxH1*4DF8Lj~5R#p(1l zgzkISB?;S~iOi5XN#7`?7x}{D#{ZyY$^DsyJ2J#_WohzR=syqW^;vM~3>*i~%2+S( zrR#6M-^w02jYVKa|Fv4{&TfQdfMKce{_gx2Ij`Qqn^&s(WEC!V3_)1=GV5-Je+R?6 z3q4etiT(_EWjDscD#WpV?o9PcFMKqW#Pb$<1+m)KO)3{=BNJ zjTYx5k7#yP?X7c-ym~`cy<+|v$J&1R+X{DAm{<{g zJ3HQz;c@l4&!PBbiXcX?f+7Az4nbTv+_G5=1F~aGNPIoO#%6W@ z6XMT|0T?D^H?d(jw(+OxS$n%irzgLXBmc(4Ox5k1Twqd~jwycR{3SR}v%5z)WcfK8 z#p`Y!MxZ|zp;{))-Q9E90hTWui0fu^U%SPRjZZnBdD=%)wDVQVrX*IoaBP=1#IbtO z_9wEo?{ZLQLWn*X0_d=}{lnwbT+|O4M&?T)siv#DS4*sL7ZY5fTQ=NJ-amu7A5Agj zIP~eu`F$We9%|z`Zt64W;!$AV0ocM(U-uU*Ej36x7qB33d+$fXnb4|1c`P-R{Lyo) zx}pYFzq*=fw4=HRX3w|zIOA=yht}qv7#({?RDx8M*8B)zoZYf3^zf2#N6>q%?L(3v z$eeDG@t7yWL}kyXT%BBA(Bm_vh$mp9h+ZpKAR%jW!J4qN1CzL=*>|In1?Y`kMj3~> zxecWsb-&K+s|y{63M*Z|F|>V&IS13Uj5IXGSDX}G>lfJE+P!lo$3HXZPHc!0%tsa2 zr`#Y3zSlNTEy}eptC{4cjIHy9gzS<_mu53c|53!h`+z~Jw`$%3(}2++El4-<_+pyt z)7jgy%>@r;_4T@OgAgw-wtp#lU}7u#T8ZL1ta(6xsYRQ;8+VjXo@wpD;68dv>UmS; z*Je$(=H+0ivNZtSG}lQvT`ZUrArAVR#RBt^>Q z+CdpAeA;FiUBh}UeZaiB)BoWD7m zEdKN%hWT$WOr9Ug6?DV#!XAf`o8j2}@enrTJyj!NPdyyR&*VDWhrso_TDU;G>0*p= zl=YqH1xR*$2p>tP6T|A}1uBHw&%XA?iJThY?eD0Z4KiQ!MHo6tj{07Vq~zHHH#6S| z^3&P&Pai!vss_}$6VHY+Cs?-|E%V`jnEbu`jenkBhU%L2c+)G^n}~V+c;<(}m2kn% zS7}7)-GfIj+bdTCIh~@+iYA~#7?CE6qRu4YV=dNk6}sXU!)%Xug0$kBLNHusbaV7W zXP7(1(^E(>=Mt5E6R5%%CJ5H8TE17K}x7+ zwEP;_(d87+YZ!jjtYt#m^M?l-%T{ld{iFWrttj8T1FdP*Uu{$I1Cza&kXl)LzPaK+ z;#$R0hjXnN4mYcUWU5q(y@&_%W^10$+V4=_onhc0tznl9;%6Nk7#Au&JP5~NP7eG8 z-sBhKyjau~y~pZ3p61QhorKXl~+zNt{s;XesNpJf2WNN0P{$$i} zu8uwQ$G-HbCSl z`tI<;^5lrXm`rzO1Gq_XCwzS3C8W)19#Aa5C3N_LSG}yysT~*(46-3}Rs?h8%JuEp zM}x?LQ>j08-$MUADg3reVwoXuff3MK4z}DQY$;pqHbj$@rTZK|uCxV6qtt_}Ii4Z#Mm6HqiG=5A}IX`RLfqaWQa%VE$;WtN4^nWr1&IA@dUuRqR3Z zI!bcyLz8(`>fVufRW`1X`By$??&K3j9%{$%n^#)&#nmKxKlu{F^gfp|Ss>nCJP;vz ze}@kY%`a!~pVvRD(^7sY7YT|G2w0D9g+`6%{L-B;U`?Bh8H8J8fb`cjw!e!Vod+SX8Bv?J zLweD|FrB(DnS&|nG4!Wo>;T4hoalB6p5AL>J^)&PB4_6ae(ktfKc0>@!JR1S_{2+XcM2OJP z=C%m=>Dwyred&W)vn|_$jpDS5M%9q7wgGi7OB@_3U(37^CH`LrH?VI?_TbUh`RSMt z299q_{hS=H&+Kgof*I!9{g-|tg_StFDXv13o%{LqD$i#6#jPs86B&UM$&7&KTa2&4 zZO2Br(yzZAfiZP*y62&mkagADyMeetHg_xL*%Qp&o1=_ib!(QpxRB6aGym^h155pd zP1SuMJ_LB2=Z@+3Ok5n6NDb+W_hm^w{#@K!L)HfMpJ;M{s;+6E6fTT>D$82U%qB6S zKlx95Kd91*!aHVs^A;dk@gW0Gnf$VF())kYNnosIeGzQSox0#(a*_1>N86J0TB##Z z-ye>Dm@@P;>g91b-r^}hTbm0ixJQ+zDEy8>c@7atU`}R9lXfMyJ#XN1UK3g(*u^*0 zyfr=L1r;NAtmGghzb##BK`*n-I*ay_qY(TxrvqOocyZ zL)HFT@8QfVYlc)w{{J6WZypY1`-YEOQwSv{Wh?DMk_cl-QYcFpVFpPlS!0Z`lc=#) z(rO9WXUJ|0p|MtWBiqOlX6$Ax!|=Vw`}rQf@A3QV?RYzmr)TcxzOMVa&g;C-QyBRn z&qLc*P$-bLnX9T#Q^a3CFr^H{KSATUPclyr7<~;QP!;}HjDl_%B#2x`ps6AMKL>E@~cFoo$dRx2&_y6o* zqXFr2!XQH&hK|E+KYd@bJ((_b=QQ=W7{R^Dt3<#v^SmT5O{O`z;ouwm@g&acQcQW= zmGrnj!hWC=EWUsyck-pX+gbkzC3kNWj%%6n%|q@qM&E*%R+AM(qm%bFPB&?n%^0Mq zT!s(N+cCw2PmCEvUj2JKsysZ~8}-+K=jz`v|F_11i5R73{PQwNX~y)Lk7q3FZEakl zw$IDC%?@q>Y(tb5^;;G)w>t4*A82UGVxTac=|`k_r4CEu#f6851kS&NHW=$gS57W) z`d}0+H8l=_D%e#Qn6zd&rpc?_59aXs-%12MN8C4Yn^ACy20^z_HG6{Mqj3!W8mQ+R zPwMR|uHOJOh05ji_M>yBE6>|KZ>arJ7p>ygM$S#E5sWlia_pZh-4+Lzp5oS|A8$bq z(%dJ&F(MX7vzg>|o3d5JV{Ma^f!gXqsZ)C}Xv2OhyJ*KP+S=S-L*kpcWZ{*}?(2Bh zs^`NP_QM6F*GD2FiU0WS-SEhQiA>7#HHKE8~Jn1 zob%Y$OdwKcP;(Rkz$DU1ak&aV&}q1|6}e9E{$<>W;ioux?(ejlI7Be*5f!>YYO^aA z0C}@l@0$D6rxMp6H z0(z&=ZeGtxfo#msNZE?xcLgEe=~L-Dh@`oxVuzIch8Jp zPiz0IP^D7D1~5X5FAWQafrEipGe+#X*?6MCV_3zjnv1`$5T;Y#l8$86?#=QYIQeN? zM;0BO)CM?(lTRC4-Rz-5Y=!qR5>hmrg6MhUk5;vfH>Mf{h>%)QY zufhVy7_jML2bSJO3#BeWZ$PJ8LTyQ>4IcUG{omSH=tYsDW`5;2|fuOe&YD{i{HRIvhX zcl_Bml&ed2O$0EqvTMRHKG1>h2o`9w1=0NKn_`gu{BN3qC6_FL(a*BMSw{I_HL_b3 z5kIUnB5p~T?i9wD0L9YwMQz*RzdrzqYbTaYwrm`|{eylYm)vI($d|I3&Z?NT(9foT z&v^Zvw$_U_y!psiV^czQRDF#dIGviLfYR0cV-$q<9sYW-RN;*`E!L>v|Bp~XN zI*~}vtCMJLN;k_rb;SL;MGM!F)5_6KR8q0FfXkh?d5I+qby*KGf)q31qyqd}j7?{j8~ zJ|dK-yR#4Expc*X;<>_E#k!pf0(;2>GVj(}vo&*+eKm6iz*<2hFH85abcw|)G`b}D zsx6f0$0boE(NKT5y?gVm<~rQ=shPsLY~ue`L<$tQmhjg>|3x~k=EB!&l6;Ojl$CuZ zm8zi<@u>|YVpxw7B2?q8-fwA`0Oj0GD3sw}Y63I9(q?rAPPB@LX_zi7e@JJNf-lH*W$%Db0IXYWE9oM=ZIujD`u^bAR1Yx54@LlC> zuKhk5^P7L?N}0t2y{5&=M}Ax&iFAX-^^|VTlcqaLGt2hOwa9_BdoN9bj8T??ygh!7 zX6D_e>+$yV-tkVtBqj)KIDW5RXY19k1wODZ&aamf(r!-4Axo74`?Xg5?WFRg@`AaV667&87=#_{mG`5Rdk+uafiX_7 zfv$9*OE7W{Kdsu#yFPdMO|@k<=ILRui-OfRrkyQ+FG;`-t6YYu#C|Li+ zxL;!>Srg`VwqhWk&~Z=f(QX+v7)+1##7L|F>@7GPx=886+zR9e)4y{?IN|yz}k7i=j63H}Wr)>Er^Ex(gr%C_{yTr(|~fcv`_HoUV;{Go+E0 zdDU8@Z@%kZn0r-~ZtWrmFj~BK7<__?Dz9gPK2T|T=K=++Oo9&K0ycpGS0jU;Cz`4; z7N9ZfJp7&>u8X>pbZBes=-kMsAk{be9d42C%cyM3>5)LESpn#3cxHk?OGtH8=bZiH zzuGetF>8rq3PIvE7ndiis+ZHGaXc9;oNGmwuIO)8-FJg2d6OWyx32z7#&!ry1jWw7Xh)3t<7#|T}Rs{hz!f~O8d^_h0%=E(`3imuY!G4sl_RfAOt#Hwg?3d88 zS(a=p8er27o7}|mG*QMAz5RYU5GbQ|o8vp{Q#;$_;GNUkS%F$kgCu)a%Fkk@{9uss zdogUbBbO&EzJpuF=**>T1lNq$v7*b!$ULxoV9`gTKs!AtobKflDJ6bhyuW)&EZcVJ z+#jXJY2Qb`;(D59Z%$fs(*3#UBcEBG%4*}ZU!^%+8`3Hv*|rjwHtTQTKgZdJkrhQ# zlb4W`_sD{C@s_|9TK%n_r0*IWRyUp|FZpb(J~1xB6~;}8Y~Uktnn)>RNW|}*pLo91 zqC|IhNd;%$V7Fb9e+?8`-(9Zyjki?cS4 zOa02Ok-)8cQ)X8%mnj?2i(Birs!d{LzL0xFhOqJpI+Z!WHsiqhbs%+HZDeIXaKg>Q zL=QfO2;0KBvmaLX$`1sR^dj5xRL!(b70LxFa`q6Da>+{}RaH&3KLIWxA9VZTX3D>J zUI0$?`E`ZRoN5WGieTZ}3WfvfC4A)#@XZXJ-9qT@V3GN${$$Pabfl+r9(>r%H#*wa zGjoaDxLzjzZ(Q3tKs)}1?B~CvW|Q+gPLsA$t!R&AO@?c`$k5HVG%tgQ>8Vx^QuXDk@lqFEJC3b1M4ILJsd85qu|6|o^658L)Sh70g|gJsPF z15H2OL3irFtNP9`ZJyPRBm=vxhneLh;UHul^EJoT+H=-iaJpvli|&S`FOjO>Uxz0uubnx zt5n1DWPP6WI1+)2im_K&OE3)8i4eF6DJ#ct)RKZf~Mfd2FcF^gXwtj$%ek*nV_r!Z!M z6U4gvqRp}?+{9gEIEnPBvuXB4b>Cs;N6>2axKKa(1%oVwi@rt;!dqPc*I8s8>%i1; z6MLw@(b!I!p@{R1%hou92+Yq2=7KVm+~Q$s&>jnZZa?TKSPYl(Pu;r@RAqiFsVVwx zAg2vRe-F!^srT2(Uz?(Qfp2Gfw7nZ!kBg8nbc|aYBYMvEjK0%;@Vw^T-}8xgnm;zc zWpePJQIZMY1>YT`krwY_7@8y9 zaugfXDV#&OD7_&q-=)74C9;&_4jKkKH_nzDc9FWqnF9D5ll}*G#zk><3$<77XV~?+ zFrnhe4+w?Vnhu9*EwR&=U2h`qR<0(UGzi|GQkuO0kmfHn5dhC2kZc+gQa7>n+mHH7 zz4zngqa!3*TaN`gM1Jc+oyogO)7$f=S80|?YDhTaa(jC6IOVNum9P_(M0*f?_c-ev zgIVv$1XJ@nZ}(0z3vGfKe;0ETr7{)9OiR(#$uBEz<*Nf{FM&|+P+zm5+2y%bKrUQpHwJ)MpDmZ+XuaHvt&`bvhvtdQjqK?fgyv(hTvlxy1w zm^Wu!45l5?W~Iq8w9U4IX|>PEYoV`Y1)WYltJ$TMIEg$9I)UnK-4}QuE>}-fl8@(2 z?;KhpEq}hFm#4K=BHr>h!?g59Z-KK9Uh+_N;Ek#{oOp-jkCltZb1fJBdq0c;|Eh?o zwWO08!TW1TZ*3i&L2tZ)o0~-aVZ?m7h!q9cBp5;962~|0Nt?5Pyw;_y!a)UL!ASXl z4oiXFG`V{yy93?&Y}qzB59urx(8gmDj=d|_rRzQT5sY(-TQ?Tr zpvSaq6bDnu%c+qy=&)ojZ8~W8;?mHQVpd0<@=PeFRwd$wLYDzM0yHi)g3YpHeo3Sf z@+~9dR?<_Z8`#^d<<~#3{P1~9(&&cYLtyj;+ROr_z=V)xFfjI;3<&BM_M1H2cMSLG znJyxrz>Hm5;kTUB!3iS&9ay>H%O9VFhYniwe%+uLUSES2({L>1|Z1EkqDFBu0>33=woZQ*ERh4gv{`jmxn# zz4|5xU)M}wZJSTPT~56wmcQ0%!i3?==1NbStseDozWcn&?5m*9qyjI+KzQ3$p}`z< zR0DF36+gi{bI~G|wZS{9&{?C7HE$S0g4I(2jaA`l50Mbf6t=N@)x#INJUjQ~lt*WH z(2FkPA5K^yDPKQGPz=a>dJ>aykrnG#UTCCZQPCrYutoow4>F)e11F6T^VsrT7sFc6 zGIVo~^VK*dqL<0g(wev8Er4xo-)n@S`SGUgq1bswH@C z16aFi%dJy=dNo#a;z3XQC1jLn$22FvOd-WKq`E%Q>-Yfx6K>KnP|%hc!CgufL}47X z_haR4r(9=zpG_@)feU)aa48^wbL(mCrQ>keZR5@P(!4R6jBW{s&w-}4l)Yg1{OwG- z7r>h2Yg8O_8jg*Hlu3Gk(!mv!4pFJ{a6m~A`Zx@}34z-=1zRNx9JPRHyeDe}WHuVt zW#IuNus>pCbjl6R00MjPULbkkx#SQYwHJ7-`uK=s)V$+J#Kawq?rGvnG{<@zgTq1F zc`>^ew4H(nI<0NMbN5mQC}kjP!2li5hLNz_H)yh-gNz3nx4)0cyr_Fr+QH%e^F!*{ zn8U-pL|?gJ^=$aC!=>ZEffhOYI{_a2FD>n4QUg4NBe>`Rrqo&U=;vO&sDX?z|>V>mW+h^FBert#y)4_=)d!@q6; zc6o(mwDR)PCxNH6QsD*7@8DqbjectM->mto*50p4<$U7DvZgz4JYwY-6~9LhryR=5 zXbleUk~y!$p1A-Wr%(CR44sM>6z7xCKgctYsBTi#+((DlxC#7;)j|A>FAog_o=H3= z09CLPld@-^PQnr0cW9)x0GQKbzXAt_E>}t4Tgka8*Z^R0*&N3okHK+xR zAY`MeQ~p#%6-r~c2beJ_#&*i9(M(oIOJ+Vt>8`3Y8c$E})M^X~Me=G1j^$^jGkiWa z^b*&y$ZU_rp8EVU1)W+C0ED!#X&{;4{ZgfF1VNfe(-xHGZDN&vudQtO&g)>VHDnu(2(qUOq z^K4nDilC3k)J&81^5Zm6beCntL0Utv(T>gmik}yV$++E^go^bVF1oR@;T`boJj^GA zInCh&YUZ3O^t6Z1ux9>~Kv(s0wAZj2WYG5F0#(>M!X%EjyA&Ie8iGCkIX{%hf4uns* zyfPGgl&K+^C>xl|#v&O$2E8_-Qu0%F9I2BCh(}+-&~V#vn*NOMxH|eTt-u8}{3fUg zb<1|Z-?zWuEc4efrrYyjdkE{{s*(U)e3;{{8goYc4Df}{YLMiZ1ekhoHk;?<0!Jc% z@oM4xfDlkJ922dXWBVVWsWgLZ6S6&~GyDpiV`HsxF8~FqWgDbz&}{T~3eT#?NF$S| zp{>0VFDjhyl# zdiV~@*0HpLu+HxJyyJI) z7680%`n56|NuqVdA|Uokc(1mjWNk|}!H8y-wA5%=TH`7NOBs}66M4OLSgZ`NV_hp7 z@rCsks@o-EUqb*00PjWujc~&G|9`tE3UdXnZCC_alAbE zh%o3e4sTDchCMNz;Cf%-6%^Z=2)voSz09#;9aF1hJ&g={NV|URTt%4rS=)AcI@x%4 z5DSrah5u>7NK~C-0=k8~+`ya>gmvQb%!n;?wRT=9>6NhVtPzM*F*|orTCV4Faj{W7$M^FtGnTv)qo!av-pkq#c|u8iwX)|2~l~1 znM`(RtoR_19g&EKNGy9DQ>f9BIpCGapLQJxdOX#XDn4z4Rn`nXsJUPxKe+-Czb?1g zxo}t^31a+Vv+7-PQe?H6dYP?w^SsDY{y4yYef5#Z-ZFVG9X08ghME+ZmgNC%c)shg zHG`!*>=VSbsWpt?-oWZt2*ST-nh%U8SQMp%Eo)u$*1H}9T~>96u^(nlARnFZghjQY z?2cS1f+^hdA$LtpOHx`TOdt{$5A_gzrvN9MZzJz2{oZr(1!QCp<|trZZcCJ0TInV6|`3s*U@>+t25m=w2;<#4is#oTdhf+*SfULfN{lsEO)FZjz;mhB$ zv{_S?n=GjR+B$N)nQIU|xoWIFS4Ib%);>Uvez*rHL%m&14y`d$pZLGCrd4tS;Ne#q zVGBIO3cMo#q18A!BN)y}m)nx;8FWnj9}?XC_QoXhHr_WgtHBWF`34+zGh@fRH~PW! z*=oDAP!|^7h%rbzuleM{JA2$!*Q*~a5XQdn7d95n3%gdQXff=6HLdBm>b>3g?c9fyP z=_H%NF>vmASlRJh7C#dVA9HuncU?N}K(C8ngs(rJ$p^JZMyx69@O*aiK12ntIg2Bt zI8sLQZWa|AGgwmlK@6S1vH1XlV`5lUl}wI}c&js)63vZ+GG?*|Kjx!WQBm(ht5?>i z?^5}*x0NL`f?s3!JC;yGxsJ9*84d?{$Yu&5+8#UMmu^heK z^J|!B(%{uMxcQ}Jz-7YSJ28!sRKIMMX%DmG-xDe#c_x2R``!T({zn-3n>f{D+MbGGeVcGBIUCf|8&jq$!hSq&m@Ign@0m+IPa59_nbY6u;M zE=O_)ik$6$t*yIH5@i!-YwHtfbkA6-9&0Y+!OR;)pGJgHr7mSRp(=rW`%xe(nr%M= zhO2edN43oLteu;!kNS2unEbrb%d)ar>Ujg|oG?FWN;p7reA;tTp}~PN zrd?LqK1X&}FxR62bJg?ET7&k5u9YeD+4=tRediH|HWJ~3+@}oAw2}Pw_XF- z)^qw0Ps?Jlek&j2le4Ke?*}7vSLL?0*-GXJSU?BL0?S(ETs{Yyz5tPC(DY5_HBr&w z%f$El17r9%)InOPz6DjH@e$*#QgmStdK7BTy%*<5*X_GC4anE|vn zpwdeSP)ppzL48Fy8Cfx1`1)YO-!ZiI+%7jN=Ra0xsa6}ie`T|kSj0fNBO)@1l(f<| zxRjqiwZJM{k?Q}5U=pY^2WED7bTwH;KtJHwv&^E?)7YZ`RAichslPyuiV5T{UfD=O zp|6m6xHSmTH6RB{2OD~1JU1N`0;j6dLKe}dVKw*P<+G`xz}Ib|>ndr2}8BMcZ`seb39Pb?xe zOFisKM1J*g5!{{Q*ek`LhWe_R%c92?Yw170*)`PHpZOUyk}cU;S%z{Rs;N#mJsMl2 zz3QiN4i-n=kLq;LB45RmFACU8Ld-x_2@(@F_-(wUud@`Sr(nLKf2mF}0xIwlb~eGX z;^m$@y6EEt*`e0fF8SN%^G9xHm9bqpt4K9tfzMPh6!y)@YOsRN#o~D_+t=^wrkt{G zPpmQPDR4^~7RuKUa2B#H`;v8)C|gVa zDivUrA**w0lD;&fVAq|J(u3emQ36gKbE6L231Fu@^6j#ac02!)JEwh42o^`WCD;R? zJM6(;$k}*^6wmtH@zYBdOYAvuur5Q=mOWq&ydgQU+AseeC-S3eFhO|@Xr^G-eeCIW z$aFa|o%9<}Z8i%H3pOu`o4u|T*sSZ*i_Pem-E=*%A-tg|UUMNfE#uYB5iy3R%H|h@q*YeTTv6HNB{rQYSLi=OGG**`HvRKR3_m&5?-<)tG4^I(rBt=%Bt1sS; zatU#dI1n*D*u1#l7{?ETrRXXJ#iqT9*M>uN+cR|F!+*;$OIJ@)J~)E)0C8v(e7Au$ z>PQEpj&3N0)zW>Tv06ITBdgHWuG5doA4XS7bQw(P4UZjt9cohkvSBgaa&5Zk$_?4m zOYx!-7hAxrBRMZFNWu2$HE_d$k96cqZF41hv+Fw8yQZwuXkxI8dM_*?YH0gW)-V!m zx>QlFfOG+IA5<9R4BT;*$x?<8-O)xir!KBVTK; zF@X4$O~@Ddk_ELjDcQHwt+m)iTl*h0q-NqiL^ZDwIO%YMX>X;+J zJ3h2pkh*kl?rV{UHX`s0{9+oG=N+g|0)8n5{>0X{qyAffuiI+L-i!6P@@fhBInbkO z!#`^sjZX!Raov9bQ{}%Y`LOD}@x&E>XIbCWFwZlcTs?YW3r7_mL~+u=t(m?l0e~am zA4S8?{XzW_Bt-&XNKc}N=n~UymvJB#>iC4c^~5OQEOS!WvSkDKEh>iSP;9{K%jGeNAio#S3ts%sldlPE`ec~tC1!77F zba*Sq2oYT#Yx-*_bF4mv4+>m$Q)b%H{gr~!BI`<=d=IyB3N3%=luk2l5vhAinJXXwES<_*uM`^NIe40a>766Qn zQO$|O_OOU0_T0FjS|?Bxbm~-62X^T!Wx1@`W*&&l#9bZ7$QIf1;DIJ>27Jc>0&Ii! z?Wule5B_TB+YU-ED7R*LOZ+vJG!(o)68UcfD$a0f()y*Shv;-)=5-_YU<3e0RK$?G zI`AtV#wRpUT06RVcB*^Tt4r$gjz1`s6zb7=2qO$nlI~qm-Br9oZd5N^ zfCno;wG0Gly$?H+xC2>Tg|D`qpa38wP^p^GPSWd=Ae(eL2+hLXDJ1nkG8I!XBJlNM z-739OViH(vY*3JceM%#fiH*7la53myw#E;OWk$exXK>4@YfOe`u)8U5LgP5YbsRA3 zN|K*g)v~xTnyyv=e%g3W-`k$4hyOfxFDyy^s!L$hFO&j2z-V-UB0vIHqsqFb_IFs8 z`*%)-zC9%puXHPpOQ_IP@p z*-$kpuWD%5kG@jv0Up0}wW{jhC%|CL1JUDNRQggS-<>@dTTbd;W%O;|+#n|BIX(br zrBqKx+Ycg@F%y)H@#E1Lkaq}jPFP#*9wGk&a<#Ahg+4_jPcS&w} zd?AyF8-9#;aLyO5F#yHz?{kX81M-1-XV8?NsoMK#>dY#Qfq zZ8NAUaqP}D`7?IcI+m6lJx@SX-Wo(I#B%3KalWrXSG(iQ)cYEHVqGCq7V~U@B9i8~ zdQMP^?me%+EMz6Hl!oKU2bh4}Q_J0_JJLTEqW^^7Tgila{F4J4gQRdAS?hG(3b<}e zf&yA*MDS+EICp*s-A{vN@tyJbK{iJ43{6=F9>KE=KrRxey%e)X^LHqqdr!OU?|1Lw zYO0wca~$&ftiSOpFK)Tlvv{G#ISC8{Wa`>LJ$fZ{p(g5&{A=vM zlpfq@T+7R9u>T+bRDJHHFSx?+<|nSfZIBT#wjhJ>@7k&OC9cPO+E2gHfg6-P=)v5) z{3`H|5%yK!u``SUXYO)C*#{&&7rWg#eI6@92q5tpVzx%+#opUnfUvGtN%+Py5-&Pe zM*Y&z_hV?=mH)m*i;qyQOg?slZ!0Dlddq;=dN9Se%Dx7rxIP256ViACga_I61~KB0ON? zyRMXa@60p?*NTEwn?>$q&DwkuCxuFscV$6LPJgy@>3CgL?#2vu=OcuV?4;@ln}1*n zE2H#8MM)PwIN$90yXRyA7^~fXn+48 zG^$QZ{TTa-kpeH!V|@_0Gfymi2(J7hf zzam78qEOX?OqSNBWL2NRt}vlu=C+0`9f7S8%YIvR1}3=jv%nxHD?Ac=HK%>m3i4;6t;e+Cq1NPRrgjv5jr^j z5X2UABC>u=RhBME=p(wHS_6vC81kn$;Qg@0c=qfX z44{M1r7^bpeI0q64xT^RrY&C5uhI63*F$`K^Z4|?%Z~C3Zg6tfs>;pqZhc5ZPXYgg zWnfwzv6oIk8Rcjha*N+F`xsjNd!4aJi#DEd!^JTkhAir(-SrLY-*z@&vUz7I`aW9( znp;l<+hc~*7pEEp)~B@oB-YN@v8BQm40!a{TOFkXoY-is@K8jt$pR4Ztb0GCyIxhi z_xFF>1*Y$Rdb*38@8{qX;5YY>8t4;!RptJRk@;TAzKVa~(Isn(dj6Gc&lEVkvF{pOy{}M{vzXLqZ{Oh&M}4RjH(aZ$S3Pl6so8K)sB)ch+D>I_*qEU9hGKKTC-`9P^-wcef%&UP zO$%B>sL>oVAtYz7XT5*;n2uC1Pm$O@D)HyKNf~e~2z1B@Z!|K&9NoLxe?uG3QCbxV ziSO`QN?wAdAn*d)JY5-r69In^lzSeY1+|o9Np#{tR@efsX*cfb zX&|FRV`#8V6Zf-soAZJ1d3sVufx~j&L$+moAgWE7eZph|^NO8_J-~NYpo9ASzScO< z=D+`6hrxrs+uP5uP5HKOwV5`H$KLj2- zu_egH0o6;2M!{6O10DZ7viH#G#rtSdKzcy2XQQive^|qvah48!QxD@-54!T)1pG^1 zO0rfyrMIEFv#qtEXqeh7T$q0FiLdDw6Y3*e%9hTE9?#$t@eqCadDSSMX(D#^4T&vZ zW9VI?>*ZK-!$i*#ry9X6o4)ed8(k2$tGp|5hgyC&lm3eSOIsEtXTVA}dF5JFXLPhx z!uu1tWd~%?rjx5#jn&2>)5M&CD+(NO$S4m~MRKd+tk5y&CGUH#vyzNnu?e`JKAX$< z{!-R=q^habhrdJ&HXJM6z86&Bmt#%d6#hk>oZFbAn?1a#68^#O3(2|s6`iwVx>UV+ za65vT6lj0fwPrr#I*z@%`DCzE$iIDB=i*XC7F|*bCD{BMxma*R^FhC; z{*rt<$z3q=&?aVsj!1ubkf3$8*t{>_y$|R>r&%l?5%?{id`Sg4IZpT2LYv)VW1MUU zS2x3$BZ+%(%&`d-4*a)P0i@HYuX1Awy9S?B9Tv#0R}{P4<<@^>!h_QdgYxeCt^Vf& z8qR<1HA=^6WD4PQGg<7T&jW~)GyF(oc(E*%9s#`vD=%-&!H0Wr&$iyVIyqW*!A^TcH>GN5R)b>iQ-Wl&n&ZL;xPB-Q1Rk3|{wH0pnhQoM1!HXm& zUd~0?7D@E9zS7`;1oMfBg|du(urGh`^F03Lf7xeLEu+_6u$bcsH&tOzF0z*!kh{K$ z>baz~X8j#akaYn+;5bb4ZEQa9O61_q?q!ehiL#|F`V?_m=H5r4M#uD~WyU>JU-0zn z2|~B?RSZha>jLlE8qmiGH>w0~(gz#P_fnzjC`BOxwLspA{8I^!#*5@j3H-*M?}Y%# zd&{;utN_ZOU96>98fa%NKyNPUO;9A4RYRMJ$^RzUK@70D70GNIy*2?1V#3tR->MN_ zrN-JudNby9az|0%(lxY4{(RKwo-M!cTEU2nbMjgE0aZwX#rBv`CD0buQ>4-&pcQ%r zw#L5uzsHX9e@BYR3Th~LcG!t9U(-fe7w>c_VHT^fu1=x9mtuL2}UP3&>>Y6cE zrH>RC@ueANFs|dO5P?eWm%4J>)0w7k_jbs>+)Rb_QTY5jFsru}&MhQA_0hKA`GFPa z@0?R!9AOl2J>`z!m6X2+!L}UqL&Y_P|@PJ9wzKxQ5+^51y?bwGW zo`<^ujZfD5>*IU#$qy%Jt;aRLz<93GzI?}8Gd1tpiQ^-`E<}Mksza7Dm8G^klyW4= zny{SulW@DKgz+G#pm%T#HDmmv=MK(IjMvufLLBWLc$SpFbp^F|(u!)YcswXw*}n!0krX-{@M!!}bQ4Kv77cJV=^ou2-v z<^0~Emonkj)Ti_?n?B{r$nQQ`w}aKbc7p=Y$&|cGmS+yb3u{0jPy`RF1CbOeOIb@5 zBI^XQd?`V0!);T40nm#+K}5x+Tg6NB|3%<4_InNi4`NeKU#d`4|b0QcTF>T5vWO z1T_Xa*t*b**N&qlx+%tAdI$etAEbJ5jqq#INlv%&BK^KXPWss$PCvCHr5PPC)0_fH zFN^ymn{r3LOD`1O%mMav9eC(9Q12Z`g=O|aih;|c_W=Sb@S-fJD=f9fK?!WloF$}^ z6bpdx?sv<=AeTLN3~JA_ata~)L7Sb(GB&#f9MP8T$T-B^@jV1pnJk#-QbL!nHs{{y zL~dk?tgRQGce$s$q}I-#$)K-&&LjWdo$YUpv+#IJrwlH> zM;t0(z9{OT{7KNqImb=w#n_;D(4N=JVs2@-sfHtF4Ul=PB3|)Y2S&0i?$&7M?XR(Q zbKazBgRhurA6=GDia3e&=1~X`Hm}X=I+K{?U~OP`u{C!eB8!Gsi)KdOL-pLC?+yF~ z5hY23+(=UtL@+<*5OHp3pS~y0J%5i zfI^H`Bq{_hQCN+be|-|6B&Y! z1p5n)9hr(Itdp4d65sItU~NZSMx?k5WS19fUi&#ex-79BvlO$fGB$+vxS7YE-pT zB(2|G1d9TYqbNB(y^IIRIeH=kIeOY7iE?TjrC*py!z0D=YN)I9mW$9zyD#SYYwe%^1pi_jr`I%?YljxEOq?`elKc7xs47=d|&kc^GsWg zsV8ADB_XJfX=zY6h(*1pafk@p6!ojLa}($?m-CFO_U0L4@+=C1S2K*SALxf7oF>@` zdqIt;r%hcJ(8dghAch-qM=y;smfB{N{{lnQ|L>L0ch|Js(jLk5V*c-yZQXH74|pcv z5w@&Yd{Y@wn+g*pC-^zBb;`>A16B{SR4QkO5ie~F5vmY7BrC*58xuUqCfelZNSrBs z3mUn_9#od?4$27Y{*UC|_8}QP<8E0ksz+6M_YiI21qFwSBJ$ZZ>*JMkAn@T@%Ksb} zz;gp!GpybHW4t?#XxYQoQ1nqf?J#~|)Ie@cc7G!}@m+V^TLy$o9tasV6sT;a^a_0I z413UT7Oi{o$sKkNV498FIUd@JtYz_E9Ao2`oL$s@C!Uk61K}H3ddH-p zan|0>mkMdgnQiW2Xnaq43_7<(AQrhml2)YXPcA)WJC)`2t!o=!xN|3FtDL>9#HBID zMtGL`g=N#An6o`|{THJ^%t$cCSV~kG6m0)2-OE4FBN~F!hbu*R*vh{&?te@~Ucd-n ztjuHkou!-epSd}gvFbEvdnk9jdHoBI-NyolAyv%Oa4oy+RgCvAapT-)#~P zTFjRpcBbyJbzm6fb6hcEH?MP{Jq>OvZ~(c_(Oa^83*m-pA=7%5BVE{gRjCl@Y=URa zo#Y;tfs-7Gi?}zr4 zZQ{4Nu2Opad2_(VJo*v7ffx@+=fHnGIx}m{+JU=`Th`rz@-RAh^@9kXI*>*F5TDM} zTo!!{RbQ^IVKr?hk0qdecwXbZfF;eo_m(LV@xDZMp$hco9}-bu`Yen~{_$qnflK5} z?E;{dUKyDm^bdGKI2tg!^E<2wV4vJzVo6QRl((hNd>)8ec>247j`KwkP`ZbXiSh_t z4Y>>4ZTE7T9N-`NBB>C(WhE+`mK-AWN;*}r)k?Hd%>F8qZNixMCUbvUP$TobC!A9s zcdcO(Z zXgj4PQJAOx$u+5nO$c8V*(EUB%61Q;!Z~}N5|Dm%)|wAsX;E;NJ*I>(B?V|XxAuZs zEp}8I`MEu7u98_is>f|jZAklQXi^MsWSSEi2dPpFB$<*)F;KwE1iG(&blLK@{6 z_gzX%J@w-YE3v1r)c^MBD?aoR4^6-Er~xzJG!#{k2omm1+?1mMsIEk-jdE&fzQL8~ zcTJ;2qyo(Ndl<>1gLL^DGs%_zNu7)8yW=|FH9J+S%to6upF=Nxla*Uqc0o;_)(%>5 zoG!P`t=qY5f3~l^qSGY|ir&ZCmBQ4Nhwm+2RD*{;gz_SMD$!QJa`|5Qr({;!c|!#$ zV$GaxioFpncGt{UyBt$nE?dK8UAbZp(eo1~2fvEi2w2k)`B|N^F zxUPopQ})=ck#p$nUWFqUaSu|_FgR8cG_{FV#yk&U$NC=n|G*mLpB^=oVQ0SM1=X=N z!dSZ<5elcp)A@^lD)cYaQ%=^*cW3jMYFE$h59D;C(jyn<35cX~}9_e89 zz3{tq{pl~}3$q{i{`TMQ2#~oo_hGc~!f)Vi1VGo|Gau+ndlmRF z{@{a-O>exr4ZuFK%Ih}0u9Iru5@kVaZ-d5D0NPZd)l|!QKWh$#+uYr_KHX})QO?T- zfH%mb99z7sAuxG(vsH(kWkWgvUp3EM087AKJ_DNseXOGzv-nV5(XGY@sbN1@?|Bq| zA8^wgH`BRhjR8c!C1DhQSRzNdj->*ll%%RQWC{P}!OkOHA;;S<(VI1YAIsi}S19om=(;~gho$GiOo`Q0s zAFadW0y5y65pM0p)~7@n#}QBM#j(*YkucaiZ>Ov;H-NCN;f~(hwfDP6SRRE!lll6z zq=W%tNXKk{yB>--*EgP6tXGEy2PS_6PbLFiB563UO^0_a_r zMSfOzlRWRNBoO8GGF@H!AYlo;<4lFY@%!MZ;~q!WUS@lt=N9QkT z&mz!PoE-6I5B}L6EQIw1N`(aTg+e!G7F}mK*6;X**s2JCIDXCQ7=d>Y z=osy;<(3CFK9EL}a&5tmt;~Kf*lDiz?o`6y0g!u$*zA|V601kjzGJ7^yog9HdBpn; zNGN7d7?~SnWT7Ecf!Z%wG1i~j7o$s8ay!f9imXt6n)Tw)(wSbp-c%sgJcCvF zWRAFF*{K2N_J_B;aQ~}2A7Qvy)S_)uKwn=xV{`+?J$weq| zV?Wj%7kmDR#YIp_QKPxGR{XfkYxE~5j_Xq^jTuHU(y9A^-`9-wbuG3m(*De#n%AIb zH2V+M%?WcrM|{A7S2{L?Fm z`7e>d$Frw->tqE5&`xYOVS9uKZa09PsO-3PZVJIgjz0O$90V~@-nhyo1O(qKxq<)JQlac)u~&w@3>E!qAyJ z_yP4g_oSI#OQ1ZNVX~E`l52fD=`9*rQjO(VO)Z*dQf;g?=BS?BE27%Ib$; zCE!(zwGgC=SN6Nv^m{KhTTIhR)=Dt{hpO+6r}~fowGS!B2pPwwj8GECmfbSS-V{aF zvG*R?n`}xd9I}tS$v9RvYB2 z($i=D$CE$8J-^V;H0em=kJV4v|Ky+X|I>{JGi;`4J%B$50tzJTmREO-afX+NyQ9X$ zyWTEnS5Oc59XJM7B(Rg=L=I@6*W{)#sBH2&U12)$9FEb5}iFIRQ679Y_qVSMR0kUGWvI zqpeTsM1$4#4Cn!=zRu#(ysjji(vAQk#6{XrCxBSK6ND%rtV`+g)wm{Qr&T!r(XG6> zZtRITEdc6``lar$e>Fw}A%SndT%VWvXODXc0h;pqrExOQCBSPjG1f*?_M~(OtJ=8y z7{7OXrdm~`S9HbKltHqf9|*Qu_fMP3^kwmz>cgcU(NT~Z?>&@*>la`5s{*gq`LEw% z|7`Vf@1Lhu!U?vHu)$8 zq9J<{)Sf1!CQi*}x&Xng)%W>7qDufn?(1uY+-vKc&7bR0dTPaHvHnBnpLI?L?%Jsy zAvnu{7$Cf9EQ&KT{VDh&7$9Mneq8J?f~W5W5ORi)nGkj2&-PKU(HEXVNrH?HQX`XW zjjya=VBU-DBL|cJ3YLp`5U=J#_xq|P{D6f{iXv!e>H{j4F8?Z)e+!z*>B%{dDS)_M zL;lW+g)V!c5an=G!~i+JWe)vGm#HGpO}`NZ7i-E7Ivd$$G}|91fgp?L_sB-N!4)63 z<8yU85?H;h_H~`fEX6<_WXfcz5@8Z*AWMQ>8;6{GOl~hlS?2d!I&G@b9WY|z=SEa6(87sZZ_V7KVGnSX6Co~-VtFXuPG9YB3Xxpgj0A{?9MYojYOSjO z6|@^BY=BZww6OzFumQwb`&yh0j)0ORI^&AtYHn(~dYvpiD+3_)j*T{~svQ>Pd1Gsd z@59QOo?#$cR>EEG1Qz&jdgDN& z+1hyhKx0Tewk2)Gu{z(v+_pIm+bZ4`Xyo2^=m1z0V9Kwrr~DMKtSc4`=tGy?a@r%m z_~Q7#e*jeaFuBtdWYol28Ulh*l_v!g2h@#AZ;n}c!t-<*Nra=eQU{0Jc{{JOD6s^9x}GJU==f8{97!T*S^V5Py0KND5RSywV{UqsZr%z&`Cv%pTG=9-Z)iTsZ7vB z5m7B^?~kZfB{@|PP#9a`E5EnTCosntFdo8>rwC`_`{xhw0hBdgCm*C-zCix&2Zy}X ze72A!+bHnk_jR3o%dP64Lr^$G2n2ldX-YZ4Y51*hig%ynfWymi8tG6xUCL+l&7t9- zcc(anJ~$?{nu}kvp8W(c*M$;@R>rCwI#ep|5CbJs<_#}zPZ?PhI=MFdE_EWQ*m?t0rbh@`bG=c&C^>u_`~AFUp$>hcjW1>wHe@WIoz@EkSX9*l%+@eIR4Bz zLuE>i9DI9mwmyGwsCI<)_T+TqzjTD%<%=p$97DYQ$H)Gkr2t3eJzjdbdAI_bQpsC*cG# zf{lJJ_-cN+-2UZ50x%m@lN}KGXb)5pU;74g@j%Z29o%Xt$=fvv)}+-;T!r{WVar+6 zScgUXS*8raXom4zZNlgB?Lm@@%jE> z@BG%>g4~wUi_`eZ??oc^0~uzz>i>zx0Y*Rhs2(^!Zg{<*bcx8%d*3qKl|XlO@&~NF zDWkBd{a_FRvJj?XrnA#`O!Fs&r_hY940$7wvb-GF1yQ+Drz#WmnSt70=&@^(muGXN z0E-9Y)#?x|V4fOCsh0^(X#X|OMre~AxH#I=w)@n8YCU#+nt4eLlKt$ zhgh?i(BvV9`ue0}yemYr*!_*S%!gVB{6R5ZVOw7hKNwhZ1Nl@8W7+N_(t@m6i918N z{dJJ(speAyuEN}ZI+PKr{D|QM*K~+quOIMZiuoe z^3++>$-3XJL%08vYd#)rJ^KjYk6g*n*9b4QtT^}7@oD1l718ju)lB$zc4&aw@v(%* zEZ-a42QX}8UJD0t^twea-&#f>zqTH+qeoNzMy58{q>0lLpq#gmoN`sj0P^RzCr8gW zjb-oU#Hk$&`sgPC65$hMtDOY&Y1}ktJ37|(M_UyT;LQRF`(g`+$ubhor2;%5pg?n2 zUiSW`T)Pl8T>LRz*NJ6-{s_y!vS@#@Tq#rgd9-BpM0=xS9)(d)2(I!q;^#%D6`R9F zqu`Cvjz-P?8>5wT`2OI~d{nFJ^9a##Sf z->`5vhS*AYs96)7K986hZ@2-DY6RT&{YBvFLUJ7NY5-lJqTu;23ikBFnh=#)?w@<6 zVit@d<0Zt3T;+j??++01Q34U4*_W4g1UBqLm8|N2E9YZ?+OVIh<3R7i*>@nMY!WHD zb}qac%A!*wWEYC^luN)!_3foVCoB0+?sh%DaaPR&D%W-db|@SN*pal)cgKf59r$WN5$_$hD-d8NB{{?Y${|AUAe#bfcw~-YR4T(iRe+hKjXYZns+Z1v#1@ zQnXU!(*>XNSrOZJ{ki0wZYxD}#%x^<0L(e1!{q;TZcR*ctyIuPgz~$sb~GSrhB&>G zq8JJuJCRFWIGmZS&-IrK`!hMs@bUEoR&0C>0gIX92X4-UT{IiBG(GT%XWOp;}&e?)?i zSR|9iH(vC+36?G*w?RK>Exp$j3^1e0N>tGIt)AWPt%f^@AV9D=-Vui$E}$CwLJ%RQ zN2B1IsU+%^E(ZG*cW@o;*;!Iczv5u!_e|^{Ba4&n&pz#`#1J-`cy#i*G34{%mXI|vNbyF zHI@X|epQ{+oK~QpaTv?RTi6j+#gyi|Digv&a`e928*~1rORDJaHIfKE-y9aV*917lp!DRQVziUA+cvEiZX%Y1UO|H7oa1*<=k{lj8}-?OUt6o3nYg6o*C zd82LgN;k$+ooET9&-RoakRR*a4yWD*M-mfw(UJz~a*tp<**#oAamFcfLhgOJw3CH) zJje0Qzm#8a4?FY_0he3d6lenO5l%0d35-=XLywoyL@;$$|l)d z%!_pRWby#TB_WWu@&ihM?~QVE=^0<^OOJ*sQ2W-l#G2IOce3ojmHdCI-=4uQR&L>B zY;%)KI_pFAQ%HT+xsnkYY@7F8nQqyM@Y_4;k>nUTv4$ecj*F?ZF8r?EA3nc0o9)Du z%|VR?#^q3-7Hf=t_%n={d8pRyU?;Q2XlOR~wh4~t&w`w9A00Wt+(*8Y5XkHV$Y^c{ z2xjdV6Za|6Ha&n3W0}x5zBviHP2Qsq?5-0)wU`#JUb@W?Eb)9dRmgIQCv`VvXLfN> z9Rzx{CO^`9gCkI4uuq`UFqXx%a1bUI)QcIji0{0DlQ}EHJm(_jo{DW zu5O(#Rd*s*ZQfePI9=FmDk}XQvzYzTW}AO`r5Q|#NE=o%O8LX;5#M`C@hiX9f@Fi(>Ey>Gub!Kc_gRI1_w<`JEUzY`?L z`?X}zjO0kj^gX#A=NL$F(87Ji0psMhmMQwIjUNaZHNPK5(-j%DK@G4D;&SC!&g@BGm@N#4Ut&z|Lu zC|#Chm2W_-_1wveZ3{zvS3+}r$d!euW9-xBW?g;6BP9Ao2!u4Ne}*{5ITX8~s%yu+ z8Be?Xhsyhbk4pOiVGor=ja<(b2$7dMxEFK?yh6TSu^t^8kMTN~SJJ^(t8hfnEE89$LotEJR!4FI@#m=0$k#kXMG(=vshk&j#)DbSbaq2{#|k;mD7E3!bN6$Q==&PR>Vk}-RB8PJuwm(a3n^zRMYUeTo~}sk@DqL zbZLZrgJOaj_K$ac?Ar;^Aq=kRl8{-yci73~q+B}OY+=tQ7^bMFc5<=@lpIKV<}ZjP zM%VYjGps)|FYv|Fs7Njv0#`(y@#CimGonw~ur|gYAGN#YmRC`e4V5bTyd9LYG^)Oc z5A3e}3+HZrLDF3E62jFy*Kp=2QFk`HSq4UX@wxxq+kSd}a(}s7j@*gp92clc>Lj%% zRHXPro^fFH|R3UY6L$U?~kKQD2Db21JXq;Eu|9@u|0QfaT~`yMJhNp->V zw0}jS;E|pA_5?-e2g>%@7zn9(H^%^EHc)&}l2QlBI?3a}EtMlHu#Pj`jCvm1K+;SY z$lfj@n2fkt6&`K_3JS2&yPwqGKo$d2xT4Q^gxrJR%QIs3zsjSG5XAC|61L{>hB{@f z=k=QQ^-jEfFGvDmz;Z$u$on9(0pf#9lsYTGAUk|g_N;W;mqPyz-`@4oJ&h9m;}+?2 zzMG>3%=l^pjOfVYn~WF$wc!fXkC@PPnZlrhZgG2_0l8#*QvZ(gX!tQHN{BW`dhhq6>Am zSH4Oz<>;jmhoAbk^wrTNOV;5WGj6Yk4}yus$USFv(9vLYW6pF-UcAQ2@#|Q|mhT;J zW+LjIoARQx5V+&+xUuwTqu(H<=snCJ;vFtKAj&ric1jxw@wmyTHmmwhQ*c|Y>N$Mc z>rTMV1`XNWM<3UCle+6c^-O!ZY zanp^f3)8Eet8)h;Cjci7q}2b$$M#g=^RE(`nA20d2m*&BMh=o7 z5oBP-j~bsToZ~>X*8|DBOsWb>M+)lt>EOu{i{1HP%xxz6(=AO7+HAU*9OX@`rwfhP zXWZaRi0`Kw*?Gm*cZ+qw45G{HNjfp^^a-9onGg}$qfKxcA9GJEY)|?E*USyqqJa5%{ck-ZL|!>f?B6MpV6uhHAtbN|PKm z2e1(;y7=Ez2R`q9eh_;`i>-Uwnl`={MMlfCbdp5eJ~!=^zGDkuKn+U>{WS(`ENPnf z?7G`!gf{-HKOw>QvE#=#?XTh++&6%^PXKfG%h&J&OGz7fWr6#f z#&dbw0wmc%#S5A3n4ZX29}tPFGIq@~unS)u~-?9P`G4%d|c9!NRy4!MVvUCRu0~bkrg+R7SS|nr!yD zRIWpFEwx`VEy3wO-J_(S5({Z~$=dJJATxoZzIu}=S68T6Ne#yrTe?T8@&))I%yEJ+ z1U3HlhFo2kKv00=tr6MBl(90-EDWS7tn$E@vuFvkEEPGZiHiO0EYwA>Yb)ZBbFA~P zR!93NNhJ4`G_v$AlpdSORogq<3RS#~lxErRYIzyA@g{LrV%doBa1tLA@fs=G>WK6T zaK7YNG*U>`2R?GzsU6|$l}knnI!P`>~6MDAUs7I4U%wV@d-E&1kXCXKZ6!&5~zC zST!FAyM^eFkcY+vz#60TnW+>IVecfAG7d&s5n=ZN+n^jggN2`*v!0QJIUCM83F3AN z5g0XO=mpPUX<`kql3AENE*9!HOH=nLd8Dc$kZ`j5n zyJqR!qx(DW2(51aG#9V*4ggpQtIL}?0Mhr#zrXw~Sfk0kH(B1uGd6$-#N>mV6!}n6 zl+hbM_p3-y5*qZ*iZ@ZG+Je;;)b;(tL9jVBol1GA>{>5OI{iZ~N58A0-{7JVSf|n` z2ik%7paD&D>_BX`B%!w_ld{Oq?qj%Yl~TQxW*xV&Cmu#DW6sTGX=esvl;*OFMuhgF z{UcqDaK!H}W@($$jr^M!gA(h~l0!`{z700Udp!x`eNVr@(NcKbI6X6F|A!rQj~rs1 zezgh%;?VupV)G4RMy)&aqDF;-mo!?T^FAtvHSSD8y?=}0ipu*9w94#5s%>j2R&@>7 z9TvG%%aRN}iw#<{WeKxi#i3SKQsjm^s(5KDEsRYz7VR~vSxULVf| zSj^&@`9mWGmakvjSUYM-5JVU%VL1EOuLgKzNHAkEr-hA8hPVpijoH20E(rReh}%7P zE%&NxE268WjTB7f6u)whE?o|uUvD+D|2*xJI!&;xKt~i}D--5Ohqu&N zh1cx~CD^Fr9ARg=(+!EB_~RevbXO_7A%enchOI!MN_kb|V5jVIr{lJE%|%oVV;TYN zoU$vI#BkS_x`Z`3@T*sUn$nnKefd&uO~#3DkQ+=Wp z-d2V6l6?KfqWa$e+~MBa0nr?Ak+6huGL)jNTnm*v1o%TqgP zGjcBq>DZG%-BbxKp&5O#Eox4UvC#~?$l}|2UAT97%)Tpr08I9jpkg0|OI7mxg1n<> zkKRL?OMHj6`ZYLzv1XDSO-v$!i~ifEPPQo`!=oY}H&ZEdW zyI3O`!8q<5q!9-5!aGS*r(^!nqk||i9rL4>B z9{VHO2hQ7GrrwDnP^25G4f>SgYe_5@s6M?yB9VE`9A!KeT98H%9jsB677?)qyOsPofUTHYBR1lLQyU^oz>2-+K@|7~Kb4yJBD2c< zkyhwwdWumh+rXx;u= z5&H(jN}e(fSVCi?-dl_xSUxzgCLajq&1$%?71&9AK?K(0BXQ(`&W#!g`yj!4CHn5d z$&$kmExfeV`EkhCq*~SBl7&!>U6fk;SWoV~s{woq%RU zkpfv=yf#FE)P%>kC?@N0XvwufWB&+XqzI6j%feZo;|9q0jp$f!ViM)I`U~-5op*9P z(qBe`%NGPOHvA{F5025P9(C+F$p`AcLNC~cZgl~NjLwP)l@g<7B^~%GG-H7gkBEBC_Al}#Hy<#rIE8FUqxw>x2 zRTeQL^XtO$qC2>T1nI0&!#$zx=>mZqg|ScS={$xSmIe7qTq5RftgE3qYEKe^>+7PR-GCqE)xfemsgDOm3i_8i2 zwp$8GrX=rUIpYa#AaS`QSqG&1vk62Ax1Q%n#at8)BB? zm@+~nRl*x0q!W?rWQH{ojUc4rAa?ZJHm0(W;e7%e3FgiGXZG{Rbak5UgulEKG*0u% zk_ElaAHGeZnFGCQq6EX7IjP!BiK@r>A&bn!q4mLQ5d#4HvNAC2GgIy1V;Es&9EvLI zbOoI4W{$`xNUyUBhvH*l&uzI7N}J6UL=s15mf>LiYZ8oNNJRMR@*{KEb{m`GagfC% zW1tCHc_gLcO-xB%ARx!=5*pPy9QM*Go=<#Q0hiR-L<0}g2(~F!iNDqpV0DsO>=l7a zvu%Gt`P~$lmp>?-?L}paZ{U+dJL*kNnH;017_q_A(*eJJPbA!E)3X9U&|%oBS6%czN^x9x%PL)fgYO zV$~|$I(W|%eIZ8W*jh{S97epUUrLTG;UsSN&VxS&ACS^eNkeI}5wX3ka&>frSv7xE zX^+o_SK^4EaHWR+1p*keKO+DoYn=XHdYx2m0Gs1I5sU)2M`ts;YXzn&1%6W}>3D*? zjf}fjveg;$H>o_+WD?dq0!Hdf<7YAPQqB`*p_B%4Qcw@oVpVNdIczU zfgfFBh2OWg4og@|JdFD7YywHp$47s&zSBpQ0Jt6DJcsyb#)p%A)4uBmT#AQtI(bHZ z8(Opmm4W%QZH8$f43h7+zYzTFWsj)O2v(Z@*=;`IA#(H^SP*Z|V{hIPDol0dx6o?N z!gA_wOgaF7>~TEw%wz7+CI>W|CjgerupXNd(Tt)?K6prYPX*egfjm=uyEXF0Kn}r) z&%t!34?;@W9u4WszRgAlC1h_=d9-TAo*bnzQsg09?av{-33?w}5D4frg9Txm9-wvj zK`gHKRm@7&g{ekrzXZd!_#PVn^j$;!c({RwkMc|mCwY?_Dc3~2C>(om;9y2wXxjkXBBAk3l=5=$F&^sM({wHj)h3I$#UB1b*fJs2f#4xa>EqQ1 zqZg^RlMjTxvdn@jW)n{0Z#_4breqCalyp7%a#G$~oHnp6Z`$OtI~X28iu@JHB&k!g z|5iUpz`Bs=w{|fQ@^pF!I1hG6#m@I|OW$yem8oWU-ia3Xhm@ch3q0xcV^y~jZz{(~ zT_Ya^64(m_t{?}~zDsY(iKNpGjv>TkH?siJ=Kz>;*5?5>|JB7=)c`iL3D^W-7Nz(?Zm6J!-@!>9c-5|4a)-s4M_KeV8ivw<7r{VzX?C>;*sM6VA^ zDZKVQ!3_g@;niLz&v|AP#e7>bfp~Y5H=c#`wcjvv_dDMPzl994{(rh1mGc!&7pzua z#$OTd{sD#KSC_bf<>i2%0Z~@Ry~10{h~r>0QaEhFS9NlGXO^X_9FLMB=!Sd;{{iA+ z>g_wn+f3;bN$Y^02!+cO;3DhHng93PfG|U4bv!^zJkK`yzMd0`EGkCEMJ2v1AwJm(CVe_vcs_aGG z&hxd=ZC%!O79ScNCEeHn+&UpuM{NRj*mC@)3J{Nd|CoLob3|OS6xIi*i8d3*Dov>3 zK%g(jYGwLG(f5XNDQEbPuir(pB*jnJe&2Bqn*29!NTOHCF0H0`?eQOAs~uyv{3~NQ zwO;#n|A0^vSV4L;!kkUiQbgVq(W3p0{guUU08SqGlJ91jl$%PMvPLi`}T-bN`*gY{0oBXXT~N|I98wVHiZ z)8#b%u3E&MBlATy5s-(C`)A;>o{5Su#R9S;{hDo4E^%d*ul zJR*J$TJXEpje9qLzZ5opZfAGxUmOMI+w%-L8GWsx7!Q|!B(U1Zhllh`AkI4IBTc7LoU}p$b?zfWQ%#VH3DjLv9 z-*p@NMVj~Us|;6Af;IB>#0QNrqxKhX2QLBh<)q~c1aHpTJ6=iy*@(Fv*=xW^=3a-V z2#OAQvPl5o0k1Y~O4Z?*E{c$v3?4@^Q{l@&b1J^QM>Z&$bLT;l@0BPH&^QMtD5drv ztln|Yllg)d>jYZwIBq$|49Q-db^saP6Z94S|4lAGk8QirE_YMWpL>O{L`gBehF)Eo z^di(Q(~aJ?;?3vfg$CNl`PEw;1FuKOlS1=frH7P4Yz3$`A>Wl#qjr-X5t|ES@YR2U zzr?hX(Pfl$Uu=iunPW2_e>6Rg7>@chE4II)Jeoq0p4R!ew`uh>RH7)=EFOe`Q(qYk zJNMRBLHduB_M)skKF%lJtym?zo);mW#xp{q+jt~+q(Bm!9Zz}}TjrRLkJmSL1Md#- zjmHNecL$iQ^SifiU7Usf{Ua*qVfP^`X(l#Pm@;gK{|F+m01~Do(Cp=#aW<4nO|^6kakH>$^}M`OHSD8hxuI`ROy8CG9fb z%JD3^EgtPp z>GK+Gx(XNO!ip}C9}|{++qF#WEw>KU)jO2e8|^TvKlHd8$$X`zN;gPfIbv3&nk3(N zGdx&mJC&poC(IJs#*uN=HKt~Gx6Di8r^``^O<_W4Uyv!46NR6t zQ5Gp|s^9f%sif545`3U~@UTbZp&#e_M=;jvh4b6zX7=5^v`0_B0}s06{|p>!vqc(t zvfqf4_Fr|)MwNvS4fC(MKa*)W0-jud*<%;|cIIXoW9hf0#lLCyJ`fv&@`BP_bZ0i+ ztQTtDQRHIAMlFmlG0|__D4|KWd*)!2wK^-jMw}KmtZ(^)o)^!-mx<%)2p5?+_XL@AtK4Xy(}#lbf{xCj31OK zCH*eU#eQ~?ZzW^L-}(G;+s^+}V)5OGebnHzQhdiNVEpxqp}}~fx}u$j0)}ZI$|{2M z{)Td*t?e0y3ciY>ha5?B=k6~_e%W-VCA|?&(r!7O@xMGO^Orrx?f72~mR+9tUjU_z z9n&j|(=OSIE&nTA%ca%T(NN{Z&{ejZ|7E}I)zFpu$;QIv{^Zr^S(*RdzU->$`Kqq} zd%LSH$IA1;%PZEFPyR>!{=kf+VJDyHmy-Lma+~WV06Jb)Pz_iU_iJ)}8xO!@(( zd)}R#1DBuB|o$-M$5Hp@*@zqlG;!g^v3~^uN1wA+T2Y#Q{WT$8~Duphq zs><)3k#R{yUa>z=Uew|!kRV>^v>TMjYNEDKBJ!6|lYMhAmEq!*mUY-ygs zHMu&z$l`Ia&GQ|{U2NlAK=#EEktBJ&^T_4$P+^4s5w?*nqp9Ehn2X&7ju-M z&yf{`w@g_hR@X&?mejQXRbebkI5(dhOGK9&e|r+W|59@^BhHW9d93hZD`R7>R@hkl zqYtJ2bp2uzVI*P|O3dwonKDzd5zU;NjL-9!a3xG}g}KgqOP(muSts>_0m1wRerirp zv;mZhrid+SUhghr*4g7j20ME2yQ?+{61Ta`64dUe1BNXqyAyABiw`^}*UEEs0(mfO#4WdopA}S zugt7z`i@`K!{*of!hLEdG7A%33)`Mif4YP;oBJ0{IR;z= zPqUh1syB%wi$dp~cNm@jY<%tIEwfHu`E1{P=9evj(9`WF-L-Gdjdf(cO7`}NsU^W- z@nG5JE%rauUO@9XChVsZ$u=bPXJu`X|7DbH+FS0;te1774<#xdw)VLv&(bac5B;X^ zu<=9Jwyk@gF7Gh8%?B~h3i_0xcA;xzTOTJXGkL$6M)sJP>(-zB7_E0LP?PH~gw6lx z>u~{T|6v?zM#A9xYvH#9!;OjOs@ zAneZucIErP8~&G!Qxqh`T}3nAOdpmEYwl`zwu^0c_E4e9TXM`Wiu;Ii)AM6hJk#8M z)GQ-I6LDp+paN#PCHyy<`Sx$g;%C8850&t;l#3;p@q0;#_qCa&hAd5f?3Lk8YK2=A zcU;hKxr!uyctH}=N{`|iR|wHfZBg*0M~s^l?1$Ja~eT?wrDOrPw|`2qPbOm@V$@BP3Et32NLvCxbkJ)>Y#(U zJ=q^)SB8(gzgV<@R>m+2n1f@6b%60R?~$CLAHzAd$9Ja+x4~}nFHL8W;df3Q_8-Dt?MrhBnFcqWFFw=>cE*@&HR7=uT-sDg(-DU zH+9Fty{=ovcyy$x8*H#fn3gtRDRPt&#A)8(XA4+dD`bT;iixs zcvbXlvJY6Tf08X%+z^1fsZV*G$^1Wt15q6#po06$WNz~Zx#nrvWQkcmdjsLt?-{NK z8Z=P0f7%@W1#KIjdhT8?R<}3kw94cr*cb9?V==b;8CeKe!Tk8C zo#Iw!z8;SjSXkuFTzokIu_4^7@;kRoUcNkm5p0$jITJ`a#Kg_#Y={7Ba+oS)nV1=C zIT)X*^bh~byMRB@@K~K&&|RUuqI!OJ@Z+;!`etY)VS`a!ps|SLe4tyf{i@>6xDHY6 za(}16k2AcL|K>TKl8`al6z+l+Tze{*JImA;4lPQP&xy& zSmw?l)~Nm8_NV-}{qGUvqlqHo-oa^eVu%Z|O(QS2fNbvdk(mQ1?WPgf5sPh<+}lIQ z(YPVc{*#Z<|K#JoyS%}EMYWhmLhAB@XWKgd7UK3c=~*YHy!^m(5CJG;_7z3hr4hwl zu;5dy!&4b;$_6HCKu^>US3`E^7rDKnyg8S8y&bBqmXm0vxXVy(^S9cOAJ>3slHJAa zAVU9gZ_m*JiUO>y6D=6gul~}Au`$G9Ns>MruyERkdQWq>?+&VF!piXaY&rBI77*tuXXx8*hW0Bxf|mL7^Uy ziSohv(M1>3Ey;~d!p%la$#%i{EjKy|dyMmst$PQM3eN+i$-Z(*;YXYiz!c2|NEP@|FjtXPmBKot@vAdFR&zH z&DC-=cnd6n`tuifk_$2Wt53vO`XwD$!@$HlvPr>eEi8|po6z^my-+)jFYzI-NUYWK z4jxl*nBq>)Lv(JB3rf;FN-Lz+uIpSUR!@mx+oXPWT3v3w{?v`_`cz*v6TiT9)e77) zu^?mBY=iT2&*ycZ!S93^sw~bcYcZViQ|O4knaYxzW6vzqbanor#T&F?e2VFc6)=zp z-;`2^x3?he;kCbFh>O0l1#MgGaQ3_72Hzq}dN#HFqp$b*FKqk|AM(DB>ibxdA`qYi zXB-sewkyibi5o;CCi8a*8&-yZ-SFx_`rG~62m59~k@hZRzVI1t3^r$K7q&&YA0Ua` zUh1|Fl*K^nvx~iFU-GXpxa9*_71+>@{0rEE>`{mr+5A6T(#Ns9;Wj-13}T&F5x+Sm z3JjXkw*uUg^~|K&qP?N=1AJWJJO5DMj$ivhn15#E|E}#!N6&Y+LH?LTs3K7)wpH*U zi<@7}D3#khY5M?X)0#ERL}2T)qgPvazMa`WfPWQ+MBfiPW`FU=V8QZN4|z*N&mwo~ z?t8$um5CDBV!`2|9*FQe&yvt`OX`M zATAz<#*rMb{LAtoqiK|z40T9$lC$m?v_C5l_>ho~yx*`vMMrBffe8LgwH)-a~HtGp~*?+k?uc(iV5%#?o!b%soIpX=ogT&Jr7~umI|Kxa$H(QRrS<_CdDUu-8j}s8-|-=hZ3nvJ&*kYv!BhvaclpncmbD{pPz*X{!UMP!G}_@ z4+mdo7P}ww|81x2$F}ca0Wm}Q96I5<8YS6Zq{^ZuIIdP`u7;l=%f{XjtQARQE$Bf8r_7^y+Vkyrt zJIBwNx=+(_b=Y_@S-L@W&jXQx{aR=I)>;F&cDP}>@e_AlEoxEPIfcZ1PAinhklk*@ z>-_|>O{qNvpeiiLBwynH+$SIahbEpja%kASX%I)-OPx=e5ti_X9v3UT0 zpb|bE$m#9HEyQBoJO6!bR&hwS7?ys@y^+>Ma>11JS~_f=E`MDHz{IaJZEP1g1K2O; z1h!414$lDNSR!-lQoo>Vbt3asTS|J?9GX2DsY%kXKin?vuH2fhMx?*+%NBSne~4|v zS$t&X2|Xg5Zb{69n5Weiot^l+S>D3+61iPk13I22_iz8^KKz>^mw>EA_FY{v!0ge; z6a;1ONHUvY=p!M%%=;}gn?70|SSLOGdgFGo5Wz{Akn5$T0PS`!pkD+4OffWn@8=!N zwBR!bcsmo!peb(SzbHo;kX!70m!;5r)?aMTz72y_kqbyK`R$jlTB*4TeSnb}9wdVR z-T>JSi8+P?Nw~S+>@~%0NGADg)A<3C*lk3jyppE@FwQ>i)o)k6u6U~&`jOc2vRVpz zEM<0(Z5m1V2V{Fnw<9N&%)XlW3o0W{Ug2&|Y$cc8bbi(g*csL5YS{Sl^PBBjGTmmo zPaf;GwhI>Vl=n~Ko26y$$;d$d4_j{@4)qtm56@V#g(6h4Wvgt-Qg%^lN>nV?S`qOr`Lu5(rXdzaE(QM%bnFy3--}3uOwkw+28AU29^*W47CWu z*3os(&@uTOjs4}e1MVp!OXr^YO(Z2&6AJ&+AF)2#vb1N8%Pq}CIU3=ci)>4?oug=( zWk*&MA6)g+L1`*EC{1h~I8oVIm&1pMCX(I`q%Ogw+3EBDXqSKS{!{Keai3C`&uzX` ztgSih;~c;??&x?T@9baUKX1{OZQ6;)4?CGT|HbWqoXrXgA5``r@(PA?R$ zQazm;4onyIpXqFohn(9s&FQC9w;fiS>97dG} zNYFikddJT8WQO;l@vc42TG^Bmlbc%qP7}fq@=I%L!7EEMel)IL%X&uH_5+CbQMTbp z=^O3~$Lm;wt&>YU`8gqzU)A{;Gw%>LOCNwVadFpXh$6anfV==$rXw#`3g4Sgh=d>b z$Dsh~4sw^QS8w#RPCY$0)t?XW z2!EEj0(HETa@#gs9*u~mJNV{*rvyVXhn_s`v8DN9FR4hRM_P^?E)tbcQIai=}f6(Uz(-*X>-9|J;_wM;x2J{agWRVet|B?EzeAFlH=zgvfAt>bI*o4Y7#8yh@BE!RhInSzVFtl& z1`Sc-R{5n;O2(~H64DZv#QZ6IeV-7qKk&2Xt>+CgWgA+KF4P%fZXEyzX{X%a?{G3C&Pb$%3_?bfP zv$d6-(It!8zmUnii*svQyfwFcSF+9GxQut%S1aBw?jEi4dr{W;W#y&$>AcU#Ye+MN z%i--df+w?{1+i=w2F`8H|ETOg6+hCX(b%s`c6+GSErfR|q~35q@e$J!Ci&i9u{7O_ zKbGnAg#WGiC1p*mabJ{xuDA&7=#;?TCDA~o6$pm}3qde~9KFs@(tdL&b4gQ)RGa_i zL4KRapHICeM?RCZqMuzP+1!e@_e*-25vO{)$2y*ZzeV znfe!C_Hjsxh0QjkTruvI+}Yeqt(|{sE#98V&qQAP3ieyrZX7T+HMzo#-x$=YM zLLkc8?1OM(YTzc<>WPF$al#JXix369xy{kw`-H$KnVwroIuee#DcO#*N!*-11Rvqb zI@#vaX2{>YW5STD4(n9J8F3Mx*ja(RON~)X2HIIan6HwBmERhr9i zlPY>szrufCR50SR^9(Z6hG@Um8bWWJW2>4TgO0ntk9O!KgBzc^pw`$ys?zrPDyYu- z^(M2%x3p`Pe<{7GMPMu;rbwkO0e3cYg$=cQ;d`{#8uVI35x3;cRzsd(X59&nf8uL8 zGlkHwWoo->=`BB<&t9VfO&7;vN>%C}(x$(Eo1@5_ZmHp_>xB)rLC?kopae2Zm{W;F z3d|*3qo;G7I;~2&Ri-25oh#}+TW~aKDt6ag?GIFR7B(>xQ>>{WDiCujK0eNHRWe{k zd;cc5wXYQMY8X{dBv-)i<;@|lkD6T`Z5NP`YEH@g>>Jl^r>(gq9Fq7V=av%`Z-Q|X zdD&s~istZ0kfL_y^}g=tAx$>Q+DW+o8?{*X(E$W+z&2+7-nMV{ufe~k;?-Y=au3hB zoEe^NmS^!O@k^_{$!#b14k7Zw^X=`p`pLkg;%}i8gBbUdNti;)vycSLGl2p*i2PAc zojWfq9PZ*#b^C45uCmn0V*N)}B?)nESSb;dmr}EGS@! zerzV+J%t~X9l6Ufo9E4~)p@aD8P|!V%p4@ufhWA)eePm*O$pBP~;3EI~kJES?K?NldM zEy7!Ac?16M?yuc^e#+ueOpD>?GhQTI zIyP}TZrMZd;jDJ)EdyHc^-;{6;PTbcll7|0(R{rXx48^ue+sD-}l3U;(^Q6MBk9A!hYtNODYF_`%1*!I5(mH-=BKm#obNWf# z1ObqGk@U#kIx+ex_d4CK_!mT$bPrN%-_ogj?-1C#7wSaAnR!UiBX13~A@X)8M-rxF zoulMc$l;HDGp)uGs+|{x2`rj9dunivxC8eg(RX)4LGZVRs5C|QzPxYdsd#Y}NX^7f zv!q{)FfAgYKu5pcb^?X$``a;!wOrbEAq8-ethId=PfQHC{dIpQL@<|(VAb`0Fd4eK z$Z{%mI}y!@7`g}E-f6#Iyq3kEY`8<@^4aBTBf#*Vl95}rq*RXeK^C2-@O-fbZxCm!k@+$ z?_n!qJi)z)LLinWo?@!!wy%*%yJuJ~1-pYFnLMQVf`a=y8hm{cGxsjlyccAdOe+`d z^4w>%x@ft|D#ZdZ9fbf49JzN`Ttw~m$@Wt^EU#!RJKzNA;|3MOM$;$T2F+crKT|jv zV?FJ|LXhhV)ZJ3oeiMm+)S)%0H!|w#ZsDpXp!InJsO1pBhmtytn~z9~sf`Cor%?sL zM)9qJ=q@UKkG|IhUFA#eWztpEC|Uf@vhrhaKbE#hBTwk_UDE!jW-0$@sefEHZ z(Qn&wLZfMlQPdi~fSs_|w$+w(m46UXq7sfp)RhBLrTkMp#_r`x%n(D1hK zGqXB6OHz5)}vr@*Xt_ESS@n_3I3m{ND~+kTyM z(<0k_o5%0x3Ut+M?>zK~)#Jxk%=qhogRJOZ&6l55Dr!;k{$1a1qlavKi+KOnjeYIc zlK1s7kcCLDF+SU+1Lr6dPxLDqUw1kJBKyH?;;G5|F0R$BUTkY|Vn;NjDmp==r7&?) zpz?~P(OzoR_|<*``x$!NkRq_PIvw(JJBxP~cJjut=1afA);@Hu^$PzA>l{Bv-W`+s zcFR}iGdxi7>{&J0<`kj&WBJhd!RhNr;irsTxZSf&q>pp{fZ>7rJtU(P?6%Oq;r)EIKMGJ@uQXmr3^lv$5wRs4xM$(8EDt%lQFe;Pr3JU|PSMM0@ zu|q_%Pf0<}l|ZneKz;xGd-nv-+OEyfJ6Y%kh7L^~YbleT+(CMKehXXh>*I7szdC+0 z3!MkWNBzb|3nyzlgjAt^H*vAQ>|X}~Ge^1Bolmr>Xmid=Ba-_;(R@vDS=f>Th-3tN zZ(FaPRTct@G0lN{)HjBy@VPzY1yP?%h7v#En{B7rthpai!x=P9Sv!(FLTHH1qi>M% z-kVc_OIav^=XZWgPXm{fz_&Xo+;@Xm>i^v@;vSdD_1JsZQ|bIZZIQeQC*%d}Duz+{ zHwqEY?_EF)ySKmfgN!vhi0oL~jPV8Wg~bS;YVsyMJy{m{~O4cHi z<|7)hZ;6^(1D1Hxu&)q+LMOEbX-K*%S@>saLLA9u1e!iWY#ffryk(rj(!khpN=Kv} z8=n0ix~mBTGXfloxLNs3!H@&A$59<|ztQ9`b-1uf8JFBIR6$ zZbd5McsxbEZ%YV{Z{Q5#3BH?LtL_*i(hC+VMY^^(uqye_q>T%5x08WeeLk_4p)HZa zwEe_S8k<4bUQ*{uLftI;@AIvlOVklni(9q3shBYC(%8y5YTN3xEz9$I*Pl>M%2n43 z>hlJE@ZuD)?g$vaOJA{;@`TQ{@k9JP=y0>qdOE(NwGt^aZw9sq2a_RG~H#;`*-Tl;cSi;5-7)8mS`e?!66! zY$*7r)hH7FmFI_L5N9vD|uZ$*|jVN9|a13QF9_ z9zrX2?fVe@wG^_k8_R`V{sW!WHkTA6UmGzdNpvcSH-wKLAW$h!ohM&s+d)y>=J6+- z=Y+VueTDcKEa}dn>nmN-!7p8DU)9QZ<FgPF)R*L0XrS#8H9HPoC$w$@*_N>}(B`Ql4Or}3C2FkY5Du$#Dsiaof=ik6xYS%i zw#4V{>aFjHv83Hh|6R$LUU@ELh>Mp35UZ-XOtvCR8f=_M_yeAa*#otvl5QN6kpsy5 zahKI2wjli#)kF$H}y7mZFJwG$Qhb$bA*RKuMe ziBr5fn!X=-O8dn5xts_6i|e=Y716mCzZb=B^e_4~>UFU{+?g1-O*@xR4hf1nPZD`B zf|4fai*_kJ7}kP)Myw5mq?h~ZcD)vg&t}wZKw52_U%vTD*54iSI0?LO^lJsw92+k0 zNLBmn3D6fM5l8`-EFn$q?(4MoF;POIv?8aWHpkykO2PzaBU#jT9}uhCwX@mNPGh_& zcNVthYVjEhe>M_7`Z5alaqVGHK| zuov+j#CKR-G)*aDTPg*2aNIYFCv_F;ZsLlSRg0s)zS+10K~~fUYhCzq@*!k?LL2a+ z)Bav!EUc9HZ~MCahcun{)vSO;!D2b7kLSLl595-eAls%8em{o~9^G~cSL_NQEUFwD z^I|IQdu1Pa20|bF3>WoeJjzDJwT%=j+Ks0B3<=nIZkK*fDPhzNRD*0c>jGa1m%$St zDdbEcyd|;Yd-PZp2_`AY4v+=#7-Qteys>#i?B9_Agns?}?PdYeYy~@HqoaxIIfkK; zkHrA_wwSr`eFrwWhz~xiZSln{feE?;>5UfyyZr61&5gsb>DR~bjCd1?=(f;n zLr~F0xc9{d1t(GF(9-_4(6Nzg<1-m3Y481v{N0n5Ad&rAy4rtoB9(|}B{QM;A{67U zpW9`&>ugiXo7*~4>-+4m?qr*j=1fTVvkYQn@O|$|+<-y4N2N$o1?=*`!bNcUuaBW_ zJWwR%s7t!f>mO}3*c;K;QJ>TLcxV_cR;dZ?MklN7J&lAn^0tP{J5yDpynqYLn9O=N zDnI%{YT$MY^##Q6eFsG z3$Wh&^K{mm*Ho-%H3V3%dHt!o+oftr3+#~F-?(%;sv)cPu5vf@XhuRG7?1hI(k%EG zdahA)j~x=`A)$GrU@q@V=z#Bi_v-0+0xDP=qQ=0K?UN9QQstWi?3EUKNL<9i%I54D zi}4dW-H{Q|k+fXpDcXgPY$+fu+VQF))({N!Lh(Lxml|g)3|R;s3qsj$87mN&>G%C} z`~>~QsDZrYKoL{$y$vpl;c1lDg&ClD)aG>!eQ(|ck72?vFU=ZG{#kt-y#jtF zgg4I~wRqQX`R^@GSFzTWtUvZ}aLYG&yP9W-+SYYVzx0px+kY9bXOT;PXoik$ZeYSH zw@0%9YEeoJ=Ap+oZ)9djD=quE+HaMlCT*Qxh;bWIl{U7&y%a9E2F~N-677NnJY`OY zux=ePxtc*cJ^O&5AK=U9uK4B=T41%tvElGMRvISw5LHQjl*}tqFSt3*;3SoIEwD>L zzbU}IKF6t&To8GyAsYY5?&LZ)j+FC+kz{Sfa%uSQ)~g-bi8*ok37Z-(#IGFVhELwpA076>2_uN~H=7KPY$w}l?31|1@fPHQURCeIB5 zjuE+}Opg;zibKaG!K_0J_;j||eXUP@<-XI;`378`V}<6x{jV^VA6(y;C1ByRFoI}a10-KE~qP|{;MZ!0r% z6@x*2s1gYF3|c1NNHx|=NP^K`tL5&ZE!CD|zyiP1j39-m1&{ai!W=Y$_MB}3dr0x6cM7$?$lwU6U0+3tQH z`7K-`?;}#!@<0v0iFu}Q-FS{2lAu~ zXf^Gu%RD`RC;>DRzu&ji7cAUMN9Ks03Lv;qd_6)t?+Vy)pbGBE&VSX~<}LiC)hAP2 zQL;{XN6|8PuOs(CSjU(o?VQ|p8_c|un@^v)pN=y?Ma(L=4I%B$Y%wM`97765Fy?=) zi+*zsf*-wTpnXej*Fjt)-+Fg1BA-)J0)RsgqM{W*mGKH99BG`eFA{gXDjXvs5gRv1 zJ^EdK=im4?1azB9sn1LGhRaDmlbhF!KY(p!16>F48jrI|E1UXzNF?C5R z4)v>lFbmGF(Oc&mU`vST_Ahb$Sl@JBuu$TyCCvk9viaVF6Q-(e!Ox0!EX7Rd8}~w1 z2e4JqN0L7%uZXFnP3U`o?`XUN_0I?>Gz6WL^32xA0}vZoI8{CQ;a|#r9XzG_v_%1g z`g$)cmb!5igF7qijBGfq`9=-d(}D$)E>ObU1>MhW_AjQEALzd2pxLCbB9Y30zX3I5 zDR+YEyIb7{k~A5ra88eU{_(9)rc;ZokPryet+rD#rbEs=oWvzL2*d@*NH z=i34gxGwZRHpaqIZv;VcN)!$DRyZB@Hgl?t9^5d>F1xJ5Qi6Vr#RtK z+?ufOlYd$g6O8zIIDt4lT!&Dy zN&Q~RN%&+f79L5_5*BmCL$;OMzThg#D7%b~f~!AQ(7hGK2Pl2}JHT9i3+wH7{X(Cc z<@G$$#gHlDuXg-D5=48Wd7SP26-gq517FK14HG&DCj2{reb3MgP{5wy8?Op!XmZEpRc|GYm1iW%$MX}9D zD&(Pq(sB$!?q3>_*wFr-tGwi+IbDXX)RcI=pHUJf#0#P~Zl0nNfz2PJ=$! z*;}hQ%F_bv0~#gI&*Kzsm41u+cz(CnekeE_&X`rQpMePz>ZQkhSPzK%e;t=EK+Ih2 zyJ4Z%eqrW;JT+%0H&+~hG=1`@fuW}33d^{w_7O}(WF!R?pvBY@aNM0SB`Szv*FRpe zc>M+oFO|8QXTKu3byMs$^_TbVoZ*W4r6pX{AqP=w2SoRY8EnWPz5RKEAbq*d5J$nJ z-U?SwbIpHyB3_DPYP7+bD?#>twGTs)vE*4UY#P_IyJARBtr`Xy{K8HGy|3h2%Ta2o zed2;(mbbDqk#Xy3ApT;9un_)O?W4GKxBBsL5o7)Oz$pRPTSw53BGLO%xVF*p)H<-( zdIi$JD($!kO4u!gTdiwDxU`o^RKs*g&GJrG!`>OA(Hh4sb?0QGAvU@K;0{I|=td?W zqq=@Dy1W6-u?0V&PnWAfkAZggVvPEc0^h{LcXD3?_v>e)Q~4Be!}NtOKv)U9T)8HI z-YNrnj&`{UDZ%SgI3I^bFz2@@A&A8nMpT0{obZ9A@aNn%rMZ}EHTNbx>?@(>n)_Y(?~IIXLBb0BU*+E(kFP$+p@HK-9L0m| zOS*~&d7tE(`xhl&rCY970x?s94A0u&s)D$`?>v(~xzT(jsfzcZs}AYbuguDW$%ayD z?lq@mo7ZlwoIoL7_eBII*v|h*7{MA!Dy6VCby+llR_%Fze-x}H)Ki!IPz=vT23}M7 ze+%(;>F*Rj70Ahey68xu6)`^X3H|oII+k6fla#6#Cb;t?F$5dX0{SFbG{yGSBB-iT z59#Ra^h3IC{O#nw+hq{lm;QHBe87kQqsvA&l}`vgPFZPqkp=J6xi$d^@)#Rdh5=Qth$@hD~~e#YMC=O*nT0>Y7397huo6vaQ98U&%aC!goAWZb)aoy*52`x z%ceT+c6jEuP%S1HdQvU1qjlfE!8Cv9nW-l}f^D2{JUqj7EjKN$FJq$(?IZ;-ujCM1&ZuDxx%aH*$lT>%&IY=CchKFRA-{)n!paLz$wIEF zsvr5duzlnsp$IeaKH6(l?AfdXRLIuBw%acB!PfcfN`5rtGI)eReUExjjK*ThRSgAa6o7^{QD!Jq!15AGL8#KSADoPrzC%ZMu|hX2M$m4VJ&5vC29&2x=gQ5ZuLPT5`xUVh$M&sA776r@A#&os*0I;*)6%zb*`R(! zyF+Z_>^kj2uXT+X{&~pFX5x+5N=PK+=r|0XZ^4-PS-+6zEfYUjW5uW*FQH&nC)FmF#`hKj%=BF%tjtPDyTrhDK-k}xaw zzdxfd1Kgrl|K=CN9YwFKhOMC9ShFlfRS>m=w>nSuBwkS~7;P>Il8+m8JwE7KyMp%U zZon#8(G_%&h4yEz0)*JX1>-pb*>3vw2))<^+PY-ys6}>Z$uGMYQI9TCli+7r)oVLR3J{XTeNq z#W@R2F4^4rf0E)XT;~^fUIMh4egY*AOV?-g>&fv2XCTV%%czWnOQHm-(!DZETK?#% zxwIhArKCXyory00wJ0UQbkmg535M>}6)nP{QxN%Swciu^m~=?_4R%ytWGKrEb-Evf z1q;>$Rsnt?V(*xOU~5@Ld}q!UxCvR+X@3-e8qk{&=1Dj2yR*Ol#?d5^py^ZhvRU9^ z;M;tWqZk3D-M!aSjF+Y-w|C5p*(&1MN`L;AeG_Thep&xIBDzN=i9^?op&?=F|8wP?0V zK$RA;gHvrF-Kg=RUSt#;DZc7e z&(2}n7r2b_u6*0x3~ZkozQ2p!CQj~c!uFBDS-lwe zb_BwHnz7g>jp=0+m*iKg8xNdwuVc^-KUJ<|F4e3c#qmq-Oy%k?z9bc3x^`_x*-adm ziRDXv6UH7g2)rlHWe^$!7s9$H}(Sc*? z2dnUJL-%5EcI6cIaNd|bQ=#KUD-6;N%Xba1#n5;d<0`_~HjVLSE(Ss=FS&vY={iS< zt0?U5lLYxo+pT9#hGr`3@#5HueY;8U^*SF4UV0_`w%CM&w@>|69)NLX#b4tIeCVA9dwIxi%p)hZ5(tcg#d$l59IUmZ`E@)CT~M+`6TD!+ZyirnjQ&TX)u=B zcW+co@F7T#325k9rqI;j)Wn!X%rBM+?4U6pHh2DQ98^f%{ZxW zRJkSGO5}R3{w6E=w?y_2=CQJrAzzM1GEn?B%?h)hzh1Cf^IhDB*C~?b=h&v;M*>@p z_aX6bpYxHc)NLe>@l*w2iwhb>(I`3P8EedNMq`;($+R^Cil(unI>k&O)+EB_HsFFt z(a8I)0Li|)U!Hx0UsG-G_Mzn4)T zX0&4sOAME993&TR8XvuJBCe#&ZvMxu6>6bufdNNY;dGe2&E2B`m!e%sGsGGqvHl)x zHf|ICIZtGrxUppNrxGd3zN+#MTYRXc~_)I3JHIHnqDS zjY0<=uPjAoZe&CerRzlZGaAD(d8CSCe{VXgG5*%C# zGtm{eHTg*TH>`2ZZ*4#i*~GDo1M@G0JHx3o~61;)@y7?z20bUC%Jl0@@GlO z+xxbxs4tfL=jhSH#7wD1E)xDTj{n@ok|!{Z1pBK0Hy2Y1Qy=As|Ilx*?-tOZyVBmS za_LNu`5>gc9QZf=#!;7EKkJ)rvJaI^!$?G?Wlsz58Xpm{2I+@v^Mk>cwci#e!74?? z7rapQT1QEFZ&j*~SPs2rWvCHkd>w8$DOLAe9h}8tMm@-hA6^?UJ;cf1krCtR7B6hn zlJm+j(j64TXK}XF4>(H>ec&R-H;7%yHTHpp|A1+1afokLz93T0#AyLCQ4AZ zJLf<73{J6-Dv+bAD({NfW+B2A&yJ(QEY3kFKD6hHHR`mn+-{y}?WlU6P=362xP`F| z<%B|&j-*d9wL@Gq#}$(_nfZC1~-_G#8zbbhY(=HoJ1_K%02lI*Qu(Yc4k zMXebjT-&?0y;C>qvSRa~olXzn$S+c?e^~*IRz))b;y?&+@f( z5~6?QH++cb%2D|`t_QiaN1yc}&2nK2SjZb#sC94w-aMF6_}QN!ei4sU>MrxZlfU+O z7{k$eW$MuF+GNWIO95!TQGb%9H4?mIi9c}%sq+aArW{>ZmA0fY)G+WZ=SiNO?{^F z0b{?--XQMXtS6{=^sy?(?qSGjiE&!tUgq^ z7YUE}QU=Y3haO_xeiu=ELG9^%e|04kZN z*NBsXc;XK0+I&LSMt%2Ci;fC)8f02DukHQf_3lxwc2XZFInJ*X2*)dk$NfD6HG|?>={v9 zGmxyt^woU9SXblDBx5(?uOTGl72B!scMj{HMA6@I=^bNoUJ>Z5veV&Ty+9Jcp)E0S zMx}W&yVVS^!PF5s9#oMT9v}dC)517A!7}%@YAmXSI<9*pXfHs<{@&--uT>(+@KJbN z;d(=*`8)37IKL(g=e|Ee$W71W*C2!e{9muX+oaN%0 zhyRIYzkRcNR%W5KMm4D~kO~%`%Jj~_y(&yj?y^?Pm%3H_mSDEy#pi0}t0;4h56D_? zwCzyt!{SLL>Ry8{i*kcp->ao!net0n`x;30auW=Ry8p!XK z`~=I`c0GPV*?BLv%r1f`+IN&kovFNstD{q+Np-5lmvuotbHHup$Jw)BI4Eg_bu?0d02I3eD}iF$#2=JtD!%&QZ~1Fx ztXp3HA9p6@IChdod-CAszQ9<@q3pfarQle1)m%fi>77zgaY@-%I1r zLs}^VwWpe^GB?rQJ!J7pIN>*M*w>^Nnl-gK=HvOIv+6C|D5#e;#&pkh4o#yQQ-Kn2yq#}*C*Pkm z%;PoddppP?hp};GG5`Fj2Kl`wv=N5a0A|u={HzIapXhjCh4^tv(#XDW6F6=0pc>Og z#TGxmd9qb@6!IDeA#f*wvAg0JzzGW2Nyu;H6Pm_|>QodFEi>#i2Y@(o710Y!>hQVv z@fWzMQ;%NU)60#yQQnt_p`a%m6^+umRfs={FDQa-wY}ku%j=HYg zqd|{J?o*0rk0I;ry0-#w7p{WrBi;LVg0x*rkuJ`kT;JGU(>z81sQG^lODI-&+F-*l zk!+OxoHAPIMYJDluYIgusW;>dx84)EjO1)wUwLrgE&qEQViQpSJ9_3WNIE6Wdv`k) zj#Rawg`BFq6asL>Q#EX^l_hhH8yWo^fmKtOak8!@IVv>M67ZY|gk@#pqKY;&M!l{m z^Tvt|!;Uz)g*c`B`ijlp>ky-XSr-dWk z23?ioO$^#{<>4p#{45LQNR06nG#lF?Ya*mPY&I9_LTdd3!bv*ZY{V(ayNvN>QR86h zhtT4H#vQ%~&W7#L;549wGO^*1yDq-tPk8tRV${mJuQOpA=nyn$Pc1k!lg`M*=2GjJ z>!ti<@w}_)!M3)XQ7Aa6A;3E-yV=Y&PTgPe!~wYoJehcaASRrM1h`;*(hAFahloJU za7IEn$Ia+N$v4FDTHlx+`zcrDJ_%?gj$wYqsd>esh0B75rRwn7lF*%-Zf4_7aizbx z!OKcu`t^L=Y(Y-a5X(xYe>2;P(W+xlX>eca>yf>JuO4PGrx(UeN_MQSFB8fJJQ-xP+-4~=?eGgL zxrxPo3kMi`fq(lXNiNTzF|?0$9^)Pl8w>$pS>i3-Y2>~>=keR7VsgC!HY0G8M=>y8 zk64{t?_$H@E!rJ0G=1=!wGcx+OB71FpW%E2A4(y>Hu`Pbw?Fp^2miD&Z7?q^nmQ7q)ZFwETra_~ zz`Kk@$?)X(H1FhywE!MfPc@&i;x_$yBrxYx$HH+6c zT%JzrMdeh{b6j;6!PRUGGu5!uZU)Yz7=~dg4`E->2z9%R%=PV9+?hB;mOZIK0Tsbf z6rE&m?i1^zowrB|YSMC4oh*nCjtb#= zXzuQrd!BjvL`4?cdo%g*nwdD0$|lQ{UA0HG_xkUffKg$bMZlVyPj*KbE=ThZD1 z+w1C3Q{@VJzv=en$>}2bE6w(*x~#z;G@i_l zuXl+kvAm6mBu3o&uf}Zp;6jyxnLMHfsV9w2d%ubi}$Kv;sn@SYW2! z8qnjz784;!Y7rW$&7Sq!aZ?o(y!VWY>3mC8**tdr)z< zf>5E$J#XzJLIV!l7n^lDe;Q3~z6<_Wl$QM}sd>PgA0O~$%gRcL(SMq6WLDoIIJTKK z1X)DU{7uKPxi>JTdrY!vCoFA;Gf=K;&ANNW;Uj&mKcBQ@L<%5*DltK?0(*jf|1N>S zDk*2RDHl9c1t!EPkE_b+RTSltVXkW0LX459&9@oktvI z&f!il>M2ZP?u&Ev==+KecCDt5vrKJ$f__=)i<#OAd<-_Z4AkyiHAjF2ssvu{J46h6A{c5|uXN_{ zbcLT;rJAwvkNG^O`9x5?doVx{6XJ*uHyn}z+JJ*T>3^;B5F(JqS<;+R71VL z3psu>x-wA>@EGXU#m3s+yT0Vma}UT=jRnA&K~f#p{+)LKAM@<-{+kjI*xzowregp~ zb%?Fk@D&9)t{bqb)g{cXFs?>*t(`51R~o>ieMDl@dNJlkW$yQ`V)F{V+TzRZ$i%TV zxaF3#hVok$2I+Bx4|^YK(Tmn;Prm@ftR)G$kX7Xb*u9@lt`|D-Uax}3Q>xkbj$;^`JPNE|r6cWyCPp48I+1d#H4l#KPEm5?RR}9mx4%i= z37rV>Yh15X^WMTp-U!+ga((yw%n;oO#5Z8boyj*q1gfuKChZh_J&WJ&x#Bfe_REul zR#MVco~plR-Kf=3&Hs1-{3tLzf!FCqxOXm)sf)l-_t`65SXIx{ZEP?T;>TbQHyTGX z(ZV{GT|Iene#FSFvdz~D|NpK~9q%)!6=BY}i(qEZ_ADX2Z|=Yp{g{TEG{)FuhK8*q zrPhGd@OAY7femTn*bW?o%^t5pc~g9~(e3EKU9QS? z=VxEQ!OOz3=ukf*AaiD^f=}?cI7M}7FIt` zTs-ZTUNgPmYBqe3Qika?jiv?V%lENia4M0^E(BNFSKK%#qcQls=bWU(bYpL3_DkCe+sDzb?k6}vBS5eWn~jG z=%jrtHiN!IX*ev=qj!glmRa>LoFSBXpMzlC*arADnCc#keuGeC58KP9p}e`Tj^)hz zg@+!_Ea=?4+!0F0bWK?&G`c zCX&%nh048j-NoCeOJZ{u3EGhoJ)ez*kdr-_I;ZbGCNbo$%tnNou$j5szoXHg9M<5M z!iw*{6E3}rtZP&C>vKbz4b@Bh{%oRq9=CiKZaU*{%HI69qek{Q(cc7I@-FLpd`RFG zYgLDj(olWU#&f=v8DIGQFF0yOewfiq(?HHAdkS0hCC&DsuRZDUL^J-Ywn=Xr%e-=A+*v`|%K2|Bal5EHT9MprrL ze(E)rZFkGVQC3ZvJJ&5P&ewqq1X%WWx^E(VIy$&k10?a(!x{k7Wz8r-;61wwb_g;A zRDgbZ1pu4Mv;;(1fr5mvuX0hwjQCvy9f}&CW4J^6_IQymtvrM@$~71l5I~udxp;*8kV99550S>p+hIZ zLT9&KtUwai*aI6h&9|mb39HclmAz54uxmp z|EkGMiY$&^x11yc721=>djtWQoMif-@^>|)qFuo=e-$wh9yZB$6gC$qtE(OUHfd63 z>@)EzR)j3>mcB!vf2dbtjCS}KzJU0D*!uE#sP;eZnKAaVRVuq~s0=DvkR@%m6h-#3 zR1&hqSO=q$mRpn}iP0j-zK-2QWjAiw2SX-Pc4Hmu^EuP~-QVwdUe6!h`%kBH=A7^O zd_SM}c7po5P+8Jns|0so^XXEFmA&<`FJ4ydm-?!ojICP6eVk-nI%cN0z5diSyGB7cRDyasJ8huJHv z-!SmF8GV15SJqyp2P&|y+Xl7k)W=odv}(0AQs`1g=*rRwk4Mx#DZ6q_%If}z%&Ui2 zfw+L>^0eZj%)6N}ErJs4IL-?tjU7oFh};RNnZez1qz~sUUMxvTu>1ta8rJFS5qViw zhV70aA~goJ*O4hVSuggi3IHQW8DXR>X=%z@ip)<{r)DgR?|##2!rzV~Hg zO<_sZH*=z?FEYd%r@f&*^jwQ?;tc`xIyT}>W>Co402;L9XGXF1C)Th@PMe8@dYe$X zNk+Yd-a1gG^e5__O50HyUQb(ozG?nQ036$6Tu1vc@VhAa>Ap(KG6zQyT9OV ziYZgBUNmIpDH^ku8~*FF+m{FLy-)S13Y&fhnEbBRE_X@WAv|WcSE)@cT||mhWx7qf zR?W5A@>h$#vgOjo@datO-*9zd(-2n;>1$y_^|^04de=_esJ0l#KL|kWs_kEh5C5>k zlWJ2pL@FA0B@CYr?P49r*e4tjTseO=r2hWmt6VsEIOXXW%d_=*$nwc*i{X7+i3+QC zEUOJrFKQ>YQpURGu1{5{AGjnWI%YJodI6h|Q`qD$>eK8@t3jZnwP9s#v?JO!CL5ET zXBI?R61sNzDk?DKn-leWn$wgtF~Pr$czMdas!eaJA4~nrMK3^+0d%lqjbWd1`~P9* z*h)v8pRE`Z@6Hz?-dGkThUm*Oyl*rOW0Nxek|Ws!x@ANsPM-_XKfL-F0WH4Ic_EWE zFU#$*Fg*VNOq5;2pHaq???Pyu7A{6?ywgV=X5n*VN{M(?)ds;|dz8m(y3H*YgY(xG zI@VU{p=(O3&YDktcp1^)Um16MC|u@M`JA%Np4nX}oBd^{!@6@RnZq}OnjP+iKjMCE zq{AykBIkZGKv+?SDPPA~eT0m~FFj9tQZnL+uBh-VP~MNC1#cp{8*;J#?!j%pwX)ue zm1O#i#K0Bsfa~-mAH0B@iM%y0q1eO}bFii(g73CX6Ky6lW z;7$tGoFw?lxw3bo+!itHfSQbGy>>Wl2f|HWb}uOq6Gyno%Qp$WXjkf=sKAy#4w0%X z{Iq$K=x>g7z6u9Y)1r=qwJpkT$q-q;rDi#&iZih9?5RobNx#EQSg+k(kS(&KN=SuJ zV7l2H;GytJ&#w4UwF`aqbxQWX7|`7`%DR`h=}m2s3uM?0VclVf^&J&?%Do`r`xgO| znZx%}d}@Bh+@SFUs^rYPI_jRN-BN-N)y?BRiD#X(-hgV(Uc-yQL2=(W^Q*E0+D;)R znZ+eS53=FA&@`ouDsl?z>?0>=0=3#W1#mGN+M*g`1gibdQG{<~N(bZSCJ+Aip|=Ph zOve6RN10VoNhfacZjhBO%F=#U8HAG33q4bB3wTtKUfavE3mnFnLv3n(-_SC4qd!r6 zF)kdHpUYQ6$K6jlvUP;vLENWQlQ9#uH;R-7s0qT|BKsHJ_DMxS^;z+L*H7enP4vb6 zHx>z1GQ+<4)o+#4n4{oWqM_M3sJkg8`PGhb`X0&`E1U{j^-UN*X(C+tYAs~!;7z`s-04a)ePp~%E5w!Cg;UV5d|jqRQa?e z`&~iCF$^^QdXf3#Ed%RVp*NF`h$@@j3N!-fZsuv5mUp_l`pK0f^%QrtlZDQTqf`tb zxoXA9tuQEDkn_Fn@wj zn0Tczi(QN4?3Qi4V5eiO{X~=f1_^~TJhRC@|*#l6#Id$ZnH{J@l|21y?CCzSmihHnM#0K3e+9%(Ldj&!X(@RiJer~hl#m)1CYEpli=Mq4 zRoQ#0@`oUczw=TAaj2-W%D}=}u5z^)o?{uJZ^*ncZ^HgfGuM(?DwF%({BnpOs<512 z(f&THYnC2jpTbL-){Ln13Jsd<)`7F~=I2 z8HeEHYSZMAZp_0d<73zB!cn-aXqmkGT9<>NxjUZVXha8`_L0Yl*Eovny<-%=OQJ1< zvwef+5?#8O-Q$Bs7@y@>*<}

q*Z)CY@e=u96bD^?3jNZml}5jY%S7j>hO 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

yp=)%&nSkAt>iR-4 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πbY%2nVxfcy$YEu4mS%5 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

  • mBQ$F6IQHfj25=T0Ma=Ig>XfN~81>+QK)A~q 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

    fQqLZ;!p)yr_8|!;!|Xu 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

    |&I>{~E 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

    lN< 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 z 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 bu|XA72nh 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

    b7Xm?izY-bWex zirv`p7MlFo)_`7wsCFc@-iqpO#kB|>GP9&X!kAU~+buiL|E;!tPvo56={Q;8f8>T< zZ0U|*Q#~fT-QSmiK|7`|9qmktK2fJD^$%+K_^&v$A_(bQKv3Ou5L~h2>m0sn%k0m6 z6>E2knzt0Q$Ko`1FAGE>n!j=<>1F3fR=k3xo#Jc1g%cmR{5LfM)#rnh1^aT4lxwtN zV*l7(p#)Glyfz{vdzWefV-_=c#6Gkuc5AXCW;ErDWvG2^^T*JV5m?(f5UOpUsz94JW(7+=#o_Qx8rl4 zPZG)H=cPUE=ry9QVK;%g9>|g>zI;yMfHA9#YMA_XC-Tv(Eyq~8?LH2;hS&k4MMEbB z`um1y53NYBZhv*4RU_rk-`zhx;VVY@Mp(ytmQFOO6V@S(pgzgBH;f~@m#D~gYaWJ{qo z3GXe;2tKosnL0LNoGzXiHDQ8X-1&34UeL4cT0ny7z^bf6>|GtG90ky@`6Ltd1zI+; zviZ`K#*UAH>tdlCz$H*_-FSX|2e~HR@Li@}>dIVruP41KyCY$tuZr+Tj0}MYb}_|7 z0ELLK6yaFQ6++$t2={A(@jdwRH?d(T8t5?{atJXqx5!!D`R|rRHw?v=W$@! z1XNyeWpyEtC%y@vrLs~r9$N4^(>zN6(xiQE8?quhT%LOgrb!?+!eZ5-k=(b(k{Y|a z?ChJSDvuq+yOoIP;&ILmG3&RN@P9)T%+F`#tuFd`ew1*NM=_X2eSsRMl*ECB4A6ig zRCJJ?UI)i_uD(p1@8;)`w)ejxS&F45LGcdu<1fBTJvonwx0uU1rX*c%J7UZ&=_K$v z%>qt0>eotXe3xM;T8~!J&(pBG7qJkBdAF{|iUi=$X|7S&LL91}I!`YbPwfS*4mnBj3y?9M#J47pD7}&HpC5^IrAsZPm0={=M^FvG8^_51_oHYWfIp*Gj z-Bz|-s`lNHvnl2~d*k8$GXJ6n*E97m^@Ibot^=!De#aW8z*w4N6}GB%QC!F%o=jF5nPung4^$9JxI8VsL4)TGlEs}liONm z-fSqH&OOLX;+ybuluNCVA+Ph(gGU*)&fz%-(BQ49O8Z@fF4pyE96EAeaoD4UU>?u==@2^nl zQQq*~O!_bpocZs#A3FRvsjGKHhxCqg3xfHSP39u&Wr#hAI^TFUymUbb)?a=X6hoLO zASKYIgrZ-5bP!cO+7=@oxJ#P`YN@6AeZk4BwqIXBo6b~NkzV0P#du1 zj`c~~ZUmG2Ca@pl&v72g-xuEpqW*4bq9gTuXDM>%H;;}oGrqb4Q^0FSXCLUKkeBGQ z>7fAJmZ2d|=&??_Zo2E>vOs@lu0HwwGEWie_=s)zjXM^YUby>Vsr~JGyO0Wsj zA7i2lD|pScNgupmH!#trxUN#WJqm229LMjB<67TyC`i-movx4A1 zJA49h;r@Mxxmw;eQB1wd5R68#Nr!JgrE7Hvn#OOz$~2ZC^0Z2K&JCm0&f<*>|)r zn*}7f81B`1s4JCRHL499y)N(5ey+AE4zjsl==@XfdT*eGMv<$4&4G3wPUz#m{~J6< ztK?D3n@cD?h|XV9xS6bBEg!ycYB@!Zjt2N>!Cc zV@XKsNz+$U?gpz2x8V+Q-j~pTX93<3IFah52qPlPn1fLf#-_F3Yn~;s$3<>r*sJg@ z6smL~NQrimW9jPIEP7iD8RjPIfLW23A|I4^89SiT2Vt;eaVD3=+OkWrb&edfnIfy) zwtws3;ut|vreCWhz!ya|+*YD_cC1AD^1<|wDzQua7R|m7dVaDK7)i-7&Esen^jW#V z!d)HK{)AMgCB)w)6Zv733MlcfcOSzGYF{MeFLkKyP=Dx>=FiZ(ku@cK`(C!zMrt%FFzWAEHK3EPS znd;}yoHN-H)MK8=l@nR2Ud05MY;-A~k=38&ZI?>xrADx~w~oyBkcsufFngd%l@5AW z*I1r+hcy&3&N-dn?Netr5GpL%TslHMLZRh4m^hp(aS#>r@TLyCa6vNCAKUuQ4^NmU zY8GR*6lLfHa*pS-rOb5S0sg8S=cKzmfV!X10Kod*S1{gHyrwu1nrx;=%WysnF9(yF z9kWYpDaO$`z`PMl@@L-UfGtOL@50hizN$4jv5O;qLYiZT2w?e+S}|Tp{Quuj&gE(B z-ENuVIaq~Ttklej|Ds+8QVuuq!wW(xY<{X4*#S=H91DH;5{_ok<4RRterdW;`8)CA z;^iN0`}W{*W=4mf_dZU%yeosGng>KCB^2An%acq?;@VeHFVi%K1 z_z|15J7FYRFJ?uKX=w_4T?EVSYdpLlpJ4Mb3w}w$EG@No#P)S(bLZu_AgKN0JmLe&jgoLj)YabL@EE4i>Er+6n{6% zAFeX9OjTf}IO1BDDq4DC-**ZATYtuYBuUOemBu@skupg}50*lTP|fJlDpIDjn!{=# zoswruQqrq5)-Qkr;im{YgKoah)2;Y-9<$gd@b?QiMcXN0doDtQmXHKV@|ceSneg{t zhJzEs30=}!Kt)$nX;p`yNZnrD^Z1SWwEdrJYT{8w@a9k9YuH6P})l~%UAo1MV7%(Z8L$Oq$lBdR`#X}oeT*vUWb%FXEooJF+o-UdnAjS=bitJ>dp1^FKQT@&C0 zm_1b`BzFVdR?vknTQClSZxJP(zbA)*QN$Sh1oRmO)-umQ1(ZySb!>(7#4v2d*tCZ# z`SfRVe>?o1q*YSP2(p|s`Ru&6A8B6nP!$J;a#_hZEKa`S3ew{h@LCvv`O@1WVnNLH zSnq_0=k_{r?RUcTuyq`An`}s#Tw9??o~D56XYS?6^pP{yLs}|v64l` zQ4-eJ_3z-Ih!$Q0IL{Y2@oR}nN31%@BIxDH@mRVHj`(R9alKsA=v9>T0&0fluA^N!xrPiyX)XHEnIF%Me9WyIgGxu?D+NtVKH`FLJC5o8%ZDEj^_ zD2e%eKX;vr5xI*Y!q~MQN1eAqC5Hda4kH<}!Sge3mD6u&oYf?DCs9DOp~@aNedPsh zQB(t!i0tzSlJ6ACkxRxP z={{%m{(K)^AZd%P<+Ncot9p8O8PEoGbU&{*tDqiIaLq;b$CaX8+ECDEH@p4E?oJ_yWWL zKMXrB0a^8Qv!g-9!F3pmGN1Q(gnjP16cADQ>2Oj=tp>!~w~F<(Dpg+mj8hk_X7uA( z-uPmn3zVt)PVpLo^>-ILL10x&_;94?Z z8m~~&F_4Nr!10+e`uVjcG6vBiHQc+@%ocVV*R|?iws&r(xp)+ZuwiC|e*!c`^TP|q?6zY@`#1lp)KvuYz70&MD4R|rvzrFohV+9KlWxdf zakUGF>54tIY1H~kmI-|&_*!pOeYEL#-ZEZ)D&s9kESdyU+lA-tK{C=OX!m+ojdh#N z5%8^U8Z46I1c0H=zi8t-@(QK`+D4W0umK%{T@&4cP~dFUbKmMi|g&;KH8rKK2X7SL98k&tB1~snJNbvXXLuYRWQg>2I1?$#ymh zCk7zTz9^J5|I-k!Xb_fM&J|JHAzH(Zb9y(zvZ1880^h5VO~!v(L$7%1M%4$i!9B*@ z&r6_|^`Hn77+xN&-z0z@r$~FRRFQop%b=_eTZQvaXJ(PY&#hORF5(v>*T;_0Z;x(A zJH0gcC871*6048+^HHfvUk!7=FUtsk6R7rarVJ!MYX943Og@aqeYs1I9{paVKv@%p z!+a85ww8Tktza2%5}^dvq<&cCpcHy{FmK$!TNyeJYh`GDi*ov^ppc9v3OPDm2TkPQ zv2`w4vJ&5iePDXzP8L9z(y)5wQPt2VXIeb7{c3ne#Vl`%%(&yP9nGJ8DWt0JA~XQM zNnnf8OOh&qdW;?~iSxa}M!=rG%l;U`doLR|r*A><@!~dCHGIH-fvE!oS=_wIc>ZSY zjlCR~DCR2`7g3XhJ?cx#pyP-Aizv6K=;Dr$ z3ag(|MkLJOma~H;lSv^FSjL~xG~TMmA{O!v(wTOf-2XwnyplL2z*Yqat^@y8p{{Lp zDOgSXCTS*_Ga4$*5Q5}%W!BX7!L^$1I~imM<{^G%mNpqIw1abBYp6vSEG1&`-2win zwyNfdTvdO3v{Na7tZltd4SeBr|M%;0)yFJa4!KW?h+ys%WW{yWA)EVFsV|_?T0AFk zX{26rb;%xxPb>9@2PTwwXo8OiD5$ptHA}INShXhapq@uL2SAxp@J}`hW9|Wxoo*nqsC9bFwCY zt_^y%qNt-E2lIX#JlAkI?8(ztpWewWDG~H>L;V@b>Rth%Ne9_*zTJjfO9;slv+(ow zuQH&BLFeJGGYo^R-7Uy*$sgR94--Bjf^ak4sOWk}sJBU(p@&X(T;=_d)CdJ;(V<&# zk)Fq^_H^V28SD{N)h>^J2Mw}M@<{u(==Et!=0Ia}+b2HlGpZF-=;786$uBQ?1f%ku z2u5oRVnHu;K&**8($pm=KlZh!yj1KnbR3r3I!PwYj?I}PCHwID^@-FCk{&3bEnDfI$HbF2V-Apk9ISw z`S4z^0Bh@f;&;eYPy5c9ou0;9tiN2XSkj~eV`+8(OJcaPBs9YwVph3JF}ybwq->mG z^9(k0>qkfZ)j2mLJL*32bv(ts9%^Ye%*K2IOnWkv?c1O+3S>Iz;Q8%0S0f*m)oPjw z=`tNB0FZs@or@RdE43Rs#91#;-}v{q{kc#`0P^GG?+M09S5+*MQaQL``it8gX zDvz)6STpJ2)FR3_NyV|!Hb56bUD8G`!CU0w^l7y?cukE}v|BmrDNt-`PTJ(_@&lv% z68b*Z!Uo>anwLWckDDh)^W9f*=K>I$t>2O#k!u-9gI=Qs5f01b7jnM$E7}T=mIi`8 zCq>C8?C!)LtsN8yywwnsoTvqWa&bTA9i-h=KsU(-bEv?RX9|!QRA_784$^P-(#lFT zvmAj7@o4gWn7$ItWH0T71t;pdJYt_T5CB~L{*_XLwvga=ca0~K6V2oRigfV^?->E2 z!GjjL(@wU(jOhqHYdT&UQPo%RWtMcX!q0+=Y|~^4_~+D2_dWZKY?_a_tTw@3&3J-l z+*!RP8_S;z&L2y20iGgf+r4P@KOttn9keR4xyw^Uzw_>4WGQ~af>44&Wn!6AQG&j-v% z5txy@u)f3akPeG*Ko*k8ofau*m?F&H&&HbSw{p#wIg`cB?=eG_|FUtvMFdYgW)391 zt2y*wE-8j$T98&|8C!XN=qo3A<|KRGsrOUfMSe+*GqxOuvAr1Rl{XaJp7;q_xaj*% zk7LD;5ouBQC?j22?t)=KS^wvj_ssQ7MHXcUj)wtOWLfeH|C{^^f7`^bz3$lo2z!QFhimLFH*G0bp`K2o&_lNkv<98UI&ynav49^K`pE+~R5hIk>58fUL z}cXS?g%B$hh~iJLel5o>21Gvw-|VZRi56Gb5P%(ca$bS&UmYue|57EgKQ+3 zY#74(o!r1kJ^FLe)n4Vm0#Y*-kY93036d5L>h|de-fv3XT=kLUZ5}x>&3a>BoAe|D zoly8dim}bi%WuB2Ju+1eiU5$S-}{7|M<-5n5h!9183CjIP;ZW8@G~tpQ=XCrZ&M72``>p#$VqlyqVYO5F77pP*(_T5o zG6zX=`9z$CF&Wd}g&UpN@YR`j$!bi(4)VpL@{>7yD#>LyL&meSk1QojD4$ckn36de!nWNjX^gaF-+6FM~Je!{ur&p0Y3Wt}8&*&+|iK zGEreJ0V5@?1JWXvqwC7y-M{kxn-;4iZg{s*0mX_MjiW%r6ac~3Oa@~^PB})|z-zH!~J5n*+7*ufO+6*S>=$U1a%buI~P{I*c zj-8H`1S|%rRm*Uz482x`7mUEc#IGV8f~zVi)-LF>3jI4)u>H z)}dU|H6`E5O{Mi58XsTb)t_z~R*g|vjM)saX+k5m8nPUD0hFqkL~H|Ff?e;DZUTFB z0BIILebX&6Vzx{Eo!XZ*Wsv`fWW9LueQQ;;X`}XTLJ=F#R^pUqJlm!$Qy+i!oODAb zoSf{O>vK?E#IyWaC7X z4IG*u+|STPKOukVCcZLqZ7)4N(Vj<`{EZID5j|@{V$VghL&`{Gsi?pZhISjh_h2d>HMt8N=7c2DZNjjTG}8gPTY85UNbv$qswS+Wg#Nsx<~bYlEMcMn06@@0@070t+(402GeGV|f!?@3 zpCMyFMioLu=CE85HC?qJd~a%I@D8DDOeuwq`%`?hPP(uTSM7+4-}g+qp(aAk&5x&Q zaN^oH3*7ttggSsJhKHZ_8r9|B@YFPXI*wk!;uCd>6o+S!UslyV@+H@gP4|xry2g6 zJ^XNFb?2B+bDJoCxK&lm5(BJm1y~&u04g_97q`uZj!7TjWdPb8T>{yLSk-Km*we!m z`%ah*2B%<7QTP2f?rmXZe}qc%;dj)qw<=1uu_8MG?-!t@=moguXwVb+*Ds=0d#39i zaD$Zb;X;91E8Dk+?Aur)VL|B<*Lp7x0Etdh|?f8kzV&yIYsV1k{v zNM_kS#f<@;9NlQauUOC%-F+ z(OxjQ4`3ZG-qGUCPkVvgF}QK{Zub`3K84HWU1aoZ1NA+l;F=N=a8c6u=bp+P-*HC5 ze{=zC)5dfW*p%Pj%Fxi8LTl-EyBHBV`36hqzfn^#V`s5^b%R?y-yx|D z5H0P#)sSoc^$&oxv(COgz7E5|_3?}CO;e|2&tZ`GIqn=6ivagDARKZX95y~2O)8-^ zq3ET{L$A3+3r4)Vj1kIyTlh-oF0+oUtPg~GKhQ0>o@c<{pqkvn&7ltf5dYm&7Cn6L zVjUjgwg76nI6Qq`rTJU0MH`CI^8o5n5%FtB7D_rHD^W&W$~KDYJ*Q-Ai%AhcSvzrC zs6!67ZK|Vy+t$YP^T2rdUwKOMv412lE$>z3V5SC;#g{%0gL(P+u)~qh{F&%RPmDty zD_BC-Gz3@)?>K(C(fT`M`kwPTi(rDq-+F-_7-IajdGdyTY+ zPd9H_*=p#m_f#8e+Mnbj?C@ONO0+SAtNaFVhnO#aIk9CgDTNl`frxz z`^|++W=_|DIJ0ckmK4)s)~o31B45>)CM}!lxT3JBE^DpN%YqySbjT&+iM|1naex6_ z5HrP9hS+ul3OQp3Re?MK6EG=u!WDruBS45aTNVyO?B#ajfn;oxwQbUTuHukY}YRU!%^(vBVGTfEnLM7xL0T5?7O~?0uR^!Qs)uoAw=j1zRw0lec+U0`{m9fAReoq~%5JwtMdHq9&BJd0| zbRK`VdHZ}VKIG0Tbp6Vhm~<9vuDFXcpY$DhIYlwf={p2-8}Ho{0c|o2+Y?}BIYr2Z ziCokZHaes%92JsAVT9Qn8Y1}z(y~6@rK%MtKwRi)ivbJbjEi1xP#?1~Y4LO!uFv$H zyy#m*sY?C2(82$-YKfu>e;HXQvLF5i*P{{SikK9B#j06CcHs@Ec0RsAi_K=O!@qJ@ zJdTlH-hJE9NWC98D!RErjbr8`k4Pm~0=D=ZoWjb#Vq*@u3S zMeH)CKO=3_fc&T2IEP{%>lNi#*-0>iBOFQnxF@j zF$|Z=62ltJzd4#yS&QOg9J8{Z23(F5eS)El*Q-sq4H^x1%^L^z(o0nTn~FyBq$94}QSosJ=4w?6Am_1&cpl#K(*gtx`}z`vn#T5$_WR>}`6GA4}ZDEu~% zga%w`6n(ioJD$7PoZH(mkPLPQ+&g|*rFl{k*cVl^j9O{@XP@NfH`hR6{or6OB^EB> zMp#k03BYVxu3H~wpLKaNE;vatWW}7n&o+6<81n064-fZCj)#U~^CT<9;%nymHZjP* zg=m2%lb?oHb*jieVjOVe14OC_%$&`s#0S8DIJ-sAmXmkXn`gz|N%>yjXM<=+hA%GX zB6b3hoU{SS$s2WJm(#;wIGwi(Fps~;N4cx0c76V2dq%Tf-*lbcZ^jMKHRo2ieCn3pfAv{BPE){I42rFBuswZ+D;FULEb- z{%b$Gz1be}zs21e-mR!;y}6pXy;^R(oo38_s7ySstT|#gPmKBX5UW~ZnCM&_bp5lt zC^cs2bLrQ9BtV1GWyUaZE6NhZeqtDnLbH7B!l~PcthT_VJqVoO__0y2%2!VdcH5~d%sLtHB|89Y<5+U-Vg3O z>QOIpCHv2RCZQ9l*`o8vai6+Ok^_*W+%m!_%I;-*AVm0Hv1eY~brhIY5n((qsWES2 zN+TzBAr?fgjM?dYOOMPw&{LT;KL{C{=UL4QKJ}fc#cpc zo^LkA$MR^B*#7{UZVH$PR}}dS*fzG|Ks{S^nhA1(Bn2)9qS{oE*iG#qZhhqT$UCW4 zEBJaE6-J{j&?8@D#zQFTy=|A-LtH1{*cl?x4DdA-36PFE2)zdSw?OhcbuSg0RkVr#NaOOs=Wqm- z(``e$K2uF3aY`)RP{{@Qj21Zlch5TKzC@Xs_{iL@T?3CQFD)@OqVt17S}Qnl4$75h@2Y~0{K0xP9xN_tj8MU zT{yk+`jQyrXb;=-2N)-w*Ebg8(yr50;VL@^yn3m>*;<4K)LzWIL{NgzI#I4VM`+eq zz+lGdVa018_<$dBTzY2X;8NgCql;~W-M;g{^_>>vaKpGxfYnn2K8?%L!sxiOD{O$Hv*E*7A`VKhs>0F_X3IE)8BJs}FYJ}7#yP!U*r8>KQS!Y`Eu z6cjwFmpSYbWhlGj^G3w378J>@k|WpQ1yA+4a!xN#cjh}FiB{hKtqOEk zHYI*f{DkNLF-0`VW?N8RF9LdacF|7=;q$AoHS7|nJe?Vf3LJe$fwVXNfo4F<>3H?5 z^BK4dphOu)<0>582x9?1S5`v$-v_03_-eA$Zbq3VM*{)EpyNWcrCaoFS>cGw*mo;(99KSUr7fIOr(&#}I5&+}qhx|ptPPy31JDi3Eq~E+X^cObCYA3Es22Xpo9{-gH z{BK1D)04G86azJoco*`HFw^S0Tj8Py0by^C@qhav3)@oH?*$l^m}L3d^(M)^aYjB> z;?nq@_HTd=K|^nPG7pG5y4k#|!owWmPI7(-Ul1XwC!IFW}i^$uTmZ4b+Lm;_UCtox`_bvT}&XpfZ(vq=j}_-P7E7LwByXyY)Tl) zpOrHgsyUaeKR<m0%8enDoEyHQe@zi)OIo?dM$ZyEMX9aqf zIeSS-J`>Q_Cl|dQ#a4}2-@vLA;u86)~S<0a0*Gd*VRvpYzAO+TO~+*gFi zrD?sXS*luJ>*q^91OB^b*`pF_EDO}UrAMX!nQcWj<>0x^5x8WQHTjXM z-8(b2=M!~Cx8Hw{nW_j6JRM!=qxG=CT?ARwlKSP~cEh~`A}DRxmr@DEH|*SdaDke= z^D+e;I0zk(!=I8b zBO^;~fUrh14>tl$OtsaZgb;yFx6YN5Imw=KUp77$TI1x?7) z3I}aFyB3jfEObi%L(D}mkRIg_e%Lbqd*q-=>lj1YY>C-6zcN+j+j|P=nKMM1c>ba9S@PuaO-uMVz077_ zk_iWHzNVvTwr9x+CxW7@u&aE`_HYy}kdx9?_;qU~O4&H}gKcd|!~eP^nme`toeaa zv4Wk;><<&nw`D_mw|y%?;p`4v76~qr%%6YA7VBwHKICAk(0 z>ad=1i27PBc?#b+%Voe0o5l6GKTo0PP_DH2EE3iqwyp1FSdtFswemwbJ( ze#1&Ed;c3okFe)u+~!ze8))?Mdp03sdj-B{r}{+r`4Db^^Qf`>9BZD0^X14@?%q|# z83m$oFp=_Vr!6aWGiwc%cY2=R5e0d2zaTa*08zskNhoN?vLGV@d)fSo?E@bnx;AR~ zWo}nN!@a$#s%cP3qK=K67Q6s4A!eXx>7uC?c08p>mp-^&WN|Kcd***L)P7BP7>mw5(67`i6ZffHlv#3k(R%jt(sD{)S2g{2{d&@ zap(B;OT1sUfhR%8(K=3{>Aq!+!LWW3b`3l@=fTZM0@n8 z#J7!=V*-Y!Joh(^Lk?qRD*^~6OR9n$cvq35=8P{5H(pD{YNh>xB93fWw0fTtL|W?T zg((?Oaw=Ue@#w6#1?zB8_Y`DSTo-*DmZ;fS=_DvXS;w8WGK4*+%U|C?;vECs5f$-a zcyRv^A&qoUQPUTwraPE0gIXt!*7WU@%$ew;j~NQ22Y-);eyuzf$yy)JJw3O)f@bXc z)|w_~L4$v^UhTXhhFhpDviens?kL=LIDU$|azLKem#dQS*Id1u$=t7Kwz##S9G7^8 zHTJC;f6L6mtA1U=s8~jpwJtuyax%q$JQ-t@^bq=o6srh$lyCZw8zp-@H>iOW?Q8%sXJjNe;99V%6>=) zT8*2%MCY}h`3-Dj=y=Q%(BkLoz5PQ^W2Y2bh#1&T#X;En%l_PLq1`AA5$*Ytu(~9O z6?{tlhh~l}FGSgfc(F{qt0E^SIQnr|hSMq=Ma4zY#}SF}4e6vX&^kUL^t*)&1VtC8 zY@Y~Ij4;8wCp69PLBF%=+Nv0KXv+cUzemj*;moxbq3H|TRWI&!8W;yK|OT8Y26ca=6O(FCk60#t?S z-Ax6ju|8A0H19h+=n&>?Mfn6`|EcRHgp`F?>*<9Yh=_tpLM%JoV&ApDYR}+QB^>lu zUD$@^2mM9+oK2z!0d}s&66(#NuenJXHb!&YhI*X`{COs`w$P}j18!bFo-&VhPjekb zWIrr)OkOAt{Hx${%v+p+Ny>dtV|Vgou!<*>GIH?6H@yAkF#P#*FHW+_?3}t@0bWq2 zgL8m*K@vKF-FTz!Nfm)>nhCQOVb6wDwbU+Y2iUWmN#d3h7u9;JW{@m#4VY!@15i~t zVo)?d{L)u~lC1ul<0n7CzGdgF7X5nxdpN;zb)*lIE3_NP>X!u{#}<@ai_NlgrP~i$ zOwUM)t2UnQR;p% zvSOlCQm1Q8kHYcn(;#3CU7%~f=`I(DB9PW0*I_&|<=i)fE1fpLbqzl{X|1=ji}^{$ z^}lYrbkbR`%d;(~0z0F7DNw7buL>cg@(ENuJ=74@H+^Y}2GtGAvq`I}Z_+2B2*Q%E z)#MK6xYyL{)xk>1Pua^f_jc1dC0y-kBNUL6j0T#=6vKSj5J@|o&^RgrVm(#n917=o zDCF~#++=YIxSec>xQ%G0*Za4jfto=-|HK|SyERO{Z(sA!q&L0`Oo_TZ1Z-ruD*d*p zerWXCG_mpkJw`EXI_e`QWs--a$)@2!XpkGnV~Ip zyk=C29y?v!HRj96fLrI*Qgh<qK8kxJzJ^~dF&8pWc|jCSnGqS3qh6%2G~sB zT*myhZL#?pz`LI#^)ODwy?WuWjTDPPzDc-fkk(kb(S}|)wQ%vY)Q`4+n9|ZAf^%UQ zyuPt*&$;%#r+_XagYWReo7OHT#&x~C2;K1Sdlx%I-mBV$D$qfzR038Xt%ruK1_0*7 zKTj+kBKGw`PV(<+-fNTrkVVMz)E>&54x!UMHPuo)wqiekJ1<-9+%y@R#eLwZXkS(} zt=|=DV`PGs@hUCy01nUyO6Wg};~@{ohaW&a5PBdy)m~HJ*5Kh-v|Y$U@x2+oN4B1P z)DpLhr?u=SH&sTNlo0}&d^!d#DHKOR?U`1ShWhnk7}dIS2&k-$S3jbh*fue$4@b=k z3}k=RFkfm%^1e5riYM-}YTw836%U}_?n2k+oW2Ygz}kyi^2V9TlOIsqO_9*$C0Iuu zcBer=jQI8*Yp-*%ZN=jF6!1IcSoc#*kX`buz`Z(Hg)0V9$sE$rq^UlklLz8li=-RpBZEfQLx^^XbuIc!ZXG~1T<-MSb5UJ0zoa-U;ZMUD~DOL zAPP@RHszt#f0&x5Oi_@ya>Stvey5;PemcJgOVUCP;nG^<)6v2^D||*zf&J}2W2R{q zHtV*%x!4_T(q1LixRV~v0^@9|^=%rQ=~)2%LLhsCaWsR6sx;Uuyn}45(j^-cr zeJBE31^f9Mc9){7&xHtOhSdnKe+q()oYKD4N-cgp00QRO*u}FJBiwD4$9valV-h?Y zl0Z}2%ZG7qUPACo67MNSq+Flb>HjziV6J~o^|EJyco>T`rumO)uPhbeLcA8j-O}^n|gTQAU!>)I&{kTbO;=g^SZjQEP!8|Mzjt4Mq z+h)y;m){&KSCRV0P!^){HDeO%`uGq6P`Pjm+=$@%jS$kTR5yVltOY65C6=Tz3vT z5eMAa0Pk7i@--cbyGAfkC76^YT^)({dl5b0&IwGgzQ2<8IgjN@)5A}d?w{_mXx>EX zs0q_sa9N_Y9w=;L7E*(_RyiHO%Luvx8vvy;uYQS8A)5i=kFZt4-o>@C5gM*cEJ}k+ zU-VhF_w6LZeul3HL!S!rdDF8b(Q$|G3*zvBM25&x0C_Xg4}-*}^&vKp_|Q)<-Wfa) zdQ?n-W4w%6VI<;2b%WiwK##kkfXNFMmliDTqjK>@}j%?6@zcwu7*)_uN&L zCM9@EWMsGeTSi%DgoI2y=Y33BBOE5p2?bg*;*5Dz>$EbHk@3?` z&40$Km#^f2eb>2VF6nM*Cz_baC>>{HiY4%#Q;3)o?DN!qfm2KPf_f?DWXII7^#Peu z^d3&d)FMglA(55})e6c+&J_@IU+f-(XJVpA6uzp-2iXa2^QbSinomtTvIy z3s5OA76W$%f^zCoioQp;bJ-1$;J@KgxSTaxF@@m<8+V?uh8ORU-&su;tMK^-y!dxvS=5*(Xi z2JxV(r4n_6CY3sIwMu~i@fmP}&nI$8GYDN)Q)lpgKUk<|maRvphUtFeGoxs}#2Ksi z_4)K#?j-7lCrv87TkeR_*P5z8YzBmS#(_`1W?D6VB9CuWgXtRJnJO}|=g@3Y47Zw< z@eUIk9EosNBVcG>h$PAj>(%hAriq^x+V{T`5}++~J7xZtcH&H|h#dev$_o(y$oYf5 zKZbj)`$iqi3|x{l_|6@a=}ZD})fJGEIy?qE$vJsdz^J3+L`u&FZSi9SPT;$y`y^E@ zvl0gzYn>7MkNu^v%-5S(=P6_R>By!uJ6l(@gfWyLo=1NZc66>TPEw6mtTjxx`Wu%E+y^`C7KF^8#i$Y;E| zwXYG(H%n}MV`-R|#w4;+f$ZXB!&wavX5-XiNDFWOah1Ra->L>Xo273M4$XP`Wsd<$ zy>?0CB}$jH@J_d-gw;pcD<|sAj5OYlndkj(%#D1Xz+|buasGK5Cp*Br8|W*O7WSC+ zmxlu5sAr31oNe(@mhhJ4fWqNdLAGPrqWi#3Me00?*XREGYsYm}q|E>iRR~a~{GF9l zD6bXPKyC90l@aKDTguuhJETx=lB-nj`MrcA^Y6uS>6~g>|F=BZU125GDdiFF3Ng#q zqZP&4^m52`H-+>(F*{TyE9@sDc#RxCu7EijM|1Oc=5@8~R)#LYwq}!Ewsc~TInDly zBQ+blovf>MPCR*_@2_@Z6`mivaWX#;;v?l_M)3S%*GBlM`}HKZ}!`ihY$|F4GIj_d;`6+JgvG@8UYLG|y zZIK~&fnKBtTq@_4}*mbuCe7DGxJVW*#qH2>yO%8<+Fp$Kh*z7{!PpCSo?@|XaJMGks=aq9DYTBxyENp5v<|-an2^_ib1CZCu``9}JJ_T(quXBd z-XKR!%^~?A#;D{VZ884kmx30~Ew=3pa<-p;_yBN#?R^Htq_e>)ZY8ll**BX^w$6+NLH}!@yYs+b(EqY)&;L>iLa{&rdDh;z7khL0&zk{FY|az4&PfzT z$@(xximNK*TY92XEH(8)#T8wnJYmpKZFm(fg?Rm8pKIe=u8cp;KU$uNpHye1;mub` zWR6B8U26$Cx}-%|V?;l0cCfDH-6uil9yogO~^ zO8tInE%JvM%^m>z6w&nH5(OPOA&QRkY~{uy=vsB?IABE2WC%;9W=1%W(?^e>D0KVF{S7;pDR4ULp2nu} zDgZZ8JiAXkd{hYBR4MpSM)2YH#=8BAP>Wj;^-u}r`IdLpa^65;h)uTk5Z~ z0T8inuaNc_R#AydkPtr~Sy7Xno-yEAMRpXiZMw~^Ocu>S>Z=$(&3dO7gsu+-wrs=-@IgOtFx_fgP}cAEq?5Zob{SUbF?k%iB02 zoipEyE0zd~w-WzWAJ2!_-A;+%{hsX`>c* zE>bFSsV@+D4^~72I-Ol&xa65c@gwFIYb~Ri2BMOUD%`V9>q%t0-&&enKKqN}50&5n zR=DLf#>e1Mk9r{@AXObK7cdzb@|NklFqJP^63W5)Pb}C?qX}H(?N)6MVR)Sjt)X}I zd210ge4pXr)4|5j6q}g)ep_zat3pN4yAZb4Ov0^EPZi8f96yqP_@8suUlie2iKW)a zsoH^Gxyz?eBVzSAw5PK}abnc$an7hK=0AK94A=3W=9_m}9>Bfc&7knu$LG80x^4hD zUsv|K8VM{QMT5MbLi6g#0uSAUdhg{92L$PS(#;J5<%gi5h>M4RO1_1LyG#?ieEaSx z-RHThCO-G>Odw%)@ybH(B>VPK?sk3Q2K%=Dy1(GHx8~mu4PE{r4ml*KH9FGoA`?br zh4<`i@*^>-$54p&KkO0*%0<*3JJah&>;gL994ZBK_wLFQB*9+o>Wk=wtzGR50F8|r zTUX5M$bbX+ZQQiyy(!+HDanh(xo40Ar{XYOUg7BzVGZtTVxTg?I96)0=olpeQkXwX zByfHY)+DxPOKvj)DxNR~C*{F5x8efP+i@ZX&Bv1GQts%z0_eR7lN3=+{WcCV(ki6x z*5le5YvjrwS@o60RF+3=)4d9fkuclkgPc*U*ulmJd_{Af?E^;%(%9?m=p)Zk?JJfP zb{S9G5w{fGsOjZ=SOMO>1Xq*CQ4<`U49ynC!5;|9y_hT2g;evD@F0qgxOv54@PcVd z(tmU=2{Ky7ril~s;nCwcSTeAD~<`Ck9Nw~U75AU?o`gUgUddf1Qy z$D-sAr2VnaMY_!YVd}c$ss8@IJ8&hkSLC`z$d0nz%u9%CbdgONWs69zl`DHkWM^kY zvS+fhMON9Q?2+(0KHqzv=&y~@oIFFE#`QB6-(BP^zMK7F zqUyoZul% zsPJD|YFd@7{epwNm0{kzqj(YI+2@{ZvZ45T#rq#0q@8%kFU|)&Z?CQ1?c+L>yv_nv zMjBQwEdIgkr3A4*sth^e1cj>!3^Y`dg338P(AE@V{75#%UZpaZB%gw1&`H&)S(avK z+Bprj=67Pk@%TTzw1F_yFBNw1Pp;RE<$A4s_*4fTY}^Tb<0ywrG>(n}j3l22@gB0k zeKH}E(Ba$=IEo4&EOpJuT0Q)`kzpeuNy?L3XM;-g3Oes~_0Ya89pwqGiO(@rXy`VB z>!7hMEp^ON0rRR`m12uytad^&r#{$mqp5Nk>S7yz`B3-7jJi6-x|h8$s;WNMFBn(@ zpT-F;Ik(Ld)8SA46L3I;T!yo&!zu#uN9YS5q7IQ^ko+vMIO=)|X z?*rlRE2lo+17gM;^4~3j9)cDUq*Ns;oxm_Me@3on^Yt#JGyjfDoEh75vx7Q!pCQ*0 z(CUZj(|kd6NW$Y)w6CD5&?0FpKXc$5#x^V!vJWo@_GDAIq@2^Z81bqKm?zDQnVP<* zmNtw?3yuF((SrWGVXrL;@J$rmRuL0f8C)CU-P#=>MAg$bK@_IrsN}|SnJ^(~e08VW z6K13J?^q=4_L-cf)fdOIaAD6sUpYAjpXtb$k+Lto4;eqZxv*xhEe@uWU0wmo-TYgr zD{H9uR_gLW1H+QD;alDSgR67wx8jQ9Zc`eD2Xi_qVr<)}-y6+1-)^;K@4V=Fl3`Md zXr|3O*V6($SZ-kO6Szc9A^1Fjsas%)VsK* zYX)ScedxCIy)T=V;<4A#NNJ5vEvvRV6~O-gc|9%7gQZs;f8W^ljy0Y)h=lM~8OcA9 zS>1KV>e+NVtZ)WNxq(dNQ>lPKip8lzCNzV`oLo8^U9~?Z2aH_+!lo8nb8vg%1G-}O zz+rm;b1^1@-T5#F;+16!3?w!nQoc2NtK+x84 zI(VpNP?@h9{;fI?({opY3v@;PPAe)~9aB823uWI1c#XPety-lJ#jLPY`bdnnH3ivL zk3AyBIULgZ13*Y!TInPm=>{=99Z0D@Wu!L$;L20-8D0r;?rM{cda*kW9H@#0?iU(O zvAagYy>-tyYZY@Oj`f9Q@~@_M0zq72mq->oR+HqC5*HyCz0l6wYP57UB>;3)x%?-J zE`1P!U;mB}4lzpt{U*7tMBGI%vNBr5%R@t`CwFGQPgX^cREshVT|IAIsu z%ovelP2AnuZTWltyz*@T5hHBs8Da&{Kjx!9Lkj#1-3G6gQ3jFeomDs(jM3 z^XV;Vai7B_PG+m>LEyD3@8$pPz53Eou)D=Dq&~;Nw_BU+tPCgjbq#Fq0fR)JD)@J( zdl&jY35P@6o(Hzv!EhsQU~k5pC8HZSPui!nM>$iKCyzHQY4U5u(QPYhw`6G-{^jRN zAC)I_=Cz)37rL(xJuA5e`Hj*|+og#iUTa6YMG-oljeJ)`3yIxEj|&-G&8%*I-*W)p z%Z(r7F2TxAS>Jr9so%20(qib*XtK~@jO;-cKc@)r*5 zA~gL$YZ2=w7N_aocROufiVztj*v6vQoj z`PF*kGcuiMMDgiodsl}2*`iB+w*ss0R}Yph?#C#jH0(lUbT^`;tvEE)E1sW5`^vHb8ECu7Ek z7!@I`0jRUd z|3=FEAh8?2M7{QOcc&&~Y5Q%G7c6(~uM=Ufu0*5bdD0hQ27l1L;pC$jz-7D*{W6hu zlAuR=J*9E>#I``l-53iR!S>1ex#uC1(wm92Kj4c&U&#X`!-(@`Cm5!P^4SQ_crwNB zN6248GnFc^KM9^7F8sVLk!0-?oU*+tO}Ww>tS<~2s;e{R@zU411+DqWTsZIDvcn1e zMfS$$Jf?>lrWkTzv9kz_;Md9}pk6T{#MnrvXYM>&7_RL-_*ITjAMhi~H~F(}$^2g@ zh|QjP1B2fcbcJqbvH0 z$HyCn`~gRHG^}N?3>vgx41Thbq&;7NsnizU#i>xC- z1I|B&;;x2mcM`!JVq-hpO7vWF7FKa@EzjEzwN;Hf#c1X|?{FGr!uMvy zpxd1=I6v__kqM$=dqrAkVq1I{2L9922$?7m7NLw@Q4e|5u|i#N)bM5X+WnQLU_GyQ zf)7bDcm1?=jhBHb_))=bX=S`cjYCjfcGgqQwW$zd$vg+{DI{dZ^#)N)PfgtP9avi* zQLHhq259AIem@$<{MS2WkK_8`dp;2>ozE+1twOdnb=vdx4J3|Q18Fj{S7#MXVJw66 zbrMJxm@6VH?@5I|d(FG;1uqL6Q`E7N`a4%#KX%9Fzb>pWZ}+=5hyLB`w%R(Nkg=lQ znmX^CVZL!+E{w3M{*Z(DN^R>2R$_aGDus6lMVX%QFjMXGZpI+gfbe0N5C!IbNae3C;!Azar|3m7haOP!ckPmHbmfE-}qm>d-G~@49vSz_B<$p;Z zO*UL?j>@^cIAv%)Bn*{;;kHY2jB}r0Md-U5GIHzLYn=QTDAqI{ACRr*(KCoC_9)zRU_rltC$HQt?}b ztle%25@8*VT6g_>Nuugcen?MAT=ZP`YdHAwzVfLhOD%y8L3To$#_E0Q`~+XFvSf6& zs6N6fv2?X0SzT>*p>ne1=W#B>>KWolme%x*DUN_ZP+HBs^jLuE5#! z-OB;0T!0AkM82wN_NYg3*Y`- zrk+0X>b-WY4mQP&%T4Z=;pf|$EJG(^x)`Ipn4A(rtJrD|kSO8Q!+({rg23QfciE7< zqU$mxlS++V&KBcK4$tQlaY6C!bhGCY#qK>rW9p1O{E77HTtPEEMNeCvy|`kP*sW6O zR#Bw5u!?v0yi_p-X>4wtib)JN!n}M{%~8?A<1)Ng*LYx-3xHZK!$uFfsV|yqQfsTy z*V(}J`zH6hr7oV!zs7;Duo@Yco*Dn0?C}v)RER~jhD_zHwmFE8#mB6QR2X3l1;l_g z-+y~knnHiNKlkZx?fyabXIEMtpvT2}5#sXoY1!#Qy(%J#ev@Zc+iu>|_PL3~UO`Q& zW?uWz?ZK1IUO~Yf=gj?Gs6=BTC!xqG24cG=W=Kd=izheuk90zpy@BI^PTR$DJx+2I zzH6yc^VKe^Rs|lHcem_D6@(@H7FA3_DVOapOH_C=s+K_VY4DQq%tMXbpcR~e+wUwRdfaZi&^4q zrWKy>V*KUKYj)EU?<#767EVFs`0L1Y0WhIjrk?pi>I4)o(Ckyw$+)j;{~?(SGo20> zETNQ18p2%?0XcAv8W>M*2`GnbA zC#P*k7WfNI0H7^hi}{N2z97nVtJG9HxFE`bTn3-tA$Tsp+DmxgYZisUkymm9t9=bV z%<(L3#Ji={C**})vj{1C@)JP$Y_u-ys=ammG0)3SYc);ZYCBUQQ zNM7Iyl%g>gq-&;77Z;JF$=LZwW~pr2|OHFtlfHCA|<^}XH?WTl-+CI{_C*mIl4en-93=x?Koh;ni zG;VhUmEl`psx`gBT)L zjF$J)m3Cf;I#E@Ta%xQ{4DcHgAAh1F!sLM*D`PuVL)zc-o)e;khl{MQ_nOYo#@^O@ zO&8DtebKsf13vu!9jiF%(fa^>C-i@+(xA-5CiDTvq4GoaJ zmuMMX`_l+1q;s?Z@bQaHI^fLPzh3px_RAYIUGg1%+9+}TW5aB6V*^G0r5lUub#ICn zxe708&##hkA82MzB?{eXhW!LMAZDD{oprK~L{6OT`zWuG;>7UzmX(EUc!0)|+Ec4v z={8D{EquWv`389j3@Dl#b@Q}zzgL^E(hRX_?pOXADgRgWQ?JQ0#1h@sNE|Y|cK^U4 zAugtqZ{$^i9u$SDDEdYsJ=Z`1X64Tz8y5}G?$C)X;VH4B%(^&(30H<4aNJ ziO5Qr4}>{j-g@gB1;eB%C)LVLg7&*>_R-%Vd7{qHo1EiZ;+3pkB9A|GT511_Hf-h1 znQiSBB?I$Raz#A1ek3MgCeY>GR~h*iJKaLOJ&Th=9UXIPrpHb$zySTPz% z1F_^3VN16k@Ow=jd}1lErs%G{AFcl1VQ-J|%IDzA?;8p;suyugGxR_Q<%G2=2QFVnbw_Z;q zLHCjX%R9Egud7*Y)n$g-?nG(EG_mI&fb#^vF@Zd*mbgvanKhT;5>4;-M|GCfi_9Z@*jDDyx6(tNhIwF0X6N4ALNx;zWyU9Ed_B=N@HV$eDjf?aZg;VB@%*0f5xOjVzU4b<`-ESc0Y{M zVT=Tmw@9a^53@2vNNzF=pR-WewyJ%{+z;E{Z$A;>7!FtcA?Qz%JfW-|rkdPH8=27c z;0YvNb9?A0w=eexp!aoC^2R=+MT(IE=i0$5C_^5QVT$ptjC{)6{*)_{Cdli8mM8nF z(r*j!R1+LLCS}Gz$?!gVJLMY6*M5KB%-Bef3eNlCO~OPK^`Nmnv00%}ND)=$v#XgB z_oGUl*Z%sc>-Pt6Vf^D`U*@|%(^^b01cQ`f!g7;nYBb)Mata(gu&AU8=O^Fly0uuD z&;!>LV^sH@qU4QMxe6TL!b|@7;NO?C$uDS5_=;qW6|3BNd8h1TG~`?IX@YT;ynHI1 zZZ}zY^23iBM^kIdMhZ;wGRR^^7*}(X11uM-g2nFED0(bM2I;>t8(tgEwDpY=x_59< zjrYVpt-A+m=+gu@FbpbDItGLlh!aL1nB*GH zHf_1P59{i{8c%4nYue(#7d22;KgaiDwUYgk8pQy^>(^|a=!FE0c*-0pB5kcrUG0%u zE%ufWZ9Vc1@DJ8~sjDYhM*H29KN7=}LpoABXJfQP%NQh!-sARb*PZ6`m zZB_k-&}jmhPmJU(4Pk*>=~_CFCgUg>B#SF z-Dwh|Mikhm4@V1~WW5-jPc%&5dy0HG7ih5j*RJa6h34+b%1qHKKr;c?pH$G&mZ3Ty z2k;lW+?4!goW$BzW~$fPohU7MaMsuzCU~ho1IajZXNOO6n_eZ9Iqens8ZrE$i|HwT}Rj zpg!*eyqLyICClryxKb`oD2mzW`{B$?I-h}Is23|x z`u{5qy)G+n;i)Yz9kImOQtX6O;tRlBLnS^_U@1y`u1wC13FkrcO9&cuef!>{8j-?P zVcexwa!I;s$F?Li+=TRf&_z3Oh=eOTr&8*9d;N$Qb7S?tAYZ=%4So?6v=Z|$* zCb`gP=3zGdmhrmUu`dUXJiLq)<>yj^i>h~TXg&V2z7+bMMyN56?gO;(7^w)hm3G`6 zXoITVgG3;OAJjl+s|;_x%f8~>XMm!b4ET00XF|{hC6e+6@RAjL8lLoCiny!00v1C) zGhg&qb=6R*?u+Y3w@^BP3i06qf-B~7Mr~3sp^q3zl~MyirToj0d&133ZxHZBQA`Y$ zHrwpv&ZIo+c?Qtay88o~Rm&Ock3iY`(O3FsLY#)|P1gX^*{=+4l*`I&vC;i3F@0f| zx(f=(T2pQZeEWre{^v7MI*smpTi|EE>s$|^A1}S6HTAd9vO)hj^Vt{6XJ+e61vSBb zcI;F@?w3+!PQ$!j9ccFsw=*m@^@b6U--4h0ZzwxtF;9N~xm>|y&LsUsIyPwkb?|NW z%jtkjWLZKBF$>jBC&^Q!SpFDN6|~jo9yGYZz_aQxq6%b*Bmv!{L_bn$C{W~ygr(kV zHC)j?y1c!9bo{ZeGK7!p>F9UxqyufnfW6`q?1|$(Y_H&K+~kx z5@Q6FQI1f*_w{XhbfzoKHmv*Vs@n<5j^`->dy*GaEm9cYyad)-Th1x7fQ}R8I_M)2 zk7!`dR97|NoazUB!rZ>{{-zos{Fv>*<)ye;VbF@uG@KbthrcPTI})1{F%*< zr)@PIMY|cDML}0iys_B;jVl>Y2WXrPP)&@zw(#db`Z_#BCikX;%PgLR;B8*SFs17@iAH?d8y1WA9i`d+6bjs*9`q_Y~5g?VC6*TSMA9 z72s{e8Yp3qf_4y&HaeaccZTM^lL#2DVogZ$iRGXvsgp)@Qf!!t>kIe?5A~iM<-fgvzLeseV1n;#gDNu|s|rN>^8>+xkkxVJuK|8W zsbub%U*kD$vf2M3E!P>@(k-&YvAxtRzRx@^XUG1HTitIpR6T7@Y)VVMEt2$= zDE0g)h-vAdqP@TrQFNgj{MwBG-rGcxDjL8@=Ki#${M&P&lvtS!VkOvZD$u96{~a7! zQ_?8nUclJBo0K8+p?pbUwgJdno{rhuhBP8pO=lb!*lq6R1w?Q8>U0s~fe3@QmylnTHD60Z z(J5-%s^pDj-r~5X8V6{?J1zY1&pb3xxN2Xl?AJW$)Edoa-T3wCd{|M?emhO+=_8)z ze5pjR-~FuW<&F~~`JiuV@hn?tk%2HQR?1sLlxJ(K>jcplsUglQQTLfOi|So`zaSO& zKL(wTa@$E0&>uFgiUWJevO04@mNO$%I+ej{z|j(-akrJ%8J3U~crgGud5rM|YV1_c z&A*|LI#k~5Nv67E33eAI#TBlc5u6ybL9DRVX!WMBWJ+>~;A;Va7F!M$1BUrZok)Ii z7l8G5D@s^N9n{Aw%?#M9W9s7Vd}!KE8lt)Z9YP#<&y{JeU#=OAw98g{WC`KXqhFor z$?GMF4{_?)u~`uSf|3xIjva>hFDDOwjUEr;BmpoIr2@$0C4iQZU*U4W-5*6myDPX+ zJr4Xc_z~=_BC7J#@epQRj;l*c^HnjCxEHN*EQg!VG0B1pfY?5>s2_azqJJ&zF+hY> z@e{QrX|F`k^k%3Y`$VgRt3W*_N0#tzor+gbU~mcOl&f{X2%mM6ZMInR>7|l+NI4pM z9Z@R@*&{eUXah}Q&?C~lEoMP+g=GA)5$)iZ#w^@hAQ-2Mf*%jhkDE7+AZrVtfVK@bnF8hkDR73tsh|wQMJy1$r~V zaj@gSt$+J2KWToLKHQL2-42JLy{m55|9!eozpA#>oe<%Fg>({Xd71&(X7*qo!oCn4R@&7BEm#^UN2{v2w1-Lf*#;HJVw`v6eWg&aW52pUYp;vD!A2DEpPMh z>f_Mzv#&D;Zz^8BHUjaY)nfk4uClC zMc_3}a6*rUqHo(rPdRQeKeZ62OQL!grrF`f`stFoipRYdt=#C0QsAga<$uGFqU1G7nzZ0q$vBXagg7@>cI`S?5MRHz(nLGneZc9tXK z8QEL*N!^p%fTT%aVnLb=GjcWA{~A5!QP0Y$`1$F!%J7>`iRa8DO)KZpM3epfjBH5g z-|vJbi5z}0iV}D1#-_N4@CCgYM0Z-fg7f?uCnR=pxp*qoP27MyB4VH|EopXV020XXp;zKGwKBa|9$SuMWTig; zSkgdqijKOrSjKJd-lFnf;I^}wiJ~8TZKq*0r#4A^t$eT6a80WuXvPCC9EI#(`T$kUBIJ-|k1$+MK= zrRZ(7i~9r9P$JjSNW}0_P_)>gXewA4l?r&B|Ix?T?Y!Lkq`L82R$#>=E1a4qLAggE zE}5v_)AMsh_$STbmp|QNUaw*@MH!y8Sdlh3Az0e$s9!h!TW6sj?CRkbG1|ARN&EPy zu*Xub(+`q=E2yhl4$-$_lhvCh0L+9t(OGUgYnMLA!-qw63R*Ku!N=iSLahktXe@P~ zI-u?2s#O(&LQ{i# zs*YxGyc+fbj$nun=13AAFtv#7);QB>gB%U81f(pINAmxR3~ooSaGt8%hA%&RLsu4H zbp0~(ACeQ+l0$dxm4wW2-M|FBB2g4baAljAniHIw!sS8ovY3KeG~=GP@KH0`5&Amd zxi1ru;)RM*+El5}6RSS9TX>m&4CASMHh3gV(BmYw_X+g$*IrMf^AI%-j?ab-6R390>{yle#=nH& zjWjA?swu70l4aHFHgiRzC0fC(46dxiL?ULy;o?!TFF(8JepQ}i{)+7BPB|5GfG6gA z@6OUElkz#A-IaR11^K+umey{G@e`?h_qM@mhL=QTLF~GR2=D~bS0pKV6{6kB8XGBE zZo;)s-n@UW1<7aInuBY{|H>}A(oxe`h134_)8y@4r+5%Adqx7qIZ0 zv#O=qt%y1JHESYSERmZa%sWC5ZF3nMVPY3TcbV~I2j94DbE*tgv0-ca zk`s3)3;@{~zCk&1rltM6 zyu~FwMto#fT(u?Y#*4siC~1409AYZPnQ8h6#j*|ZcsXwwRS!IPO|jT%Md<$qRp#N- zK#Hj&K_NtWtz13po0s!HMtHs!GOkqMzb~c|yj4&O<*tv0RK`ZRDJ_vuIH9gq$Rf1I zGjjpV6psOJMRIJ(c=m>X5oHM$=ekXh92{r9(1h13X6Zg=`fr*P4OJV0Q57uoPR|})H&fhn zxkZ>0{KBP&zx<1re@Dncw8D?kPxquGwoKn;k00B=7IMD`OvtX<5PVT_Fhc)yD3~OT zr%3m~+3_~2u_c88^)0%nkyw&qgCwueL7b|LrGiy`{PyC{)1!D>riEs_UJlEe5%YiV zsb~mW3~DyXL{?Gg3tj|P=?95xYA%3DPDXNH9&YnA8t^>>6pN??#AUd+wte|8?c~ks z^0){qutz(HbIKim^HEsw(7tKx(2v++i5A=9c1aYafiNF+g19Qpo2Yq4l~((j7+2>V zV8iU+CK~weHlXy3b*T<@l^nih_9yY0F!Em!00-&ai^JF`;c)_F^?($mVI8N}u@W?> z8UM=e=L=&yClImVx!??q3{w?1^FSL`XN0gs6N4T5)n3Abjjgm!sW7`jZXonj)g|Cw z#HOL38de}P^EfEt3E2ZrR%HXVXMZm}0@x?6OrzH`y{r1B9~GFhq?oXFPR8*NJyH|A})I>cGK>2g9;9Z-zh z&zftP(|A~};3&+Awc}YilQPnAL1?WGRFW{}gV{$Ihx*l<7az+i*3lik=3d{QBvk=y zdv!HVRd})llB+};%1%l2)33X@Ffftno(vh;kq$U5lWG`+@{+?FE=8g9LKeWna~L`* zIQi`|x6IW2s$kn3y*}QUD&yRkal6UgYRGEw62-{-RLm4pAB(5F8cn3IEyIdjRbxdQ zO#7IBDZ#Us|F)ozbVFVQ7higN+ZY6V(46h+iS(?!_W^bL<}HQYqFCD>;4*mY;xZU6 zNz8i1lT6@u=t*F^T6;*%1SxVQYp|^*0+?7jtNXCy=cG^mfJRY3&<|uexrfzA4d=G$6Ggo6+%v&O* zy4xStzK`G`;$5N?i}fV4TmDw?-3UK&#^3D9=*lv&ZA;`+NF$h_e>NxicKWM&s-{yuH?dqjXbooz7OkCy0(P;pGyT`2yGQ&v4W zFy`-Mm>2E7VI}4LU?6*yC4-pSJ_HqeUefE10@p1QK{|+2!1dxA0uxO)b-hFo8dM^a zu@)9rFDW3!p3$S?>XIm*jPzx1i`m=N6TkQWl=iXsdlX~GqehPYmb$N>|0+E4)V@(S zW=uVAaOS>e`LV5veW@DO6b~;IB{H-o8cF;_IXDHG6AK#q2Hj>hLCS;Zoh3=m!%E?= zJYtlWt;XIltOb8Qx)?^VZtOq&n8NVV&7O;=k9}{Q11;$!!bO@BgJyDshc(f~|Fjmf zbr1bQO<#&V0-MIdNRSz^rQchzXBi^|;J=neyw#H%;Y7Bon+D&b^o05Z*+CmjMV@3v>H(Tcb>BhHI5U&dESG%4UzlkitAcU z!e0Z(;Qd;%BXdezWKEjiWprY52ebqW-!)x3D)`vfm>#B4!U87BR4(e#S>xDwM3YNK zeAq>JmRo+(W8*+m*+(4nY$rZi_^+_7*ic-aA*VDogl&U|fiQ+cLyNl&#gnYfJKUy( zVqP6RVr43K7h}H}Hmlt^KyHWbAH}!J35OhB)WK9J0Ubzb{ClZUUUk)x=4}5>PR;Rjs+5QUUg* zE4a_o{q8J4iOrPHYQz>B(iK7-d3db`nWO(qD%=knRO>>7uI?&22v zY<7wunU776qqCC}e89m$Y@D|Rr)#M>1#^U0<0Q>zX zixHf^*K`S)m{?y(3ay6mPe#|-9(|_}3QZrzIjVK$w8~p-Y^Qwz@?x`aHT;COzOoP0 z=Y$ku>cf$l{E!;K^57xM8oma0W-u>0PH3@y95Aohkz?sHGt<{3&c^bDjS0ST?;y|U ze5C}Ch7OHoL7zUKGV&)pi}6>Vi6GQaCX?Ku3W1B6^D6uxGAq} zbA{V=+C$=>-cCJ8zsJpFxwF@6e)ey|8Th(7H?yAkphr$K+K+4I&i_WA`yMZRojX6e z{#SjK!{xxI>}YP{%Wl($)<|^)cD5zA*?ywj6gE6nO5^$yA~&gf2Sw2(JHjcSCm`ON zb_p4-3LRNfR(7Y?bB%F-LS24;ZF8TzXRo%gKwp?(_`qbhaI*CA$$&di+~*ib#)ta> zW1pf9AzjOPmx+o`4cxZ=5hWO~OpCIYR&j2$;0=n|Y6mvzcl`&}6P{N6y1QA>8Y#;y zF|hNDnWXY^JOn9`r+UZ3kbmn7$8ZrS_ zC2vN2y_&AMtb9`9g~Y7|u8avwBrF>u=@sy~oFt~}UR-0g5j~>611{)PLLce&K;OIm zv2chE_HJoc-Tmlnuisy--8F6)ADD=?pBMN)aakCMc2hfUJ&h;yJI&t*GJ_?SM*-h* zA1pAyTlmeFywRN=Ru6&1Xz}sSlOb# z_kMUD_i7)M5i>ckf_cSoMp562b1v6~0z?k%0f5v+9O??ldE(OEx-=&8z#xTx_j?65q%zJ{87S=MA}?D}ET<@rUct0lv2 z&e&d%p&NqS)L#HIxKC#I0HkX0iV7qcyx4q3s!d)xD=k9M=Va?Ppc!vKjPb33r?rj1 zkG(HBQl)j*a}XWSvhy$e%v;R%>8M}0{pYF~u^}Ja{-n2Tr`I96$CQnUXrzt3WV<{j zi>8_3ySWQS`vp;yCwPOgvHzBzcC5RL4O?of0_X0EOOnQh?bs3H-zHVb5bsxJr1STp zPGs@%eGaN@W=m`gXUKqPQY3|l`O?M_F#6ZG$E)|Z7Bq;RNu23nDFoEUYt}Qm42&q< z`9Top&jkLss^)U?>qP?h8v|O@p%ReUDSw)-xIa158I3TF`qt0Y6XqmHauJx0Mj;2s zjrxWLm;HlwKS-XTl3Vk@pK)1dzbo!67eiG!3aANB3zvtF+fx-(>;!?*%^e9%WDxty zo$0DU(S16I=1&xi)YDLLqdO4MH9Y1Q_#*KAs*+8v&BZRi8{I&dTleP&SFXHvLz*FZ zdf<1P&n^gZ(s%Fhb91lo#IW!y&x;GFrSZHPE-<3c`v!GQy`%x#W?MfhEBhv|Yx-u~ z%=A}SMfu{i$tS{yl-!!mhB{uUG$+_hkdSQ-_o&j{RNr) z>(vtDMR#qVMm;U;V~(@uH)HBIZ*`1&Ax@NGgfKR$Rq(PVio+fhD8ad#dT!$_B(xP+ zmNw-ll{~W_`IbNS-!!}h+K1A+c2a$O8W%40JQUq+lD`ahs>t3==lD64z&MOSX?f06 zQb{?XkHj7Gr@W(VdF1~POxk~>dH3^jJ=(S42H45XeE%`62EEgh_Jk{Xm+t8^B?3n9YqQa8z5W9fm>L!>9Evvr}F7iXH>M?WJ)Jh$( z(1+M5-xtb}%dd@qnXWcgdNd9&$bV;-(72Rxb~aad2Qj=xMUsmESsZVyKUr6`Ry)cr zfX`#C?#8F<3L$ah@%w{W{@;|po;K#L?5_-f+SX|5rTs8@Ow zTL2(&1r0|S9|euhy$nhFEJ~E;*`SeX0exf8D8sw*>lV%o3(I-FdE6R;oZ+y zLPH7;b104Mui`I;&%aK;SwK zKwz{baqKjV$Bze67Rkv~AL3ku<}&A2oF}qjeu*~^I%g`|sS_sr@;nk1Cuk1G;G$|* zm&zN_TEXar=FBV!QnpRo=U|FrS8Q^uLCTI<`$$>PhiUiF)n6n{g&=p3RsGX}P zT~N0&8;gO3d#b99Ac8sh+TuFFa7oYlo7A0E9JwNXVv-PLdGii|;m&s!6FkO2m?f@) zm=Ga2XxYiIDq>Aem4Z+dQ25cc=vUik#mZFmL6vH!fA0|VwE+~Q_{EqC+EB?qiHHCD zcSY`D4FZ?fw9o}Bt{`r^2`Z5aV$iWKXMtHrPzU2?aT58DSD$}i2#)aIe?Ig7MwrIY z%Mq6D{F$VHVvl*aK@C$VN`$p00=bLlqyL@t%9K{eYvb?Uyitm;hP+=wF3h&idXgZ< zR)80{yPJ-00~IwO{PSC*pr|f|%emLNf3BT1P{qiF!eT~4N}{4Ie}udONv)^C3#MkV z?B>4TW}Lr|5|bG$pr7C=B0f%!?>72^1dkV4C4T1nf3*b|UNhDRugf3lqG*vE3iK<__oii>k;uTUu} zY2-q=T_%~gxbP@T#PNY+=7C$SNw%M%1ztpJ*ngIWTqG5TA1zne*&8>Zi}BjbdxO(37{^o8W8^3#O0;us?a_*Aav(An4D@AN%xK-|!QDj%L^ zeup1o18@6j&yD`?FUJ; z0O`D*!wo)?gOtWYxnIV)>pcfV)6O)x4~=Oc&HONIeTX?NtneQ{V;eHj(=Hb)7H1%C zyjq^@TvwA&(GNGsHCt%G>*sK<4e(f-l}qPyr$;2^mVm$h1yqDjZ&43kOC*V_x(h2S z2-G+JWKM@!Qd4&uDvuFJ&<*8nTrdz**fe^u@A5g{oo;U zbK_&<67)3$<7UX}El%nBg?kf6DUayg_6kQ|b5#RFmnjMlb6SdjrBtu`1{Lc^mDO1c z{&;!0o74;VT|FcYFwS^3D*ubQ|A*{_=~4LP<@xHweN+BkKlhzLU*r2Qf9oF`Fc&(% zYb^$nY@S^nFY)Z*ei8SNW&E3E*JGIZ&AChe95r82pk<3VPtb>v)`w8MC0&1}jR9C< zu9!6jl+nyF07!5p#nv8bcB;24COtxQ&CG&ou>)GDY3*hT1$OcoP(MGSru{s~Q{-Eh zx2Mqx%-5OEiF2K1im$scfjn&~j>7)u7~=qrv31(+e0y(=b;--Uri{~jY@A9GM|$? zOD7S=rPIa^R1*NMcyDr88Lh3?soLno0X8gsMplNYRiHvRiU{HFc=Q-zC^PSmwDX{4 zUb8G$3aXF&lQ?FqDt0D!;SweVE@FaEJUcZR{d})!GcuV4^(UdvXE4I@A%( zV7xpTT+qco(aBF;pv57rE|}r<9u`dbSvNcqiiadl@A5EB99v$clNpcUa@&hm)NGFX{hmj%)FB&oga zuD^vuud)UxsIAG%HMlhvZgwkYL!9o&&V9U1YiDlUtJc}Ui}5u$Y@L zoH*^2=U6FHdkX_De$2LsWy82g!503F!KMU;xHEO~+RuC^{2dM`q}*&(y;;r5jc{H& zR;G?3xlK$ImH6_r60>DENY~1eATl%BH-`0A-{8)q5P@uJkgXE&6)u4H1i+i-^CpR3$;QI7jnS6&ZDo7X} zLm@CBmkak$=p&jYTus}VbIGF6COgtjT(Wynmamk@4kmNj+2SWoYqJ>X>qt`vkbTQi zkPSS+{6YnqyER|p#hU~e>Gz(52~y>szWMj{nro^Js$#nLG*i4AXvC}8YIJ{Jx&=D3 zr`<+soeh~D+Uj+q8Z-dA%~Ru^5BzP*Oya{YOudv~;7#tr!owFZ(gDqV$v_w}dmq>C zo!GG^^37C8Ok7N!oKWREmP;!EVyxYN4&{M3pt9oZ;jjZYe`$V@5i`fQ_m^mT^kA1r zDDJrX{xPvP74u!?`3l$zQZ|B(L)?iRN}6_)u*5hW{3*f6w$mR{co4&x@|kHja8zn@ z73&DTtyPcBmHdzvqxKIb1wCl;+G>x69uuUrbv0SZ!zo=Wh@my}r4pVg>fW-@3^r5S zi_1hc=cJ)SAGzU5RnA=yJVrTQcgI0s1F3HvOOnL`LLG2_AcZL&%IM!NJ!Zt%1!=J7 zvr)hzBG=U;F1j;vKQQWkPDCZ zOh}X<$ifPID;^vBvUTavmm60v+Fuk;;(VR^!gbQ)V}(>z-TphPE9TM2*KaxlDXgkt zb$4Il&)M)}PFX)Kz%yL5I7@^%3~8C|^$BF+1;Yawo!1F&8Wxyw%_N9v|Hth?EH z4XqYbnUJ;?TV?o4Ub**i*w=oXghrC{Ag1=Hs(xxsGLHNz`s=5QL z$fKf)hw-W3KN}B8)Kxor3|`U>-p6`v7LD~$gt5P6=arEiWA@`iVXfn4p6qjTv>J{9 zl0n6tz_!P`^LtlM{S<4R9F{CA$~*8)KsJ5F!-Q1B7v#_i*HRK|@o75{3oIDkRUihO z&RQG-(g!j0Mc1P#XE!F$Sc^32D?IU%U7Zt8?e~FpQEWLpVq;J1m-|9Z*yK6#p+h4; z{ppeD`XYBV0NSO8rW!Fl0;@6=uP5u|O+08_?`k>riIzrv5e%-qc!mnQshh8|haA@1c!pX5H7Pv#cX5YF@Y$9sPj;Lf}lv`8y~gVw$JH{VMlBwZX`*iQiORC3kT?I?+>ym!&1B zG)dfo?gTh_OhBvSO2tx4=PhHsQS+NHYDO>rJO}RG7tq`5SzG|2+eQ@#)i4mPXG}BU*>`w8(g1+g{X)&JK~RS`Ebxf+YZ4;4)99Y=P+tt zlE;L}|4zgdCtfWB$IVkm+r&Zqw!(y6IF^j6;9#|$;j?jE;Bh}p!Nmf)V<}#_I*5j0 zNG2TP+&R*{^PHEX-wO{=w#PYyI1j&{z$WmQL@3pF;PY&<6_?yzA%5gw zOB*YWtH*(9AAI;Y&tJvvB?ix`h5~yUe^v(RevUD5VUd?6&3i2|P;5cTwO%Q0)KP|7 z<-PWOw|;p*8b;p}48kLC6F1aS->{vLd6~VccEb3S6{(`2+8P6#qaAR7vmY;qA!eA{ z?f@tV8MsC=!#X>^%l5cW?Zj2Bw+*Kyb$aQ3^@zQi<|lB6r~imWZZM2lUt-^Z!DOBg zOSzbk&dd)D6l@TKgnWSU(+#v;LaiWp!&)~x0OMij|g2`}SkMdnaQ{D?HM0cWUP45#21RD<6 z9r)vx-J#o;V}ncaFW(5LDb(o^kBOyWDadDYs}&J87=#DQ8{qRh!Oz2g{AnK-&x{^c zQ2@0>*@HBkzPXwx6c0;~a*t(FX#v+k^Ajz)`6eH2o+~NQ<%m(eqUf&>@Z=itkjk@i zoaLYBi>YD#=N0WXFVQ*3zS|-1?0#I|b)w#tcKnVwm-z9+c^?j{zB+(7#sih$ne$W< z67=DFECt4@SRN`W3bhIta_<+YFj`+-QwQ@j_iqN$Q%?L&sOqsFJh3}VCcu&6;nyk+*;G|--iDVE7FeKaL>PESJQ5AgiM)NN^3#i*9&c*rWjSz zPJ?$meTmB-W!bn7z3+;}U)3J--f`rP1K;`df=#sn5Z)>9(uJWTNUSIyuoom^0U!$= zv-(a0;Jf!ig-Lu+VSwl2u;{g*7>uki%~Qdy-Z=uYWf+fxX|ns^Zi#0sRn5qjYMqJv z?S=C{YHUpSWqd@hzw=>ofA)F0!UIrEh1u|#F%&q}K@_x0Dzes6;q9vp&9A!8LFo5` zDuC}>S8S>%=i%Eq!L1qW{d*XO`cYqsYI?JY-ifDs$q^|S)Yva?-e0P1(+H2Orz`GV z#L_1__-z$TQeB)(laH-3Tg=LS*ic;b3vLN)s_^f}ELlCQT}47MIM;T9PjW+o|H7FH zep%tF=_^|Y|A@QKJO+}XmV}dHAJ9t?eOkK|U!Yu;B$Z1F7FFu#} zM3Rp6Hy6b%Q2$AEB1vE4`F%=ttC^nH&&9Q9lpOC2-m`nfy~94M& z#VuQjuaZ@|H!BdJnOERysQ|*n$NMjDy+Kaa`M9{^kNVGD8E$IYD?fjL6Ji=07ezcd zXm{W{u(Tte2FKrk?{Kij56pu@4wVO>Vvy>)SOz(s7UK!3qxiUI{xH{zf zvwD|09;u+1jMzNa=ksQ^_NS0$qV}1CBydi{0?tx(*RnIa*rYDsMBKf$#4VS@T;pu>Qe_rrF2*8%zstNoPTrTkL_vR|x zHEnrgw5o#UmOgo~CjI?qU)?+;29myLtg9s>EUCUV@DbguA{k$Ph!Om~nlPM4UL#6X z#UsbyMX06rVZ2f6(%;_!S;Lkx)MJ1H&U_01d2%VkF8Pz7vesjKtsYfF8%wH5+VnPo zgCn~jGIeNiq%%f2NQYP&!$<-_j!CwkpjMb(!{D_3>gV7G6%-AIgko}K6!Rbj@YLr% z>(_u{)?xkl{Z`LhQ-}&yC`aAX_eQ$-!`N&ER}s*22%1VS3#pG*4LFj8e(3zhnifxX zOKIh$juDwu+JE7O9#ypFWr!4Z6nK&-$%N&adR>x2N(4{yFY!+}P z9A#aICj%nUU<6h!KXZxJ4fTN=C8?d4#$bQ z>7+5w+q1dP*zf)u5z}5{Nw+BAqZ_CYxIL;LHm?n1^9K9>JID+--vI$aL(kMZn>a0& z^W_o~vq`td(*KE}L2g-30!Rk%q2TxU+bNOj9d+e3e%}q__A~M3#ZTGeZfTRbN7V@n z@GswCkd6&IU^U+mgHyKbf@HLRhlBr4%fZcdT?uRP@z~y+S;+Dyld5~lxn4F%zx}6P zLL2khWgk~a+bmFrn{9ztoB2Uk>-#g9CMP#^BW>5HnIPoiAY%{;)h939+B5#8VEe2M zxwja20qV2LZM@p&S-uoy#$js6!%T$F!_H;Uww~ZHg)I!NJVPU`__-MvfDCi`es#b> z$7px?SP*K0qw&$i$XnY8n12n~#$C;m_Z_?ytrqmbHli>Ev5p~dEZ=)YB0vDmO2 z_;^F6j6kV%`ovtJp8&Q#GRVSAE{!}bD?9;a4c|Mg5SqRfsU{F9e|d+a{Py}KI@YrV zBN~hfpaRlNKc8g*{sD+I4ESy!-N9s{Yw63;*1_V(Q4E$({%hENj-X;8JLCLmi9aae zD&wg@UWQvZ98VUgVDoV)7-4jz=+o;NjHo9Bx5Suap6%kP^d63LwV8UMv?Pg*^PFs~ z<~ghmLJ{0OxQ>CI(t~mIThh<4Au_$$1U_--`p zV9AuJzE!=i7HiFB+G;tH3?$97E(|20_=*qjCI{h(d$R@K5xPd?bJ9%O9l2 z?x%=hTk&P{G-g%mY_>xwvp@D;{|zs&I?cHoV{sNe7MnFEak%ziB8@OJqx&wRW#cm9 zURk5b`_JEE?Je(>b}L9DG$%tA8fmkrF@Az`BFX<}lLqe0Mc!4R3zR5`wE z4I|Ld*h#R_XuyAbUJ80UyE(esJ%8@uF8J@4u!MlmtC#S!UkS59#F2ZvC-i)aDc$M_ zbP~fsC;Ky}+U@08Nyx|eXAU_jA6otTpinhaF}_fr6&txxc@%#sk*aZ_?97ArjqTm| zLM!41CGTgjQ3nCS141I{)9jxf4deT-K;(zyg0dM>110W^@M9>w!fXEQC4CUkb=OpX zwVc0dxnILxoquk-*7;lZez6_|N7iO;uHhQD+!vM2K?Mwe)qhYoH?^pnv@blmAm+y26Zl~LCI2$I1 z+CQHfc&%{yE8BT}Gw`p$bc)jnQD@?h8Gpe!h`HW!p9afn9)-E(IF6M%k^AmMN-h^Z z(iWK+KJJ4O%N}(XdGpmrF1yTP;-Ln^q}^vVsx6tTSlh{7&Z^gUYdtQCc}kM7Z95FR zsf{20!oXROjM4?K1ZCQ?MSm4OwKZrP<-^YG7Khlk^6ax_HJ2FwS+F<1;6Cp#?Lqjy zE}v@h+sCMdRKm<%H|8R^V1B6XiVy7;Q0UV8Oi=N(WhcXH%Zz5mkuUq}{)h2oTEgVO zm)X9p_rB&%w_}E>XP*IMy zHYs)0kb*Lm7R)FI4QUvbt=0;=cXoWcg$^$?v^Ddlao9QThUowHP-?*L7v6^WwF=2g z^xiVITtU@eB$J!Ji;8JS|F$Zs>Z<+`+zbD;oa=jq-Ct~iz$#pC^Ft5i6Tv1`d$)}| z|8;{pnF;d0LB7quIb2=58NIpgTD(Da9dZHyh@cNfL3fVQ-_9yUs@NHY_w;P9e?ZcewoBW`k*XMmfsP#U16vn)+&e_3Mt;O5f zo}E@k&nk0o|EU0<`K^a%8=kfj3%AJ4Juzf6beg37R*^@~EFVzisRa z;kbA*v&;Jv)%5gOcLGIJRr2^e|E-Bh_|1CWmRyGXtn&t{>*p}i<>SG1l>7NozRpF+ z^^xGQKPbzBzkD^XwP4@d$FY!fKGp4fyn0VUSY7aUShwSk^VwoXu_gYO%?&i;&O3`p zQWB;h{)+2OMlX5fxanV#h-(<$w4|aHW5dZz(J*JxnAZ6dUlrXrC9<}p^SEi4@?1YH zk?*S&@9ninX7y%S9S18WB#$t-$j{0|D5_wziWRMl9ST9cuDK{4-fYUkCH@@~65X>| zpQ1^&_k(d|ddA2yM-6Q)xA(+XA0a)>_FLB|75BliIj*{=&{NQ znaR;~_%vIqm~g&`BiWI$OT2VL&!@URbtrLQ8g=xSB@*Jj{|xpF4~rfX$n22yCX#@4 zyc?#H@|Px>V`KMvq8menueEpOPTpJPyAs@TtpA%PUo-0FZS5yljBZuz(1egG)tvQ+ z)juz~9KS$)QG38i$|dROc{IB_VQJ)Y4Yr0VWlD7kaz1)b)+-!qArU-{1t*eR=u z7OGf#2=Gu+F9W^)@ay=U6I%{kMzw2|%xmU(=QMIGz3pt^Ur75?+E^QYtx7S(ZSy%=_% ziK|40QS+(oV^c`if@L9L%8T_Hn-!s=X8$aWACFc6PD4+NbD%@0M&4hlRpPYV!L$5AeG}WWNdCpmk7t8f z{B)lJavCSF=(v4pc#njB}*&##MIUT%t@%G%dx z+B^+4u_RXo!({$g!wiW?r!O;9_Osx(u6mzBF-!IlmqmuW`-F)?Ay2vrRg2gFUvk|`sF(d~drLYm)b*Z|dt zwA$T&G|+Yi{kSxd?2(X`o0j@1`&)21cK7eNYwTT`D$%tS!7$W}qWlxYbH*@u5K&G} z?n-hQvPW{R@6>=h$UgT%bMTFnzL%kXkHc&zeqTSaBfaAs%HLU+UD)-=bLyG`&od)4 zI&Q1?Kcn3vM)^wPnX$N}&D4zBjcut_0#fV0%l{P)* zDcetJO>^{QN4<@srB1P~Z`Lv^qX&Mo=$&1%RS@yCY z%av_jPY5Dlc$cez0-t>%Bo$sH9(O6|-qd`|PuB{jVZV+lFK(;R2^RKbe|8=S+9_t36>y&t0Hi1&kJI!fi>GEw8 zoqS`Id7#0_oY6Tb2jkzOaf1#qQCZWt5h5$YP9+dMw*U6@fne|QMNp;&Qgdg>Rxe>R z3p7kNGN4i@IVW{9A17PW_lGvjnG;@GFlV4yj@=NrLDBv-JgY(rmlI99VmzE%oceBi zo(x86%r_Kn8fh9(O2Ar3Gg~p*E!H{9_~hHy`fGw+sf>eL6!-&BKtMF@n(^?@;uHn7 z&Q0!5mgk>^o}ncqilT8MBFrL96SDR_gDE~mq-~`vQHeN(S^cv#ZF~Pv;O7nVC`#Kb zWche8%lse`ykzMP?#x?@V{|hgJvQITQ|(QH`-=N z%biBH-}p?a@kQ@*jQrBIs}dlqYlF>JCGv_0@44JL2J(c8_@XT0p4pTh-YDnY+zJyb zSafp5D3e>{lXSVclHYv}4v0V)>Ivcm$=F;gPwjm)NoI2>ePd0>DtaG{&JCk|3Y#Wx zJ45s-Wn}_=COz}aOO955d7{e(1%cz6f*am7H{-i@ZMQvLlmr3em&JlcD1~mh{RT#c zHu5s*(kRpZ?qnkwDrgJ^ld|QcLWt+sU*q4%|K7a&+xA~)`k*tGqkBDQsnhCrpMi#= zw+%B$yNQcT8I2lFt-_*8wt;z zh@+red9dP(mUBg!vWOzqwM7u@88nC)#hWLHi!+xy2nl&vMUK&%Sl2(o1{XJu|3t!? zUv*fEIz+E{(aZZ<#XI>%SpaU#nD;d+#Gn2+D8f`H>lO>&1ordXHjEp3gu2PzyeX|j zxS;liC<9NOGu3UTo1SIUxGh|bB!Uaz|2hPH)+x&87bFXQfF~vEQxcXX_+Ni zVYFx2r|}JuXVrJ2!cR#>L4Q9BZal|Oz|4rAZ3&C7-ckve!mTu|(ahZ;?NbyqFVNsw z)BT-Vqco{x(WBkin6}47h?-OV!?&l+yynbLY*v6R2a~f!djrNuj=8`6)p)ixP{eas z^ny305-k}2xz(|bRo7?l2fKi25+gSk@(3I7*QD>wPb=Qsj<&$t7c_2xy4MrGjyQ#x7D-xXP%_9!`8Awv zTX)BI^=m(Y9=K)=pezD7cXV z;9cN|EK$_wo4g97yJI2@WHo+mkl%L+l!GOoKyw@l5UNOt|8r9 z6?Dp`W}A|n1r$5-4I33v5B}CRus<|9>~5ous&3Y1N0po?uZ&h_HuACe4UA~Wqh{lL zn(n<5U0Bdb)KuhHb4D(ZuHl%BQXIDDS=* z=KLJ0sfoO`KPKFc+l_AzE-)_gMl%-j}?5e{_qT}$>y&5cAgl|}r0!rihW8%@7 zeP!5Y!-?y~+&{DM@s?s}J->FA3!|`fq1WAP{W>AolYQ@=dV<+V5ZN;(dF7Esr3Qr& z>FL>DDYmA5H^-~3ih%_sivTJzWw!nyjQUNEt|fM6ddcM104ZMnRB=yjKgqBV_zl_s z)J-mQG*J^!<8?bOvCr$uoD%{lNjhF0DYAR3wF@SEYyDhw^;<#mSWq>`}# zl}-I`BI^KOD4zM2``jqD^$4HpyoKtUr*k(Oww++gWLvNSFh4^tPXPU=QyY(}(p zY^*riYrs`*cDu^@rOLcf6vu{9gM3BzfS&(=&h({kO70K|E#NkX8EG-D|7%P^)yn4n z!h{1~v;({3Y%RS^4v(I|7U9Y1c#SJ`O@Lm>t1M6VbdG5zmyiDfn6!eIsYh+v>%exW zcNeJTJNLu04EwVim-?f&N!)Z`I%Xrr@@x6WP4x;RwiEZL&t`vV*3ado$oc>b%IN=! z!c)lXy_L4_wDb112>eu9^iy&K&CP?iiESE25T#&Z$)XlE6j&vCL&W;NDl=NcHo@?B z@D6p5iHK{~!-X5Uw6l!qn8D0OjIJ19cUX)wcenby!r??I1{srY@|ZUTVP>yyQWGl^ zHMt>cS{{o`@_GOt7@A<8Xjl!JlixJuFN0Z_Z>+Bs@K7My_+g&2wo)7^i}OBU)4dRmjA@4F)9c4k6xX-@2C$h{k51*%&NHU7+6w0KHEnXU(h=E> z1^q$VtGH4b_i~wRHBhhyI^o14l5a`^5t)gikKO-=q)1-0!Y-}ns6F2eAT}ZRrL-u2 zQUpzubl(C!BP!ATfh)tYdkEYZS$n3N@Ot;!XQp0}kF7L67cIpW)g$SZRX%hhJBrjc z8^xQ|Yz0e(=!`R4#cgPgMwj|JvbjJsi82$g)$%j-`tHb>vHBcwaq9WcXiS0KfzT=e z9dA1WlTn5m(c-nSI_)?EY|B%=yD?+=8Ky_4+3Pc)yk4CYyBASzVeqr=;ZdF7e+UD3 z(^cDMLt8no5c~=ZIx&LAVxNI|bN@HiMV`{AyR&XFtXnJnWco`=Ex6b-fTR2Mq8}=7 z;rS2SG_Dtqrhv(((gBjDM0Ea1>zrdL?1X`Kt1ux^6*s zGb7OLk5G+uoTeFy%M|sG6v3!$_TlG1vlGNULsGgHS=UU9ytj87rit7ZvIP>|Ujk>G z&_4nm#91e>Im`afR)Q5~7BR@WQO&!^X?zW{1%j@4X4MxkwAEP-EPP@vOCK6DtJV+^bj8xA+jcAygY(MaS?)e9= zH7Nucrmlr(kfdCZNCs|cfYx5FbGn~IH{!ej%Hz9WK_%~zQQmyh1yC4o07;Xk%F7*J zE4Op^fgIQu^5g!Yrsl?>aLSE|oD?wfRpID{p(Tjalk+C*q)-tP0V%TwQa62%Ml4Kh zD?>?rAnW5A+t!~(F$O{^gqSkUu9!G+?kNvl$aTa2d`yfjT3Sah6&QzC;7Zgn;Q^O= zrj|(dInVsfenW+ihGxNq*O0OL!;kj(T>km6gM^d-1UA{)UwA`zOBJ#Ec3=ctqUp{W za`5Ne6nU!5ci>?bill7^op(Q0us8k^-dFi0KQMf8+7>;cTQyo9D|LSYHRred5!)>$ zUez0EH`;9!L@Ti8j{mM;%{NduK{0FKNZx;hr=UP7zphG^_fu4@4nB{c4o8zIOZEA$ z5Zjudj3S2J^+z3(6Rp1Y<>BkfLv6{xZCgpUz4#Zm8NAsyZe0q^@$T&@=@3MoQGA>X zjrGqbcME(4vtFd*ltzY7IHLv5ycw$zEoJ$%X%6tGvk`GB*S(y4+NhoyQ<#R?)$i&X z_`sg#4lFhO{eO&4xVR@l$N43-+lHo2;t{W=E#kr^B(tsI^Qn_0ZkQ?RlxvNS`l=tw z=j&$iL_YjEPs7b|7SEn#X{8jKMWmD{e^>;Ksul6k`U=!7p>xF?I2?2&r6o~ouz*l?|h z%OOhOqodlE{m#dLO7a{0ytd7o&uQ%JoUsHrWNF25AiPGWn9Eege>|tUnbxXsFd%rS zDDcZD2b=TUZuoEQEtdF(0%mSnN{Sqn>9}RDqW)l8R|&0ZCIcwZCd|%f&QOD~pZmX} zlW0>KTBoX$laM-^)Ce>Yg7!S%Mr}TN1C%-npVW5b0Kk1)c4OpspaCQH_}$3tKY)zd z3beE=ktSo$C`w2m8os!LXpMLOS0v!fTOw)eK^w-c2pnBSEbS7aYOh;?m_(Oy5#_e}tpi)Rr8gzFzc!}wJd zaWN)!Vs%a~rOf=xNKN*moi>xXYRh6{=of!^sg9ni%sAw3RS(PxQlj-u|tJ|S_jcV@%p%XwYgy4RZC6r4J! z9ZB!tTFP&C2BbC2m_34??4O{nN!ZkOXj}h?z-JAPo;+)Wrwj{ZD8#=g7h0E5z+{cI ze*+a7;3dF+)7s9KpKuasLi3B@Vo25tTlJ-xj;2qmcenR*Ow6wLvLaMmW=$($g6NH* zXBO_IecwqMv#4})?Yr@*%f&afq(t=^E4YNk_4<5WIA$$co0fUW;AYIK`cGUsC)er7 ze&x;N#cMhel$}>$)9NrkbKN=gM!km(>*sQpL20Q!i)xc#KZuca*~1 zlkMNBIb+VGZsGl%n=L>z$IVXRb8`HWb{wxaX1KvXhcET-2WjE2x6Ue_g7<$Gd(4T3x}!m?t4B=9+z%8eB37Ex7B-5?UfDm+LLcH50BW?cwzkXF@Gtk7_{nk=pm!NQ(WbbW8<&yJjYLx>j0$5RLB7RI|B9(mX%Ch%+ zCfQ|19&%wdcVySf1$*b2iO8)jmj z3lYT|pQfBu2FiSy9j~Zj({D|x(&axdzMU;9XHWY>pA*+S+R&_CN~Ls@6Na%@-$~|E z?5O$BK~5z&x9+i>$=hJOU3eVs%e5h_Tr(tmI~$E<9Q3xhdOw**CB1dOV+DmN9Js_I z%!L(6B*`RURt%Ta{t|wS@DCbIaAh5Lj(uJa0=2J?QV%64KU|=dNUc~MbcbD%I*@f| zm_9%$J#D!lb@LTS+QVzH+@@U7ERb8<#(*Ga?!6pzq&(bYX$qClRfayoewDnTC3T=s zQMNge=wq}I9W^22$>Be!Yk4RrGKNX3Wwq_xiY0X|^r{bYSHbE{1d-l3XEi<1P-Mm( zHCOG(S3a3|uaY482Ky~lA*o*pYrOC#-p_WJ8|LFP$m|rfhO6XyQT#eYIug`;izGF| zX^V{1PdRD{EyM~`_Al=j&nNhGM~yl&5CS26FfBxfC!6jz(!sB&u>6>-bID4gPbzgI zi!-bBaMlg~H>_6a$3lVgIA$1@RQ{hbC#E4{SmtRf3^pBte4U|5x4;-<`jVH@SV_~7 zGw)Ghv|{!%dM{lgoXIDNYlLGo4lUKfuQ3z%NwG6LJTbAMx=b0G*W*5IVQ?}@WhkQw zaXNTjZ$3G{xSO!X=Z$^`%LDrauOG67^ja1V-*KLszzfrfr~*8Gxi<46SF(9Kg3qK8 zSwBRdI6w~TjGIE$?}u@-DLa{s{E4~HACVqg;nq-I05gzI-PnqZ5;Kp+v3=ju9lM3E zark7mF|_$WZ&YWP-eTenjwCKsqwk-2T@sWzxS5iBVv6r zfAWNgN~=cLrou$0R#vbh{ZW~swG8(6VI_J_Od;w^xK(u-Hr#&^LP{Oj*RY`sA=UW< z1}fF8+x=29K1e#~l;F!XY+!-$km)RFM2|Oq(EX7|NjNSZ3ih@T3;*Zg$_nJyp%P2S zyC{y$WbLqWZpnqanb!Ef4&Amx40Ww&^@*CKwhP5{t&|o7XTTRU-%?G^gvBgo|G~S^ z^kc<8;z(7GmIzr$JV*adrY|0ou$F=dz#=$2%*HX1xo>ZDRGm}A0MLV74_80@4=jwu zW|AsZa=4COkWCZ}H+il^xg$SE$ku_<^w4%8{Ijh8hSvM8FQjh>L{f$o{%qA$b3NNpx(B;V?CAZowW@?vr9le!V%Vpa-#(XKMy zZ_=KrT-ufmgLY#@ux#k~ZvB%WU%-!165I z?fb3GUVN#^ggjO*H1r{Mvq%e;rWo<0}Y zA&^^38Dm9ARRJiaR;l0)e_{RCNfw*T1J60vEj-k{_HswNSEI_YgYDMzCZ;%)z*p9| z`NZ{QD&0`m@`Gi#;(}E|Fz7zhBwg^fsfdjMl}E$e4@*2>C?>QPO8Q2*kZNZ>6gi>y zrtfZIcIZ0-Om2aGp+q-S$h3|k?IBT=6be9tqEb9Mqt=K3m-5|!`J-YFQanOZ7)Lb} z&%nU0cd98_`YG4>#Hc0hl)M7NzDi&o>6^(zZXIRRvQVFV>ISzCbNqg-r1X_hbl*YK zZ+so(yAoeA9-cK>QLeSO_;XF~?t_gi6Bh0pCJZZk(eW%(UOXZ&ziZUM^|e0w!|`Z| z7AcICB?G&d9&L-g*zSB&*Wh%PuD@ojTxb!k0q7C_R{A(INvgdzfHw4`o;{S_j(i0Y!dxy6N^s)y8CsB8Rt4nsNF zg`HDtCL)BGATI}E@FS&zT%Q#}_8{@9y|UoDSfbKEr@{aYu8B0ZJwkzQgBt8?Y;Fz+ zjP2$$Voar!NDxE~x;nl!zbG^|;F3sGY6uBeO@B*GBn}~a$we#zcOwi<*L9_J12ZQC zGk3+nWMT^!g>5Hk%Oi5KmFi^1C=WTrUX$7oaLdrKS{wBg{rX0g;G{s%C{pZ38%n8{ zL_0xT%dKaJge(o@Y ziI9d)>nMEC3qLsDp@TjIL~NM?*NPcz0(o1=H$+UP+AQ7jGOw8?G&!Og? zx*BfH4f%?vSWU+igW(qrdG-5S>Le;XEMBEjq$?*-sMTfTYJWh1C`=>SiYw^IF2q`} z#6nN#%Kj-sUPqZKgbYuNoRbTf-U#GY(UtNA^UKk}*jt6kio6e|P6wubk8B%Mi~30e z5$`XpvPr^P({q^%Flmfvw#Ubwq>LoPCG9Ea_LvNV!@zr0k-MQ5 zJ;TWszEvSTP8P^NB6Kb!0=sCc`?eDSZR?m?3y~nG$Lz8%_&f=vi}ogpW$x@CDC5}F z@IESoM;5Fb1pS}*FUj6e{-&~%Y{1Ih`P>#OSIo?`c}KDfN*6M>&?`%$fk}(u)_N%f zo=C|ziPSe3Lx0J%&W80VH&l#`*?d#&R&mPLH<5L21Z)`v?gyVkreN!P?H4CzZOM$VrE;?2Z5MWx;Trh!#|4RlzvRNF$S>@-OE)us799d{$N+Jyglph(YkEa0 z8h_b(X8UH41XlWxTjj~`nWa^*cbUmZo@PpmvbAbt}@Orp0hW&4Za2jnvAj^5|aQ(3P1bkf767h|Ia^aEA-7~;ju z3mbM|4wwVS&s)5elqI_gL}((B89x&6$uIBOGHUQ#7mhs{Ym7+UIuW+JQ@?;y#(ywP zft=_wB&VTJ+~HJsEZOO@_bTBHK*9pOHl{~l6b@h%t11gsu<}w82O_stCVB6$;MqF_ zUkD+>#b6=ccdXLt`#!|tFJKY3VO`kx0S0g%Pw+YJ9k2-w!L~16bI#z`@-;R0?JdWeR%sp{C%Lt&B7TLeU@zpoywso_ z9~#c@o5oGAaiwmJwY#JW^k!Q~3)i1OzY^L=UAD&}+4sTcZS#Z6w*vy{^Y zYzevC4Menr?gK6je$9;Pxu5nCU&5xvvKAJW^2@aV_e= zY77fJ0@~za^0GD6fTYG}TT_{5GfS|8EjP1T-f!41SGz`JI{B0sdnpyHC` zy_>pkr~l|D&Ws+Q8L?ClGBv!05tqrSLzaI`??Ll$(yb&6G#AC$f@&u5p6}fK!M$q~ zYKos)=sOc;uSblIX=S0RoGD5Gk;sJ5x|cO`{X?>35@&atTOFMG;t`LScciJQUySv< zqfe69HmJ&MjTw7r{iYMn?JtCXXl>G=7aC$paLRmM_l#*>>)&RuVOiM7yxj~?XGt~W z(l(Y)U?eFuOsQ)QNQDBd}IS1m5dK(&zX0VZUj4#HGwEQJ;9k|9yQSrJelDV;6GyxZEfC zsW3tkp!h)v-hJ2v9nQgDDcqPtEelb`Q+8Y1pxwklgcT>0Y^_y!6$TZXT1+7O> z7~_?a8I9V3A7fp|4~V{w{ManFn)2mxz&|>nixJDjBs=?aQG`6P(_0F#33f!&xLz~2 z26KjGLb$hN{oMv{wjd}bUV<7yQRbph;v5^h#k*RA#K^U-E4m9{iI@rr6$P+!3$OW= z70YP`=$n2<@a13VPyV(*g(w})8nvD#gkOtV(88P)#N+4iFYS4Bbj=a(?YgBG=&trr z;Q>McW`-9gNun^hG?;RaeLFg}4(4!!Bl-KpexU-0ERCKrgeB12o$G8P2IC|=m}}#p z53=x&pL%i?-*hTSb}hO0ml74ZBEm?klX`>kuD-+zrryyDQ zyOkN|K(0>_5D7gdvhZ-1NX3XRTaNq85@C93vsew}REi99)(TxuOVGdfmR7<_Z~dlF zVz)V6{rP^uymw;7ObeS_xBC~`-{3+#BJ^J8ZovJR(ic`LY7RfXMVVm7_um(R`sRm-L}__WL8}O#)D7n)tjg<+JYN| zFK3kPv9I3{aE%e0Vodj?H> zGTnV-44uamoZJrqbjP?!Og-(WOyZ-$GcgN;nnojsIk+V4&6*<4$zW?c#4W5)79<}9 zN84+>$;6oR%x5ebM^m|a(h9ogwE%pTejZziIHJh)@ykNy^k|PgXdGZ=irgxE63$8# z5dPx_laJte&6$9=&D$pc=_x(PY+dNYqXEFV$I+$7;)ZA#=(g-s)5m~dUr!ORrwR%^ z$C7%|YT6XSpi{jxvjHnlQ9Ea*nVM_0zYLJq=Y*9(PtBNQ z4aqq-oMWPU8Q{ouJlJp6QOK}nDr+|~6*)HW`KD!{U`3MH|++}2W3xg9=D zWGA&E12M_i{*G?sWN=jU`nT1>YQ?vu%ml(h!rlYExF&L*Wz0ke!hImLRxZ6<3tPUW zFNH5JF{;_>6L%uW$UBu47<>%wDBe^`@KIj4iIAH*Tm2Pd0b=`}n@3DS5eKY)bo5(J zm0Rl%B>_{vw4olz1xKeZU)ma|F=mR2H!x^h`MGl-N-VMQD(yuQBh!cjliy5`F}%y{ z`?J&c&uEU2e}zzP0kglC-xeE4zE!9h$M*hjyWq6M_iN=Z9x>{e;D?q1`TR+7MlC`-gQbhQhE0@3j*IYbLO zF9A#_CzjFZYj@xjp{E7Wfjt*O+nRPDrK$q_4!zQGl4qYm$CbRVt zd$CqpnqMa}3l-qZWmj?U#Fg3*6S_`NgLNBevh5*Y^LI~XJ#=DPb7WM~h()rkyBs?9 z$rrVyKIn zkNw3N#JBd)i;HK}=W;xiB-ZOeT* z|DdL^fmD)!fFWDS48+WOm35o%XY(#6eNXFTh81&c>gLg^Nue*#2%rJ?-hbquZ?1pd zA70h-6MGThm}1ONbY*Tfjz2~ilg!*?J-Tqh{5{6qcXM{QhgbIy{N@j}?NJWqS$0xx{@%?p*yrMo1Uc4{A&&hV> z7B5^a6og@0DB1IjT1UI1xNv!j+#iodXNhA?^Ic$GwzzD0#CtoH^4-7B--Ny&CWF6e zeJHo4x1h(H+QfXcYBoZ%RnB|vL+jzO<%V}}S|FqCFhHU}wQ+tEfz2zX3W=H4x!VE( zmYDpe+OPj2>RlC+tM3mD~6eTD<^hGkROtG(Y7Fvpu}+ zfoAA4A?$Gqts}Fh(7lx5+%bw__aa{&Jzr*(FjlWJZanL=WCP;+7V|MuxX$lu`{xq{ zb0BUY*zvKW8M^1-^6=pk7p3Qa!}Dx7$ zLg%25w6(c#nu97JQ_2%N!;l()slz~1#9zN9LOa#F1?|E6o(4~vg`a>lTivqM$bu96 zVA^rwrVMV{cXxF|F!I~K_b=#Gq{Oyj^gORJ>qz5pL&Rr$nEU(Gn1Xdsi$<6Pe1Zdf!nKo^#-IN;LG8VU-@FxlQch10QOu1>s66#2 z)%dd)|BtNyjB2X;zCht51PDzCK>?B8kxoSE0YdMBf^-mRB2APo2|a*Pr8nv7qo5#2 z4~j}rx`HBAkfQY7-yQt@?|a9%WB7p&p6s^vT5Ha^);W&>rEHgRzT*j*u^dA`@Y)V;(l27mIs!a%db zAqu7r#A25s^*L%YUCq9Ia?Hby*s*RVR+F4^4ENL=?3Pyrd6$MAembS=ZPkyiFzFb(ry!_(A z{klTVUz({*UhDDYLf1sqyexmupQbB(_&y}yW7GW0Dm{fl;7nIv42!vn(U$FgP0}-W zB~sEHC*Y@s8iLBdvl#CBMg9$XkR3OOQY$J#{z7YMiw0`6_iTR6iA?g2wk-Zh$De?S zIlrRH?ISny*_2H`08QX21g}K8B{{W4^HO|~dT-{o3Ex)@+fc+$H#6ibtJ6u`6D(O( z)4D=hM6byT+STZ_4ZYI3#SF^~lyizyL)Q2QDv30~y zF00>VAF*lMwB-!%CW4ptr-Z$TTA_SSQck2DJG%iJQ0bDI1a|UvTH}+$*_D?Td_0`A zx0c~Os$*`(Ed65JDe_M)9(TVyhb>G{9}^bjJ=_OZD=EPOKqjD>l&6>6h2L48N%3>` zYl(m0E&ls3w(XcAe=Gt`7k_OS5UIc{!;yz5lGQN-Q$K zb)#gJAjXl%*(nLT(^h)%o^V+2)Rt?P9?yA3haWXLyxh7Qw7i4E596hL?_Yh=6v4^~ z{ggaCbas7j=H+DZU*EcQ%=8$OIcEu1Pv({1xm1(o=8RtpE97VnT+44+mifMC*7dd5<7Ud(pMB5hHShXio?L& zydi4nqFG)=by`%#89Bd!?`Fro2Vkg8D@+tWboNs zHO$S+n|521hWGiZR06N8%h;eZ%rltz7X?$lbl~1E1OnmoMv3X zRcBB&X%$GrogKB$_?CWb!=B6h?>xbc>Ai3{=ixf|kjFyI*r{f5<%5?-=Hn(zLUQG|Poa2uI0*dNxU3zxs=Oed^{l^TTa@b-`NUK*=kd z0ksWJ9g)RoE!DpT#sHiNbw-hxzBGqj?i||{6LBfv-70QLesGFtgBz-ZbOd`HF6)xr)J7xuArz8QL){`zH6ckp*JVJS;^|^&dq09{uYK zbzo!lMdgzG*H*h0ZQd}YHYsdI_tenYnxC~xAHK2z<%K=cu9=t@%?A_<0P;-z)mULi zPG9ma(6mid9*FN}M&Z=H7kP4fnA9<3u6hJrp|gl>lVQ~dpHW0aUp=;rwrhfva#Ou3 zAYE=I{-$*951l=dLL`iak*Z)wEU8ki@F9+ zgr+{wh+kh|*Lf9JP#iwzmhuB^3gBri9ud%4SS z?wygT_j-4Ej;#joX8HRIG~hN|nYu@N%6q4K?C<)8tG%}B*gII6V`s{BW;J9{(?$s0 zuc2Zw%zVfsu=8?e`I`}tJJ#hjHF!U|J&L-b=)kRScSJ(_Z(SXvX(xmZCBxj6x>_jZ z#GbSb{iq&h(Ki;-w-?;?j?>!K#4``8w-h~$aCyB3b>v@%2bF|WRoZH^-)&HIHH%v(jx2mH93v1$uTh7py7HeLy!oE689gOrYKz2P4FMG2x%G( z=5n8iTJwCWV%@tLbNy&EV2-cf(4H?e@vfG1_8q>c!1s`lDz@4EuQuM`2V$XRN|MCm zcTTlVVL#E(ytltfYlb=8C&*LMf4tw)4|e@p$M^7Feeb*0PxYLvUu07hlU-FMqhg^( z$C`0s4!+FY$=aLJyKDsN2%|REDMC#Khx;)3qx9vNKUtf7&%ETO*T)&3UT95f+TDwE zX4Bdyw`od#oilwCCO|KRxdl&Z*UNOt#VrdtzAbJk+-K|I_w8=F|d~IYBb2k$m~?sO5=jZk5*hx9=ucr=EXjeZu$3nhs+3qI8U@ zX*(}<=xOZT#yOe(C)XxY+M}A2%|xM|Sj|S8yH#KKVe-deipV~hj6yf`Es4?({KTtG zb79riox8cXmJh^%@m*sDiK-g3vSNYG8DIvbuP)Sy5gB*pHJv7v$nQ*q<2YaE;hG;K zT-^@?vxk$upK10CLD`o}~qlqx{>AtYErOq?!#SG3k#55pW{?Bp(D2O%g>K3T=qM8j5w=1%uaJsnW>?Ge zocX;@G1o)&Ol4^f14Qssw>yakjZdAYD$fmfZ5=_<1Jd95QNnr#5UWmIFba$5>iN!# zRZKZBz1ai;75$qHn4aF$)Si9-Fal8@6VFB*za&dCey8(o;QBd;YthH4o8xLh_PAqz zve$0#krSj5=7g04Emd?}h8eUCI-P?qeXq-a`tz1j!o`qLxG26YmbNJ|P`N+e5@r!M zoB8_{w*mAsm(a}s`CFCn0byG*(O3L|x_vdwobD^++3C|@19!m&x)oX4FRD|~8ahpe zeojTV7hZ-Oz2plhLfEG(!j$JtSbVYr25Tuh(ycqYGav@RM^CnG3*DZoC>AWxgYy$u zB(Ej6fJGo#0}7J51I}cR6iIj%58?gJ&w6473R7KagA)3bh=Fcdu1oKU;By<$rw1X~ZwNo8(e>!wfOM!>Vit9>6+7>ul4Q(_9oemW+de1if3Hcoq}ohgA|Xf*IX$Z% z2@d}|b|r$qz%Ln)jQ{jito!IMIrN%}s;S39uV`H$$Dcnj92iEnlyM5ZP3&%F-7uH? z9C>>B`S$KCivDL_H;S&cC3Kuxj(>UyDp}8`InlaEZL+fLKTDi|?YlV!vc8iA3Zu0j zg@lZxoFjLlCv!3B^n}%#PS>6;AVMafmUe3WpLEL!Vn0Gcka!Qr$p4hu2H!#2e81jT z9YpjUJy=CUwvO=S&D181600?4+_pVtvDZVpQAVPf)F!Zqv*7S;N6Y0AndFWX6&Dj{ zw`1Ck;Nr@Q5B2^`B;f?cQv(UkrnR2Wj22eP27>WrrPOP_Wok8xR@nh*ZDz5IEV&&- z1p|R|Nbj?bP_De!Ua*DsoYdv_OgtCax#Ik9QST+J`gm2U4;|BB#qPys$gme(n_&EK zwqXJ6okcR4I+jk6Q0dgF?IWxaDRtQRs?b0CBFXWJP`EBW5aT1YlK z2lxB2#&6{I-gZf;{AntZ*|5?@4g5|iLF=4;tPsBK5p9!8Dm=UlI^UWas*kzHx0?2W zVHLdQLiQk`>Z~}_<~Cl)_I-5oey-sVJAct&GC|&y$M!iRcXiZBK5pkmj%RhomCJlG z`e6=*ZZ+k45Bk!eeQC{fg>I1j(8N~Ms$WrwL-BZ1|so_XVIJZ^)n^GnXTUQgr{)Ou?o$zY3D*57~)+ELBFvf(pru}KID zzKmUJmRuBziXE2W2D>?c{x&bmFX7{KKWMfk9fO45{-hX~h1xi!UlgtOW^>Od&3yuuVurOS0rsnDUeFn#td} zERH=UzVLFZC}!D2;n-4LB3rXulahMKjmQwDKF>cGHbTfmt_=+*+080@DFBfWHOuv9pda>4pDL#Iyb%K@t<(IeroV=D|Ym|W#<(;F# z>o>aAo6yI-xdKmn6o&FHK52^n!o7I+NA}bE1sg-(V=s=@$xwl#Tu;mR&Gjt*Qo>V9ijE6W&4JLYG8~^RQFerC#9w}qS6<71D5eMddtN^@ zps`pPva%SlM3qjQ)N?K*{1P=UWxDX8QuZ)^wg*XnokgqIS_1M2k-2pn=I;L@asI+s zKZj+&H;(b18W0q7w5<0=qwT3^Uph_ZSqDoYjX%+AcOmTwxI@Dv-5cpdoE9olClFQT zMf17rFP}@Oq2S^pI&dXY7yfVXqdV&$B(*qEbfr#xU@}s|m6?cF!>iKx$*Rzh9TP_5 zIsVrK&zNjnC-OxZc^!XcNdG(L?|uTxO=Cz-Qc9^(1*b5VCfgchws)(U=Rrbk z25^Go5i=A4MePo3EHY{ka7XDG9Gq#Ur!NFn1DE(kP{S7@^H8KJ^V3 zvE{t21wE0mbqZ?mRprg^`Cuo1J5elRqMszL<8>c`~ed4>OHdTy*~#rIAo7kM3k~V=C*eGeiaTq38I9aSR$b+F`APf9yxu!JtFD|4e1&En)NF~ zu^e?z>(RX5Oo)6c@Aygwk{GOQ^D6Nbl_V zXOeD-$OqohxcC|PX4rqp24>oykFOOB5*m25YF5cjTzuOP*yUgWf?YEp%Kh!69gxm!A3b7%Hqi$QXn<6~$hq(V1^IhhS<%U(cD?V;3ec}Yl7Al} zlzi#3*KHzzUu!C$DD0w&Zf<5WIgltByc!pvlFDPb<+Z?g1YZTV)hp-Z?MEdAbE zv;arzP)K+kP9H=jc`FgxkVl{Xnv+a)?Z%;^0+MrcJ3aPCAinf5|Ma>yA9iz*E&crX zppL~eA7`U{hoHl$VfdzsxUwfw{(BDYwO^ym<1K+gRCpMwD$(u1OY!4toP)LKlAVMy zRn7BT;`CZqv6ZBNEtF8U67O9tSm%5|ZGM#uJ$si4MA_OWQqXb&4jeB0 zuf#bO39C87I{1G``Ek}MJ8`*5sBf;m^=?qS(8}|DnF5bC;WCowW3bn|&tDDHf z3ZLVtndr;;n-js3zfC;*#LB7WRbUZ<4Lp8d(NG!TiI-2xx~xp6<1EI+#`QJ-foB8Cb;LALRdnT46}x2FLbCHyqobE1eM(TgLofXsqb=J6 z>_zGo%U|Y{9Keh&o&~2-qPDqcl|K!oS^f75yN=Y!iCXp}#h60db*f#aa2TO?Gl1$V zm$P1jHnAcjM@{~Y24Vrc@JKfjOn?CPA-(LC;&5o&`MGnm(SqO46>|(9NUu;Bn4R(a zjs_=@5}x1OZ1c`-`u*+&N60>NV4+*Ew0e+4UyXd0PvDiS+(BDn21B%dx2q`jKc%we zn^~>4pSu?r9Pgb!k`~nF9N7Yu`g?1FOdz=Ft^7s7LMj=CysDiqZ`o{X%VF#&Vt!SXKDv1-MNQYXdw<>jR{a3 z5{p>ZNsq5g+5}{a*#P5`ZMU8# z8(+~phrTC0U2?dl9|LYPx}R9s7?Hs^uQ?m-|KJ|IKdfP{Mu<{pP|aaQkY``+_A0hA z5_@Q6{p)TZ-KyD{!YfApk+D6RzZdjl1DbfT5Tmi9Usqvc&ws9-b6x*Kmt+nfAQX7^ zeMz9YVzhaC#4l0oyTG!Cu#hHg{|18VS%6Azg@PlNrq{9kR~8G1Z77lF)LhR(u1vMf zASNFQ9j%nwiAg>z;fnhP-(oQ!<ADcb+AgG)22GJ!Dc|rz7S*UMD54av(~}Eb2c3 zlhA^!j6FMDgdH%TZ{TIXpU@blv$TOohrjXVmydsnbMH{(yZRcZ_QS{TIQJmN*i_Y) zwqk#TPSL#?;^pYw1Q}b7@utZ9@nk8y;adGv=#z_hZ6T2h(nP!t1CjY=4O-P?K|Gdrl^3cY4-OKvVI$R-{f9@u2UPJC@2X zV?7GL{h^j>*Tc(NM+U-YqLws4Wx-?b4u>jf%8=!jh+gG-ylshHYD&`869Y4d2dDWI z%TBC`Wt^9trCDtPxc9#39V8^hQGGJj-#It}?x7Zg^oopRHl+a2op1`>MUaW7v9;7q zbo@(Mh%o*bIU9XB+jgi-5o+GW`h+qWGo*%rTtk~w7zM(DM(stq&RZz1-MlB<0qg|v#3yn^C$F_{2QNa=}Wt>jcKST?14nr$!Fhtp2y8lk^6^MJOz3) z&$&-lxF)#&JDOwtx)5u+UM?d=LQxuj@B}2ul9?y-98kQ7ku%)gcV^LSSBux1!r623 zan#Sa;>Ibrt{D

    aNx>^O7>=>y&75BNs=IAIu6%?1pXr`3W0)`g2wJqyqKQuFiLO zn}u6AHX-f-m6MsMmfBhu_mgu7Mt824ZRy8UdwyE+^By2L5Ax(MyMo|sSz)pVths_@ z&6=}RzW&)qHCncj+|0=Nll#|6lfVw0GW;vf5~zyO}FlL!3LY2~KNe(eSWseflIZc$EKD2`b`lfnD!ea&4q zcl23`mSz?Z+8Ew2@#gom$6h~TGm&mN@`rMa%LJ&L9mFZ_^s<)49Ai+UsjPgiMKgtu z)~QC^eo~Fh@dy;oxq4nM)#SCce3{_%gN^r;()$=&E+Yoc!WSD6(Xg$X%k~)Rf2~(= zwnimWA{=R?{Jr?R<7*Dyzx3B7;4hu={DqVV$=|owC|!TVBj4=64D_U?7xWWIj^*L4 z2BS_uD4MW-5!Y0-JoourTPz0EOzRw?<+Yw+u%;438 z0C^NI*ad@|$)1|CjB}c|h@sK0sCAQ<&(G5aG(E~Pch>v;otNR;+oov2LC9vMTarGR z@mWUEB?IIsmu1>Mt50zK>Msgi*>Gpy(9PAor6NIFo%r%6Wc2;5Nc}((rgl2Kdt2u> zTbSUgljxV6fgQ%~Yh(NFVoPSRKl}}^mh-&K7IzULCC&sb;e?Xc@^y*Ac72{1TYo($ zphvcCpArIUogCY%OJrQ9-Ok7md*c6Gr|7Pf{bXegLzBQHiB~}Q$f1CT7BfK0vKV|2 znpD13GkUkr;{+sUJgTVKGo$DD3h&DGp?Q8*X%SO}Cx+%cbXvD*vbP`nd!BRJw@j79 zOSoQ@%znnMHr~OqA*9+NaRgG0B}n$XLsk71C@Wvv0K)rnyGN%!_~A+()j?O?L0a?@ z|G(dW`^cqok>;St>VSS+S|6&j7k)oj_PZ?w{&{P*(ESm=T%`OT3ZsOo7YTuMY@4qq zU}zJ3p9IS#`vXrA61^zGkRd}3>|p?XME22CDUVwY=XV|-RCILR^P&~SJTXET{sA9E zX-|mL5c>oVHDvmvnLEx10HYifmueLLH1!(XhdNjC`DDMnmEn2{pFtl^+- z*r}8Jzu^b4yx~-U=Gjff*LegDu5j8SM!t!47ktUrCl2eUiGH?dhp>-I&adTvF44k# zwEDbGnnDwC;A+_0e9{yi@dNDhny!s;p7Uypr18BLJCtPqW2i)J4Zl6-w;ZvjFIHCI zpV#F%KLSthRkokB?ffinPV}C55yVFcMLJ16MWn+ho?r4xDt>1#f>yzv@EUKxg&0X8 z%sNNd*LTuax1^$9{^#{yZ=l}(O0*r_h{1>3B&Kd35dC4`UW)c#w$A}Su$zMS|MKl;evXD%$a*t%Irq{y&X}V zgj!u90;1G(p(V*ck7_zd0Nkfhk7*Z_emKA{IV7I!P9>^JMn-ga<<;~U+HzefA&_d0 zfJ`??)8LaxHcXRqhkR^mCNH{gYwsqkYTe6s$}Ta_IqQq#+cIgJye>V3wfP=An&+p) z@#Q~WC5%HhH6pkZk?ZOhX^k&1J}IILL-4=npMpJLI(?FDOV!aZdWZ5`ortaZ952=huef_sc~&lYT?oAvAhrZ&_{p||?!-Q*kc zrrh}}6%0fLy)qJ2tLtoUPZ0Z7viDXJGjXX^u+Zr+3wLZpoS@32ZPVM8rGSnZP#6TW z7M&8k>WT%OB$7MpE#@*SAi0fz{oK8+jDR&{(B)SIjQA4~yE_!WFMWQZg{d1q`Eq+? z?nrP_uY5mOcJV8TY>kSYBhiB=nrVvbVa$^@!C&)68C?nh^l|6=n0fifhE!rS&EO~2 zLIFP~)8mgou7GU2XJ^RH-m5J^t?wuF^yhi0`3bCN`U|Kjnj_!I#r@gi%wU|$cOr%! z+Y2CIJ^hHcSG1a-VG^?lZ*0FBv%$tdtt$_MW>Yg|(YB3tNh#&@o_++lL0rW$!tMs-EcOm!wELBESqka+c*f#kT9TK2m`d@a@JZIQ$U@&9?`wGfgO zT4fh~h172<^{{v1ehsA0ZhH;9XlB55z8AWDH%y#T!|%>6RohuuN`*y-hGg)_MTR#k zFdaQ|FgzX%&*zinB~iNKCz~O8QbFuAnUw z*)ssBJ(3RhJ?LPj&cBHGi0d$*&4% zhk$L{+?l5EUUpx&ubYI*sZ=!!q^doV8%Ce|tBjQR4Y|x$JoYgq?u)&!Y;53_H}KIj ze5=kblFoYh`evM;lRn2**%ygUt(21X50L!}_<++$z-~aa@*jO*PYB*z5s>NW#iIJ2 z9(>}rTi6lZnH`vB4D&*kDSt-ffG-6P&zj$M7gQMLYUOD{$(Ab{}ei*lxY+ zDZQ%9o>Z`3Ndvvcib1Ii*#nhT_iq8KLs<0v#^{GZ8|MWY82doPA-ORC8TF2)W>5W~ z;+I}Q7L%Q zpX>?dwJ+|$j_=@4sUR9`IZtb5&rD2)!aCXNOWw?5W7vDN#IZ zd*K7H8%n5r{UQFtX6#N>=wg*}>7d^yX#cwntyWv`JU~2p);*)nfYOTwjGX*33Sr6X zcMuK@5~A&7BEz66x!S`8#;e@}MTf)6_i~{|>w3gsw@Q*F@Qz;%3y>Qm#dJMIJqIfg zPFPa#m(w?K@@4cjnj`fxu$FE#v;b2jtl<9B4dMsm2YO(h`GNF={4rRd)nn#|vz*A5S_e9#a(o%n@9A z0yEJ&3skEpa22pV8eY;^D%x77$@qk#pIjlh3Q=qONj99IS<7YGkbXma$obizB5JgT z8+@ULnfp|=;sGQ%0;qi!uzXqG2iCgw-uyDgV((im?Y;UfcqYRjIz%H!24k7siP1}c zg#>vw=MU#V%2%DcB`22Wej;a*_vp%Kuu>{1y)#ja=k`Ywb?qOTj1yJZ#s@q9{(|QU z=BHIX9xN(V*1$5iZ=&{}@&?ojZrfh$X*@7s7E!7` zd#x*>e?W~;s16RVI;pd6NxjG1+MOFtUyg5pDs z<}hgx6s@FJn^ILVrB_z5Y?042M0Zv$h(j128zmj);Ib_+Omt@jutT5x@|SnH`3(QEtb2-t&K0xm2p zL~|%XL)IiN>2^f<`WKqsGKH&H7hadaET**}tvJYdbtgcMEFqmTeS^XWXOay2{h--p z^{P=yu;Wj4a6fa#VveJ8Wyz?%NQhCe6v!$%%1c>*V513QdPvuVF0sP=+`?jgn<$UO zL9$W5Ei~Iv&b8=5Q8CNM=8(TIGCL1y^g~}$9%uDq&mR~6fdziBe*i4hiOzmdwh&Q< z+Qj2Z|0+WC$W~eRhS)-0e<};9twTVK$dVDO?PVTAH}wRTzJA&?S$V|J|GlGlJc|L$ zJr**qrGz@&0U6^hvsEm&8o5RK9}oBfwlbUw3I923#FY?KESx7hy@bWY5-aL5c-(iQ zLM(NWUM^R$&yU3lA|IWI6C1q?59;`PT!Lr^e}%R>2UiYoa{|Y>zd|)n(NQq^;``3E z0G~UH6A9inUdp9Z$So;gj4N^mc?p?@UjHOOVUGM=A7LL)1B##JK?3RwU>R_aXIhgc z0t1DF^91&JzRC4JP0=041$AW}qfZsf8f|Zr6nI@AG?32H?fh-OoD`t`36goD>+54N z9c9R=IZsyPYr;By5Gb#OTsa8s0i3|1*nP7qMd!i=uo0adKX(?+0-e7 z;Uv4WAVp<(v-2*qZisul#}C{nJ=75*T^}gnocfxLH->l%{kZa29L~!@kNnOIxM3?y z*%jByN{8D}ydI%?#Jr28VQTVY{oLS2^eGH-k3Tyz6~Pfo`O)-7L8B_`(so8_UM}|} zrzlS$=N3lUB&I6SU!NGG6esxG*cqF-xOScqA3~bKftoTX(vg!!DBq z=8R)a=k~p{ec2WJ6CGfp(6I`bk(u?3`4)fTg5sEuhM%mok&7jeEW}^|D>Nux z;G{)lRvjmh{F5%Oi22KI59|=T$!J&$E*ockf$GC2seV@Y?DD&Uas3zMiVm*V~VmkXLF$yNOE(qXGUVg%-n#6=eUcAy#C z&&)UW-vk_|VTFtm5F9w5O@e7ujQo;sAG20Cj#YNUJ>KWxPA)OvNV?$S1<|IDB8But|;XJGtfSrfieZ3Su)?ID+{9tWw=l_gW{74-d+8013442 zBu?bGaj|ub?rNF@K608rx4c>A6fp&A|2oo7Ci!-sr=G!){F0fE@pbw`Yjl7LI#7Ww z*)%<2aVU2~?Cz<;o{fbIHAwK0s}4at604NU=tEAUg9bRn(_iS%uulOo^8T$!o0L`N zA;_l0lBA4Fj#pbBMD(0gsKt=R$NZ^worH1qr`uHYN*Wg?J@D-6g4bkc~c z$Xk<21%J~hpn3R+a^#a0?wLV|pEP~GkmD|+h$UB&VaR!fTv@BvOXXk>jr^GiJ(~I2 zxx$Pq{!CPpHhZ!fMeyieA(=kr1`lIMUz!HA4-Gjfns2%sreYGXN(j8J1g-?);@Ii< zGlROxZ$zTp{g)1vMe!(@K4{+Y`i(r_1Ew625`f;9{^+o<=}8%BD2&A{IXR(exHrZWYegk z<1+N``Bc%yi#WJl0sj9 zTPSMRsWMmF=h3!ryFCwmpq6j@))VmAbe)@d%c<)tKF*e&U+zB|@9 z8xZBXsA1YgliWYXLHfn_=nh_*ufAX{56_ib7sIIPv4qNSChQ84cdCAjqzDi2ee0TA}Jpo4^rF;??PA}eN zkK!C=bcvp&C=dN$cbQlgkkB{wV?su4uG5}S=WGhTwEh^D{kjmEO;Pxbug|Q7;PA_a z#A+=jecW0*O@YyCe4sikz20)T-MmpM$ zSCvY*ZQ`vRbA#Fh7(OcQvpB)krRj)wg=tvr36|lrjFpr1Xb5QI61yYF;NK3op?nO0 zWQo^8s-yw%rEwx$pb;e;MkrbNF7a3O?-~TYIyL{nd5#=+5>c8ZDu#}Wf=*QgY=CwQ_n3v~iT>r^ghK^q#O>5h8#!f`y> zr6$Y42B=kQ$H*7%f7JIyS01hR)pykUl_@G-mx-KXTp|-tO2gC%+u{AmjXh4Pe?IEh z$Iz+T3+qzZgMvJMU0UT&y!Hy=3C5gsV0ie48U$`7`ia0IA0TI4-m@9BoYe*hB_7e&9xRz% z)Pr-1+iGLHgj74%UvqdXb^pBZd&XwTuxg81IU5tBz>ofKH$ zA+R>wkGc*%5msMHmNg;4-6Sodo&FH(B0s2E;NF3!|Bv!r#C+WP-$wQy+V87V`Q7ww zOjK4G@&Zc46M7V4pI$LXh#tW{Nf@qZe&htiIJ(#EXox|AByN&hjh0_{ODh;tVEI?Taoy1_Zr-(LRr7x8EEL?76`5>c85U`Kq zAp5IlDubzuRyD2F#Fc?6%V3FwV1Tw4{<#`ZWG(_Si57s>{kNh9Ax;RW0j(qr&?MC! zI(T6#8Y2B1P0N}Xt9X}W)S8VZLA}9gUVAIHJBt<|?f}^MCxDwt#HEa}3%>Ow{BOx7 zT@@K?wQ$Z7vM)lWnty34?Be8ISWq;mg;L-y`d3f3Qr?}#aGFg{81DLr;oBb5D)w$8 zM)uQZdl*X@4$^!ZqwZ5}l^*8d>JM4Dx-F{G=omqXwK}+4pv3y$=%7lql;{MOuh>c4 z*iXm#O?`SiyZxq%YTmZ5fNGvI1YhcNCnvSqI!33jy&TP2q+DvSeOjR`4MZgp&PK1j zjgU*xv-jpBTWR%^nK!`j`=%dgQa}$b{`}+7N!jdkr`#>=pphW9XQ&yfTkdvpFZO;+ z{L}GS{aDwpt^ItL*C);fWWI9fxOma8^G$(_zKd0W%&h5I?J}rq`wG|BhTr z!v26|0~vKKAt3l{(R~~3(o$+4ITCj(rqyo(A+-sxv3eJOQ|=v|-VbT79j0m;@yNv) zacJtvvKE+E@fyIb@AGp(CtWL5hhEZL5W56+fK;a|H@$C{C&J$|)`4Tb(7#|GVRHs^ zUZb4MR)>ZX-o3kE3NNPF?eU-|!ECFL113xH}IXg6h&{rQ-`J_i(1 za;}(hIo2OlF5aU+uoe>J!#$u=&8~Zr>3DRUA@4!#y~39?FB>0-C)EtGzjSE; zRq4E-meC^zpYc}fz;FGrkB9+qhvKoy0`@njRtOg2v%v?A6(?SSQN0@N<`*ZPo_Vv8 zTiT;x2A+Nfp1wt(M4=z+=7wF_qi&LL`2s$Ft^y@bXW{n3Br)Ytg`Jz_B1lIWtRUvC znfM+ea>l>L)ZDsy+F#=LHlILhEGPku1))U7IXipjZuNi93+y921VII%p!DjM&YOXmGqZ>)CM%fUs|%uE ztYrHgqHtv+=Ujh;9iP_23(H&gVnHC&LupWsB1G}WUuG_@>Z90((CYFZ5PeMDs-~ip z2JsiUa?T-K<8;XZdOmY1@QeY0M}b65&p)WT1Bl6{4x)^Khh!fUFNX94%@lq%y|U2F z=T0BfD9j*u;ooRV*1aXCqp?%e(g8Y@l{MfTCt@U9I3t389Peet(64@{LvWG5)+@OZ zntpB=#EPRQBuVIhy(<7+WNZkK_QhYbL{Fe)?ed`ef+SEJZ^lkH(B`kt13%^q9^$LPP(IJ#M z6L}Dt%_c7?@2Z-%xFrOcaec<261s9u_Y-O?T z#s)$NKM9C}_Z$moh~3YRzJ2JfOA@LmPEAVV5>r4VEnWIY=ToeOkVIOAY}}5YG!pa> zeM+g6>0@eUv#%87*}gaYJ$C-aV_v0H`)Fihy zoia|_$=|1v9zxz?F~#VUeGb{`V%0MkyE<&z(%$+#=_qt?ni@2HJoqO_0xq9a*jY-@ z^9RgRVc11roX<6+t&g*D)l8)j?-~aBW6|VRl+?oGJAu;uhg_-ZeKo_}r_M~ieIx4( z7}Tw3ugwp5!wa26HiI5UHgxetGN%A?0~%JIjEEu=JENamk6k}`r<~)#hGKK(zmoij z2GC$gDWfm?`dkBa|8&QJnk)Mq>jlf#Q>1kG^o@0@{0dct!#TyZmj**t))&0WkWZ{G zYL_+Bo+?;r+@N2D#L+MvmwB7d5#J{tsWy*N z&NJvQ7jrO%n6OPyuIm&QG>TjDIDCWv+&MJi-}(gxEoz^?;8-bpEkC?+@yH{f*xXz^ z^S8zd%-1a~=U4n}5R5~e<1Bf(uq_l7YjGw;v%bKpvUmQe*}ix}!2e&!G0~PJ|JU&G zHAVR4b{pdzR0@n`&DqpFf~zoiHxtvYM{1w&V1OTfs4?d{JwIyDbMdcNWn4?q6o`P5 zJTiTE7~p?t=R_~3pCcArgl2rAilk~UdeQqmojwSV)&>7a>s|MtQ_h{uq*vtLkw5wP zpxQ$Q{vMTwitj_>^I{D?-FR70bEvdJG?I~eM;;qO2&?9&gXpbsw_5Hke=(c%Mpv08 z>&S!8Qnpl9p>(XX*>pgWeSCuRFSFd)8qQ&W6ay{I`S1+?fWgs_7FUqL4W%Gi6Bzq{YhzIrdov za4wn#iJu)45OvMydjBVD9W>`zz?A(s@{~#U)wz%^P;^I!13K2f8=6;F$oJ}}GNU|O zO4{CKHs6%>vn`fHPgSeQB;CBYUE3ffQ+ANG=vXJ^Fav!;;$H}>Ni)1i8ngwn< zsOZCed?_ui^ut>GeuC`eSzsSb9H0Y)6pk2sr8C!!VG$_S00DrxiY*>ZJ-R%p>BOUZ z*`la{+f;6barBwGpthwoSv_cHq|SA<)TOWdzb>}GK@QTjBJ)D;Ei*z-RzzXkS@Som zR;t8!FhgB?k}F*Tzu@{j&k`3F%o2E&!$1w0`C!)mYLHeaWPFa^SpyKJai1{-2`EVo z#SGp8*XAnzLAZV=@1*Y^7)JTlUGf2-q%mD79Rxy}5((_wk@vadc>r3+t|a5OC~06ytIlt5tw9KjMoe4RJW9Vtc(B!FpkpA z|Bz+rD`$UB&_{l_T?R(5+H6%}^T+GVeMWIuJ1j+P^ma@6k^Lj&7T9;3WwD_Evx7AfmV8$t})f z0xpY*qCjc_Eg}-iN}*uLa1!J&fk;vT-qeVPY{j%)o;W$yPH|h#SNI#HUh&VmZ!YTV zWH5svl#?_JidlgJ>TO&&CKOIVFoXMCIqNDk|xC&LC}MeL6cqN3CS*^ zhGeg^1K;83Pyk}59<;B$OdoGyP1aeH!9|^$0?J*Q@^nrMHY)fs;h^IHTqTZ;kwUo* zUx;fQ9lkUQRKBpAsa{PN03~>RA>=xs&V@)QDTS@wFT>OM#EPE}OVkM%J}uXOwyAT5;X1$cj=%Mnsvpq}(ejo2+d57|AH3ZYZHL zLsnKAlzP2dRJ&%{F#987 zd=Oz~>#Z%n_A&9TpAf6_!G>=9Wq3~*6?56ZDKyJ7rjP57^1cc{Hi$@#D2IqmP}{ux zQ2&lj{{Yo`buoF6jMsE6ed5?|zS+VVI>qTtOk1Yq`|TvcmEaB*=ha_E#$k`nar)17 zq-0Xh>rtr5wXolT%Vu9nMl6_*3X%HVWpp9N{nk%;2wbPY zF|1bFd?1{e|20b;Y?=-0>7AJU+rD+m{m9otdu917M165SsPAKUP0Y0bBc5dE;Q%go z^FL#MT2nZBpU4DEkJ(#N-py@HJML^p4M# zfxN0fyb$UHBzrV4qH_^j}|F+F=`5VzqcOMhiv>}r_UUH(2l649yqih8YP zKu{j6lYYUkj5dK7nYXhQ+-~$Tn=5Wwmd|Y6}sV+fuYIMADlky?h;C+r^ z!Pg`HC_rj;!;1@fpH4*;r}KJ08154c1m(S%B`J6ps4;5I~Zix-a?F~=+KtFGY!&@@WrOO5Uhe0b*Mg2v}<_lW4pGF0Ft2Cd}Vdv`Z3( z`JzAri*#DXVa_zv_2Pw1?kf-0Hk{^G!5x~65PU=t~5_-lJkk3N^ z-VHICso1I&%rEiu*Tvqu$6uJTuOM$*IPh86TVt8XT)rz`=vLo)+iQ+%KKtk6xNi)r z2QcK_fQaFZAjn^3x?DH&n^b=&9Tt&rUsnooMYq1=-!PM|EH2IpLPi-gR^ms`7n^lq zlL029Wc{!eYYn&;X2D*gz`R^IcQt?Ey;;;w?oz`LwViBJ-E%5VJHY}yN|XGUi#`mP zaz7%%5`*<4_Ge4?M*UzCe%KiLl@xUS)8C-R2mSY7+`Z89*`1U03VZ+i<)_B1oCTE_ z6$aALYiS6s7@4b%vf{!c@CCJE!0{E7ig}N)2wSfU8z`VS4C=ja*=ppE9N8uEiTadM z#v4ADolTLA<)54(Sj)VhD~%=1xk4Hu;ga9L9Y)r-nQ1CqGTgvqV!>qgVO-z4G{l^n z+2H&Z>y_vpL`#~(MPI&Qg-9cvmYV;%KwWkGU!&6U4eCG%wbT?!;+3g)6Lva%pZS43 z7s%ePKn}N~wdaxfJ!RBx)3$oc7Pev&%fy$M$}Q9LBYEhlfjRqZ%2NZ!@3P+s`f@_o zo*)-~T1a9)5c;z@dZT2na{al__w>idbg#W=x7)~ju-x|iMMnwAFj1ReRPF_Mc4rVJ zc0ez9ja26mBiqb#PO6@E=#4@$ig%{~xa|+jYugPTMA;8-T=zboSJq>?d_Mq@DVaKb zY7*>01b*LjI-T*a-6e0&t6(lS z|0bw{ny`_uay2=0VR83WmTS>7Ob~`iTtbQ@(>KktsuiO-?i3FBk(>9L+70h~=rhOr zj{(8=y0Bs9G`FFvz3083=N8K&84=Qp5^;pQE^Z5hjWD5+vm51M`QC?B22xNq@28jC zwYrHer0Ukj8RER{0MA7B-?g-FRL=%rmAV6!bFA~X0Q2jVF!56gk}Mo=#0qhj!L>|XZN-%lY>M;}_2E7TTHi{rBadYl zB8WpyA~7-QB4p6q?~tFJ`|u}*S$FzQgIW82-ADDgsci3QDLcCUWU#m zoc-Hunt`rwf41Q+0gpGjeJJpr4QqBd<&6sk9!bIbt0xRYD+z=w`+q?fRV1eLRBk`_ z&@ws>;;V*tpKgA`5KX{&h%2PQOsMchwWq-`jx~c$yW;RJA1oE1t9Gg4OyX6t;^)@B zyP$H#*B*%6Q5p>$dw6Pdap{`L(BVv!2F1^-QG# zAdiF=m$I9o%}PV?g|&NNwhaH*+^Le@v0mia3IA%y)9S**VPob6gd+cL+kOCZz}=k#w5)*_h^p&NJ6 z66@@r^)Tq}|6n*l?Z-a3uC|slNK+!7wqj2pt59_UP|@liM_Kr?R|t%xeTfJnqj=RF zp>vnn;L+=1&bu5kO*9g3kU7V`i11|nw5 zbfo*@*e<_x`X9ock!w?}klDf;rodAKN>z?RJCV5%AJ+k=Cq_-uQi92y8@m$a$zZ#j z!6rw}ss9Au;EiZ1P7o)*0_xo5da-v|@XNKyLyXU)bnpQiu=t?;C=tnIj$FETnu+)y z_d*m;;qJUQoy+^Zmc0Xr@Zb(+2AU!@5VJm}Z|dE5Z$!|1dJ&@ery-V26Sk(aWx(P< z)H9vsYuTw4;a10t7OBq`*PN0eFZtEhKiS(oQ9pWwWVUk7tyQScmjy<>((HKs`1^WC z*lQ79sl9Y2jPHl}bBle7nrjLxBd=VmzrYsEb@{Ufr!R(|%`O5hfwFgdqGST{p1k*O zh`GxrU$(rNF??zA_jmKJ$4`y?u>3?3D()wG5%iZq0g0UZ0tyuz=@6*yX=(s62lEjB z2~cvhE{tWRi!K^Hzax-85-6qt?O8~+hPjm8hG7-)wq?*BbNDA9vfjwomOpVdlGty+ zc3Z%9)osfRANxEqxu2SNlme0G)J2i&{UZ$`@#b}q*b>=cJ~$Rx)y9z}SD0#6(8sfL zu{e(x{hP?xeKmMZhGj>H!@za!QSjB{Y!eSYo{{TP(8P6rJH1Exg$*KA=4IRtrKiv$ z>m~&rciJ-CvFgp4;RUMG7wIbFBmyT`zT&*3dWb>oA~b+Q8$1KHm)JdZEJRC$j7c-XLhrh^ya^k0`1~dRU^YUx=J* zXGK;?)itd=8x&Ox6IOEEW`+Iw^rBKQaWQHQYdy-#Y#WkT)Co+!0Ze|52n+YS?|NlL z#A#qu&;NsdW*rsZbg!7B%0#WS-DT0-hk;HkFRE$G#u5H`r0Xy63x}-g6In5!7msRzvEyexQHnL%;ch^Q(Z~+)WVudgLJt-0Kym$)B0Tp%+XKD3~;PN*r{%)$GX{F-heJzKnS=Hd(auS-C8 zPwy@q58d9uCbGvH<%|4yVT`W-D3Ch12$pw3(PC==E(G{DA@A#+hGF7WYXb1qM3HAB z%;!g=q@d$bMB}(4x@Sr{-134tD#_#{8T(xxC@?oaF_YnNHS`4vK z+BCP{kekIM(_&)JUIXHu-r<4XaHue{%t51fDey;Q6lL3dJNNCtb@g3ca3o zExVYx1N6Bdk={a_6D%gRMAHZNEis^Vv0y_$3=|3(Qg#R z2Wd(Hm&hyQ$@%RX^1Jq@6)YihCdILRuqV!J=lILS@vjUpqQH0&VkBXQ_KCoYp(rTf3 zBJvbzT!gw)MT0hS%(ilh7J{+riePHxKZG#+FWhkBQqCE3WR)-j?4y8Bl(J*Rkb&T* z(sY6AgVZH?E7Kp74@xHX#^1I?y#R6lZ*mfoaF!M(atXNa9Qr2jEy=16h5F!b-dkufj+y&#LUQ66>@E2tB<#gp5zjd*X-tzRovv zMf0;U%N@*mDZ;bF;|p+^!F`fxMr9W_!hn@>_WhdQ^^jkVL~7OR!l>Vym4r_zVv2u zcz0ZnC}!q?r(CM{_B7G0)lsI2`snvX-Kh@~MTq*ZUeKZV9tJN{uQ$38v`?(tvie%r^M!qsCUsStQQ5ZRk8E;jlOUJfoST9r|VPr z^{Y-TZQ6LnjB>)IFI1Nb``=|ZP_vs>HC~U{l*x|A3ThuiDIPXK=K~riT_HLupiRL6 zc^I3L|8E$~ldzj+87Yle&aG`@+=B(saOHzlrfFm}wd|*SC5O(lP+So*_fW!Wx;5=s zF(bZCF5Kz`IA>fk${15mf`dL*4cLtM>KEC3d5M+9i?ML*0LN!qT~Z?PZ)Am2RTED* z3&UYd3}lh@#n{5<=Ef@(%!o`K1v6w zOD|CtuX?9qApMd4|H`U8E0! z3yV0oMx?Ql_%@{3-Q@YO$%UlL2p#r@`_a8CfAlRv{5^$1R+P_`eP>(%`NZi(IrLqm zl|1MmEp;V*?7TubNe=9_gJS!YG)qgd*UJx9XzFM@>0X=r%e1>R`Ev zuwgI?djx6{nmaL*y}AL2gYE_DO!r+T539=4NTvE1rT_Y$G**{q?OnjKATn1}7Y zDn^4{kT=g;^^?SE<)0L$oacLL6YQipY%^6Zb6>k+i`sGTV^MQ|-i`KOs%3qAt=+ZW zhblkGWlAngSuqVWqy79xW4%BDSD9E&RYaPunWe6|X#=a6N3K<}D4WltE2WS9Vky<0 zl_==b@t3k%_bipOfi$E;!GizjHvrH<_Ih4f`H2s$q+};4sM7hko(Z4TtBbC0e>6#gs19) z8D?1571q$im{D?dcr1m~AqlGR2^c4q95WC;Scd}?d%!$=_m!v?*#zg0|MwO4>pKpT z5K-@WKhU_+E?~U1Axs~XK9}mD3$2A%N8|b6gz38(8yPwMn#T33l_)m}?St zNrHUN1qazf5N{*}3dWoGDhx;QLs>or*frNq60y4uamG|Qu|=kdbq4ftFau33`w4{2 zhC2F9Lxy6CM=q}g8i$E0gYQt!kvfm;@$;qM){QU@h`&6*7;J8gwpaa#WL3-*n@Gmx zP&!0T&$e#{H-vDwc= zpIZ*URv`ytPJ;z?uYRz<>;rFblFH7?1X%-rAWAgkPiF$}mm8#mNQ`^X!rpMp3YT z1pJ|J>#f&_*{AROKhtZGj+Ha;`*!&f&t{l=R{1uFp48mQbL2HhuBmAl9R)oS!M~*a z_73vTpHJj0VM(q(2h9o(7xOHrGPwX9hvFlqzkJ^$;-yqRU;{M1h103Lt>t(+DUnlj zy{+pc6!}B6N3aN*I(R>jU(3dATq3bp(DGsECp&b1Mz4jw5X`-T4$iSk9#d4&;6fEJ z2$@SY;7e+GfdxuRd4UD=YNnMj9k@Rrt&(0|p!JOU!;-{#Pw9&oq!_5sip^X*&`Q0h z954F70xK?9m3kgU}*G7vwjpi6$OWoX9n=e(K9t zXfgb2Up zA4qC?+eK==+xy8XRKDX#FX5I@w;4Gju*9g+aNGa531oOr!rvqa8efw#EgicPW;A_@ zAsM9AOF7<$@jo=>OWmPoUQ&$TQ=)R7AiLiGB1-tW)3LMF!L&{9k$iJn^!LwB3zYtZ>m0`Ia=iGwYzlX+hYq^73) zKeaq`X7+%8G|h;ACiv#t=)0RL_o&f03W%X!Tf3q*<&?MG+?$hRQvvd=t9Oclbk(}^ z)ZR~vHwuY7v5`{WpP#<=i@A8Ffjte5yXWK6`T}WhyVGwWf&^u#G(7eJJVGC&mYBSv z@I}?qz5#~40e&pE>37)qX}@D>DZj`AT8V^P4Xx`{g{qs=h6!#z-rqju ztLM|&sCIjfhjLo7H+52Q-8zU6<+~)AK=d&D`w;X^y(H%^@eD03^(d0wQUUuYvOjwb z9J?;Ci63%91obgM*c`r;Blu{!cE0k(EA zQ55^Iuy7BU-0<9=R)FG@fegd3$Iox$o3n1`awl+4yfYF(BCG5&hp3B7%~|4&e)<7X z{Ggdv1)hx&7GMvhUjFk z=)WQDKF?fyD44Z8NX{y(2*0S$JMSHfSITZCh`=agOP9l!!;DUPSQBgCdWE&Ko0QGR=>| zi@)k#I1@T%My3jIV-Fl@0qMmDzIVOA(8~*&cDW5QzO#jdg7T(X8k^di7D}#BBJP=% zRN!2Not&$%_17l>TFUFg7FGi5y!0&GzZ}hU+0q`tDw%wWUWmme-e#W`ZH<$fx1-zOMbt|T8z)q5X{1qJqV|Jh z(BP+g+ZE-|Wz>Pvru2d=54(nD@WJ{>37fHt0ZHt zwUO=W%K(D%0hwkp)!*h~n=@#jBf5Uxo z$QN0mKI;Hrf4Ni`+Nk{wfYkfv)EP6t|a{JebNiVFmr zPhq_ZkuUDm6koaf1HQFw-+eHRkOn;resd(3bgHOR4*LQEi6mat<}BBE9;&XfUaxbo zw7d&Bi4zvUi;xGA?A3SZ!jlnf`07P!_2pmuxz6cLRQz5%9p*n;oFPSwawNM$#P6ia z5(DSkz#0Hf1lG_{TPB|Py(o%bWNZv5m+}p8CKvqey736ZT1ik$=aBDhe?P^=TUHba z|E;ilo6hHzgKIf>{JLuyc)XPSxbWB66HHJSRJ+*pE!R>(vu=io(DDREcPh4MU~A>z zIU+EnaQ@u6fXV*0x<^;nYEt;ff{|ptY_Oim8Iu%!9V^Jwfb8*OVm}6nF2+iFg|-AR zUAFI?>z(Cy#}`>olj@21iWhp=z(r3ws|OjLQy|(sTB|AkM_JughJtAI7U*9ryt*ld z9iFBT^mQQ^$5~ueT5oV=qK{8Km7NLP1^oq6R zn`{>iSjY18{(G8!z2=|j z=6rtr2axp*g9`9ogpf3j~nV7Tbny(4lr$3 zOAb9qZv0Ot!%K|yN-=7y{}b)E%HlxUrv`e>p1!2v!5_7M&bO(3=^o-HVm^~ft=IW^ zBsb_03s?*Zo>iSurHL+_Yq$y7tC)hfU?sD^d3m58A4qn{GI^!gNk4V=nL}#QSOvn} zqUvp|Q`whO{KR^vW_!%AEK0NBmGAzBL`u;m@HF!YcMWh?Apms(?2vZ_*<--$k{6yU z`iml$N35ENtovw8N>+!J(LW!WS-xa3zcqOM#01yD<7DcaI4wEe2GR|nTDpG|clypu z1F!M}rXHCKZ;kUs`mZf5=@*;W7hWu2Ipj2D0gw(4E{U(Nf8ncA^jDojkC8-F_NqR} zS-OEN1nCHLAa zi#Nh3P0;dq|ETPNSDBvL>cUCNWzAs}2Ov;IKpdmLtEJ*)<5tbeLC357MTf4}h_MVK z^sytC`n6IO{v7{T*|^&mP|XnlLOrwIBnlE9fS{?_z57(DM=P00o`Z&wNUZ?ZR}ieP z;cyEJl&4%UOE<#0zGpQVi!U6Bhh}i(QpI+e1uBidZ3d%ot)F~`VaB|^tRk?&pwndY z=pXkyx%a<}lh}i6^w1LmE_pTlUW^JaJ-%)GkN$DCl9>G#cZ5NvhjlKN;d(W6B5moxkNC_b49 ztVf_DyfCb~N<%h<$jV3A49}UdtZ26&iSG!2#7%AQYmq#TKpQrAhAy`XBMjT*eD19- z_pP$%(OS8HK=l>kNi0V=|8ImMxqy0sfT+9oTJ`Q7Sw#2NxZNE z(`wq+7db(%-?vj2p*>5p(v)0?as$L`5_$YxJUr2ijp z(P7?zM4SB^Am@8$7X|j*MFeyl)G&&P4KsVzI2LshWXlQoZ2mCcvQcz#eH|HpbCuA_ z+yUL&$asF{Xp2MC*)yFa(PrKl#*KbVWji%8m1I_qb;#8VXbZT`edL`tz#sEaw9b+4 z;ob%H9M5al03-15{HiO!k`hESsDIBSDc?%d;oQ2HZPX{2JI(2zC)lDufT-mRKjwVT z@w|d=GpN=L)N&f@TYM_66(%eC%#hPf|1^Tv$xLT))y`IvK-tZhAE&-*+FO05P_Th9XDyM&1tqz~SNQS-_ zhZ`KoPm{Qti?r7o4!_N4kr3+ksW~0aNy-;w7GKJkLFyzqq|$z8Wgjdd-5Y~XjcN=^Zax~?T2*~u zL%P&sNX|#X&u^2bz`(5e>NH3w$Ux#yR8to>{;M0BB^mPPEpz-2d6(&C13ik2`N=A1 zz*y36=KngZm|0*GqKU|ex2v-fv16j+9!`}7?W`6JSRvZQO$OK(6dq0F-NEc9C1@ujHKkGE~Cr$kI zR7`BE)_I}F@6rvp`Q6M5^I=RM8mqk#(B#3V#<$hMMl>-~pFTm-03utf{BIMHf+AhD zFF@-#C>+j$?uP=YL*vv+pzZFrea)WbZ`E}E){Q4P>Ni2@pg`aUXNeQ=et_dmfyO$D zR=AQr=dj>BXRXMeCQli<;8nf$b}UvBF{eRb;Fef?5IwOpE~n!wvFHT^ZQgGLbs?)4 z1m4XK2~x11x=C5aAFG8>)+*WZ>tlY4t^I|UL)`XB;c)!Lrh8_i3yQ0agLNb+oSs{V z!^I@(+zBi!LdBOzgxEUP4;VFQE<7xIA*ci5Brfr8WSeW09(0$WdJmLzlz zzJqqjWKY=^UQkg^(AL4gc+tSevogW>LRUN+kxKm5>O!=imme4^R zAsNWR!wZaczW+S@o=Aq&4aOWDg$iRhH@FXiaz`|pYb|VHbt<2hj7>vm+nj51MQiYd z$mjA@`gyX~vq85?JyxM{jRI#=GLJ6-*a0#kn$UL0rfZs!*=PVrrCR!Dqs(h}i>OOf z*1ef}Vy;gTcW$MG!U7{C{quSpXVyzPHH?60LT&u*;}fO4GcJO>nb&6#Gve5<eJamVV-XjA!Lk0=d9_%>2+xJqfCoNNC}4d4`bIdC14 zYy6e8&AeIkNt7fu;bfFiaL0jxLJMJ z#&*b(BE#iUm3`cO2Rcsg+h19pDcukjJctMLQNh>HTq}TjZ=rqrOpto_c^=|mH_xS2vI+sZ%CbBq<>&zxeH z_bHS#yIRLcN6GSKrUf2zNe~;Rstc3xD-7tYL=UWAOy7ii<6fnQ#yy4^x?gH{nct>F zm9BFReW|caJ${>_JfsPqRq;8IbpU^SvFYELD!g)6_J90oql42e0_5|5dg$X;ZlQJF z-(rlgvW;LnK|s=7PP@c=|0kyWzH`CQWu)SG7AVmmQ#*O*4U|(sO!E~u)giPHQx-2& z5wq67XJJ56E~Id<#z5ZC6qtQicxyD%knQ!v*ZM5-1bsuw1YJ7el@dc18tvmwNXDVF z4-o_Yc;m`gw2Fykd=R?0{n;zOZ35taM%H|}EEWu8`Q1DsL1;Yypuv;V3`n-2Mnn*n z7;yRvF7~EmQP2PA21yaM#sD`yr{FX7&ohS;gdU2kfTF8iFo#JeVt$)rGM{>ps_u6i0rgDG#9!$f zq}sJvS&&>Ra5B2_N8tp@yZW#156 z59bQoWxnC9iUBH-?oyg$M^U#P6Y_N;QsQ~1uQ6NX9PDPm$3d5@?8^;k4*ZD3Ohfq$ zK%rbJ@D(n$&n|bk41UBx%7hO)K@ZBMS13wuMVyT_`2BJn1)%wNLtf|!=|sAO61edj z>km9G#Uw+ASE3=m#eQDp{xQ^;P(Wd_={=wEm|XOsq`SG+R}vgBoB&E5Zff@?=lWny zkuOg;YqBPV*IV5aQ<=xhpaw>wv%N5CrS7cwtVJZ=Iv&j$b4Dd8e$F>eG1cz2d3Ekglkp*mLHz4GNrnmd12T={i( z=Inl~dEPNPmCBi<2XQlvU5aaXBm%KORqP1a;tQ-P-&0>N#gJK!B8)9>T@t}Q*q|@1 zVV`htFWi&&=M@h=|4*htw#son5N!#uydnppxxJp3a>Z?*{CdI3hu({4suQ06FnX$c zTeWTS`4P&)fGIUnQp=yqM6T+q^m0dh)w}YMBY{8S{gB@rKW|6GtzD9WXYnLc?xS8d zInkZJ-k+@t?|F{ub8&tA=}xllIg06xszNj<#8KcfyUQ0@oc@M0$)-8v?Q9m$+0ChO zh;KodQ66lnnFqSMOg*onYhKugXi%k<(l~WZf@yEdLJi9X7yvS)4f?%ALNbiRSAhQ5 zu&p#-9Anyho+RA z{**Qw!i+cKf;QYyeG_YRz4aINt&&IQ#j(U!HJe(q_b>nK`%LA1VObm?k@BgF1{dBM z1?W9)@|`tp?t&_KAFV3LX;;&$eKUo)O)BG%(qwEFz?GFyBZ+FV=$ zUp#^ei^x-ZE&&pz;)Ph+-i{JYT#!T?_!rt_9SOk(m_1%#q8~`Sqh(eq!JqZf4>TA+ zM9^;rAqK9p;&GX}_=*U8p>;00zJ3ru4>$YGBLRy=mT){fU#KjA0w&yp1OrSJBKAWMdEe%v_8X&@zKr}<(k$ExppkZ2bV>@Dn8~I+fdLWx zjF61JD-`1`2lZ21+CYvOf1vSXmzwl-jT#+y{vbmKlu=qXOz*Pbv!(>P7ck>5wR~0F z^0u7_?c}@1ve|ti`6U*Z?mhNtRW(r>7Ib(BGS;UGKwvuWG=GlC?j^)T!E4r@UJV-? zNsZRDdA9*B`Q$l`2{PPj0Hr8oIFThP(RWMq8sHE?ah`vIXwZ|ThCeiW=JkkdH#vmD zH(k0OOl>P7A2LvU8oAw_buxk!2=V6nv)R}E^`1Z`?CYaEJ{2oqEnms0Xn1y2=@ggr z4tffEkSPUe002MzQ|V16|PtAg^yFl(MeB z79|HN_Ho>NWLYG6J$ea!ryPR>_Y#qTk1sT+Pdp@owb1d%v+~NBcx){L{Ck^Ha8v!Z z_DQhtzePO;tXPIykHKNB&goyyiR_Vq_7Rc4fZ0}{G!}aJ5^Eob$$;4AZr<5kn-T6R zYhEL;8{92F{`AI0gJ2sI@2#C~>3UsOqo&9SC_5afU_6~2MGq7!8(v-849QD-K7(@xM=)8!Pj3J~3BKo5CW z-}e(e(yH63?OL?~*}{1rFIG2|PpCcf)czvaRk8jfiGm<^F(K_ckUn>SfI;-!WgMM< zBPQn7P8@ZYC`_YUc=FdQp=XAa=iU4w=eymZlEb%E;n)0S{U)(pIok;0m4j=T1@_@k zY100E-P1lmqL|3}>r%jgXlwh9i+=ks-;iomvh5YW!G~%n?Z?hPhC~n$!`gM2q!c6J z6DTkmU7Nfu;pyv*evIT|s3CXt#P%P+;aQ-_8rodJrxmLH7$mN767xn9oD8 zeipez#+mOJfi_obUSzMt!4O&5$Ak0^7y)e*fuP_UL6w{BH6}CQIeM;~qLbZ@?CV(Oifa~^2GUgcXSjia8?F;*q5rO7(eKFkIXJFHeK*w=;tc8*Valc<~~7z1o5jZ1FAVEym)lz^18w|{_Guvf0>L1 zdsX3k*7-=WYaA{MAfNU|Idt9*IXuS|zi|ynW3qo(k`lzNtDu+%x=VkUZQ}<@#kN5C z#37(T6U=i&_W}*b`d|MGTyuWcJW-QE$!uW-fC%Rr+PcP#W`=S{>vb8E8Q{uXl&gfM z+CLq>&1%=d`qW{T61Hwb9P#Rp>BG6@Drp@>8L;Ap}>u83q~& zd`X*bD5w5a?3)26!)2Sz-_r*E|-$oF$nAeKW9d?Kov+O!F7L6FqEuh%*(s5_paN+(9@%;Gv*}sjd zI3DjhaV`ESpCmGeB@w*iGQv06{8gX}Lc9H#2#3Gec{uis+v|Rs`Nj*Y3|2e}Z0E}b zK+fHtP2F29)2>d*Jxp|vqlW@C_+8*D3I!7trg4}8a&1qXRv>r5DD@yMtHhenk1t~B zDelr@fiehI#`ronyiNqSGCrKhMy&e^XhBxLI<0qn=(&c|aPdzq3M&+I!wU@x8B<=% z3#;6chh$hK1%Vepvbv~1)sMrK%i#jFnN6-`T58L#Oj7%O&t7Mxu6(R3B{1=VizSi& z;R3=%%UD3SitG}`;V8A!2xpW-syy|u0A;@g7Ge0`NGj8k7@?1fSXc`49tHY`Z8k$v zf6vys*kgh7>5uQFW-V+Bd7YKb3To1T{1LGpPE+o?$-VB8G<$j;O@oBRwF7mbAJQHa@7xeU!qkq|R&sI9lW=Fdk*H`k&3v_#M$pTuK+d-BQ7w*2bLc-Y*&jb*j}eRrF>5pdhBHeue^DRP7b z<#`(1@w#$Z1jE|8<|EH=xPXG)n@H-{GCO5P`t1w*E7Nn0kDV*s2!1F`%HqfoP;j_s zt*6a;{);h?iPr(P_qXBwX$y)(fq%d6Ec*O(D=(CLTg=~T?KH#h$|YXmH_9)?g3g5N zEci*SVR%|1n`=**1PTD3Bj6dNg6RUFs!#aBKl6F1jblTFCntQlTsDQr#Nl^DA1m$V zWlj@mkgeKj6uAFdQ;|z_oQ0>Eas3X!`pmu6$1RBmuwxDU4o^&W^=VZ`qoVXxFPcxQ z>~~p~UcMX22!>ikU3)AiQ*`52p6ApVIZR84Yq@rkwEmg@o4*U!Il{d+Ut~oJ=MS$K z+|$XxFU%MX&1n1gT}`lWMd)4dhYDrkiA+X2vV`@Qz};{4=1KR#Os-!qI*&x%uI(I!>AdBplV~$h z!HSI)fIfA-Ef9aq9jq3WMI{Vhd2(@lRDS%LWG7{1d3Ke-k$j&=d)q9(w_Eyvw{cs8`1%bMLR0PtK`~J*X;_Gg^ZYZsDcHoPYYa z+MVF^@-u)ZoDeHJx--FRG3;;2#i`%W!I!KMbB(h=y#M!A+#4Lxk`o%i3h(ofHq#Sk;<`@a1&w{yb6uM1YiqW9y zOVN<*O3(-xz=_BmY@?QBx3|ik5bg7a*$YzlksGhd@{@7F_OsFY=%gXNUwlH9e{Qs6 z-+3r#)wCKRu!=(D-F-S&sJ=X9UrUvfdVLofTsqNGMIZ|&RBMDM=Zp{s!s@WV0os&m zX;?;y`tIkp$_=?y#DPiah%w)v2g{FVu|NUywpbl3Wv^+a2~@%pM}j`(gmSAftKeyO z8$&w2O))w1NJ^}8gSs5acYmqfagw`ez5FfnwX=+cjLe2+Kf&W_;PI5#arHB#>m1sE zw!dFpd!7P9*OMO>A9<7a9h#ohN3#nq1TtlQtainN@m{nl#zifI^yvbCEN)*)h9@#G4H zb|7S`22#cB!2KB$`itiB3|oxJ_8E?6O@b%?=%;1}hRoLA-F@c?z*sQGtd}St`~7W9)|3F`QInCw?CLJ zc0xY?LsY#q&mzzZgDS!OOLy%>0vvO#QbvCA0{7UsUTNpg~~c2dv>d zg#W_XbLc-C{QI=(cSdRX9uV7CS|k#yc^a)4o*>%Nr}~p}T}(I`e9@ii_x}@%;ehXK zNHiS-+4ddwGz_qUkYq~>ha!7O;RY;46Wv}UdPLFWKajkScJ%Yd`vIL=%s~gd#eo{q zoW{$6&;KtP ze8`Gg^~6JX0sV1mTbIZ?D-k_K*2t?Kesq(b`75mmsgCaSU3EocVe?!AUDapaY;XxrlApufQ zLG1^F2pedjp(0n1pooDxUUqDrjxM&YR_5kzu5AA`9Q>?a_I5dGlL;&Ac;RQvG?frI+zjyvO#eM0q}Z$2bI zH8z*nDtSFLMa}UJgstj=7}abQCgQFXN1NU0p!4If1A0>iM>QgWWP{4D$T;itVe*R# zdv)B;DnzrMB|lrSJJ`Sa7%dri; zf#7`;@^Dnn?`*@d%ISlfGRq+)#k2~S%-Tb{`@+w$mUFE1jy}B2Ze2?8vm=rXMocDg zRaW-Fuxz8-_~zau2gJxb%zdwRM}`*ZFp@hYq1?47&++mbjZN?7&>!C4_vH|}@VI0d zFg3gL)fVuy?YvTejyPXRe|;yxm<@=XU3Bu=I!^5@dK&7k?8ju~<%yz2_VV1$N-cZO zho%Bajl`H#gN5|-C4+NCk;p_mmimc_eQ4uDx#32>zXRbUL}9PKtK6$QC0>v++7v|6 zLqxhb&BqX0u!Z89j-@1IQbNn@9WP>!8iBPK*&4#v6iReuZ7FCwYVTozlU%xkkAcP# znb9N+C5IX$X1|?9z1@C$M@&(ZY__XP}*LvJ5NQsVNWA3v>Zc$Q2vpu_NPV$meW>E{88#nigztq zCA61^?_;D@fX%Yro^Mxsrh1+s89lEL`EPe`FWdQn4-Su~m_2WIY;X7LuMow#3y|3J zbkocJlGw}ATVCMP%hKlSMQxAYUA<1=-ICbb_og>v6QN7c%UjP|$Lkfv+Y4~>LR0bS zRm48VI{(ZXl<5(mC^XbG?z!m0(&}7MQO+(kcflGBF zwmH|L+cw%W`0gQy>5+=oaaTLgPjT(IU@u?NHMbz)mHcwZB@jdNIqg=)^Z+&I28o~U z6~^+rf|A5$q?y&<>9Eb7H=niYgtGochuJsqWFFzNh5OoR+4=#5jr-O78(Bi-&9H+G z#g$?CZwPfLr1M69tSj?j+j67&cJ#FD7y@+sZmSJH8)VH^|X5X;Ao*(It5qj$W> zROMw?)Y*%bY&I4lTM2Bjc8E7_`WO@%Pjfz3&i9X~lYv*Z%QYKBpF73Tu2QNtuoMVk zJ#Wub7!RIHDm~dxdJ3B~%T2@Bd7&gSNgCmeCls)T%tEk|vBCSVNZ_POm~9U@N!(US zKSkiIuKZPE@F8rQ0Ne0gkv(gkzLTrI8EBVrU=~(XjBwexai#N3S1Nn+rKHl)+3i&t zstQx=kae~rI7O6@SX4_Ym)fl!jNCEr#q!t0BZQR>*DWb-hNV?%CR`8yuLsRcRvSEU zkP9;T_k0ks;711mAK|LfersRh`%M~di21jQC=Y$Jl%PG0&Qy@)kl|oI+lA>3OR|od zNU!NZ`v^Nhk7OE^YQ1Q5#XK)dsfmXPBOR`4Qk*=?os>K6X{t=ezgDeANYt_gXkr5G1nK z{d?<1Frsle`5yfu*+t4q;h^G#!t;RH4r1~*irRO_@xV9%7&OnBZG(!kLz}mMj1SLa z&s`17F8kU>Fy@X#(#h&Dy-rfr36`z9e9rop1EuclzV*Q-f-Ga@yBdXG6bg3*plfQC zDrL>>u!}gG9b(6TN`}Y2z=-YN+juYAaFFZ|C9Bx@r-7n56yuQ)=W2m5z!7 zAMxg|md%T@1GUWvP&dizG)PlDfT5mCc7EKR{#cGu2zbg7dWJeHK2yl|U%EwUj!_#T zpkh>ow3Np!M~`L7t4VUIw69Sp6T7IF3&$&2?+~O>5pTkZDRQM{&mH+&?bQuRv`DuQ zIwEFBw`|mOqc=|MgJ)K$vlS}O=};9HR*O~uK|;xp`TQc!<@ya_x}}&K$ZmPJOB8D{ zIZ&=q(qfc`5U3bbcUubLmXU!Gl_WVOvviS$Ad)pGsdK|fX`k1@oTY){LVh|fB+aX^ zG`4>~=jziVs_V%VGX{_%9$g*|(p(u#y`J|YLZl*~3H(eaHQz@V8`L)>@s-=aI5@Ns zI4eO>As!Bpmd?pu%x2=Dn0AwR@TLoIu@C%mBKeTFLn-WLCdMLQ%oi>0>5)sK*4>s+ zuRB#Nn9ny|>*l#cMtONkl_1tIwGq5w=yx&rjR4M!LJn^WBahM&h_P5@=@|l;MKKI#_)5Gp{ClW;&Q+pGkwxm>w;@ zef#?_MJllV#*jhi3UTW#`kaC6wk&bt*5%Z2UqA=!`(Ss?Na27^TbWLGQgr2Iwq{XXsOmC z5}%LgGC0UcPUjlvS^0`$13Yqlru6lOMY=@Gb`KsFDtkpBA2(071$m^lv(6NSF%0TE zkma}YCcdu1sovAite}-TDFM2hAjf?F^@)_I5S#T2;|aQ6lQOgSDQZmcS|bFnH$yKk z^OuV|SyysfY~g`!TBF$WIrh*d-^_zwdSj1?KDIlUENiv;bMCoJU4@ekMd{qV+#q%I zgUv3R6x}GT9*%6}@M_un>8{}y#;NZ9_K{ONhWvrp)x0p}9l?E_HN7(OM$e^Rsw*OR z+_z3P6_%RCpK7(T!hW2~sGQz<#W~3qum}*LBn~*Hgc>KxHITb}PVNw>7bq>3Ggb&3P{N+$^fiPfjOd755$a~S%X5^sh&u?Dg zGl5dv2q$RVPs6o~(6y`wl^=(1l5CUbzoMB6cF?7Z7)Q-Py__3pH4-jWcz&yd%)4b| zL+~g(mvV0_?~vbcr-D7QE`9Q9TF1Aqt~<`N8rhJNAY*LpZ$t84DgUxV(PNQ#YEWZ`L- zTg@uDB8A_at{|QY+!i$M_p0=ES+y+#HKvIyjpPmHfN*49@b^guc3JV?tL)1Tvoc+s z$>O;Vo;gV$QIL7?dGis;NBFznoN~Vp-%bcNhp}q#1%HUkYPZfdLNP_q$?n4&iUY*! zCpWbaF`EFylb4lYCzO$Nf1C37E?`#!PW}6mzKH&GgdLT=ltYmNVu=%9*DE_n+-y`p z(-PC;3l41Wt1zljh25{!T8ArjvN$NU5BZQoY-Nw2%FoqKY?bSr$kj;hVv*c|Y$0n{ z%w@X#r%<+@a{pLxLAkSSDxGIgJ+sYc%-v#!$a3ubgkGLix^@RZ)AnCWYKYwARb1)8quF4BVBa z+cEl~jqg0?0h=T+BwYZ?i+dc|3{g&I0xn-GyY>(rYrNr(EcU^Co)^0*X+QM?gr&DWPn za~rDTb@!jH=YNGxxCrSV5o)z=;40XCfn{FGXLO5IVsv1{4A1EVJ+$enE71-J%p)5) zk%yis0(a;ucp_!eZYew1G1&-N1il&XyiRMtT9f;yYyT=nIRpezSY23Z`Eb<&+r*Yq zi->b~aeXS*SS)T6hA1u4A5k=Lj;X6DzZuC{iX+~AgjMZdJK7KHeJEC><#SRg4F zd^D+85aGw86nR{X{#yplMsFe1R3Y8pV^TUt7^EOS+twzZm7uv)LHvnt>2RY0WOO2W zL1UPw!eDAZy|P7S16OaCIi*dmuktGGzTS`eo2@#yDbjflkMl`tRRJ*SnQ|XI z->I=@AgQq@BB{yJEBU+Q29sPah?8+<@EWmVms91o=+_@#WtMA+dU)h=XXuq_eD07> z{LGTkivJF6t*dj=2cOq^L&9G8az9$%BClPT1K~2JSuqEt_QSq|D~bWGGl~I@Gs@vW z1=}OF0zgK}qzvW|I_Y+}O9HpzOvg8NJM#6*^sZtddw6?OR~s(gCUdhO$n{gVuPqXH z$BjYWeOH&s32qrU22emw2)=Yq$il}QNkQk1d4$AVKm!VqRps$@MJ9qLt0tpYP4D~q zmfgqt+uIbnDD|(r7u@KV`kpq|F)QzKA|dnCAj|HY+XTn|LX=Y;VElBjcSy?tmA@9> zN3F*LXFO4u%l!42+ilzC-Cc+nGw7?{Z2x#W*63Dlt1Nw1(Dzi^ z=Gv_FagJGtEs)$juh|*%4S^Z)4RM3PpTnMCLqoEe(1dj#@m)bV`%pSJ#g;BSJngZ? z50XEDavK%A5Otdrym)nS&27LvZ5O`CyZSpXqF;8P1xyzJgMcsX+0ghT83OpXxO?hr@xGYlvG_G~|yiua@1Eg?0&DzedcZ86#SF255O1>`0c6KVr!?V9F zc;oBqk#~o0o57ENs|qY5wcm;}_oRy9FMF+{Ik&$RSE-&pRAghmCMm2=YTXVT5Z~vjIT3p~PkcR?` za_K5uO{BzO$dZRatfXr!E+I&wlrH>KvLoT|k-N2@9IKjr|7T}_J0u(8_BP)WO7l3F z=;v>;FgoXc^yfCFSuO|V4e*y?)on3}T^C{eS5*guqx{=@K)^RZzzaNKB(3)VUm*N& z<1DaL5dmN+iBe5U%EgtpG~#yNnN-Nioprt?t0KSpe?il!00^20YTM!x5Uz4?@S{zD zmL=hMHT*mkq74%%gRBhVSn?l?pP4_rJ#tr`u6H`(q29i`!&GHMT8{b|YE&KdfZ4ix zK6LId!PWv;|I?{J<<#RNJ_cSBYbYaWdF_Fuk}qlbNfK<@{A3i#oU`1!aZ#~{1y2>d zGM`k!r9<+cfgce(y+R-$Z*QBDTL6dB`Pvm&)u#3(6c6z$vwQK<=hm7gkrqj^&S`$*=p5{D4txnC{~$Bp|Xi^CuV>7iIiYKHgZpERRK1-G&OyUV>ChNTKj zLy<-WJ73&?7zuPX`&A))A1;162W9-QQk^5{R!d=(Y8+5rPDp&PzRH_Jf>(0h3Ac#G z+n~EG$MV&Y;7iQec;f)*NhD*5{L#Nn-kQ!K~3VbTSl{F$jPp1IF)O5KLd z-Y$z3edYhzw@~HuKuENSJd}|@LLva6xdDmspfXr+Px2%THT-Z!x_R$G{fmEWzx(5_ zGvDKi+Cm?1o61ia6(SX<50?Wwp#Zj+Etf&&t4=km^mo+SlsE_pFzRHIq!`n}1qTn)WzB68FM6=;DlYD<8 zRJz6KPce5Gzo`iyotTv`yUyrHDm;!l=B<(NFB?$@QvxvGCCwfc#mF8M#VAYvv$HU|ZzIlZ_dloKdMmZ(~qs$^#{%BqdQ%@9Wq-d~A z?g&?xEsM8db`SUzBXQISabla!(eD&6)R!q(6NWC{>vDNk?oP0*e%7oa+e11^SW9Vt zuR|&UEwqO;TTvT+IHFu*xW{l%dEI;~bqZu10w{;~v2RVsjgxWEj1+`drmShtnqoDj z9-De)bRp~dWycV}<0zlFAOoK42K7G3AGZ@GzAnRY5cE=p2!%kS>*R~7?6-b~W&ymI ze=p&J|;TVY?gb?m}-|GwDeSzF*Wrd5#=`Hp(u;r6QV zmYCLw4T)B^Eb74Ux-e?7F~UM@&w$pQt7wpin?G%_VVcZei#a6J#d2v>Iy!e>U%%|u z2h@(S@z7VHrBsvp{I{^eo%|mJ=zcLmx69saF z#v}#ZdaYa03BUMguNl2gVZWYZ;mPWpm($1vx8E|0(cW9regfbz-@&o>XyMK5d}g>( zbp%LKbr?uevh-*#rgCA%iOqEs4Fo{(z*x2{SA*I2@MRWr{45}&@n7j+zu!}AqBbS3 zfOO8XTc>$it%|AW3qQ0gh`R!YKBzq8TR;)YY&7GW7q;@kF5GcsPEd)13jVCMA>Oz_ z$=DrLe`}PSb|4EycN*sAixYJ5n00sfub46q8V^B@p(FC_DdMQ8ds*wiw3^ z{O;VO>v_J3n>>pgI!Nh=R+cUE|H$n7uwTpnH^905nY{&q(y!@&U_=S>#ULeQp$J$U z3miP6bQ<{ksCV-fXat)OLTNrNxxT189}??tV#e11!sH|=yz|w%Z6{vAo-VBTRdt+JKXUgfKx?w9^I$IO<;bz7Slo*(|Lxn&5hV2C`R6XV zEoyscN9p!+J5Vr?fabo3KO7({H4U6_Od&7fFf_-zVdu`tpZ|JlBIqz-ye#*^Ay#ED z0DyMQ4Npd^AX!WH`UQk-!nq@j?GNA;^dRyY8oT_wpbLQ6B=X}H-?+;02msBD*939g z0j{MSgu_zAmKZ~-_~!Ha9@D2VOjyvpHR;(*9AAfJe5g&^1r`s8 zLi5Q%M6ZlsRTKzU5ZuZ{@qYrT@<{v>$cMCcz{w-4d}{aH9P_^&;8pXB=fo;P-9q83hgFFue5RB-+|U=-ejbVT1&aAy`@g}{50ZJ~~vSlaO%)ZV}lZlmy z*7|y7w|-q64lLw7|B3{uzJG2+8Wbj^{WOlY@hdaL@htk*Qomw_YeQ9!Q=&9dY6?Yw zv>ea}s2aBzCPFe5Rw=YxV3h6K0a{Bk(&lzlqfJjf-CBja9^(7Qn*yK}9SM3>TDfqg zbrb;K;YVqrlaVzR6AvIs9B)-Ly8VqgO!Y)nu}MRV_7p%dcj3RN@@JHWANB7svW?>c z!1Ojkma0@eDj@R-2A)e5xgtP8q#ky5&b`gk`5zrigbvZ zIWA@_C{p3i0{tH+KuwZ59l%~g-Z>Y^l*9X<(I+3%TgNSuQBdT5L@X^0v#9>=B%g~@^O7D=#5jSR6$O{#-855BXX zXxloGHn1gk5VLO1StG)aiL9&Sc zaN>p1>cEdWse^R;2*o<7D7iYJC^_TEy(0kZj+1ti$bib?zy4z3$Ms3lZ~KJ_e^m7> zUbi;98qA5=AW!RnnKs0}QIp2C*JPIjg-VnJNlBC-A@-le(r6`yI+MDv16Cdb3LxK& z+G9)Z8=yJJT`rCv`*gHloS5?8P9yg%RmPX|9~$c3J;kI+YavUSI%Lvm7+GOy7-?Z? zfM?F1Osag);&+n@zs-NG+PQ?!akpM(V#AROv008KEO1+@TCLik(|7Qo|NFSnfN?hv zq1ga}IJHYXoX=ra*6MVb*yDJDr!#eHM#=7p2gvU62XfE3o_VuC|PS z=sWqkWBk(?5Qct(!L?OQjp~)FWAoLfNO0RF1m6+qzxpA|&KIEIKF-|^6ByD4^A_BO z^BT5^@4B$7m=p0FUE<)3KPTp-Q~G}THSD`#vik`#31LRX@*mBmQFOURj8>(QKiK`u zK$HOocz0k#N}KFcMJU~v8BL%sgRxKwjIm|QjIrg1jj?-}!0ZQ=Xt6mFXmKSDCPcIU zv@hD@6ti9FT6Vf4*vvNrkY)Ve)vBJ;g7t!sZNcwOOWt{!RSqz!L?o_rynS#|u)8!( zyrCb^;{CGk!NlX$!2)JhIlVKz7af@j*{oVFhazCit9NDeBWygW<6Zw^d!3%NDyXWA zex_Ht(|1Sq9`l2zt2jDiJ}l`y=6z21^Pbqfy>k%cf_$0=qi;1N|(NcWJd~qD9 z=MSDj)X`J{R%8JUK-2RTp~5oijhlNQA4o&-X02%u#tj0Bui+N>dVs~>jJs}w?5U_^ zt4dMR|Jg|Zr1O)MDM<;p_}0~w$26U&Ir7$YexST-ldgD?%O;S7q*?KZ&IZU$9O{ns zYk*{?9P&P6$wQ{L9XMO?xWJ1?s$C_AI}V5jnBT!<(ELWTelFnYr)006$Z7@Kz~OuYz_)-O={%S;`B#*KxyoZ zHz2hgI-yj7=DA*T!`h_i*`xkfOr3KKzyUMw+TQ53+Qj_QTpK=A7I3h`zZudfN3@Xh zf{_C?E#uTcwWtTPY@_aF7ndVQYc7*CARN=L1%Qj7_`GEgfAqEatp#9T6xuO7bbqvg zw*6rRTjBMkzr2AWC0OkA&@~tEg6$2B)cJ7?7r?a$B6$PX9A;l8E_o~2 z)f5!h1~bGP;=XRWfA$NRBX5gUn&KLhTp^^U9|;d?#)*@D3k%A0HDkVAPaB+6a-1k~ zqD=R&Yh(~cvRj3T1&81NB(SI-js&J17p1*nfn9}S;#^NU&t6%teM@(FA(?s1vxAC#N9VSNP^xvEnfjP$*Gkm{|k%gzlTTto=@02cQuN!vG zpHXsm{WuZBsixni-^JqE@_zbUjYBOK!X7tqtlIRH_sOCjiiT^RI^{!L%n$WdGn7gg z-45|mcBaco{E_1Zrcw?N_2}kkm^0|CjG^GpP)@IDk{=eOF|x?bBHUp?Aa?Qja0gRWX>lwemTl~;0S)`lep9u*ZnA; z-jgza`6n-4{%xkt%bABWHZStqA?WKiqUJ6rEjY_R;g;)n@3k)unJTO+b{ zd;WZKDO$>LMl-s4-id0p8Z~-J?=@c;AriQrh=p3kGWNiSI)KqQq?13h1;HhWk9CUm zh3!52y>$&D*xeYi$)B0A*JYcLhj%lklA$^cz5)LYX#}pIUpFxaZA<1|@}`S&$*sTQ zQ3ah=4$a`z40P90uvZz0D^CNXUUK3VcK)!SO^y}enAT_Z&oGhm&5rSznuY6ZW#E{n zPE^lg#2BTrYj1_JYf~CEtcjU4bi^fFPcVGG{g3p>@ zT{RbP)k3dN0#~j&$eUmH7|qV?aZ1s|R*I(anFBf2Tbi)Hcf3+I6?81gBWur5 zf2PAC`&gk^d2_H^C$`^n0Y5Tg_l{)-1)fv2vSk#mID8b20=S@4+Slv~X_n2KO0=h7 zRr6ASQLttb2vYEqM$`;zcsbX3m2uA-l}=fb!i7ivcE{d-&kP^Av}B2!=(gqId^uf+ zL`pud&UCit7qrt4qnKZzRIgU7Z>8Jji8r9Ht+&UemODHzwe;**$DbW7UG@Y_SBKnGQsok#T@kCO@!5BnD) z9xQenIT5@fql}aWa#xk)&S)LHnHIv7AB4(RyJNskH!xm0p&9Jaim~gA8BWu~*1~_4 zzj|w^8hrSHKU_dfT+?p+-AMvlcm@&X_KT9ZlXots9*3npoR7#s8m;%c8p?udb~>g4 zG)?o-$X{xo+cm~GePaHw`!K#I7D>Y^w*0KzIEYr-k_(Nm8T5IDSm`4)ow=nrGH$gPFR9Hj%D>8TW4=^tekNBJYJX z@_L=}H~0k|@vkI!Kvz8GO5(`y^EL?56WY@D69rmKq0}f=LUE(BxHdNZNK*FLV_(f1 z&nYwTy`!&fX1qT~6oK$Fy?wXEvHSSxwNd<$X z2D{JE+UWcChWA@ev}Kn}tRA9zNU@@Cz{*Mw?>_WIg^XM_D5|WA ze|TrR?-&&Hj4sC}WSOUAVmm7NfnX`-H6*-#$2nF9U#!T(!L%Z?AFQ?-6r{rt_Q6_Q z96Ox-2O5$cN`QSiF&2jBNi`Z0RuZ)FVJ@Z;VT?ZAF|-aBrLb`*h9>C=-^?TH z=tyPN?)mQ1?W@g@@g@s#ru`fAQ5#h0HAO)bOy*c%5Dv=p^!GO`SB*Z>D+-`+1qFTL zYkWBV#4J2n#iXhIS6S2ndXiAHyq43PYVadXwbz$-Ooy(tXwA|Lo;RPt2mCpgxGDh` z_i6z!P4e3p70+-zt6+Y;jQl$CE8OHx5e!23CiDn=CGtqf4Q^*pu@@=_-jjx^7Frb% znj!qToaE*pNen(c7_7Hy6y(DiCSc9}Z=Pjn2n>Z-2Q~;&6WXY**&Lx%quIy7P#Rc% z3hAO^frBu)t^~7n`j)_9(m~G$9t1z5Y466~i}*}mPk?#+HcU{vQZ;c}im25%Qv_OV z=5l*Is3E9ur1;9>B2tbY5@I+k(6a=LerwP9956tS zdic`P2*f|%cQ!n$8CX;13@u&guoEBEGAZEFFlgt zVD9&|lCHyXOuVb$Ki?tmG32A(3?V+uQ;TkP*C^LCUE?gY_M@9VX z0o*v7$CLJ;szKl&!7f!O1ZFL@f0pTNCJ)>-S`=#ZSN#j;B0wQE2d5Y)TI)1EjPB^H z_5|554DcKpietljqy|F2$NOFJKnN%=m*dT(_&JtgE1s9RYe?aje;vPu!KKl8DsEiv zdkF`I{P649Y&I1;bqBkLb)>?=MT0!(e=B~4@ZXAW7KZ)8P@tikhwZAN{H~FWcdQ%O zM^v_d_D{u-$wIjM*_dc#Va9r#N6&`Rv2Lre)nmnZyMmC6N4iy_l34R!N|H+dC9A5I z7aXe$n95nUU}}^q#vZsY40SqJasVJzng)y_JmU~0J_N+T1bi?+_=QQbAl*i27{=|^ zHE?2c_4;E^L@%ol68nB&0$*wgov42OrwH%@HMiTpt8uvQ@wPC$X@Pq!u5i^utso2K zZ%A=NuuMOuQ-n3**9RIDy1&bBA7Q+x9(=oXa|~a(_Nt164$AF%m5tpt;X8RE_w!{) z22rSE8@frvSwmd66@o1Oc4Rc_|FCD;a9PJ3~E9ye$-=P>+>aDheR*PTkBF-)5E<< zf5{`ewr9&TpPumNhq?^r`6ptJyvKC8wJ6(8fSDQk`mM*U8S)zzf8=X{{mK+-VdD13 zBG5I6NS`4@2#sk@=0(-P~{~{1OzYN)WR! zwZyFUbo;JjoX25%j?TB-N6HiXCl0!PYt%=+r>tAflsGka|#R+j`Z;rhq5?${W)nSLFI{1$d7>WyZR9u?%&n2{?_YFcwQE zQWzjA%d~Y48S8(y-oa6DXD^{-F5}DUWE48G#MVPFQmh&X#67M%4sp;=jf0) zmuQTx4kFeM4le{DdA2DtxW%IDvnh8z5_fcueVR~gVeO|@gPgD&cNo)9cLV>kFkS+T zpKZu+`R@XSTWhvX%O$7DpOd2Xt_l>0stIdQI+`6xY}S84%w zz6{)`WDjSryjc7B*w>=GLn+QsH`SfXsado}%!9Xh<88KTR_kKI#x6rL75=TN*M_+W z%e+r)mjO_|d;2OlR(nL-+FgpPf5y-!+g;?}tz6SdW^nr6 z$weLI){9P6koT9kwW{gxBUp~1Qq{+7 z3UN%B|78Uy)a$X;uUqrDz2MXrW2_7QbM_nE|4)}N9Xzls2UUfjcU&{coy6|NL7v(5 z*I_j)@Xx~Lg+%)uX4?{78Q#G^F@4A3e-e35OY-nO-**gnxCI2@GX#X!(%NNV&3utR zT|4^vh8APwBGG$h&QS0g!iRK62%zRa^C>)7D)(m3X*~+>esVL8UlW}k9dQTAvEq-s zkD0OjdzMt1(3y>hUtPZ$@%JKOCUt9aXi_T9dlvL1c;=IrZ5>? zq3iQ$4%kUaEopK@54QkVU5YH+4z^MuP{7j3Yii-DK_Ei4lDOuh zB@i$5>xQlL2!V*Hdo>N%spEg_L|O0>$ShJ=iJ*xNz&_z-2B+J42u}UtTijHau^dAp#K5s~*e&aVI%??8=@w zv1VSy)AN4o#eQZODn*rU;^x(75G&6PciCDDKe9Bo>rh{M-AF84_MD5b;Z4#|)v@q6 z?~!TnG3B}P)v^Pk$t-JsM2R&rB?DUE2hcIZVYi_oUzMk`>qPSxS>w3J7%MDvbz0N4 zXysD440Z$Bdbhh7fyR0+wm%vK+bi1SQ+gq!`@548pkLAKQL}NNF2;j*BE}T&%GQL7Z*a)eiXI{GW~`n%RF(59Iwt-u{R)1s9-`g zuXS=W+@KV|w-A05Y3aOprX%mo<*|xD%q)P3@vc9*?|4XyEc zsoqaeeVeoJ(b2I=a4D!Tr&I+&pFl4CzXk>~8^4@pO0;Mq5TiH+Qp@F!;`?jRv^s8f z%MtuMDM!=4JJ{=XU{w<%kpi66EdyPjFoyNz3PLhicg2LPd%(&KE3-~(rPvWpjdIKw ziuPrz9I^mL(4NpX_ne?yWeNqbFpyR*e^S3aHw2ZQ!^ZmfQH2}(YrMW^zFA^l_|dz( zp_&Yaj=mv>3>ILgKo)H-Hz^^f-|DCnDgnVYIz|W#cwnGOw+-)iSb}N%PYWj)Qds8! zavHsHHC~$ybr6qqsL7cVeWP@_)a>7F=QDXwrhB&n4xeh?Ntkd(6s`h3;jl^p0O3dd z!$b+}@bb!M4uHkG+rDZ|XvYI?`x?+NKR-DDnV8$tM42wZ z&)Q<*4u_IxFUP;P`o#dU78S1Yj{KuvUqaDhe)pYUB|0JBzWn+v@Qe%(@0I}?{5l!{ zgfq8cv<49(v$#`GP^)3XbK|IZe&acuJ);{6y1HQj9id>GlTG3Ot*w*O+E~nK4B5oCEJ?jL(ubgO*;GGss zID1wlWlwbETPV1OlRMD?8SgY2p8dP+%Vv7rL%&S4a5}xrUsKIasS^K`LoRzc^4Dcp z8{d@GcSEtJX;uVkS{Vrvm3Xpg27voh^0fE`tL=yH`y61c?uVZYch=E5raZE4Ri`os zQmdaNnNck+dH)((%Y9Fj<)9YL6HTD{R5L28A9lpV5@Az&voG1#{cXhqT%e9p@`WA^ zm^q1Vw>YDgxiB5%>sU!d&Vs{HCTd!@0*#Ij&e)stj$Y zDGKrw1sE^y`e5IKo)YvTyp!CQnv)~p=D~#@A9?(Tegp2{yEs&{8MiXh>n?L~YWcUN zn(1FIFxwGAjq>*s9?IXJ)!43~>>c{LG~`27m9&m`NFhOdq75(>tLn_e&E&yCiY6r0 zg%DfNK$9>k$iH$Bz_9XxDK{V+5k9PgNY*chgzNWwYLE7}Lpq%t`p3H_S*(r#ey|pT zgW_ml@N2>$qurf|t2McE65ydzG8*E`o;Ps#kT~_bn7vMB!k-0JRgWaJ57kM2@g{v) z;mbchx^oR3QL8OkIk%ixN`UaR(gFzZl#SFMw3Q@-)gApTn#ZRF;~um>Z&>gkc~#Od zQPwlk@#tortSZdRoG{K5RXrKF5Er4|#7Pno3?V(Q+<2uMrjXjkFH9+`SD$>>Z5PSI zk7Y>u`OGX{EdKLdjJ!=ozB|!XBT$31!8%|3q#^$P=PgS)CpTf?_gfRY+cYcX=Gu=C z==&Agdi;3lg>D>{p8#@6FSHcHpQuFroc#r;vx-p$^nRfMmr) zBbPtixKgZ0piY?U!wrz0*xoF(g&Hp63WK22%3A@GPe2t{b}|p++QLW-k*2vT8I`e1 z{HI$Tz=kTu`T#AKERt4bHhwyCp6L5>X`u!WeWGV}cy(pS+$f~Ts%Q_$$wIC zA+YlXkDNTJYJ%H2P?I~-UbLd6)VN%Ts={J!S?zP|vbsRpV` z3mj6Aax@mKnNQN`c}n=cRwNbXwId_U^h7ZZY1>C|&l*;&;(n3?vTlZQCxS_ipLL*E z=M5EO(qu(c%XeWiXS;y88!_IYeAyy;RG)5xh)-z4yH0co0=M9rFu(nnHX2i$X;ac} z_++#3TGKTe_HEVE2DJ#l8Bgq^3QbluR6CY(*7v6ao|7!)EhkJ?5ip?HZlKd+#wQd& zp%70wM|FU?taCgal^-(!f__Zju*5c_TGq@fSn2^5(Zc?BU{?`Id*nTwK|Dm$g{6v7 z=LM}=QcKf+zT-jAq!+AiZYhBbuVL$<0fbWbi77!wAyl{~j&DCQWT1p4{HvCCemXk+ zAF94GEUNGA8ju>0PL&+GyE}$b5QL$-o1cJ$AdPf`z|crJ)X>7vf^;ff5|RT52oeI% z!T*={{Q$~%al6kxcdoVeIc(hYah08S>NPVprfL0Cr~R^?VV*A%AY$ziI4-Xn4qqxX zQ5vS-kpnwgjiFE^1poWV)PhC~`S;UimR!cx;h!@0Lc36Xd52|gK3hS`ckfbZHhqg0 z?PoUZEn>cwExiciwgLR;e_tK*c#Eao@ZTQ`qZOC+g2>agqjN;$IJc|5jtR)^SNvrs zp43wMuqsA285tmO=Y|5D@U=Hd&CmDld5Si3ZfpXURw$rEtpF3y(nWdU6Fihg@I$Vs z{L8^!)a^c25GzrMO1#ol{rNKV$C6XHI%9kdu=4q!vx8CF;<XZ`|wp_zcx;4wJ0Le!)+kvGsjUYjtC#avvMu zuRi53oe z!R=h)!f}woQ7-Wotd)7T2ppN{Qo75_vZdh_qsY9K+DbmeqQE>i$}-Hs;0xE^Z?@;9 zxVr5YOby_Res)tBe5$7MwK0q>D7vfpLzdt-H8j3kDe(gubjvr!@~_IVcH=u3+FpPp zr}2x4L6UlvSXLE^-YVl^= zuR|vGBbE2j6Sgm-2l#*FN(me0kzuUVi72;lC>R(kk%JX7tBRs|LEyI56&&w!jSP2} zS?!dhsq<0|t0F-Ra-SJIJcLVP(%%Re=x1h)rkFsz>(ctvQ25NEVlWQu{Fv-mn9{gi z27RpVOsR!YL03`^u$h)y5X}k#!?yqS;hgH(O}mXsGG}6@ zm2M4yUHA)fMPtZ@_XyjohXaDJbBA^SBD^g7xZoERvz{2ub=itkqM@2F4svj4!e~0~GZ5Id^$=^`bb`=z zX)`t3b5J!V7Srk&Hl5$`ySb~N_qj*;fJw_hK>2`b%YZ}6&&sBVk}G5KBMpA%JV-`Q=*y=lCfAhw_RpZ-qo~Vf8D0rWK<@E&`M3A{ zS}Eq>-lyP+S4mA3L^LgvjF|rc7nUoDgQb;6`Qy72y4Dv#%1&>P*0ApnVvts^?+;v% z7VTQ-Tc5P4)MJDU-dZT8)kwy)tO(9r#OXJx29lJHDq{#L7IZyIqho>)UQfHOG9i3hy4M2$XwC; z{G#HDiuMEZh52TJnehpSI@HgYaZPH{FT!6mNywAIk-kBcmk3sQoQf+JPa=Q z>hdc~1s)U2^0j!+cY#-c$r%mI#gq6$dD5Ke7)5hkK4Qcf5a04>0{)g1chhyYt$TC%KU85WRVSt=3xOyb^S!{*JIg^{zgGjo+*ZQ^e`ySL9A{x@XNFBd|gOCP`C% z|E7|!j!A=`Rx!IB6Z)K7#)Wj{OxMV8yB1o=Y@K=XS4r%bwK&=bPo+C3x2o%Ul;&7M z)t^d}gNICpe-z=KkT}Wl4Veft@Y-!=uF#N+Qe>{+l#2p0S6uw1 zS!>AoGy69;?bJ){*B`5c4=m3X*>r&HJtM&=XhQ)fVC|^^L7s@ri_ojSBed3!c4)q( zZt6EDA&iQ;lVw3^3`8B-_SSd?vMctwPn?{{AW=0EvTQ#u5g`}c3zO#aD-d*xZ&PLX zOF{$~AvIUnz5JMM`mA79+)$vB?ZOn8^#3p&j%UA;p9_kgzo&BYb-kK2Q=82AKoqGq z3H?9>QJXw8lI;XMQDkJNgqxlZHz3Q^k#9Hl-GBv5D=1<|mHh>Ip-EEJGG(C@8)h4; z-Z@4CNvL~5MHy+x5#oC!tRd5L4|gh0YZ97B{9sK&@t-x--4Yr`KHMCbt7F00g68MA zj*(=aF#}>IbwtiHV#_Aciabd7eifGR6OyXgXlF|T{iuGP@40oHJPd73fE!{I z@CW~O8|Zn17{yZu9ywHfnb-Rm(w{oUpXb^zGy23jOJ3>Zvr5N&a!+R=t`(qWqmyYAvHT{=I1V_0!;WQ?Z`|eBwFmAb!)H zkCj#Ea-EE_FUOOGdKvPeb1_NAOjMCt4Hfg&Y-MV)6tt|NdO-;iB=?76@J$%v)A0Lk zrnK0oyXR#4O=Fa=b#K&~qphumZc2_ecgmxE?qG%f#|+?+GA$Hd`0riM{N~v&Fy+C{rGU&&dI-oJgSNz0Ll*{H#=| za6vK2U?1p&av(q_l(te8UDlNbf^FGDgn^Ye+%4KF|9I;&W$M)+>e&E>Y5k)9z{S)Z zT6WnEo_3~y^NBN58~5F=pX|L|^0~ydxeBt)J>n(Puq z_i_?_xh@kT#(|#MQH5L6H39m(We54Mg8_Zc{lC#qH4aqEB781Pd|Y7%m{wF-1n7x% zz^fbau`oVED-4j0(b6Q!nWS4l@Tk*HHYs@!9R`QqCjH76^sKt2zLq;v#&-^>k??cI z|G}y^V%&2yKU#c~ju^4mx1C$tk1!K#03*$l5iWCl^#>32T&O|x;Ug_#u?&Tf@D&^b z6=*}>wj8yA}no~m5x)1%0Ivw~1j$F+3Q;2%b!#?W}E#iN6?!FE) zsBB|ZX@$#I;ax!LQ!1vyNa~Xzrb0sM6R?_fykO@$_G}6GISi3Ow8+*_lMx*=AUdB% z7Pcb6hHnIHX`_^{BLXN2NFPT5Cv2aARqB=Z5oUV{I?)kkKNEB!B3AOnwgUjyI{WJL zGa-e+&&E-1o@L_q3oWeEnrz1n-Z0=QkGv@e2BI3BRdRw z)~x&*&#=P{jDLDPmr>hA;x)Uh7YU8$Lhn4p5ef*ml?w>V@16TSBws@`nDju|)L zzVLRi!TOeBx`x7bk5Q2V4*m~e66wrDh;Z3qr<#Ik|8zh|{juq;d17xpAW^dNn&;oH zI%PfVs$JHsy7?~PY(D`+6$cvz2#Ge(abIf8{ZbKxXl z7A2D$ep+w|o~tB%QPC+FEi84ArHLodmM7SoY*+m&o{Hv?X2VV2Jzk;2#o#U{o1;b& z;E_&He_L`!^-7tf(LbmnfAh1!*udSC6b96rh>Nf?_~zS%7ZnD|pkveg&Y1g~#4R;Lih^^iOTc!C}wCvUJsnd)zYlw)EB-@Q+{$ zKKj^CK)W(`e+Ui-4E5iET0#Bhw6&V$v+?0eM!};IoExff71#p|Ep*0iPLI9EP-I%T zleAK{fmFSnSrC5n8z6;vXD9)F?j1mweY^ni9b=T@ii*c-KOtF6%9YY`RBN@Ti0RcU zbivNf!oq6X9*fBkJJzi5-E!Pfs}UT7g)Fz~Vz&Cc-rDZD{A0lF_zZ4i1# z4N)6Byt3&8<_?iyRMlSrzUUjeqT8$+Qj0i@HvK&oi{2OP`TY!Y(wtXs7|G0kI$9k) zR;anP*Xbto9OEOU!jbSrB~F=X3}zhtvv~B+V(b4b`l70q0gFq3#lcqV7^*>$1NHQ$ z4143Chkj3eE?xqi_$$6XE-St_Yp}?Cp3rjl(LCKpAn$V>3gD$6Dp3Nl$%rK`p0j_+ z$i|_5U{~jSX&cMx0&NV-Y*mJ;0`?m0hYq)wp2D2f5)zW1i5Cxor4d(%PHeB=-9YB@ zf}Uwt_iF#1ztUlt0>|OeC5vBl?!wuaHICyHnVD1nKr;7UN)G5MTHiFee!sTyRX08B z9N&5eAw9-=ZNc=rAaG~+Pv4`M*=`n#o-z?DzihTY6wKRE82;O1xI~YL{Jch@KXcux zV#2n&)PuV%cEp9DtNMF<=5Rd@>Xm(-;!heqi{~GU{?>XvIkJ~(bFA?nqZ6!)+5R?kKi3E#cj>YW^Ktbme}RACw0X&4@4_lozM$|m&(O`Jgn2sF zXL1JNHZF1Qx~b68CJ19{mBy^TvcXJP(*e~~9vn-m*2o0t;BcNzbx`$H$4$z;!9gA4 zQ6x2orp8pkxJqqZzVWkfwi6w|%jfAKJ*Nw-i(iB(3 z5Wqo*i)4Z;>##fAha;RbmX~J1U!@&+_Q`tad6fMU>d^M(`V8<3^(zCZ)(4*#AJ7>| zA8k%PFD6cbkoMIvfxvNxvzV0cCV1mq%%>yUOManUgnh0iUL>OI??&0VC|>uXdGMVq zM!c00i>qiJ2)vgNen%A26^5oKbwO@7Kf$`ilfb*)QGV-OOkb5a#?;0Ks+^VvkgrNx zy2y5Q5>kDWQrfPtn|w3R4978V6)8w7x>GM0;@;Z)2Oi|27pGv}z{ zwrxtYL7vzO$p;h_T{6kfh4_lnahoKhxRuEI12Mb)y6mbyU~dJgH-Mqp5Z<@wEPZmg z+~0uVn0Uz0MgW3M69OxS+2Z`K^IJ(yhL}z8!d!eNBToP#oRm~i-1q1d3X8jS|PP5w45!`|A#+p|VsRJvQ6t+Z^>&yE@7(Uat8`=u5)-nHR<@hv<&wj#>0G!(NEY_jQ>{+*E` z6p042Z&oWn+;ZwPhL+58mtD%!A-TNQ$*4<_ij1Vx8AwHvRBlHq?q2bqHKw!68DRP^ zyO^)pXffIO;Redxj_2~5>y)XsGoLbbr3)+hwZcro;jl+JlnU)i3?7TEBOX~<+GApj z9*Kuf+IT?l>HH#M5PUel2p0t3Hiqbxqq0X}GP+wfdU*`)dEsbSP!YRFdb&(Fjy~Lk zh^&k5M^a+WA?AzdB{N->ub6EWg#HWMyJIr>!{CPMoP=tsr5)i%s;TK7;X~Ba4qEv- z9XuTU%)BgO1J#~_dR4?6*el)!idxOb6u1j(3qOanI|U0{8QPIG)3-!B8=TZqo`C;UpHRux z@AC!p!hc)u&azf<^1TN$S6#GI1DFG3u05;r)LM=BqFUi*`D`)5Ih7bS8!c_CyjVrx zQ1_b0u!)rZ8iwl;L#VIG{^yRr=A-xYSo{kQe{o83#p4Ex8CYKBnz#}GBc z!)yVdqRog1ZNo>YNh91`CW8>1bd!D?23CG-EnSthCm1svBUmNIScF~3M`ORqe}&Wr z8;pp^7w3h|7tt^$c2KodfMTWtfSVOF901&`7@6b#Kd98t+a0DEe-trb|6RRP3XtS+ z3f@_cDsjAf?}v}=Z(lk%A-YqJ_RAUV90QxQGFeQbW0DDj*;x5xjS#T;^qN-s z*{uEg&*qG2hJjKTqWm#X&&5{}bQ}Wb-e_eD%$`gEWcx{?F#fBzhCzf3Q_`ST{uZjI zy9pgn+G0U(r*qbyDM+jnNk;0P!ZwfJgqcs|oD3Wlw``A@W{4?;X@8HrkOp0FI-C*? z`qK*GOw1)xeLFz^Fiodsoo9oVSBF$IU{p|T;{u>1<6$#kMUwg)CU>$5w z+X9qsLV?Q1dT#p#Y>zg#v?!c~zJlRV;@VAK=>a`0(Z#34PCl+*e?iOFE|Wgqe=baZ z0Iq}pC#tv@1)L~uANIrxxc&HknUsybtYE3_xHpsi0<3x-PyE6rt`r7~X&dZM)02gF z5-~|1GTe7&Cyj>pKoh{(02pDu7=60dpt|u5W~96Ih2u3}G_t0!Be}vp!$Op7e}XQD zKX5i|HF?!o`SwISZjkSoo(I4)FI^SSLqFCQM1wnmsMZ}}DM!z3&p%Hn-Mm*+)>kK9 zb5SEUYQleZ_-w6VWFPkKtOWH8Xt1gZZ>e)*tJS;V?|M~(6uv~f)>wW@&VPKUO=To$ zLz2OWsqdAB=ekW``P!6IX->vUXHke8Y^AdxM9yec=P+@ZZ$>$X%4QRTbe#yF05DU8 zfvfOD2U|A3mbCE~R#8I*SfkQOnVl6vfB{8?-u&Xa)4!FcG> zS{k^@9DmyKDZV36J&aZsGtKc0>#Z{pRZAAp{As&6LOvy-Kx+4?_{>tTgsoxAcK^n5 z;2b5ZGxs>1P0XdBv@Sqlc^LCHsVDDm`cMh6)2Jz$fEDidDm4{Xe8LO3wmZaG5_%HJ z?I33?ovq+}1ZEsbxP7{oo5Fef6d;W>f;5>k;8x&ISGA8m>CW)KbP3W-NovTgeGhVR zBPlGrX7=kL^Btc@hi^wt7KPZmX*c6fHhN8m_q2LpvUm?8VviI-6jMmr?d(ds;T&v6<_+ey}i%uxv7* z{pQpy6fi!G9(Pfxx8At-z0*M63)OYG{aDlJu@WPx@KA7!<6DI=`=FlCZ9Rd}Z?OAU zTQqt2 zOTCs`$4(2BVT2mt3)?AtQpz(697>?Ovpn-33*|Uvj02z(K_IDDHG^h4U)JV;HlKUB z5XaH3nPC204-{U9Ua}NuR_I>_oon48h2v?c)^ZX4%X3AWij3eK=4jnG=4e+R_c6Zf zH)f)9G?@-!Tm|j80M$Hug&QA*@D1`rQ+WThTgc_I>tohJ#&&pThDI=HXsM z!mUg;qK+~nAmr7Nen{!>tU+h}fG_lcWsJP_u$k7uju(ry#JYI$9!L)=4w%%2;uJ^b zO6jR(6W&Y(no|SC8+N7zi@6`&m)r5sy>6f{g#PT-j)<7af3z9kV`S!KnV<1!6YF&g zY2!}ZQ%M5Lx{FDZrEG0JDHIJJ_hM1ssUX6Um4JY3gLe>szwcp#IW|fCVh-FINs)@o z+?+{~U}o+MX-XhXZomdktE4IU#IcgF4pmplUs`Ty3d#1BBf86CZ~$(&hJY*VbrE``+B}pFXbk2L z{rQ2$U`2#z+sL2ayt|S!cx`fZ=wp+@*gz;$$idGX>%X#dQA>easmTU4&mPU=WJ?}` zghufT?Oje5M|C1#v5p)>ksi=Mmm`06pnI(rA^K_L&u;!79v$9dQX~6wEKTanZsTxs zj3q)A^OjI^88$NyyWSXo7a@z^l}Xurz314KHc64Z4}Fj!5ZmxmLw3bf>;SsB;{_W) z`%p)I_22sed@ZYR(nc!%nSi|!dqolA05`?kQ0h2pG3Q2XX#44jm(~XQ%|b+AMXmW4 zUngpRPH!WoxPf;xZ#e<^gId_`r(}lu`PN6MY-gOfW9UFNR{ zx7rUar?YHg1-5m0ILeuu_C*b*up8jc}zX5R<)E`i)MZOG8Q+&!tW3WR>iXNK_SbCwW;Vuw9}i;k5U z0eZ;d&-Sg$=|4BH+9U9trtsvq0uw=GAQKxxuOOch4XTk2dIDI@GaV%U&DIL~l}aU-1VmFKAk@8^_PbEQ-f zk{6CZse=D@{O8V&0QcuS@ewdsRpT!#cIp`2zb48T&9~BE#~ba%&tpnh0|&5B_M z* z83ZB@6{(Q)!hPC8OlW;H7;c_i=uD}j{HAQ!KG?KAn(&Hx=4R*~!KJZhp$%P%#(;WJ zDVH*6=f&ab?SR1}04@fH?nO_~qX9_FAGeyn3X!aVlxydhZAv&XFd^?D1&zsb5m8W^ zUMbmBDJL!XcWnVa?Nr|D z;{CTiIGE1~zul=3>e3)3(fKkjJ1}=2n~$-R7N}t6cqt-`BKPqdf%c=IZ^IU09C<3` z)u0Hl^!kM4W|!iA6olWW?t>(`tY)Ir3|VkE>j5UD(&vn+62KB>Sa6(!nIAsGOp?xn zV$j5?^vRYCR_gO9(TA@mb%m}-FwToeMLW;d66Id?5Tm+5;1KX#SKagO``Pi zvmTpA5mKyt;I2+p$|&3?sKA7JR{U?@38BjWfR!!n!=x>3h+f{06a$(}v;ksy3d9&* z=sw_gl5Ci8d$*V|;}GYgZcAKC{STM_Jpy>KqmAbc-YYix=k~Aos}k?Pl>i$Ew>5<5 z0i4LAw9tZWn zZ>dk3aeSiQQ;ImCQj0PW2e)wM+SDS7GXQQv!HOszxJDH36XTnY{EceFJ~14JX=H}_ ziA?X~Eq!^x^G&H#!^;!iV?6*ui-PH}lxg?4A2}YTxAxTBI@ginqX=nvoX6*(iIh=l z^Aw4cs%rC1__Paoo{d^Ai2xJDhG=JS6>9kSj`tY$i<33f+(h{bT4A()Q}yd3=*?;q z{l|ANA<1SPI(n5j(CR-29!&~$J?wP(xmH5pdnd#+_PQv$*wo; zn*DM@Vt8Th!iKJt zxCVP_79=)4It?N(Y<_21qCBr|((Aa)cpq?YQ{LF*c+gwk%;SYIqzmtydaJ29@kRf_ zRM3k7xFnqQ`++(41}g&&((8g62n@ZOI1$E|zr$xF!U?MMixzch{AbNB`RSi$$~84;=zVacLzetq%eiqK*C!w!p5kk?A1{@gnody?;A2Ak zmI{eyOxo-EslFLR+bopz z@~y)oxP5Oli@yBKGEZylQiQV)fl@@PhCqoC8Q#sKibOX7ppJ050YpNH5&Qse76YR8 z9#_T$AbSW&W?k#j>igRnP$PgFP>;hsXoZWO?pj6jyToN{r(pX4!8HbKBoQeJ#>09M zj){a;#8LsIH08&oJpaf?o`2+H^Z&?4N+}MLQT*OlA2$5Ry3;(M$0KQtV zl=V)UaT~+tI$clh#@8}U{|v;_1Wenme{Lb#L$hL=YSkf20b$PR?BJ$q*G}3!m_Zng#y%bAUIQ7)Phd?rN?<}XCM&&MG>1$R1q(=g- z{y+`2h0pMpd-3ZegNawb90A=2%;_KYzJJ2^44P=Ff7YHib7aP27EwMvjC!teJT%ylr@>>KfuX+>K}|LaN^x*- z>0)IHn|Z2pMD#79?sCLp;Bvpz6ftdq_!Qgqm&4W-zESJbu$g5!jI}gtiU4;Nh!$?t ztoiUoH(=`2^V#x^u-m*KHu7`1vI56w-aGJ- zkfV9bv#}>_m3o26wxNyFB!eY#ZmCiw-h$ zM`O%Zz1fKUZ_@H!N4X*P6#I7kJjJG*2en=_Xnyw`{&k*o2C-$Fx2NU*X-w*sS{&*_ zgv&L$nnjW-2L~JhIA<2JYcUzGq$?EaM@48m)`+9_;yy9gF(m^1@vmvLA5~tQgZ_Dx z%&m2ge&#eV@6c4FGau8l)b8pLT6fs3c zJEk(QN|5#y*&r7fhpzHFiZ(m#`2jJLriDZQ+S3)1AC|gR@i;lG={LApznJr#EWO6X z-+CyX-~FA6c#96b5%8AihUcYKIh<3;N+-Vq+GVfwdSMMlQvD$vJg0O3315^+sA`)8 z7$%z1Jety9FkqVAVE{%z59^n&fVS#dW*}m&t^-fcMgDNJh3V`En(KI^Jl&WK2f~SD zt49A$Qbn`_Nrn?wdcW2H;mDB%U?T~&6iukX46l-{7re&V!Yes8Fjw`R8FZc#7acFh z`78+N-JI_m=UA8h2H4veLcR@`_I-bRx@-EH%uu9D6~%$6zZ3L$zDX%gvx^^_T1u@` zVx)3hL1W<@Tc?*7ux`eub_##^bFLxBV2-9FkESHcAdlgQHUcdwoY{vF3)!q&u-McA z%J>BGaX5g#sCZvwIR`K9qZ73BZ5|(vc&)!`ahc_iVWW2)CtXRy6pT0YTmnR@KPC`c z)n?-h01NRxp7G#H07fBI3<-zULCFo>f?gV~d+@;9$^V-rCP(uZ28Q(m8q%sa#>v!P zIFDl{&7yHL>jO1{(Sh$k(EZ0TQhwWpJD2{mq1H$iA{!JfrLc^`L7(QJzX`aMXQG?7 zpTWhU;Vv!enao+ikD6Hm^g+aOGN#ox4z-K6iIFXb(?FOOHv$DQmGK8eTG$tUC z(dd-0F=!J9K;ul#3@~!I-zk%&Uh3xt%7s@eC28SJ*k>am44RQ-EP2a04VW!sC#Ya% zz!#X4P8}bF9jl2zF5}90QK5ow*`l)CAMA#Zx<~+qyqez$z>rsSn!v7jT5pr_JY|Jr zZMS{<8O2qy8DDhHdEsr=FKHQR_soN)g(p~Tq0 z(K27Eu-6f216d)g3A~M8$z1h|G$6H_eiW6X=q?Er8o$viK{E!N!Gtmw=pi+?9}d3k z)yoysUhwhI0qO_KbD0@1P3nP%VlG_n=sN2`>t(Q@c1QCP)GG6A2;gCm_Dp#h30qjN zUFaI=KkW1qp)S;FGDu=@WCj5hk*QEwUn~)zQ2O0<1VAVYj~Qm#1=XF8L>bEyN0N8J zY_=L?z{v|+PO_L|?|HxSmHl7se`JuhHQ8zoc3}S=jx04tIaaa$yV1c<_WWu>s}V1I zC$Rq!tND{eCxY4OLK+OP9NREe zZ+*HHs@&dANk_T&#nvQ5leu2r$--kVfZjZ`4EifNiepmPN>H?#Cj}xT2adbo>f6QU zPON;tThGd^K@<((ZEw@qpS*pm01W<*P6v+aKX0SwW#9l;zDd(a@Ac7onwHy`BWW=s9?<|1guMtZI zv?^b0yF~q6V4hjyE`+)%No%md!5`L|nBw*yw`QkU^(?%x+qUInTA508ykMAA@^g=w z>-upgo1(3ca8cv>Pnt%UGS{x2ku2-1<#wDre;x}I^=p$nL?t)JO%n)N;~;ieWAw_w zP8~pjRdEizKBR*(h93Fs#IpmVfnm0`<`ba3D(>^c2D`$)9;ua8z)zu+yGtsYQ{}Qwsznq;Vvw+RJGPii)y;2 zRn3}$a#G~^i@%f)S~N0epgPtd%(A~UKLRGxO2y67Nw}1}Flpu> z5LypZHO*OuRaS9+-UKYl=O*-c~6&Za$M|FhHXw_dWO>A0{2ZHF z#v`<5r7ikMkL0`E7#i2<>uI1d)AX9WS8F?c7Q~vKW>h8>L-0$$n7`mfQ2s!K^9s5O z{`Suy&yI_a{SnUw0V?#F?DZ1y5R^iHz>K~t;u9WMFkU%N>hn7TW^pqlR&`|o zk!Ae@_{4XGd&L^#)~NNcE87jD_!1YXrkD;kvio2q!0FV~L1ZUC3|1f)?!^uOgs`J5QC zw2x)1dd;{6&|B@f6AW(3+|7pV7NusBy^cNg>GcD4Mi zGDY~R1_ySpH>$;n?BAzneZ^>NFwX+@CsV7pVCxN$Z|N7ou^+X0o!iOJNi$s4Ig`o8 z&}yf=8JNxT7_YBs{K~GJ`ex{9oY5S9>K+y{h-Br{V)X$`M1M=kyW@vI)lZe1lT_Bx zKR}_|cc}!b5y=~TU_RUNKAdzg#ynI07D&&tp>j~q>rEw>qfNlm3DbU=aCJa4UE}c& z`QQf*G7s{CHcXy^z(}8>&F{c4ne!A`V`K-BwVwlRyqCxQuj&Iy3>HeiXgJl<*F8r8 z;gX^2={_1^AV81i17wW_4zhi>>!qJ50Yx{@NEV)=B18`O}ps+fE;nG zh4EN4z)8CFFOV}>@POtIIsM`zvHB{D5KlY+)b!T$5HI8jeyee@HwLE>uZOY#a;gW)v&3s za2s-<-+lDCcvQ>*H5@AlKsC=P>|T!+(umwN4IvlPKl+$?eUA;4w*N2ea~H|OQAXeV z9(M|OZF$&A>r)Ygi+jG>)dLJ-tB!CX`6>DS!lrMZ0GLA4vRcuQHZR8jyBaSO9>&<0 z31DXbmYq*m`77W<-S_2?c1LtT8CJK>tG&T}FL)q?{{*!8bIlVSkC-SBJq)#_e0<0(Iu zU^JAmGCJ|R2$^bw%UupNRXDIrs^n~Kg7j`cPu-GtCI+s59vQ@ZsVb3dJqKWn&}Nw2 zfbEPsG6?84O%9#L^tnzMk> zY{>7==VKe6jB1sEXq$(yyKoix2O3mgl(>oj^8s(syK#M?btCcthGUosE2~XU4XyEa zXvj*dvFL-Qn*G;81eMNjY@ccsP2LayYm0xfE6VI|u;>ivbCAROAA!S+GA3jH0=ZI# z!(H{3KKbyK&}Bg z=4f6YfUpo;ZX%s&zl%?B@)YZHLmvQ>|9`bP533~=Em{l$B--F%4`hz^J9iR5ll8V1 zm^a+pzK`q36Z#w!&1gSECAx_K`a|Tj{zGnnHa~sfSr?rD@vJ6?>I=>QWeAwNr4|}| z_f)eY{vE=l$?WZ@LnqgGAyDMZi@Ape`f0k3dsBjY@+Xs)Zk^`AcXuq%b3Bm>9X$_J1`j}D& z)rIR*t)}HJxDUV%$8SfttbpD0W+QvJOAqG;n*U#`eP-E{LG#Wqvoq5^SME~){@yf` zYRtOEK(dn8#sEoc#uWGAJb@Y6DJGvxSF-Ow=f8FC{afeHf9uSz{oe_Knf&zHuNW7s zlR@p3ppkVuv2}Iv&z5t!k}|6z7Mj!zmcI3d)wD+Kq3C9n&SW1c3SH=mE-fB;4>ZF( z#>)mvs{aM+!y>%{`hl$k&b$5FN@m=CXW+Qo{>zXY?HN{#hhL_{o(BAAR26N7vptqC zfawsXoo*0fc7}VN+!HUUBaG)WFys6$(E@%1BwA-6(Y6>=ZwFk=zcX)`iT%3@6TfM^ zUOK|Edd4P9KOV9CY$C#W?(>{yx6Nu;SO2eB<6eUd6QUFzIZ1R`WYpjN-K$>I#Vp--<;ci z&`-ovgg`-d7Yhbj-(S;|$*Nzj?G$vMbEHV+Y397IwjV1y$vzyu7c2lrn#{VV zDnWK_l?Qn5!dvgH(@T1nG{?}eMC<-zkME*VA;qIkSsPw^_zHzO;QxSs!$=)AL~}s> z?c2tqIrys

    a3ntu~Iq4 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

    lxsm^e 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

    r?hHV|G^U?#y~) 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

    _e$_is=AuBHQp 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�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 z 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

    @m z(L!7v|F$#ic<*gzwzQ=K`are_ER7k`nZ}Z3kuZ&LK7+5U6M!;ym98&{uF}lHXDM-D z=D)W+7qnbF#@+}KJ}wU~Z!cHF?l^vCXnHh|o&%ph2wPnzoBwJ@wAZ zjS1Hg01wu^}#QFAMw^r76Cc9Av=xF=w4%D==!uq$O>rb$7@`4ao7&x%u zfdc8(Q36?9CMMuI6!K4^cp_8%(iQ6)&vjp=7Trz!`*!Jr8dfUsJMbsgAbbw#>QAaw z`SkXT^vNY^!j`}1 zfXk_&w)c>EAfJdq3XEHMwSZ^P(+oBF5yqV`{op46f3l9wrl>_a`nIKYz;}N*bw1Ni z5NwF9kcF>c!aQtsOh>PSQykoB?aZs1(d4M<1GihjzY7PZNri&!jZxDlMcjZ+bPtF{ z4FXw$9hD}x)lGI=kBJTG-dY*RKnhawi%Pl&y$4T$f#1|p68ijd61W3Q>CAla+$05| z`D)ZEr+Odo{G|fdop`U<%6K$xPmqx7@7x*Ube7>3>!XZ&DN2sj-SY!0rv8x{sDF;e zi^GSxWu*T}bc$cXN_jtKy@GPHGJdWusOL=RCQUZ#S%78U2bOu3Z6e4OjD7X3L|Vf0 zWK=FOI$AJc0@iwD_v_x)tGyk9zN=zhc*6l>xROS+S_|Dq1A;M$RHH^o@Fple6yx^G zIu*Kb9t?&++#lM-=zg#iHow4_=p>ThY{-_Z&ql1Yy*j+s1fP|_hCvOmp;3OiESThb3D2YX(1PudM?PO!8TBU7_TS@h$WX5X@}JGFSvpEHHvvbdh<|0 zco|!wAcR8-cNYF$9C8N7Iqd!8=?MJ;n>wE~nz zwUIop(ES(Vq-ESM8?F28NC!|~on>e)qLW;kt9LQkv15@po?np4 zvspEdEYj3-g`WzHE`q$^tO6{(r>QD6az=dRkm&335)a*B#A?!zR7lC47}MT%c3ekX zyYWUjJOUmDJ}cf!gQ?rU2Qwiv)%h6z{7i&iOVeON0VfNEE~Yc01JeyQO4CdnIyI*EuR8KRo8sl(AeS4`684NlT){!r*K0+u= zL{OYc-3er7*@`h%8WSV*r=$C}ZE4!pMS z=?8Cl(yyc(LS}pyfOJI-%+qT~G2VB*QSjaW8_1xWYrhQ5I;I))(21q%+Fnwt1-m{) zSU43GA)W786E>H9*v+z%h%$Vgf)-4J;gGNIGsNr9L2Y^en+pt(5pi-!alVJLTa2=L zI6tG&GHJ{2&12sZO%)Cpk1~B@Mlx4An4>b-t`eSq7z{J2P&;~L45x^j=K=ewtOv$c z&EWPvTk{c(!a^MZtx?l1mD7ASIaU~QDNz-^CG#%b5hWX^Tq%Ebz2TvDQFmsW_S#u$ zV{~!&$?j@Y|G6T4%Yl*_=ovczhachj zkZ#SI6pNB&2L%>qKT=S{)es8#WfHOGe!D!Opf_rQ^1D6c^tuQL44dAS(S;|4aY&vs zikgM>DaPa`;mxH&BL3p-5khoyx;R^4Sz{BZ-%M=Uk%B#5>Y|t8Q_yVr2x?>!SI*qf z+lRkhojVMsGszM2s1~O7o=3|G2nwu5skr?Gi+VZH;PD3+wwnY2bwUej%+B;d{LU-D zVSu*y;W}N|inM543pH!GYROaAA;$kDSW6tng_%S% zqCrQR9{dejRu=k_>z7eh?dw!vHp`4HB%1E&G#G?j{vI-41SX-Yr#s0)cpYmv>G03` zpF)AyW3Y)0kGdt24{@YE6^&*@)Z|Bd~bhkO|cD{CKWXV&P7FXwQ zU;s+;t=TFlk05;{7f51*a5Iy&w3*n-D?ZBfQ_euksbjV~NgdAJ=qL5R*{CZLR{?Fl zi{hYDX4*oAGc*M$paizixo$0fh}KzARs@qo=l%r=5_2M^TO5N^SL9q4PBEYRQPt0&mqg$n%d2$Us%7&YQ zlkQwWiVAUU6xC*pUxvnXTk}?oowvOSX@}H+ypKO{Wjm~8I~^1zRc(N9M2TAS3@??o z%lvWdlM^~FmoVMd8%4(9*gm8W9&S~&KZCn`^YkZe@c+BV0mSmGSyTp_>9>uxCp{nJ z7g0Yp1S=+O3)=waNqKMA#O-)6mKZ0+=%c~#eM}4wLx`!jK zvNsgO_8nhgn^1pTOJ^Z_t(w1mT)U1;-cSZ?0Ov)9RJ2LDIU0Q}?(m!&G$es8urLtRf3wJeCborkU}L#wFliq zK8zps*(cmV7f0Mp8xaev1#f_11UywyjQ31Z*p#~1C7ysoiTJNDaV7`cJEDWObu#$C zAZzYHsi#lMT|~RL%Aj7vu;xSCvC@L)Zc*UQxu2Xe?mMMpVpr2bz5`^BcIro?`bsCh7$nEC zS(&k6HgmXv-;+{nXxnvHH1N+?*b!UM%0v7Huu`6KHsbZU7e+V114mEEp{V3{WR}*(l$=9i0HbPK(?* zWA1K2YLO6mw(wzSId&RwKCCF6~BAUKp*{S=+aCDrGZ83V;-1Bqca=m;n$FHM!8=_P=5qFCVQoOa_BRWPD;v7aM8{w!^G15r^+k;EqAO5{vVTcULhoD>7<) z6gta7^#TLRQQs_w%K3l|A2A1?R;u=_1+5v$k_#!N7as(4R_-Nu_Q&jy$fJQBX`>W& zb8CgD3A^wKfMtL(myu2!ajIBXbvEIEf#BmV?lfqp9IW> zmgh=5l7==xw*;CF24rvHv$DzD-8|@|pzY-En2A!}@)on}S>&pJdSnFeIo~~OST7fm4fBt z%UJymrjEXmmW2Fe3^R6ET1_oJ}F?3h!-6;Rr7`{#4&2q;h&2JPuc=T z-+&s|WgN?R@>KGF#dIO(o)L@VxGq9#hOGoDFja|)50Nvk)3%(tJRo)s^{U)uPBvdD z6h7NkI5B&~rM?%$>LAA0Ke$>0+PEAP$Vr9AmDZ&??-|1*hWC;-17GR7PLz_$2$6e_ zT2QMBKsDu)AY%nXTW{6T%oE~+qRHW)$K)L7G3gYcfq;uO zWn17aX?4~9X6uA%NVY(&{{C7odgtNqNYzBy1tzJn^-SJKmD6&>psteT@=_4D^bW2Y zD^iVtBIm|8Q->@_)RjkUel_uiq}U6+MhXsIX1ijAYz-ob9JMFb9nW_fj@|&9TyKa$+A^D|IvDa+_??xiH4^m@{ zWPL4!I*+7tIPdJyb8~l({@C2wAGMQ`73>1FtR+?jy;94d-VogSDg*k6qW^C37H$&S zD|L=vB$9k?D;V2-cShla<03O8G#j8!|DoxS5ttbUjWoqjc`R#|M&B3-$O}8OUOIFr zaB{(0S9a{wLFU@`FrVe5B$0c6dj>+yP`=XElIv=3bFj|6^dLE~UA9(L3*NqQP`j^ zeg#|$7_IeL4$B?g&^hV*@f~NF%cc{SUIGgihZ{||+NBV*@y8}hi5MS)U0PY{@MpTV zkf|nEHkV(vyuV*TiNW8T&Hx#6sGCgJtd1Gowyb}nqbLqvjG7;FMJX7*Gz3J#mB^BZ zw#H%02UxDLcId1U!KX!%owqwdsf1g5sJPI_ILCry%2c5!#0YIaLy1n^XK`P#Eo^eL zyezKoL+SnO@Tk&@o;L1n84;U18B3zF#3sl?&DV#U_m{N2M_&|@zCWw#{*?Vny=jo%o`)JnAqKU ze(HGPQRUaQ&sMbuwC1EX5R{lyA?nw?z_>kLc0s++3ts&dvf)w|n z=P0gVC(v`~pz8-`^|F=_2`gJf%hEx2PqwD45c#;Q5JCdJvfAOlJ|)ToFMMcqdu@N6 z{G?M;K_A&w>Wz@iD|gl~UrdlE(gK6;33WVom4)^QR!aN;hs}H@;Q2qbA`V|#F4ssA zpz)a#?T@wv-^#7rClSB2Y^0ZUzzSS0-?9b9cwEnO32m;IkZA zFljaeSB+&Izv|ri`-1N;AMO|6F#!kp-^*jqm+E9q!!8++2n!sxVC3A~ERN&p=B@f3 zNq$P^P3IdQihaYRxz>P|gM+TeYF_)`7L_G9G3HLbV{6G%63{>jKzg_l z^eG<4djaFCnoTFEH6D@>;ij&-V}ajKK)X+n>$e4dy2IuI=2am(1WAi2g$PGv;MPUC zH=hD~GPQUg9`$ne0(d0JdsK;DAJ45P>K2jr46pQBjQ?Fh zolNy9JUnM^8OEQ$cJKTAw?h*95&;bvK@J2GL1-yMBCt@yX%)A+uBVoRRylP+fWH+R zuM(zs^zj@! ztPfwBn=s*h6T~9@K@l5rb6Ld4IP|uA+)n>x1KRgH#&_4z0F~Tpxb5e;#8~&h!RRw+ zox*`hVG7qo>r)b?WYw|$AZ=_|bjkq=2k~LgUH@zy^6$kuYDNsX>GJ^CH2-1$0 zSxXvJqX%5ylW1&i?gs81M@LN*;n_|Hg*q+=TOSnS`mK;K-Td*Y^7%up#ZRMK+Ne2T z+TGWT70I6aJ^)sW&zv&SdIzt`<{fI7#IzJh5u%P!bdK@zOL4-4AuE<{$K<~`>@2pP zk0C$3n4BGcmNgek*^)je{@y!z04N=kt};2wGGbh>y<%6tc!LJO)>n%=!j_XPGtJsW zZ+0A?>;Mn)&aF_e-?U5qAvNwdfZh5ddq{#zE zK51O(CblW|>qJ5UDSBY+7S5yWZUP8dVc-$k07CI)pfY7AZ%biY^x@Bw@mTom17-)^ z^J8J`DX$i{gt|6Eigl6X-{~YE@m7O^s#O%p1RYaeecUnN zYbNWsa0*gsV1}X|YiU@P9GpVkULMTzuD3I7Y6I6otlKXBt8oVe1$=tbJg2M@S7OJr9a+CgtdiRf^|pTS{8=xTVuI7 z7KTgOi^YVNgm@iZ) zT1GDoo6704tELDjI1fUdBMsJX%S^?`HW2a37JvZCy3q75XCDv!PhBDJAEaQ+W+5j~ z&VB&cokR|N=H!ikg-Gsyx(Kv5OR|5QCeRmB%){SfneYxpv2M%n?-rY7@ zjSg)`N1k*(4Tt+6viU2ZkgW9c&!j`kqD_S_Sh9>aEvCxws6vNeFDrp+ z?-n2>ME^nX>7Cun=ropOf9JkTJ2QROrTMAKF-{XEFZ6i)Pfe#*wV>Cvg0;1rZplM| zoorW74QWB=zZ4w4{W1wckuUnC8K{2=loFFNFe$=1uPTQ#e)o&&G)#ScyH^eM;Mfj- zN0*}-__S*zg8E)`5&T!X%NNQ^H>+xl9AgM)*Leq1(m=58XJMwWkLf?&iKYex?HH|c zDz6akCmM*gJz#6V7bxuZJUx8LC}Q~}ShmkkzCL`rhjIJj?2{>Sy6lY+Q?lK$t7fgi zY}Z!pV|QFG6mTU>i>?%D*V^+wgw~2`KwLmo>d>ktYqcbUQkI&asopUu|0SYn!XUpV zP`mtwwv`@i6wd;p*=Ly*!7=NvA=0;LdpsRK5B8(SW4V_JoOsqf5#k1!yrHm9C6ONHINf2n;Nc-i^!Sj%e!hK;5|hnV|uw zcRj1sG--JF>Hl-jsU^K5*ACA;sO**cj_Hx|{DTw{YCl^&4UYW{gmg4cr8}Tj6XRU4 zEd}Ilot8cq{O{hm=LeK3w(gy9_Sai42ON68cco{|hsQu4_puaRnkZ~11_64}TGXA% zF`2VEcPdUdyw@dZn7YkIKINZkdV${rR ze4h%_gRO5HPRbQ^dg?WG5O2o(EPi0&mi1*@jQ@2^>}RZ0AuI|wbAa8aN_uulH;pQ>~)XS9$(A~L$V^v;Cw$*Ml&di@Hz*=&5|(oRfi6kRDa zzV$fm3R`O;CQ5}{efGx*;+So|PX6+o75UMn$hZt|s2 z5gF<0JhiJ6!AbK+K1SAwW{)MHgYmSbgZ2|MBi>TiIw?opb@w%pGxZU@P0io{+=)ad z?x4=@yU(b2i-Y`45!{O+FSJ*r--!vg!tngBAHQFzmM)+ECP-N0;rw}dPl%A|@BBTa zI9Yt{_P_TG(+%JQIGHFDhVI}SBGWtp*E6KoWhP1m%jc;~hyECdewQ>l);jj|gOItb zm6&#O(nh#CYwp(pZ@z)6|CW0hjswHK+bU$vs#TOh;gdqdP1K|ab9t$)`ibpM%PQb! zOkHiZj=0Dd<58RbsN-W}sC(@q7DzA;d)_DA!|r>2h~lSZ5Bl&m{Wwrd3{GHn-o$Zp zzF=;$1z)-l;irnpumTUC!*&hQwWf7C+ohgH%>>lBJ4n5UqP)v{7%kiG^w}ySfsIUa zM^rcD0JY#k!S#)}X-ijGyVKn)Kz)fUm5gB<_j*`IEBU2acrP5u;O)IDJ^I3X_f;fk zWA!&^5uqfP=zdKNCW;GN83BUxak|=av%qi zGgEUndZa6VZt0!yDy+|Ks6LyFf9|DsN>3j6S}dUfFNw9U!}$UyZ^^W(D#>e1MI+$k zgFl99+QECMi!PiOU$nhsf*o0(-Fkp@FdD-a@0KeWds|L$zHBiFq#EC}-1UD+#6Q{? zA>{Li^3zEOfVx}QsPsKcotpi<UN$wbG43KLzfDtYaKsQ{VsY_i{IlX8Jxpt@KUp>A6q z<^sgx-T$gt7~fokPfqvrdXfQj5aOQy+BA=t6$cJoLaAAAC!7AvMd)sL2wuuyDkG%E z6Ccbc4nf|em-8pZY0Cjg17Kl>q;d7_LdfF}h2Xm!4{urntNy2k1Ul&8@T&u-xl9NA zJBNUWReA!G6~g9@^p>VF8tO_7@95EQ4$TF+0${q#Y=Nfr$Zc-)3H_9w@1@)`VVlhC zaB^dtp!gL-+VllKIumAd8XT}(VthJW4jiiy5QA73o%a5H6UZ8%g~ArJP%ORqT0FN_ zZQRJw=uPB}1z0Lfu94^Mtzb3O6=r8EodJ9B%>eJ{QpgK3{}NixgqwRQz2`oRZ~K+q zQhBKtj)BVS8xilw8T0(fb;x0Cw5fxxiDuWx zkA>~v?n{l#Y6a3Hw7gg*E(7#Oe~o?# zlj999z&INOqHr_r+Z^xhTQ`QT4*&f>c+?G=g}PAD#HjVsJ(r2o#{o&W69s1~7;vMh z?%w&p-ah-)sEqxkmCYi>`^b!Mjzuc-Sm5m_Tp;m{4(ME6X$1pKt#AVd-kSD+M=x{$ zbbJ}kgM@ddSCo!Lh@1Rf*F-DtCtY|zSk-hMJz&+u*QTg3i@#Fyg&e%@=b<6}xZt>z z=!PL^kdpQtral3RCgZNxM0u{h3;7Q#b)WoVH|p+{ZJ-M{^fY41DRw54r|s^2VAzV~ zbqycwZItF^D$K89zSO7TL7e7`Z-T@`iW)RV^Bq#=d{eLveVA9#HNxzy%PIDkxvj5l@u%b84HstNa zOO%ls$c@WlHf=4fC*fH->JN|`%*jH`=EX8+(r2rcT z9IL<+u~RhRMgzH{ z^<#;Ja0iUR9k3b`wGYN~u7PKdNH=dpL!8tQoZT}0d*hou5 zqG&`z+<=X`v&$n~;9Q?UV4vka+Mh&JxYBtlqVa_10FAxatCfAb;~$IhvPa2A7a#OF zT#sqQg|;3*zmTYNy6A;7i; zUn~RAZJD`lu$~1x{Q_cyx*;6#;Z>{>JTW{0KPT?7tSECtz{^%pZ>>CPq8 zoT`i+jUQeD!{#1rOnnt4QE}ldrJv$pd2C9qacb{te47;9Mm`VB?{*Oxm4AT#5)`VJ ziS|cDLCV)(Iuf0mp>SavTOn(vrf7HL_LJ`g(OM+l_%kSH$HQJ0PlveT^BGI<2aLp- z;lDV0D&G6|43~)Z?4r3L;(HVmi;(AF&gOtEQL8vlALn=Iy`TWMme}WhqUnu4KkuWk z7v-L~N^wP;xy@(~k^m}Q5@3!gBeX|;>ffW@Is@~}sJo3v_`y6|Zq>32x7d6obGfJYy*gR- zggt1#!tgugU-kX**d@=i;qle!|_YEdff#%}gmG!t@d&AKhvLQAlcaVGsz4~X6JoEG5 zJp_oH@W57m{$5#!t%A=T*{VD!Q}A1n-s^Cbk(TXe`~_Q?&l|d)*+2A>HQohe;TAE$ zDlaiVUrP>t?dox+5VYbl*S{gC=VxjlKR)u_**yq)*aMH2L$lE2@GEUP_2XW5&*`|t zj!MsyTjmrS?`mZ`ZA!DQCUywT`hI-_R6{p?p%TPz8dTX-I@MU!xO-Yg z{hS?VL+0R6#}Kai+awp0{gi3edz(Q1mC_fN*1sWe{m+~O`}*y^!3k(x#3{HmF`m%# zDP)e~9_}HEvw&movw1ZffgwxM&`t{>6Xh1R5y=2N)lI>VWW5x@>s@FFqo`9p^bJ_G zZ;_j*Fe>8Qk4UvC|F@NnU0rrQ1a;rHG%%s%oRyqTz$iKZg%SwZj|# zht+?!%dIlRU=z>M8$84kBiA5M>Hkagu^}F=SKR4*1!iBT1Q1tdM9Fu-g zj!;@uYgb3Q1icZ%sa!swG^Z_VB2)ga=Vo?a z;nAhpcHxcQ5&?I1__Xn(=RG7G>eX>|0kd_OS+z8hxQ4;?HWl74U43Z#miBY!Zmi%Tc@uoj-|7w!>A4;w9==v?VX zlwNK*C7Pj=^pS*>CxJ}jobQ;(II$XuiGMF>*h{UV%$T{GZDXIzTmJ&8`Im*kc@MiH z180sS?D5hE){j0g3WG3x@axhF$DwC=W*)Qc#@VAcm}-}|&U=L@*M~1cIHHP+R{(W4 zoHe7WW}m$T>j9hxKH7Nj$k#;bRz6|a`_)&|IR6|f0+;4VmE_%VkFQMw%&w$|U2H3E z7)IS-HAbyGbX#RbWA5h8&zO(8h%&#+PID{7>jWqsY&2XzFPd@wtWL&k&0XB$5iPyW zaV3gCi2Sf{#^!KJu?)87^aDsp)1Dw8nu8~E*LK6ATy?c??%tVq&MTjfMu^vo6hUUY zg%0{D+GXxQVH;l0%a6hKo;F~uac_>#vyIOjmniV$5Yb%=g_nNOVLjncRkXv&J@o;o z;q6x6jI#Ud!`UM&@0p_X#L1Ui+SES?TElZK7LFZrf8axi_zU zAwHp6uUP3FsIzRsS;{4(2e;M7vSkfMH-$8bw0>3K!lv97+P>%7%8SuWNx_jpS~6TU z9L=Ad3Ck@EH)S3=y)mh!AFaQkfBHoS=!_W^Rh{dTll9-nt@E|2ie37lRr3nZSg%Ei zUJr>4+V~o@S(hGvR;wU3{gxu^Y3;u@xmI&nZ7*+2?}qA)itp@~QpH9X?9VVT+B47H zHDKvAS6}Q{n+=-1hVQR2PH2HdWtv z<`wgqsn0ea-X2^HtF9I3*xriw1JUxe$Sxt~mEB>o7SL1+-@OYAp=URGqrHxTywH|^ z8}XuD#`C2$c9znU5|$#C!sT*edZ#_{3?MmP^ic<%QvQAj^`QmuBKPQATqBz`B2}7f zN;Qvvtk6EgV(>s;xT;9H=ZxC)N#jt8UDiQN8e4b@)+!k(~z|bj#SmwvWMWZC=ZvF(7+aDo@31GP9);I@pU*J7wb-o_X21I^`8r_u{gIr zs8?CDfSZlkalwrxiXO;@5`xfHX+wcoTy@+<9`eJOO%PMv<ykBIy+mqTQGX z26MXQ+NWe^bZI<_GMf_-<5bDbw}C)>eRneI(|-Fo4>GYlKuKSEvX%=c?qrmHQLmGs z*KmR3&1i}-CGDi-tY+F1(YV1$T=V|lC}Lk3F6+AbpRbb!pZEU_{6PS-juweHH%{tf zh-h_gbCoHG9_QXJSz#1=!k({nz<*`UhP36<1uE9LUllxy(H|(vT}>8>}GCcqNaOM@@la=VNz< zz^oF`!da#u{*7rz#G@;V8xQ4+te08i<^S$tvcgTZ@6dpY0splF+1Ju@Irof=uhrcja8>koB43RV&OxVGJ&zv0 zbzNxti{lM!?1lMGA@P(z)C+GtOaa%zFIs=IW#8Me;JlkoM!#LAzWPeKiQU?I_UYsi zj2tD}14u%ANA73@}6O;Si-`T-O6Vu=4AcSDS^d z@zc^qB3PX*&oSA9+s0KbUiq3E!|H}&I_N~fdz%Q}TNXdx%bDwQyH5q&E~pIToAs54 zDz2~E#?%Wb4ED^egdF|rbE?;Mu3`b#jDAr{Avx@foGLy4IXiu#cNZ7+3D@FAnG*3W z>f^{z4lrb5z-3W3zejMQ zfa<1`*AC0-{#TPPQ*stXID-2z+n^(2!;kN8zI|TwxKIpB)+MK(&%45=bS7~=6WrBu zcE%Q=uS1G2+R*AkU&E zaWEcKsAOz}3T{z*KJ&?gD^9T`9ixcTG)Yq&5qa}Wzs>8rr$C!Wqojqlaf7AB`1H+Y zp&_AFysWVh&z^|zb&-as9J8rrF*9n?4wy7G#n(zCO4M zoOt^KB1U3K_uVia@3>(6z#x*l6=0X!cB3{LM}u=2vyX)=W)6e4#nP-Pcb{{0K?K$B z+HQAR!79A_M=cIBbUoHYhseEsom;)``yp00z>2w@KcL5MP7|G!Ng7v;$HtPjq=9p( z7UGMn>3O(QEWKi4Cb!++|BEduicWiDwEC&Fz%Ui(PFAOo5mlFUv~negYWQpd(QU4K zSB773f1kq+cCH9#?!I|DGS*!4Rm=^nykl_Q_#lI=Rson4F2f)-_176JWP$I*ovxev zc-w*r3(FT!$PR z+=nBlm(FQi+6*@nvkr4ftAbBOV()$SiAW{3EG$+N4=Tn`D`zY%UX7sdjv2+AkXGB2 zs$|X7RpYMq4AAUf?trIZpIi=YBnYsTS!lhiQWYy@3?_938>^gEM%+thXNSBQ)W)$D znNlo0i3BbebJ;6T{jfiCCej^MeF0vaK~&sk-;$F=;4e#*NF8a+Z47M@JDjB3Eacaz zQoCHvwm!75Gw?K}Ze(}DH3{;4E-iiZoa@y!Gfu0`TZqk8`_11Hz6UCl(+EP%a0XnE zttDbN@RGG4!d{7c)Ra8Rma0FUE1B7E*ov>KyKm1od*a^aZov`|b(RxeAc`44ci*%Q z9z_+|+Q^X>IrVqpGmXkNt$Y9SeS`GRP&3<9N#@JrbdD|h>2l(AN&{ysi@> z_@moWiLG@)557Wo7wQ2e-pH^eFvy_RzgK zlxdjcPT|13j5JhfyCGvKX+>=nUOyI0C0dB%V7%lQSLBo;S0r=W@ko#5C$~OXxfUyX zl;^p?TR#IjzGMfTNhrFgtgg`P*puA;-7?;RnLWQAiYDQL=lOMr3+WXvGNTurysqEG zP;AxO*ANw>Yd`_3FLy|8*;%?vVxm6SMjx0hD`4DFWV@j&386W zA&Q+dg5)`E8L*^$#X*ENlS4o9`-QnwfJ3J=+ur|;dB%sS-CKV&#dyt6F#62N?4XWD zk4O47gZBM?7dsPeMT`LUWWsa(riw+_wEC&=4j$)WXBU6vM^ejQZhxKGU!I^TGyHjy z4{E}S-eb0L4`jN;x&h`RRF)3hDxG<vd~FW0z_Ol$7*5{Envj(PRN*gM+x0u&#dq)cK@60be0FMtzCfkC`q|D#gVUol zIg)L`-bT8?VkfV&Q+eV)#7SN4R1*1P3PUyM zU^fsQY{Dd6vu?#kG_PPIs@7ljSSo%J0q@%g{VeZQLNLHBZIr*!YX-tuV^`w;zfQU+ zGdsFoTTWpm@M?tkz~Or$xNzrD%(m?>wvfDDHIGpYnji<6acy*ojHY?qt$;P~hI!K8t6>JApmrszjySUE>bYoJyJ6d(43L ztnaDrm2M26sUTm?wq?Kc1J2(xNKvpECZgLG_E_yaS-UXFvIm5$5zpWj9N3f{lvifV zwI%2FBqhxQp4j5Bi$1Pg(zG``!TSSs8SKs34lC6;25}Kd>FyGl4o^f-(HC|y6&iV! zS}_%7n>TD7cZESkzU=2UVk*#@T+|*!!c15zg@p=wrldy@-l_3ftO!a$+dw?dDYmQIzgnTPS_tE40F^CA6Bzm^4?4O!5pR( zfGzKqn4hj2ij5zWsDMrlpnS!t(3Gc@UQQZs<)CGkG?YnJc*=|JqR&hCs+nBVV>_tuAy^qpBY)AY!&d$& zxE-f(83-Uh5S3op|0Hm*Ob*d82Z4I{*pNkg?3GWf@!si}_{z04^JQDPzV7&|6O+FQmWHZN3di+gM zP2fp%z`2~xo5J!mh_u)^vbvaaUvUk@ss)F>A`U1XyZV!-w3@8R!HUQCcJut^1Ym|S^KXzh8Yi&L&HXQ=9A|mh&Np@ z&b{wc2lQCYnjpc&54m~Z7j%i}0IZ*WJ^^OCFORn*M{Vv4PzYzZz-1C&4UF;7m&l%n z<&4mxW00%=K-$D%{ifacZ#o(BpR?~{An<22ISUpVYvw1***c+tr_z~YNvh&^l86GnT@)!NnGUtKKZwo>LQ9JGE z9IF(mdh>R&iqH-{)52gy5%s1k#(I-y?ulsOfvyB8FCv@qnfwPiW{VQ#qmk!NgroI$=5r`()k=)GizBk(mmWzNm=vEqiExpYKmEqtONQtMJ1i-pvQ+Kn&(` zXLSyin=?2m5?3wGfv%Y20s9i$Q=JTNDGu}v=2iiMh)=2xt52U!%si}H2;W?`f3X># zjkt+9^c$45Wu8#-s$OevyE`P_2wSddJt`CDvJP^gt8d<-5F0b8OL*hp-m4y=Y{rr65ehfhFQSX6qJ+(PNUs|8BespN?;LQB z>ePh;g+?+6*PEmqFFdzXCJ%fEU5M{M^Gx3h$Z!G>5znsYwu6G#3KykDkM9(0P}J5W zdL@uHEw`(YRcYTLVunx8^R`gOEDWmd#b3ctS=U>jd=Xf7I2EWlfRLM-u_Js}S9YuO zUamw*SDqw*LI0j&eJ|L-o&*OC!i`kY+T(d=6|X)^;E)7Bn{XGLB88w3h_^!JXX;C= zd!ynjHxI>$)+rQ`} zZeaf)87F%nM7`xKk`3iKXwzjmo`H$%ZTz`|XCK9T3o>H)`*mPgh5?=;12E~^NF!jJyFfoM3!=(Q~n-L{q@Otw9hjD@Vcb{@Fu z2^Z|p%14~t;BMZ)IKTP^3)II%0TCFj+TkMyt`iC6rG4$tUTHhU>dKzW8a1jEMWVaX{r>%^Gvr{>+S8lRj0xUQ;A;8H{BYiZ;)6+9V*Oj};@`KUi2IcNtSej0n z)Eo(dk~fvVjL6~RrJ?v6_bq2ExGZ;tQdTlHOR(cynn zNt;Z^6NPY#Pvg)2{@e~KYj;Q?17)Xl7A$SoCTq8uE5@>Dx8H4Vz=CSKTd4Kye@J5kaSvFc1`13m>~ZwBq4Pi~ssX8AUw% zChqeiYv*GH1wK$ULUatfD=VSdR8<8xY0;XvCB_x0)dAEUBCplX8W51*I`sqT5iiX? z<1awSI8rtKFafvjufRwhVh`U1CyM1G;IsG~YTzuP8~C7}sJ<-thx?83|Nq)A&FwW7 z;(Xy&Y;ihO{MuO|&h43%XF^9anTCy8ql+!~r;n`3;1&z7x?s{r&WFQZ4jM|gbvvj~ zuadGuuAO$_y2|n?y!e`3M(lGxsrETxM*B0G`Y-fTYYGgoK$38yCR={HGl(3g)3~t~zmX;TbAqiR2O?DV zkI`|wDI8~R)C$^Hk~qp_85%OZaP=1`nmiSRxghS*78T#kQ%LU9A;^8Y+tKo{VR9?W zA%ANzdfjX5Q`=y6`|sJE2HdrO)?}TIK`WHlBfZD&I<-OkGg>$&J;B>jh0bc|ic|)d zzPsvaUf-|QgJ)vWt70VMxCy1htBuVi^^unTsIU$5T)IGtYJjY$8XSYY7IcHq3aV}- zf$+*;fmuFtD-M^ww{AKEg>|uz<7Hjs*075;|L^a|(9gvE=7*p`oLXOtvPnbS)l|vH zWHrO&;uVRb#wK>ScMU5Gp7J%Oqo0&qDGwW=$ANY+rGE@9ezVH zHk|nllej5!U7=1|Fwi_+q#M^|Gt1J1I97>Y(@r`teDpQ_1mB1Ud?VT=f6wrJRfEs+ z)m?Q7IW^WNN6=>cpCzn@WqHSAJ{YR-<||WGvrl)sPqvI){_bLMy%Tr17F$qQfV}qo zHc=opy?ANeK)~mL3~}OYQVk6kmrfDrSAJqhQ(=j6I-0i6q79xTBfzol>$Ck z+QoU%uj&F)Lx=XjGbp;kT~L^EZ)o#ZKP=h2VZTn2Sk5?JHkqh8qR&+5sJ8ayTEL)t z?KpKTqjr$ob8-vU^!R$GaB=A#7o9&5T;WP3?x@fbq(UJN#OZGz8lp0`JEctHG(zMH zgrrtaJxiElP?B^DDD6oB@QV>YG%8^WE0@-U4hHGOb1Sp=JaAt~w5Km1NowMl&R7VyDetHN zd)vT1#!`RZ$mr5a((MSYxft(19a8TFT-ga?d{?N`vF0}!t}3J$z3(`&8yp^V_Wi_1 z@AF7DP|0vS`e0FTtMl^#qA*|EhT#*z4U7XXula=r)^4D#Bcxi^bK4)0n!29LkA(I;UUo*TAnqkQ*-by(K1q@Yu=VK}>nWYWFB2E|fr z(~<_d?-Z-8lu^s_<0dF&!199aGKzW!l%!3zYiH|6s*~m}p?d8U{WHk{_y)yqSSEX& z5%hRtMMk3#X_Isia&ZW)OJue^4Im_MqfJuB?A(#3V>SN9l~>*$JO4xVT56*(?l7~h)KB$M!5>`L_&<+b*dbM96sraT zr(eP?NIL5AQV`=)A(k7FLGuSWT;!P>O_3}dY}9)y$mrYH4y4?SWwu(Fv6=c$^6F1j zbm}(pE6~l1<&M!(==16Qp|yA<64p$3(J5b^Q(;kv!#)B6dd+rY;^{V#Zs_VsgVNug zhpAIrx3v7+n)->uzvw5jN1zLUc-O%^Bp00eHcN)>(3j6o?Xl_eC!nj29iwqFfSDj= zlw01Q{B2+FBUSW`lc>mr1EAnY0FwO+kOY+}Plmcq>w;8Cxm2e5obe0&%^8o|cB$e{ zQKk;EZ1W1oWe3S03=IO!(*ftwW?#jRk#fr5Gz`fHU;Q0G!mqCa4~N)bMIPGpOS9LR zQoC0g*+3^1P_lnzxC*@xya`s0Zd)Pl?bvM+U&wKDUtZH)p_$+ch1`nJO8Di%*2&a; z*arU$qRT-jr3sC{s`a_{tbtB{mOYJY@v9B8kic2PNlcEAB=^nCO5uSL8BqZHMXdFj?w# zzxs#efe$($9b7r>GuvHEe41YaL_Irv0c+!l^lqWV~@n-la z2(Jd=7_BNaodd~}hyqsY4E=M%Z*$xhHl(-i7cV=EIb({;;T!E5KM?_`uX;YBT-Pwp z#3HEq(vZ`X^C+(Vu3LA2K*z5?t%DS`nJz_Tc8T}YfZob>SIev+9OA$qnLVDzpRIb&=&m6OL*LKbipumQ-RbzFD$NUH% zlt`%^4*}==iiok?J~uC!dEVKFAATTFx0rnn2th@OMRKjkTCT;7;0RuHJ+eC;XXy#a z1=w)@R(w~~B5SD{#EBJOyiC(KR^B`W@EeCH^_C-yO+&BKwXaY?+%caR!SDp*x(#g2 z=DQ99tNOk3q!S>PdJf`5bG^BOfhT^->`;ngZ zpP>cY?+;=cEt5#+^G<3nGM!Y|-q^)D3;S%m;%GM)~=$AoJ3!?#$i^Wqaoulc`@&PcEhL@~Iu9iT)$|2iRmY+TS4t`mwBffDD2*8m&Xszu z#ECF`^07zViK$kAQo6eRU&uSSl~JZnFFPeNy%S9FKRI}#o=wj$6@QQi~t!VC* z$>l4ZYQ+#_AZzyT2`1c+`vQ0mtX1~Dl}KQ%dR!wU8T;ODvz5XHc`|;)hg2`ijyW^g zmS};MvhtDRVVNd7EePDJ!iGBCNoirBmA;e=V*vvnhuR%%jN3ak`!wL}N1;=)T39dmYWk10E%x&^4;i^Vg1;T+}dtrk6p#+ezw2kV` zA6g6qtwdl8TKaSNS9+I;Cl1)rKfHHyL)*S&t4Y+&FPHcJ!DmfPc2&D z-ANV8*jEk~u_?qNhM2sR=q9f-&lm{&f_6W5&;O{O6y}RD{PR;y+4+fjYa#(Pfj?9~ zrMb{Ny4sNU5L{`r*Dx2^p6E6^;*fg}29w-Z=wL+-QJNvpqXYF2JZvCjbR9jn(-k|U z4W@^j$Khr7KY9ti#x% z#1ueqfhnr_$=k-fX#d>!U8h`@X1r;$f9cuWGC2bRzYtO}0dG~sxyo_q5o6&GJT!_8 z#)L+-fN?kfOrj)usRrJX!gQYG@T3bz|h3>NF-S&--Av6ec@{AzLJP^W?!|5#!>6fmm7+k(W77?!xI4`wi`sr$BeYH9aYu zZW938x+kKJwJ|hn{r;J9nqSf`2s>QKuj{;S!x?mQK_skV8vzwRqvBy6!Okq1i*=}3 zrZ3HHE9DkYtK?FGpv>*8i@VL|Z0q8k_dE!a9y+hU>3uSF#gg8tE zfZl=BLIsg@dZajAl}pgs8VV&wgeng_k{-1E$nuWHY@4OL6rb5R7>}k7n)1L@cV4TZ zMaw(qpA~H>wngC(;Du?hqvzu3Tgn{D+DeC=};qdm3_O7#s} z+g7kxF{v`OP*~V9!G;I0nf*l#yp%tp*H@Mo@f^-=b&k@V#p{NrUN}cms)JPuo#Yoi zUhyuQ^N2}Gx!eWBc|RnMh-D_ADgX!-n1Wy1X{{g8br$vjQuXkT<9Sm)T`q8hmu7rZW(IjFWiW~5q0iQYY!f-uASU2R$(rzEcc-a&P#C*SvjkO7B~A&)u^-uLOC8F$S37=nHe(^NnKD?!3C;@kh{3B4tIJ3i${B=%8u4gE$CzrznRtD@!v~9dmD-ur_fW9*}Rus3M6R9E@$INyTiYqsnTVGrAjww6o}G3j*;-~1!mU3#$vWPo%- zLAuTy`7s}74nLEY_mCzkdBwdvT-UMmcBQu z)hA3?bAs!3S-K`W@8|dnGJ0K(TDu!*zK`POR7z2=Hr`K}wY@uKg1IQf{^Cq{ythPx zj}Y6c&@Q&^Jojyh#)H3}-3Qd%6&xT|9uzy6=a0Q|_uiWmUYAlx3g@(sX33WsF57sk z1z|H@gZ1`U&zN+{JigBu@6x|X`>8{f%Sg(`#IGYK?V1n-biA3u%~krjT$sg$_^Lyd zQ5m|R$ik#-ck2h5@p^)UrfVLDKgfb{1oEto3lAW%0JCi3@XJlWGlz4BgWBuF;frW? zaWk049q>!e^hR& z?6)8%gp{cRfaF)-J!H)^v{x-YX}v61DMhcmK3RG2WXh`8!1N3~X*6Z-780*80YSBp z6MB!aLYKp5PMTyh%QuJm7#$w1@Lk6JR+A7xoX;C|_=rT&3Xkxicw5MZm_f23CNJhh z3s(`qaO2YUiRYPOjPN|wo;>nv@iZwSnv4xoE)vSJ6_y~Y9@-Ue%gpA2X2Y|tap3Du z>>0U9Xhary8P{&}8TV*aFA~xYvH>q-$PLguHg5k~_w}eK!)+UPn>k`4TvEa6`SGyAR!VTucv>F2yIyS`D${El3s4ZhK^myKpuP zXQTQ4`7%n0$pOvlU;ONNEvErfX^FiiM0G{Ki1$7`uu;0O%_Jl}ZVsCj6uA&Tdmef9 zl$^lE+C+LR$g(|~tmZ|l@hYctWKvRita)?!)k&b>bxel0>7e_LC~SjBJ*B`uKb?%| z*4?_;bOkVv82|YN)?H0$W&s)CpMB!8+?246x(UYngLQ6RySaqxWza^amyo1sav>{! zi|MDAt3Xve0;=LBB3sG4fG`b_=Da?twXcK^FntuThXnDz$_Ae3xsiBvBct+^qIq)1 zyN=50(3iLN07(H^G6_X+qgu8dm)xQm=Mww26=Sg<&G2C6d&zfc?h?rZagq$4sNG1H zonb9qc|B63oEO4Xwn+N6c{3%*ayBuM9cJSfC*ayGc~}UsR~(Z_d75kKztM=sP?57O}FJ;X!Je^&g`;q(%DE=D8{%_!x#U$0$-cR#gzA+PepWZL+Nvu^8Ug^ zfadYmUV}9Es#`+1Fc*V0pelT#Mg{`WmDks`>aYI|Lg%Q+3~PmK)_33ec&2GC zWmNEHYyIoPi>7ajymAI*=UpFuKycvsJtuAKs704mfvZ^PP-^y9zveq5c`y8e_lokR zpDEDI&O+eVd)1Uo>hEKr`Cq7WSs~Px3!hir+89HgQEIdD*sUKa!q# zQ@y{*4iI;u`T5tp;u+iT$_Q>^3qLH8PeaeeMu_Mrv_HG`2W{w^d{0%~6qT*?I(Os* z=+);vY}@=R?B$S3?vIGE#8sEM-Y`YIX;lO5clbmtx3URNtE39fL*eUKC#Rtq(eU-* z0lxa0n=#0Xx510Ac5nmP;=Bo<|Ev8t0H4@J_`LbXm7OBiaqZHiA#a`fqLVW796siS zt(x;(Z-%{@GWOr&e$$W#T+Pz;jPqbekpYea3UC-qdhnxfmV^?>FC)yhX6o3T7p0}g zwIRDG9KyZGkU^kY+Tr_G%!B}?D_#FeSH9+??^CtPTIOLFI)a-I= zjN^8p){AP_gO#xJ*vI6vr1c|`6>@~+qa%A+i9d?!e|bm*z9$^6bJFRx-sj+jX*BZU zA$C@PBkIGUCVNt=;TY#cU9#Cu3vTl^@9WRbaFvedu)VdpZU+j~;^WTPzYAT))Q8^y ztA@Y^wF&?)-USx0M(4SE--a ze)+>Xpn1$VUyuNqfX};}>B+6s>2~ic$l~94I69?5esS>A)MLKYeb4Kaos_bpS9adz zoBRDSx_GA#)*>ww;>D;Hbp0IlvW`-$2t+3Q^8@)_|HYCan>EB9x|sQE=q(1Fw1d6- zMqW?Sx+${V<#5TKlaX8Hf+5ZK_J@e0BOM|-y%)jBl$Re6(yra1Ny=^!wlmL~t)69h z@xlY^)}BntE7b>%8F(2LnsxOE-Bl8gjW0N@<`gHntOQ z3#~3Dmvlb}$d!F8tE_sZj;1I0V~72KqqLY=auMY4#UbLI$s0Mlw6B=MJN_ur7$VF? z5V+y(deDJyZh$+5bPOXwj$>yY(rb@qE}ZY-1r2JH!C|9KF-zfP6A|hMy7%68qc!?W zZd}yXAL#Qs=o8wS<#2CLw)ARru{2<=nys1v>Nkg2*8j#5YW>Q)AM~$A^bQ}NJixlj zLk>X#{p`9m91xBhd`!8LJBnGX?6>bm+oAO4g|Z}0h-6ehW*SQJX_h!~gpDw0B-5-5WvEoS+x}0dyZ+soNA~J>k>*BnD@oG0r(Lmgi&)<7;hdu=rot7bFK1AZ z{|ub!X~+?C*1HI<1Ni!!pEA@Dp}?Fai^UM|~v0>0HE278?wPW$?!$MHXt%eo& zwD^Ab+5~8!--ZG|bAOp~LNqZv!@G7o?Vy{|ubq-b7Y1f8yFfU@JxCQOTRn_Hcc`iI z_w#F}t!2V?Z0P8BaitJSP3}ZM%A_?&3AfvkW#>Jg&$`9-d$NLByvuLw8dAMgq*jI5 zo$$WvMK(aFbbZd)KM;2e0dZ4fL<9mZL@LelwmAuZ%6nxNOdTK4dm8_glPeMgyj?Gj zhmp3hC@0UI7yaoe=g(|l;=d0gcbgSTFXp8es5Tcf%TthWCmpnJ8NWTQ-SI53S<9Ob z@MDfQ5G=IJVfo_9e5a<^AJZ#o4pgMo17bPR{0~F{k%P06e|jX>-a+!0kTQ2twvH8` z4a)mi2w6pbm<+dAiA2cN2x2F`(OM0w!fc6S{@FeLQ}7SY{VcnSm|KS<(mv#->)b9rU5+(d(J{*dW1`Mt81x@@MX( zjDNBbcm^be_yCfq+GWOVc?I`Ie<18rBp>^#rqkkcmG@l_&V=dhZ_$%RMNOI1ySL&G z)TbitZ%}dw%ny>={um?;K| z|D%5{`4&Ys$!ulo77x6VBs?iBe_2%(9gZzyo#(T5SiI7} z0(}zl5o;sSD_-o)LWz-8g08$6x?d(=LG*xG(}3l^{^djv=dA*LHUacmj}^*d2gEj8 z7Um37jClg0$3J!e*+1iOsY%FYpUg0^xxbgeJCq;UeG$9cKf~REY~Cd#yvmThm9U+K za7GI1B?Ul%J}iENDFvq~#M^c;_sityHh0L@#HiQ=fb&QA8y!ft2L=Kv3aU|E@a5-2 zJw@LN*!{SPxhA+Hg(4_O?>6U!vI(@}JT%TR_pLL6^D^njd9Ufnf0XaLxxn3*Arx?9 zAh!pWP@;L2HxPG}O$o--b+On; zEtKdCJvTmUXaJQ!FKWm%akQ|+%hPc1&fotcA(xP@ktrQ@&;yb=~hy<8%e6^`mX~#g(Me>vC#Y8+)Y?RK- zP@^RJftMbpg918Ic3E?wECCK9!+MrdlK&O|Q{Daphz-Imhg}q|{{P|WtK*_>y0__G zYLQra=@3|2L_k~CTMZO2nhrb_#W;%PSt3Amfag6BK-`THV*C$G>`^HXe#(g zGA8q94TEoM3!+Utt*3KzG;MB0d?HY z4EXruT6C{suDWzQZB{sZ55#Y;SZaGl(NF4JeXD?R-0#nZfeOL%pN3uF z)&tN)mZD+MYV31lLAQ-7NZ>X(xx3-6T$RnJ0B-<50=Mn?^}6$ckkVX(f|^Dxki+uF zaUB|%YnY4KX-kOw$3MMseKJ%$#{s`$9F%$@+4Rb5-!nwqz~u>fbUs4{vR72G|Iv1 z5i@Kh`n&?$fyHQf0m;aR*|yyBCcrmrr}|V-d@T4T(waOP7^XTVX9ZqByBG!UP(Ug% zyY|-*S>aIPJ&2y80V~NKy(+}U%jCnX0gq?}Xbx+IJcpk!LAj@y7SwkmAKnO^oWD2l zp;g~^j}9b)u*HAP7XOZ5rp^QsW zJ7MnmG^s(KJ@IS}+2nD>E_>n0|26r!dcoDpkVVzJQKY~9{#9@r$ViDU086UHMNS7` z<4Ud+f{z4kwi>1y1?0rEcmJdOj7ut%N&fHsmxigd!do%SueoQS^w*&x4eKxGG4PHd z5!cIrbH`*CX(^G}6uu8@TJ@*sz_vhjxN3nayTNA=5Q=4z=aErsslbFM2kvFDsXFjO z3Z=oDMOc(Of3*xK1kb+UEk83zaPrf{%xlUEbY{8({J7+?Nm!c?7I`vY*=|pej%zi! zdt2XGjF%$(U*4CA=d zD8l_V)B=zzz4V2uoMP6QknK&2eBTP?9N?+u1l&PIf|+_drDa!W-2g}qJOP?t8(TjL z#b8iJ2bhi~D}}1aC4vf7@6KA#H|)7`6!`VP-TK;BnQc{&m6Np^xqF4W5Q2JfSdbUn zRA^U~P^sDDHPbc!l2SaIo$n+ou;B4+==MF|r~*}@`mPVYiMP2+>LUx>@IJY*-9DKd z2XGe~*%=Mp$zqKfNM3$g2`Bm4)xokkQlLwfXzfd21$eq3o3;L`h~F`Wfr+3!iU>Z( zpubFBmxrY^*MlPB--J}b^jN=R7*w%sN`>{QA{9W1oRF}i>DfCxC@*;v<=+md1zC6k^5;i3D)uw z^HTDO9H0)!YM1GrR_F)w65&iL&mM1paaSGwUycHcaU<%h=J5Jdv)V*|aLl)?$T^IP zMlR-kpJfL1N^CnORUzDiR>**mLB>)igwK@ZBTz2|ocTAaDGXm&4}lB`Edx7F1Dp z0X83Pqr&oi${v(fgfB9vQr`v`Qai*Csq8=WlM@3t**DK6*=VvnE4TC9?DNw>^%B?r zpP|8;eMi)qk{OTDx`&aDx4&?SRV-g#ee_U*edvC~MjpldA0}S#%gJ5AFZOGSI$+Ai z=LGz90bf8F0eJM_`>~O)tI{dx!*+|?6r{pRD}?HG?W0BDMGf>;$d7J?8|h7c&$1eC zgU4gcS7!Ia`1pUFA1;ogj7_EdKu<^;`4{#t?Nr%#-o=L_7wv3a!ou$5Muy#NjC?qU zeSx+cZ+su{yq13S8MThh%sldhZjCo%fYvY#lF@L(R;-C8mJdj@%s}2m4R|QeTk&NVz>bFgv zc>BlXxP`!JH@DLf){h1m?Fa*QIHCr2kS~eX79j~XGJ*el1p$zgoH}d}dy-e#=F=d! z?<$6&oV%GEGh_}qQ6+!XX}bvnMGvHp^UCI5h3ireTE$fM1Gbc^|Nl+BO>#wCQ4MK5 z0&c(8Dl6ax?N-u(cHjZG|*?M!9^Kt;3WsPjYCoT0f+wBj?%R;(wX(52kdW_h(UHBo3MzV|Ckj5x|tEt z)Tlem=PArnc0|?TNzHt@R&aRTH2nPkiuZw@q@Gy=iRNCG$LT1GSJMd*Q7%fS%#3e^ zo+HGlX+cJkkXE7u!EGGQ1;^ZdArHzNy#;MQK$7o`1vY&5k@o;Cij=G!s7Vx~)R8xZ ziXvC+YYX5>l-$r^7h$2A-Opo6=nxq3H#Q?z>|0yti>(2WqpKcEy(%*Gg7)4=6Ei21 z#mbU3B~SwTJk?;p#u!FV2r>-UjNXelHHfV*~)n4T-@hQ42d55Zimb2 zTiD`-W1s|3AkTeJN6rCwTvZX4Z@CzH^AtN!x8eTPkS8ekD^o_OX9J_X1U*+kcX}|x zCeq6D$c4nZ?55rsb;}TYIHHQqg#B`6ZS#5yet|;r0)HUif7{Baidoa(W)*mFH3i& zWCaz|NTM);4n!vcn((a`FYMrV+o0Q%{YsTmGlLfm$kA@2K0qt+d%aUF>VRGE)BBC} zae#m9IutN>Eg(F5V;@TTQY6vVAOq11)#N^hcOWOx2pS0|YW+Kupg!LH^Nl-KyyaM? zT`CI)J8WrpI{chE!QGOVilNT3@}bU3+!%(cl$z{*{z?_ym>9zpz^0pha;#gviBpB#Q6R?cvc0l*$^o|EMY1Jo}D6GX_GLc-W0Y43`wH4~8=oR)C&n$KQQBak@x#ogr#id4UvUoQ@ zVYxIT4m`F1DL23p=TZq&L)ZR-DU5Fa%c*whOU&?FxUs9Bg7lGZ~|q`5J7(>}lL$D8`75NVNm)s?cLm^k#C z?{P3!M5et{d)LG6Z!aYA^Pe{C-iF3HVc1HZA|&m8l-kL1$=$juS<1H&`8DhdGWq;t zL5ac}v<8cGu#1nHDKE zG!|Sqdp6|^eK`LeE3{ln-k6y0?Y~^iA>RG1Emdal-13tH?A2;!Dc#8TwYAC6`=})* z_-9*x?T9BuHCzpeTN|=RX!S){$3Ha2zs8}ahtWUmh1AC?D7N#*34yycN!S;hGN`V zk}d6TLARZpPr30s&cd?EHoXg;H;Ua1c2N;KWf3b=dQ;t%T?H>kM*?!V3d`a~3vpc$ zWp)$Jy(-a?Y7QN)b@b!DmY)`|%P$L1RLg#JN$oJ`dooUBb)8awOQh{?=mBLH(H(|$ zIc~q7a#XLWDi zc!iRokK49!p5CAhg*iJqP`^A_B;EYiAO~ zrGm?xj9heYGxYG9=-V*gc%0O-1; zoo0mFAa$PvChoFqcj-qi>dP4(Tsxkhps)#GC*4ccLrnMC94)}avKmaCZJkTm3q$TT z<+WAXq>0gK6W{cMdq1GR1VyYkeUP;gl7)y;kMcN;&3`u~qxPO*rhDkC?JjAd4Tl}D z@nnlwb!Xen>aP%CD+=p^=c+U6-FK!?z4xm4eJ5$i65G?`jPJHLJv7>y!m(*ge5ai< zXN_D787Fbwuhg_`4u~eTISYwh*R1U3lB%=jR(->4*6eE(Zmirk`hfqYVGtYPW|yr7 zlZLPj>rj(?;%6dI$4F26aC$9*IKY!&sfFUQ=9$#WLIe9m@M?hEplN98?e5*z{uKc~ zqa!CChb_$s8hT!+_P23sl(P1uG)ZB)XyLVo^W>37d&LgY_YT0iFIW5&|@%_$SE?JiEbnVx`$#qzV( zp?`wQyS{gOD}KZsxnXm19u<*iNR=vjSNkEqpmzLUwG%!fyXI7U%5Dp?*a2uI<&T)j zu!)4zo3b1+kwh}5)cyNp?ew8w0kdEMVegA#QED>a2Z(i(Vs=ky@;OQ_mtiC>k-yn# z1-Kn>9ZHZA0?4&QVOg{4!uz8jFdou(uSEo0SCc6_8-k#}p7g)cmuyS~J5VW`*T{ZX zjNS`eX4&J6z-Ns9n4o+Cih_g z*MaScbK=YNEXFn>3-r)q8;I88i?5X*tz_%{m+P>p45nd6EnhP6}Ta&b|^?C#(ru+wY@~M zA$!aM`T9o>L2p}oaZIHBA>chx{`qMlO!i+ik**V=4f2KLo8iaNXtICsyfocsn9Jk4 zgRedgu@|0z?hwddqZ>}!Ak5c%cO^@>alg%jxunDhC*ntee)=pSSjz)=3}yIh7C zq0NE5-Ud}vN)X6m>{94lhYqa-5KA@=m!WwU7r5#~UrI=$6XbT=(Yo(7* zUHRb=9DH5zp==r}PNoauqvvm`$E{w?BfTFCBtHUCa7C!S%{>vjbyuW%WV@22LY3L1 zAGwx=`xZ4v{l)khbM+HMUEbHFcOq|H5EWpsYb#K23UPTMv7@2yQ6Z3P{dWEY(vr!_ zm{dfF$l={(sljjx!-ux-xVpF;xb!+largf`bzLETR^+SibD0_GD_om46cnrFy4{9Sf?umQ}cK2`#^vzWxik*^$>F|iWT6y zT`@%C4U%E{x)5O-1&xp{)NQir#0O@%$K2HOIbv{DtkpGx`Y)$ROePl?>psIB|WWCFx*zJUCs!DHTNV&)(gl?lxxn4|(%M z#*XL=^Ko7*y&IT(dA%8{N4zeyAeN-hoM(@tiO>hmksRkJ4aiDY0O(;#75LcL?_fHm z9G5l#k}$zaTljlqw)ppolfsqkgv6ei+j2>L$M=s9`!_maNq3-z|J~%<-%yckDI4#*3rGt%svvlI$2}L`O->nPQ5cS}%y42E)!O)nZmF5a6CH#n! zJK7V!sGKLiy@VBpSbJXd);YKsSJ0&P5IhP%MQ(~W#G2PMLV9<<;hIAPs$soV4iOJd znrF>{w{-SG13!N+N^I5Zi%ve}2693fN2()U3gwAnkqUN@Qi{*@d#|7l?6J>ez0|Wj5-+|qZ@x? zxQ^i+7fb{bn~MsG^Y4?2co8PFzWR?6y;pX@2^;L4v8#Icmsn!+L0imd>uakIM5!gb zmo6*>5_T#tBtZ|Cpy7t!@(}aVT4&%W;U?_n5dF!E9qzjAVgS*xjwtJbgD)2b-sy~% zDlC5u_=&5|zgpbJl+r}ITKkt42q$PM9hiWwzW04e9jAd&VhEbTif~Dbe`5RBqS11p zl6@d}HKlyCb@J(j286|C2uC9B2P16(^Ov{9T=#R>ydVi?4Ma_ZR>=LT+&KPwQ%G9A z&_BfHCpTmMwD-K=05ezZdgod^$?~soG~Z!wzLwgvhB=Fgd)VE=C0I)Y9vMG%oP)n* z_ND41YW8`b7<10VYx!4Qob5qk%;>EDkiMF;ZTa<@4fi_b>wNbYE7^O2jb}G zCsNR+`XeY3W`g3OwlLSgxS3ZtSIX2^MJQdr5$2AtwR38Z7#&eXlQGY)Sj60yKXd>G zKJr>G`=J;xQLFZ1DtkS4WDN@GGjRJ|9;EXjp%(%#Z(P!=b1?kN@?BSWHev-5uoF1w zTF3a!ccVwbR_>3`_=AV?SOaH26((W@IY!)Jpn2W1^HF8kc?X(UG*jUv#Vo-j{q~e~ z0-lHPg|k-=nZ$ z^*(OGeO&Eu2!AuAOc!cd$kR#$kACf*Dqv;VG=0byD@bS*5N+-0!=U%=IZ|K-oN|0hS zPk7zZVdi%0Xn|2IEBUoM$(XF#T3b?=*h~73SF4rxzO#Zu)+D<3CEtzA9=;(hPD3e& zZ+UzB#|F7m`SxhR zxG40lBz(+h?w-OqPQ%9c)>J~JR4R0ENtX*q_2&XD(FZbiD@#8B8G{GqO=Y3Ym_Lgl zx*-OwiiSfe#_ji2o`tgEm|X6>E#f@TAgtS!<|yXuuB2aJ{B|J=+$+oXvT9BGa-SFr zi3hHQx44mX&{>YPb9#(X8*L&nTIPeH6t^DoRw=4e5z-XaCcFf;P7TsdH0m-he_Ju^yuQl0oxbjZ(2&%Qqpd&_cegIm<6<4h;lrTUD)}8Rz(O*rvO3A7!_2 zrT<S=J|c|%KJ{0z2o^OoYjTbJj* zTP_!ThTIgLa7P5VZom_5$S?PV+?ec^Ld~-SSP4HtkrZ4Vzff-P{?JB_{*o%ud*M3U z*>j^+^Tiw|U-?BZf%bz;N6T+=ypx`^khs`Px1GpQR6!^du6GM1RS|WgR8jo~(*yzE zlp3@xboyoTZo7l-AwG3Eclv;OVAYq z(_e~|iuQN=^lr)+9NWe5ZwDt!FH*#xHXS-ph-LX}wtG8dZCvLnF%e4<>(oCdwpK=h zZo6aEvpmy8Dbxa7I6N%({3!YD65eslE{;=)FE}cuY-^EC_-ZyM7>xuM;@=^Ahu4r9 zCUA~nOCl106yEo%4BU)#%ZV~pB{!7Cn^J%l`t%0V{bE!>2SpXPTT&{0v<<~OMteGf<2BNXI}lzbjDqw6b81f z#zUz~p*}+})ZgH;P$dsTDJ-BvJDyRfq@}V(Nj{RMu0%#oDjBAR$2G|{;e2|UnJfU&gQ>D!_%NYe~S&Q0Jm z= zC%|mqXgGjzaD>+oM9{$-4g^KzdGFhNY0(=EXfJ1Yy;q1Gwg6j>HBr#Mtu^(b-3Vs? zA}vg;b3b{!=FhafE$EG$ZI=uB%6{N#r0~WR4-yHa z>@~2nfs-c-ggmDyd>_UUPDrxU!iEw1<}M!|xs#%L-QyO+B8{Qovek(r}n( zY+7(i1p2~5eV-dY(c+R=?@`m66!AoOMJuV!{<)Pp1s}@!vZ;L8PHu_&!HLP250t`u zg991f*{Ao8tcO+;8%CQLXk?yCF+X+pt{sx(PE5CL+vqYV_7E18&u%&#J3m8y;hVI2 zmI*U6Ot&vHB#4_gkxosC7=_B9n;vp`>kteI>b)-Cu}eoYb48sqDxMrX*Kq`N^nnhq zHNKPC5bUblyOhBk|FPY*Uz^gl9{pFeG(aAI z;b=3^qW3YNeX6SqyR&`sr;5ae=<;!Gvcv}aP`ZBi18Bzc9@satmpjnAglMU3jh~ke z3pM;pGiQcu`9_L;#H7ak;4^uQhnKo;laAFU^0VRcAP2h#xH!TSaaE$(nSVgbcW?LS zq5o~5{Lo)DG>^wp`tph5QXYB;PssVv6y9+y;bS$Jnn)C%>RgnnAT=c7itIyayjH&5 zk3(wMPfo>G4hZwFR#Q>}M3lO)CozxO>M&{_9U?Sr?4{IO)z}e9n17BhKmjZGK#dqU ze=Czvg-*YkPFJ&U?4RH=@agHuoNkrSwXJPp;NDYLtYQIVi^Js_Mz~3@Rf&s@wfyGJ1=-#2;?vG0)$2=jbveZZ(p} zGo&9oe_->a!%IucaIfJ+>oCWHlGdbX2*;-RE7F55|EKq!YUhd?+(|X}GA-F@8ZYcP z5|_kIpyf>i{oZa)AP=}moTM^gj`#0*v61BN|Cka>JpDPxt=&9u!i~pUH%zm@RVr~3 zXy{>|gRezW@KAfkC2vvjObeWv7HyeSQQ!0_iE4drSl(pG_D2J)g7VmS-=)|Z45!p{ zLbXVAP1q3e0uSm2_^vpx_eo(HSsp)Xy6>cOOUH=)wF;tSvbLAHk?JEDq|*0R#$z6z zbk@<9K(Vr;+pvls%%cqE(WP~hZa4n{(@lp<-xI;>z5}x-cn4}bi_9>PJc@iut95Xy zh^q`UmKd>hH0b)bQS6KU%BWd4*poP-1(_VY1|cfGNnUj4u@Wfq)O`{PB9` zqRYFvvbIoQotjl1?N*DNMHki103X_oQsxInIHS=6LwLa&xv7*y;LPNlIy?Z!g#wnIcMCOp06mXN@<4 zPC>0haArCt$7A$Ki?-hkg71v%@(;3&@7!6WUk4)0r^7S8%91I@>OP6#Toy(=W)YYs zN@iHVji8HfHDILr9_!&ZhYDJ9DpT@FHkLPufVHE;i8c z8k!SuS;vOb!XuI*7`5mL&%ZSXV^7P{tei~2+cv8c6!W(ntj*9dRT-?e`86s4(H(YO zngzYjY3lJpbC$30&#&r@zj@CUjsMHaQ?lN?4!sXTJl!Sk}6`(A9w-2 ziIfVbbusZ29Il}Z|9>8vopsf#0mGPz!Vrp)q3i*2?*#jrTN+F}^Q3iw6;f^UZn)G{ z1=B%?V>h)wge^w z_y~81*Ym*NJIY{KPFlU&x4J@=FA!la9XyvNY3qv9!psoC*y zIIX{RsQ+*TQ(XsB6~=S_EK>~4yjc-L;doP6T|vC}vk%ndFYD0v9}I{)XB>a0b+`p> zY@Thvf9GBJy+IwuWYB_brxn-w+~L*Pd-eBKV<9l6i1?VQO`A^Pzb^*26QzbO8(mR{ z!2WP)eq0YPsmH$)WzuT)lN9}aD!;Mvql{9}hsEFK*Xh@S^P%b_PNj#8U$%eLvfk|b z(?^o=QD^qS*PNYi>K`f)>%AQ7(>eBwk>kr|>JgepoCKog zqkqQ(rzl6>q;XHuUQ!<^N!wm*69<{eFr^a$E1qq}>J; znflH3XJ}mk%?7JGdO1M!NXI-+q7hHSSCx35VNyN3p&gN9vy~|oLZ#m~BY*xI&i@*3 z>sab~={Lo&DV8Ok6!w{0Gfq9|ui_Cc`=vu8{#a$E=n0%>kc!>zO9RWs-$=_5DV$ak z@8`TS%h&Oah8ZlwG*5RwaX1=$vN^hs6?*PT>ZJQ6oM8uRU36^i0ncwMkyK9+Ms;QN z8d09dxGIsVbI25VEgEIx>lPdiJZa(yr6;Y{;{|Tx{fOj< z$(S^10UMf3U*_W|^;S(4=gJ$h<^y$#P1%9p=P+OKa0pP`XGN1<5vgsUZ};YTv}}_5pmj+#>lXi;PA{98&rYDpE-X^y z?=(S}B<50^Eg&q)SHj(oAZ7wLII+g-Y_Fkw(oXI^_lMsD(tJowpf!e#JuU>GB|M{} zPYeRp_m5C=_5oo$n+>?jd)}UWw)9C6E9D&E?6-oB!q2?39|!TC`wummINLJW=~``W zD9xx(_m^-ZqaEzL-6PE>1wOr|AqRhFy0qg#^UwFV*P`L#ze73I(5-cu7xcDedUR?w z5RBLerKz5=hc^cZiz(Mwtq0%S7R<8yRmJ-@%mAkvKR@axuISp~?`F4Gt1-ZkC5=4z z&ux7*{u;xjMViG~4Iv9VE~lxyM6l<Ss4UG!{&Ou9-43RA)nfa`vLEX$@ zIFL1{saBnhaXr@Y9Bqw&=6@SNg+j~QD}lnl{KYD}L-W#X`ljIo9^aSzd=A9Zlgf}3 z)uk7|O@X8*CAln_G=Px;#=o5ckK|Y|k{IjHgofz0wCfBZyL9@)!u!sD<3_(z@Xz%Q zI#(4;xu5+4@}~8qv@!Y!_??}_&LzB~U%U0t@#7>6kN4Bup1Z?l*LVp-GCUp<;_|Vi zPxcTx7GgF(l}}?$cA-xb$-x_}%@#Nx5M4T_dhwe)Q=i*K={=WI_>naFvpk+U)2a`i z_a3fpdX#5!SL4}Zn`YoKX@31&9H7T)rj<@Fjr&^cmLw`Stp8UXY4U+uIyK^jIPEq| ztICV!Gfj*?*WF}Q+@RkK+hSQyk_ZA=9SG_TiBqBdUe%pOznC8@KeBSINRJ_q$E{A6 zB!?2`Yfi~^++kGG$F;Hcse?9ekpq{6U$d^B;NT5RRx7WKlgvAWZ}(jawSg$7KB2X? zC2Jx-1Fni@P_qbc;GmYK-xPuenEMxbv)~MiUV<~^(TN=|XGCeDUkYE4{)rpSQKAyf z)%j8x3@tx(KyVs1ae@bkJ}P7jlyBzH_5EjYH-4sVA7Nb+)92|hGu`yyAMZ@RiLoM0 zB1c~{Wa`JQJ1b+vDRdhlz(Ox{z9LiVw?DmTE(cyv*5@ZGvI^HS-;K8Oqq~`2 zi0X5f@R7pk`fNkvgP{r^wn=nh^RktpL_8??Wi!@!de3e8r8pA1pJ=VLnR_oHR%y%< zlN(uwW_bVhmR1nzTDVI!lIt?k@=MQlz9O)XNOq`@gWBVw?L>&Q@v-;-6jm!t3Cm?yB6AAiifY| zwI9SKc}`LAVbPY!Y#C54)_n>BEqoq5i{a|mRPPT`^%$l(NLIjGaui#e#WZez*JHbi zt8_tC*EvV`8;{cK?j{8%M~t3!Z$sfVXc+h|m}6W$D)NTQt(EJ~IznkWCsi?*Ey2lM zf~P&rDZuAR4s%fx`gu z<9*}i#GOO$^95wj152NF(%KkFRo6uztV!vKA!+(OcccVEelaoTa?8X34Faaq3X9_c!0F#$%$#_;L^yS*|2m=9xfV_m?>m3-vz?|JWC@> zZjOiLqg%s&0=^RuWdZ`8fE94GsZ1vI(1ey38C4MtT?sGJi%+}rnA9Wy5t1W`nI6Z} zMeoXF3Kt#sG)DuE7}3{vEZ(gj1GF)zN#kZ%$9|;GYXY3}&H)#XVd~m;na} z987DIazA!uak@Gu zz>;y-$GfwHA0>BLS-xN=$HQY|{lUBxNO#w|O9?*&!Q;buH>M#!e=Vo#@z@f z7AN5Ni{lFm44yH(BH#m4)?=q!;GQd!mXh*_qlL6a74pFC!{ieMB|}rS zNbR915E-8qcprjjb@KVGqwuTCROD~6i@i(|TT2q%8`tvHCwV^W%aY+{eU_(ooBxc* zSu#2PkRj23nI_D`5=Ji~dXv}Drb|)JIH3KDRl&E>R$67Ia+d%!8*};YTpP(_2d%^V=X=O*fN#74$F7Br8^0;vz90E)wJ$j?lorY{x%dQz4We1igsS*C97vzNZC7X`awrS(J_uofnsz6ZBng^4}CXYl<`@N)a- z4Yogdsb)IzctEZF@PRkbY)UUFl469{j{jUmt|^(ZrmQ(~6_^TzDcR_6BMzH+yyID7 zGz)wi+NMx;b&|H;X6=XJ8l`4^ge=RQX^!hsS6bY zV3_^sennMn>p<5eN8zoT%Z@f}ExL37?-?s73|Z>Tc|qk(o8LpPH5JxtW$FuG#;B+} zMr~!i4kFW^A0SX7eU%Sy1~)x9kmjEp%?@cxdi&^T>yvq*@wTY6BZRkir^o!rpY7xb z^hO^JuD}Zdj&Kd8+a-KU;XRm*f#dP07`?jBY*JDc7=5*jK2+qJMl>YND?t7)n$#PZ zk!;#^Qru+lhpj3?p21mWE&Ad$n=^5?{E-80ld+5jU{&6SiCe#mxAPygYPiO0Piw)N zXf#0}xpSwLWf*SXZ+O;gES5UX`n<0>Iw-5)ILt=J+!@64b|RKOR(AfKTT+)Ao#0;@ z9>LHJ0qJZn+W(*rI^!WP+U1)#?;CWr9GZZu^CHPOz^^p2g!@eIHOwFt2ANcjTMCO* z`y7c*I*m(_Wt4r?^yox7#NS8gF0`9rzgIL-FVVqFhu-Ae#ik4EkhDX1G{@w$(mBd{ zG?YkP@+FJ9P*b9g^syITW5K-5nc#m&Oks(mdsCR| zy3;a@cmCZ7SKs?LQ226$G5jDcT`6h{;-*YvLqf!(-I;Oig+XV_q3V?>vqTvtH!X$v zTkdY#`EjqrO6O{xv_zzdao9G7G5J@of^;zt$YJ2}Jo}EWqaWGc3WQLNFmW-BJKk+) z9=KqqePo2QB}Oa{jRe zd01)2Jhf@-@aot2+LjiyVm1v7DQ&;w6ydAYT=CI6MBqE61+^QZfIsSNCZ6dS9G2{b z{8M_~4Anin25`+bzR596K2a)^{>!>Rw-_PcK@N?Za#ooH15GvBi+PL}sf|HJ)_+9x zejX%8crP(zCsdWs&hU|8wG3~yA^sgLqmE^=Ua?!^F@g+HXnoUKfv?vxMBu#IddT;r zxJJppXkPQ41oCA9WalU<49Fcnkh{#|s*?$lSF3aU=?6T9<2c&Z8(#*k*`lmWYZJBQ zaeJb4raN@#p*w(Z3&3#yB-$N@FHS(k@TB}`prITYn(V?fsIfoV8{(Q^MUay{H+rm` z(cstpvfThB-M4kqGdYm(pMt?QfC}GZKTfE0jz>EogJ;_1xi6`z&q*V?KA?f!dN@JQ ztg>6ClMX{W#6@}H&6lzv1Qz*HudY}fz(_oFQ+Yb=yA$w?D3o*KF&_U;;Zyzg(R%Z_ zlT77X{5t~vzI_^Pf5x-)|8Gl7pPFFBeCN&6I@0@9#_#-bV$8^??Q!c!s`nzO;Qn>F zzaPSdS~kKG0#7a#61PZwu=kxO?2TJ>3iXhfsh5AJ@u1-_^_~&>BLZ;^ZV{*Tb~ApC z%X-hj&xUUM3JvFR-{DAwtOR5^2#Woy%Oo;eF}Z`{-^evaQhd} z8@alOFdm~-3;kO+=YV1g!YZcn8WzqxL7}I!CmHiXjl)f>ZASRg85G zr7i&0Ks}@{Lc!2DiyP*R6PwkdvvzU^$pMvFWWf7f3R~T}A{%^4<0X11a-sJ-YJh}>dK{3L$Q2YyA{sxkV;bOQ` zgitZX#oshj-hdP^xA$8&zbp_JfWzR#8L%f#BNRTzqwpn`Fq?2QTyW6Rdap;Vj_Z_* z5;^Fe@+_lWzR?jgv$w9x|8smR2YQk1;iHE=xZDb9-T5U6*~)bG6f>Nd7}{+D7ETtl zCvAMICOs7F{|V*D>c`guD^mEtbj8FhJ~xYVx-OJ`n`G>B#7ltuv+p#p{kA>Kj}nGE zahead{0FbaEDHMTv;teg)j<$|mg~b~-&u9{0MbV~$HUeZhuXofZg@)26@+l7L12V= zXBE%LfD$r%a;?c}7K@SJtppOd>QxQNe>pB@D!-|r;Vg#MXmX~<0C)Ol_&X0*C&Ug2 z%;WNB5$p5}L zyoObI=h4`yfLuJXGjd?a$0yXo=t^%xfAp`z^g0ujrQ9@j975k!L^sP5V}!K;pb0KC zh)vqp%Y=RgIUhVt$y38;sCk)FVLW|IdQj~Q{e=z|qj`-Y5H#P0rY^d?EmrK-ui~E# zIwS@+8k5Uh}o zbUY9Y%9NBUp*gLPcaoeUf+9vzzr7EoA;K5wBC(!dl5GrAa|)>qCE`MnUH)$e+iPg0 ze%@1S)P0o(x{N9MYN`x2szR$9B+}d%b6=X)^!A{U^oi--1Ux8OFs2=Aq>{D|g2a+| zf#a+R?T{j&)NTAo#AhAnunf1?uq#kXLP-{mKpPzkX3xG4cGeVtow(X~Zo;6U=O);w zxyVz(+b@e!H!|fff$Yu>&Y;!c*ECN1wY)W%;;8Xev$+$N>h^MhH{%u?>&M}ZCO7R)SjpW~DpzbZdgLqMRm*7(1E7+y? z&mY^^Fve0{G^%70I4PzB{{*HpXf4_WZICSQxektQT%P_dohCl470vsj`P|(Cb*j4f zvTe5=YWPX@d|jMjhpELG;p}Fs`RIumuc#Rt%sMXl1!_YRsKQ%`>B7om^L46kruVUDY+@sAuUCOkq zO*DK>87aLQjM3>I&<$|B*VZEPlrYEBC@P)VOqsu7>FCndKSkz;)+i;~e89qX*j`ep z-&hW==!wH%r_d5ZA)@@qX5!*c$oVJD3vK?N^xNeFmaPvaNAs46QfbK!s%&lj_~5F~ zSpDAkp$eZB8m~&94m`0zima|hT04!?T#H!>=fk+Vfa58flW>a$M{|eFXl-dElrD#` zXK<-TjvgwsH7B5bhywKr@^s{OxqK9!EnYW;rW|E?R9&A3`xE)CuAW6orXthK6QWhH zIWUT=^$@OjI8IZG7K7_I!+-d!UGB1ITO)yt1LoNJS$af})hDTQ;J?p2rMH$00Km9% zmgO{arWm>VvWWBXu56vA%37chh;F->TS=uF-vHD{R~7`s2JJRSJRpM3JhC z%A%aV$u_V=eJkAOLfW@e1)+Fyo;2SNrts(B1ZyvGm4A(}aw5IHy|#I#+}rHml3j2V zmZ3EY*x96&%Ch;T74lWQyFyAf+nJpk=SQ74Jn{QU z%6azd!ar{c>b9nD11xPPyB9GR-Bv_m#0ndlw_CM@&@xQW()1bJsa8r!Id!o%ORP$C zs(f$bOlWRd7r^Y|!;&>bb$RP5{PYCHB+%uCDrlh`o`Q0H`EZlshi%j&)Ds(@R-`0# zW^)fx!1|~QfPDiRayUV+&(DOsfkp8(eb1QRBc69#9Xuy_0yyAjf;McKAe;UhZs<-z z#HS#^{<$WgL_TSzoOL@XNysda7Gk&D7Ey(v z$kaKF2O3onw1s=1&jUVlLObEQ@KTlARkTwtG-nuds&$x}#QQEb zLrlt@afhT4Gv36&Ro92}GDlJ)-ij)=HJVlC+z~+<^xJe78#a0rst58szY|@q`6_2( zLq1=m_@a%prsb|GwVw+wDstc?jzfPq+i@3l63+K@yg8*MOXDPL0HvCs0KzfJdRO`P zxZVIw7%XyuXKP&l68cW8(9Mi9@1!dPAdAwk9gh1fcrMmIl`mplD;v+JGHW{gJ=nwSm{Mrn^4f zdc+*u-01NoGXwPB9|80bxFjz5 zVek#D8=P+yTaMv|5wn!{=xp-4!X9;JH|Kdi&S7;%glswPX<+&cDIJ8UZ z<6Q`pMEHk^nrRX3SgNic1Na_vF1TvvbI-)uwVOnCSq1PzGrp@C@t-{Ai`lqyau$`M zS0{7_1PfgFv8=@b6Kv`%#$TYG)oD6Sp>)MfZJO-CbedkBzESK& zpid$19SasZM#reZ5(Qx?lAZeYxU!n~`-eSo=yu~@kw4l-Yxozou-D8;_las#KQ=(X zXfDBw+i4ZG`=AC)dT%cuI4s*g@J9l+Ij_Sqj6X=0O#Ly-eS;pwLvJ7=816}v4_Azp zS^L=AfEY6eQRmFVP!~`T3p7>xKSvT%@JV_Wswt0sZa3IHi#zDMf*boa%L+}Iu$wPQ zQ~JBCV*h2L(g}O)n_~R*G59=Oh>M>kJmF2#`Giv6udZjHMpq;@a`LLoD%8`#V)2RN zJPO*xcjOc0R70*6d27CGfuJKOy{3Z zb9{8uf=p59hYU1RIbi+~n-f)B8wjn(Kw%wr>8| z`WAQra*RBr zzxn9@4b*H|zg}35jeEWK%so5q!1PU-^oOYzxFv_WvUsVQY{E6H=#@yH{_WOeH0O8h z>IDALJkQzgg&%wdy6J3a1YFkSUhfxpe8OI$IRu&d9_t8KxW8C-uv=Y2xb<5#Oxf8s zt)e)Hj;28yQ;_l#?bAHo?M~dr%4s_FvlM+evlcpg{FaA2W%bmEM?0DCElKr^(+tUN z=$cRI-PK68*l(ipJIMfykO!_qi?!tI*MJGbKjY2LlCN6@5-E_ozR{i_$fhm<%7X0# zAJ99i`Q*D4iLRJ}gJgY*F{K;$(0R<=%x`Z0ikfKY_>|1tF*Kus=f*f1Re zA`qI0v=B<9DMu+vjX^?36zL!wI2L-54gn0(R7eO-5Co|fK$PB_QjVY?AiehzdMErF z&ij4;H^Yp>jLY*p_wL^1x~_YdRv~kN3>>EcUK+|2!p0O5r?EpCF##zD6#rpSM~U(7 zKuTaN-8$_w{P&Lkvx|C5PV~q}e=}sx-2aT`EpPggT(?c9z4BJQ-R?YqazV-gpxmAh zA;A9$WL_{4c&v7ERbrnZp?1)V?ds73S89Ptifg&ZY&@;@Ydy0sYVBEpn6*y8pCj56 zw%?DFfw3pH)1s)ESHBmweoA^Ma!^hS>o$A{%!?vL4|e*{spKzT{{|Aynu>a|D&`>& z2qa_y2NU-wq{t%2+$k*Tf|!s;FQ18K$9KkqF}C)4_WX@!rf9l1v|>R&t0w=$OX}+N zX9Ai=X+b2J#d5bK3{V4)iF*LMJPyfE@)i6?iX|j&ce~0uG;T7%`@lgAyArcE5akPi zF+Ko{VNFHOtK`4w9C#UyZL@gyikf#n(q!sw%XtbiAYm$)h&wJ}NABhvEu*S{+$q`+ ztP+Nt>gS=&+i`G^Q`&i3px&E=;`%K(rygVrfpqn!eH48|Tb2iARRY*z0GH-%GMi4` z^cmcPlmeN#ChEwU+*B#p<&o+rY2j7Ga~1)kkeGd;XSmjnM~*gSWNcA7-DHqF=A1)7 z^2LHMt(Y6bk}Lf*{J^J25}7;`V=soV#fIQCevpO+R>!X-9^r55?R(F$4qouu(P014FdMb5V+~%j2a)UiQXmqN$#)D0E=fOod}iL zZiIYUyN%nQZ!i#V`q9$LMmT`5o7}o=A?R>*l{7{co#60pKJrhVOrWFaTz)VZMb=z5 zM$Y71b`NP8x$dhUhiv(cWG$c!6AW*Y`Otd$pDJ8kJ9u)#V{`03DxYco`W7%`_PXp% zX4mk7aZf)oF7u$pn-&>3B3NdLTB@gE*kGe&ElKvq5Xln;(R%E2*B^Lk>@^-sAFXw$ z=!`J{iA@;7pc3!ZwWzO6{GohPaU)CJ4|W|+50Lt~@&D+5qrRE~WwIv-WaK04V*>$$ z_vAGTp;+Dupvzhe!Do>tr&g#n_F}eV$KD=U*G3?~$Dj5ltf-dWfIl&KNBK{le*sh> zv#_7h8CJT)owlv*qiBuH_M+3?zaT{~YPY5#Vppi!NxW&Mv%7P2gsOiC;2D}v@304s z%IoY_0``lXY^ZI^OO&2F2NaYdmqIeLg?66veH7LG?)X3@C{{~-J;0^`h?IbrCBrS& z$dp3kEn7zICvR^4QwXGU`5$&3T+;iOlkMc{bLcn7b_I*`(xi~CWz1vn!e^2?tmDpO z;GVBhI$yB;Rpk!t|Myh&;W&Oq?c=m>LX@Iwz75a+4*b1iPuu;@HkeeGKP z04;JWH==nV3acxtdz_$Pj-`G(XDM|@*vUQh?GHMn=?)9FICU(R7oXwCUDma8bn-Ho zTZu37GBvm}OPJmme_eK}U#%%6422xA%dAu6QkeWF1mp6&t*HLH8ob8tQ+IXOTC69) z7~do@q`x+BP@Br86Z{*iuL%np&r%SA-nV4mFuuaZV#&U4iG+Ww5bgQrLt9RF_2i6Y zt?F35Popci+JuKyG1Grf#3ZFI(UQM966^C(Y)a-bbde~R_)gO4vM(EiKC5eR=&4$V z2JNYW$@-Pi8_{xI0X#aQk=ex%MUr zpu1WNF%Khc+-_kCK62xfp@xZl3=4Rtol(OycACV&cU}=0-=$j#lsFFU#kg7eo?9HUjH#2KEK);ErXbr(${tF?^VA}h zJOTuJTx{QZtI_eaWk<7D>U1f`csi4!_2ph$lM1>T`@c<@zo7WJtT_&Z{2gcxusQn^ zV)qV&+P@T!7g8HVV#5c(&@D@#FxQNpDBv}wgR2%$7Ny_aV~4S*iie?1nb{X*syPv; zsu6L66gmBlnpcN^yCVey7Y#Ce_^Q+A&A~M4e}xiH@@3U$u(eBiBlnPqUX24Ry6CSY zq|g+R#JUj9X(%h*yEm$Hy^DAK=|Ig39lxM4X0drA(!uQxreLOrS->{!ahuyIdR+hpto4`+nKC5OggAIT}DyZ;~(KQx~zyO=amQ89Tx*J zRB);+HmP`TEXj&}!>gp2QtV@Ezzw0PQSZYFUKz!tjc$2a>-FFG%hWKDTM`k839>=P zJk(;;5CKGvUjDIui;g%7pHZBmvJW8+-K|kse@^h^I}Lm{O^SvVk%~)Det8Jb* zkxi8A)AogpIcdTJ@4jk#mvAdi-}jAM@x(R8?4NC3H7dmC@&9+E@Er%W8SGH?Ndtp5 z3V9>*g$qL%x5NTz35Ij)V#cNaWUcx0jObjz4teGAng3LYd-KYuD2E@jN?O!qc9c+r&q%FgQ+zVw)G{oup@WLgmvvq-Qc*u{9IrZldqc zf$i78Ps3QfdQ01kb9VVjq_6ah*aUAgs>ya6T(r!M`&suXwmNghvQ2fI!LQLZ^Qti& zN;~oTfvnZpysDY-L~~lcwkG$8>-5 z`!u(Gj;_b77zZ|gk}=+BV>lX=s%^eDkB{1~9>AcxMc9kCN%Ysssf0(Yi>LX;dQRC+ zPf8BHUwk_1;d83MwIS2%e3=dB>Rj+dfTx|)XP-f0QdCcLN-W&~j*?0wI$1TxX()dLsp{-OOnF zs{&oaxNsq4)uZ&`=udaaF)(PO(04(rj}pgH7tL?SmE*Y{H{x*Wx?|x$Lon+s`TjO@1jvo7UhB)WPfx?p*`G10a98WMCAz+dh(f$==g~t z1XsgMAvXDP&_z37h*|i1(+TM__gZwsD=>LHwr`ZLG~Mtqb#&nMg)A?o4^}dCSJB7rCy$gSPns^KhWS z#e6};uCu>3l|RXd;+y`J?z1XZ?m2tDmrpEgyhdP0ni?v0eIlWG)F6^30i7-Xh*Jzz zWiGBC=^MX}8agddND-~2P^El`%J6P(t8}Wb#jS>otGwPjy{nw?HIaVQn%ep)uAxos z*h*3N@Jam_m)}ud8qBx%yQ<$zU&S>r$V|UD*C21S{aF4*TIcRC@1V5rBaPb5kOkpD zP30>k@9X~V`7J>y(C&Qj0N#DyJth+K#2rTJXh+qkRw$Eq`fPB(yAfKJ+I$}#RxKW? zN>yu-cv-#k_u8>&3)4{c{uQZu_Vs3$TrEx3a?^iZ>ue5`ZR&ffRaT$lz}VrWabj46 z{+UsuZdPbXyFbH)(k$w?a5wh0a5d62?e?chT*2>Ast2J;tiFm@57;K@Qx=fpBMze*-g^2AsnT?--Qw^Z?>%k-vl7*C^Un&Q+S>o@<$2IWeqkK2Le8k|SzdIzT%_f|Sa|(-*UnAd z^6Uj$@BZ+^s@-v#s~*gV5!F>XBXK-9T<$VonxT7uzkr&JNhs7h=Okl7Y(&+q0NoO6 z{5ZC{ojAXFQYKR~PRpW~e?!nn_L_&bsM()p13IV|gm?H29xP1-PKL>#K?x5D8WoRE z0VI-N;izrZ7F(n1SQvO-zvh$YNlRZ|`cc*TWbO-2Rf3BwN*TQRW8$K&QJTE~8OW2_ zP7a|>N2ezy8S_1SxfaN;Psehqb>oz>=|bY_PVT73pikdIFJz9GKqVeIP`p4fu_FD} za-gu2nY*lbSDqJ^0rcRh(%`8MsIgEMJyuzDdu-3B6`X29m}=tL(g=(zlr$a2TGlWe znjh2Npjo4|P|<%41KjlLmC>F|y)A3kBnXV}KvF@0fvtOq-JRYn%G-SZq3yhJ*rPl> z7S9LRqz#WOm9-lmFzFw>lU)!vpYht&ZE1Ft_MeO6e`rL^Qkyj+ea$l>Z?<32dJH#s zehu&3pj8%{YDrklm@fferH?8L7+ACtjZBl&S#vlX8fJ8X-t1>9zh4s6<-m)e@mHf3 zzBdmJaD*OW!TPuMC>&NDU+`|c)w^g#hr0coMn6S4X?jwGdLy?t>e`W6f zV?Ml5aIwn#LDlZ-V0GB)T&pgZk3N~MX3l@!dokqC?^zj!_VA~yvTD`Pbu$htVyEZgFVo`y;B|B4F?f2L21be8#ASB|jX!3beZ6PJ6o~ksiG0%TMP( z@5;eHRN9d=0-663iyTAoFSxb~!on zZb|Y-1)-idnIOg8y~r(ZMOfG>{HuMS(kWsw5!zTgdv8TpGzYnQiup+QR($2-R zR=_A^+Kq!+K1F>URDx6k4&)iu|n;~Vu7HGG0b^cHTI5N%w4S5FiW?|~HI`Pg|#FvVo}uh(0~R**sX zuwd)F9+jbNTwOk$$VR`K7R>~lyYFbA(m!IcUkgKI`sZe zUW;|;`;EAXJpJ;29t_cFOE2vaJpro5Cvs-)IPn6?m|Z7W-Asqt)so~77lfuBzSVDu zy>R&5DScegYC-qcyp>oy(GxU5Nr@TxoVwAXt8=xR~`y0}hW*2<+y105=bbqr^7B zaMlU*LfjT}_1yr;D#t$Rtl;>?tN`9T(bOrsgL=#5*_lnmiT39)`~Wb zMN$yi6F+6ctz~ZA6ODZFF+0Gl5PAPvXw1jUL>ePwoMBJYy(6KQEz2Ren2wWq%gSc2 z?~xOezk93Cp)$VTwiD^;>S3ch;R0jeG;#+Nw=f0Gj$cEo9t(W%FxOD zOK)zaG(YkhhE5}Jc-vp8i4E;)VQym3vP)-fSYj_jz5}@7 zptCB4dT-7e9uM>YbHzqcD5DAUgt5mxKvRxi-k-2XjLb7*?L9tklROJYY^(G{jr{lQ zqW-8JcJlRM%&A%597fX>+Ct2Iv+Q&WhI#5b96rH>z4Xay3zgGtVFpmPdDw zCyt?jlIcW0JA=*Q;0@Z;Ln_V=i=KZ!)!&pGh(()7wL)qcFn#%SjkR7MeiE*dSW4eKss64GrhbS-> z2I@8a=Z5EpvURy3>FDv*e0yZJz%N?Ob|b!5c%4Nz4i{IyN`o4+T zAD4%LLKX{_2tu;{s7^aYR4VF)Z0e+PyUdG*jwXh$GZLYR6^M}a()abt)UIenlZ|@U zdo>e_#~?6iMR9JKLy|-kK9^FX+hG^eORi8Mu5A`-!ffBAM|QGPHQteazd!ED$qU=ZMrq!32f zQ#U@~UX7l^NSpCDJGN&Lg*;LFx$D<9hT5sr7wkTdIvi6`iuuJ*rdbj;>gNG<2X|a- z0cGT!No7UYNn;ELOnHz4!ITPf2nGLS8!_VIj3T|NE(b22S#N7k{)zSa@Q=P4@F4rE zR_R8$ZzXEnklE!`p#8Q6$%AfKGUq6O=)*=T%?`?Gk%>5tLFV zJH##>y?4W~X{id_WPsI&!D=rX@;Hoz7Da#>KG>shj_CRuOp`c(-n4AhNBRO&&f~H$ zcWH`3vnNU~xAns959&Mjy_GZhRn!?%X{iw0sf)zpw|r4p=ObF9blIY52|JjrJRZH@P;e@8A+h7BSRjA*>cb8054yvP9i&+={ZPt_SpA#U@_wY}VilXPODzeC{ z;}ulGk}2g{jSM<-B%zn#%t&tMA*Z+Yf~V6gCz#WL(<9YW-n3%c232ZR=VMd zD!k3>@iFEk_rh7*svY*m+A@({9DB6u-IoprMw_d7R3i6IcUS4CVjCDV{MPX=8gxwC zSzfg8QV4N__9IKsHlq_cQFor}2+goOtlviAze_3f`=^i#+voo3aEPUS^6_DWU6j(r zC^t42Wo+@&J1weR8o;~0c%)Y+(l@k*hrmQQ21r5mvO$o|-H8c%LFFfcm0w;7)LKV)T4F^mmj<1`#m7=MdHg3HM)T@36-N6^aHKzqqw>vCWl9 zzKw`_&5WMpqcNiMV0ndio)G8eUCEe-^5@<(qNxw(H$HPP2vlEIOj|Rb!_e1lGI8|Zn;vmZs& zI{J|f)Df`G;awMy`B^k5!Ln&6#%`?sie_ru?B50y;_cCVgqfSvBHX3_LEAb}Tr*ak zptgYS4$!OGs)MU#Ljxlu4Ni#WbuKfdE9Zk{<4D#LU`DZ$-ESym+Cbb)w4S#E@bte- z={JBcfQu~KN!E(bQ3E`7*tShvGBe@@)IkNW!?4MYR$x}(4lb^U;|rZCZvCQ z*x*j8H92@P{o~g3q=I;keKF>aTho-k8zFRCk0-8#V+*zRQW{khI3PItIvEpqDdr$) z@i|B9t(f=c8L}U!4G~V0ilVkJ>=d1Bi=` z%#6V4)Q(O=Z0z4sr?R6SS$U%=i31Rr*ze868QVj<&imjJxfimyHRP$aD%XdjvPwgH}zkf~!K%dqxx}!3clf0^cUuD*D-$P6eOE*E)QWN^l zP@7(}-GUl)03Gp6B5J605SYjuLe#dNwr|JvtEc-4Tw5|=0mJ5Mb&z6_=}3fgwe^*t zsDlXv^~RSQd3vV<&p7%AoFzP-^7(cY`$O7Wt zVB=l8TK+Uc?Y;NM0<1lOb&O%$Y|HVh%Z4v| zNP=iQk-&NL7;7BdE6#pZ>XaUf1&O7OO!R>_PfMYr9cjZ|a?U1q_>YKPUHzwLe?-EU zII2qsbYd$H%B7B?w%yL_d$jXI!c*y%EPy6r)0<}|zUE;_0=Mgpk2Qsya{>b3p$;Ge zX50$mWYk9ui|XfhHhUyrR^8Vs%y|~C#H*0`vXnz_#)TKh?uUhUzX^>qD2zJzKa;|C z)zz4z6tjKqsC&oa^8**xOx+fil{B>LA6l{Bv;FBea3nigu#titdBEgGF}{*@I;MEG z+pvuFxH$kQ1^289Pna)Y0c&>shKo!;#{gsjeflXnzSU_~tT)#x55Oja?5VO!vjCrf4;aJgn?5M#)&o@KYtkT%k@(5848xD| zz>yI@8G)=5F%Z2OJN%#jlIpOCUs@hI`lF%8uN3Y~Y`pttm*0+C!%xsbkkmx&!j?Yu zkmE$?B{~lOkotcEQ%pPfKR&d?jtO%b~%Z(9#P{6VLc?!$^# zl0Qd<_>5=Kmu5T|t|X6RUoCcBdXIXi%leL+)_VerR8i8Q7tr|urx#PpU1lGK?)cdfJhlE#cZ2$<@(#Ne!r_k>jYN?W z@1^jB<2WN<*Ty>)GCx`W-+{3~)tbK1_X?hYqg9J?3^2+JiHMQkT~}~j!uN!Y{oFYE zmsOG57Y#A9e10lS-o71bL-rFhcE+SFOK=F-_o#_-mZVKtK}Bt5v{qTaH7e{K>jn!+ zKQ->oqv`S33^|fiUerGCAp6Fb%23P8otSi;vlNdjU|^G+PZrE}UMpzcO;@J!@DbOt0X-2y4)IjL2fxCjK=Z-}>n zeerU26Ss2{9TVGWNyFETyKlvMo~ocH`$HmRf+m;|^B$xva{iT;eHaJ$(!{zTkbub; z1*+@9SI)C<5ReT?);uAphI0Y<40$d<$j_;Ew*s@eWL-b-j!l>WQJz60;DNnhu&lhO zo@JvR9UiL9H5X|`4N0|Tf4oO04=`~n?$+b^N^nk9A_v=6@QbsTG%P8{2$uvVuAs$r zt{P;|W8j3GWU-!i7nL0T(C90eVH`dvuZeoR(K+arHzJo1IiQ3f7;@07W=gW)V)_oB zHyF@Oea|Ne)m_Nd>(~HvHJ*4e*y9ecqa(263F_v`S=i!uvZAJae`P)Xp@{q-GOvS-d4CR__B*7e7AYw12UEWWg(#+@PrJFr*f)aOXpI^j$3k8G z05qzgXtHVJN&xg^s)QdI8}%P$sR+MwLcB$vB^!lQoyvR)3R{Eiipg^R=_9jLCyL5&R9 z9FfzV+wDweIXv9KEJddGtA-g*IQn$JcA7Jfph+kP9XD|{Uw901Hnv6;C<3=z6cOr6ANyL>ogb-s# zTDJU`j2nPqIcJ=0TVW{>O?YTC*bLI8<3FslA;98jQC+;|?4L}7IJg1o69+J;i#+Jw zT*te#e8RsROiIK?`35NC z3~mm14`F?t&Cn0Kdlb&pkBR%W)@m59U#PHq%3BGiY9q3R#Geyf>0|#qoh4+DwH*pA6UZfn8s>2*Ovs#-}GZ~9)*+jQj zvZV&w<9#d>7 z&gMc_AuELEYQnx|zF@Z7_mJJt<4yx61Dtf?g7{VEZ?Z0{o{e>Iwqf|%UhS>HhZ&wb|6%&i0YU>X{l$o)e^uCS`n$n0_{$zm z55J-r(P6;S!C)i^q3=yX(!zA%fVt}YA%JwXx8tf41$64cBgu5?0YAZTkX}1~1rVa{ zCJR$e2IGvPQ`Y#PK1LU@J9oMO+^ceX?%@=Roe6P#O)2_Gp09!I9Um3Z*HGA2G z4KnY|c5vQBws3l$?N_!y!+GsLybo6Mfto~2F=vImi1IKw7*%t-f0HV6hkI9tKubUA?L&%74B9-cR@zEj=gl12utS-e8| zo2!jXIUNea%8M9@H2z%J*mLm_88$bIpn)@4Zl{VspE&xDk8_sKBw#58%piLuG$toL zGMQ+&12p=CwT!OE*aqU$)gQp$0C5gvPbRB!yiS2du8bOGDQ`=UI)tGi)nm6tvfiJM z!fGo?hSK*W(2T%^C$Iw>cNL?yM{VtWy5=MbW2OLxe@0H1{jBx{l!DkDAz`;WLJk1m|{J88@ev zpvx7XkP7%V)W2Kn8sz3jFl_`*m|L zXjN&{@xCZGPR=a6u+^cVy&_b=Knyrg$Di|~ZXVJT0BQugG?Nz0xBee>0fo$vJ*kA( z+kKLgjgGKYP%9heR?7+XB(({OEP3r~rJoD-_`FXFC#T51JZGGElX;j zDEIx2Na)#kTBA;BSS>g0=NKxWSz_YdZ!dmq8Oo;51#IG)@2~Gi@ek!PlMKRBX3x=BaT6V= zbsLTCu*7%Ou|IP?jqfkU!J?AqnigsI1~E`~CseY|%>bNuWtlv2vVw2QbR_v)T}mesl! z46I~=VQGN3Ot0|*tOw3I0w+=mdNF4c#h*ck9vMDMHT-pSTU#zP2?z@IJi%dS&NF!V zF;&ZQvZIvjW~;Pw=hK%BiPOoV-H+sY`^qM4yR=bc% zzgtv${!$F>3>SFX^5oN@8@1maPYo)s@iyE75u+lL)#Ir3_0frCDS3=sXSLJW80tNu zVOZS9RCR{sZJ}~azw-h-Y9`xmP#3DNs_f#EpAJ&{P-|n1AAvd(J`WU1w=0-}mx-Ik zj?v^@st_@v64%A0UEImH|O>!qYe(B~x*ub5(@wf%U&dQ*Wc!;#Hm-dc^4aBBwv zj?sM&FZ<)E1XbNg2bUn0`}2rOs2W50`M_qJT&-iZB}%~iR$HY9rUtxZULl}hAejui zqXgNYf|hTxmhcZJcsR61a9kF25AFl2tIdh6j(i z6ywQsGN?%M38}UEO@nrh4I8Io`Mx?fAD~e~1 zxKv)WE_q+YzEJHDX*r_AP>GGF6{|G$#-zpgB)hypb*yDB0xFqsj_-IBDVK&FQiR7l zjJ}bpTTG^G`SkIpIz*mo$Uf3ygn_}@<4(0|cj--C9|8kEmu1+%QBl9AIgp**8W3U1 zPQ#*Yo+T!+LJoq!3Sr6yaEYTpt$i1kQ^*7#^ofJ2x{tV2KJ23IP03fSbo>8=zV`BUIgFY@>o^;EaxjvLPgw zzeeD%L)c#X$_n+2&r=FFi`E2{7OT(Lm4`$DC4=6?jU-~X{HB$=4K))#q`lSo3IIKY z!*G^3dXYgoeY~?8WGCPqTc|`go%W+?f+c7`A~UI!TBX^wukVXPNLshAT(SL;*R(8s$$k8~F-mmYBxp{s=%7 zIXzoQU^)>L>3+V@io}?De||#TL<#ub>Zpvw)Uj=Za@}FH$_l#!`_j&XVx;hJK?WK_Pn(W3b~$PMK&H=LQJPlXkHQ3B(gA36 zB4s;aMA zk2^s3q+v)MEDd?hz5Q1dAI^)AHe2Mjg z$Xo$AM6b=w<~1;@0NAxK+CF!4S-TICl{Zs$RR25nIx8l}3uYq~-gsBMp0`y{gwfNj zsVN}R`r2bBp*+KX%T_R&x$dn zdT_u-b7dLXT*Y3a$Kxb4f6-fa0wghwj6gXT_$ZQTO;b%`=UBA0Lv;@Vo4$4#h^0!B zSy~KN<@0E+GQDH8#jdnyQY4{HRxN*nko+RjpJ*5a-1~((Jb#UYV4Z8MmW@Zt7e<_B z%-sj!QWW=f4{lk$|M^XIZO@1PzAjL0ZzOu&!3-zOWrP8)hYv_&mny`(6hK0_qXQ7= zr|D=@jCF%|o{GOJrx<}bR=zXlM85vuoSGT#6| zyCuK39jg9_iQ<(2I6>uPOKnu*p{Z~7nBD5((Hp>|Bu!981{n_gLwUHOb12Ui^12BW2~BmZ7B4z|4oexZKb6Hm09(xom&R2 z)FLpqBfJ2?@OlImnX`IbdgyD$`)#FAQo0K02d6*e^Fh@D@}UT zM}{jIdh0lF6Tuc)&;SIH)?-kmJ4V#jM$I}~s2gUSWs#=Toit6zWKmM)pU2bV@u_XS zh)JhWZi(9Et-`+c|FBkQV-TO@E)L37X>~PmQKvoN4-6{aE;=jXS>m0tiB~dHgoM@^ z!#PWw1tneC@w^C3EETaE{;LG z%Bh4#EZxkqSgPG|o|LBtw;P!F&F^K%0uW)dtf;JGyOe5I7nBsum&@4~$6M$`BnJX6 z3-y>hTF2Y=va_QnYp>5nRXqJH4j@Vp=ysq|9RbGVE+IqH2ul#PWUm3%S0*%yhSDG# z6G;6^_Ma`5MuTjf2XV+>L>*~Ba_6Nn?RU#lS+D=hIwX*rXx7viV`jl_{z#4RlLIjK zA%JJjWuI=Z6GFXU>Wn(afZC)2CIuRxWrTmto1{`Q-X7O<^8J0dTT0<3F#@I`>wh)_?{}aP9D8F%sO)+_di_nO z3AigPBtCTe%>}^5$7~)p@EUa)AJ6l0%IyCz&;i~9-C^`C36Yh=ZNNaIoke>g^Io|X zCl$$h`kLQRBQ5)eOmb<275nDX!b#hz7)wxQShjSY6-0fSBRY}Wv2qDXtc%M7(UvIx zI%)mLeM$jLqz=cBSC9=*&Xt=p|4%_=Lsk%#|I9jrVYx>g0#l^njJUeblt%f}wY(m- zcR}uaZ{fAi#7mzTa90C&`0)Ul^yt6)^&$~TCYS9it(l5sX%Rl%8>mCo3)w%vc`D)b z;Xv8L2c$Y1L;`7WpDSBs{oCEH*5d)*t1`X{*LDy9^ffC1_f!PBZo+zeRMa|(7pv+FjvJvEgQ?}W5bk$IELT*5}7^G`jT>Z z!#p_zUz0?kPY2zt5rvM-*dYK63s?@`>aVq9M|a7nxv}2_R=ZB9ZIk*jMU6d0&<3MS zW=nZEcW9jei}rIZ;-_b+tnTgkvDNP69-p1t-H++t&!sMqEyZ_X_Q}yH?vb#Ryvdx~ES=%n?5~#j7DzYFK+C>>G%|@T$ zUWDKrc>epKNbo^ZwDkuFYXcruL_3m)a4uWwmO4ZaIg!O*&RvqHmw(lxOw&;8?=ph! zCf@_0z|YXrvzgWt9Wo{6_yXZW$?tWCLvw}*d$4VCIZCvo$D8k%#_Vw~L}F_XX{j{Z zeVC1;`vKMmjzS;{Uxthv$ikP2JYq-nrEv5(LdHM{1TDKVSa>9nk$oYin$a3n#RM8S z{24FnZ~F~20_gM`xyL}RKj1o;>9l{pJq@^1r)%R>X$PNbl%RfK4-Oylr3&^~y0*c6 z@o|rQn_8O&R7-~E1ZU3;dEQfp>l{8*$%0-i9H_p;oDeKG1% z+IqMTF;A?=ieV9Z#57is#Zsds2HFOXUPhWIxxrc&TObKl^3cBDF-@GNg8&&bKg4EOe*A{XAm^GVC^s9%n4s-=$v&K6A~=p^+@414_vr3m zPt<;B*@tC8Z+AJF$83uy$AEgfO8TEYC#-)#kJ=#1OLYr&W}_B@j$OYmL9}JVE_DwM zxm+3nN??LLZ-rLPV*tCRfI&dZ(HS{m%lGlewoq#Edzbk>)#aX;!g~NMT}faT=lK%; zw_D`)2#t3BRI|CS;3!?1<-LvZd2mi8XfkNsllNJ^1W6IBYBy?4LZArNWh*)N|y4OjAy#YIOcCERYW$-4Q! z_W|Z%Q-J_YhTH~oPHTvmWkMd%x(ryUo@xG!P~R}Vt{?-~%4{erdaT^JZTxeybsbgn zA-!!>IlQf$=)<-cY?3a^X0YigXXAUO#!K1+$SWule1K>5kg4a|ezoz&c@c9tMaJ(}7@P**7FOh(5ZW=MM z`MT&8%5k3*^bGLrpq5EK^%I_>HTY2=3)C&q6~tn~qD~%A7(q7!!AY(2jD+I*0^(qQ z#HC5C{8=WWK>z0{%HS#5C5gA!&EErx!S}Q2TB`Ne#nfo@mLEMuqoZI@H*av$^4EGM z*$!~;k*73}#{CdKWj9zY035A|<3DjoxIM6#K6+@I`tl^g&xazL^|1<#(I2j#iM4_v z&nR#GGKxINqaBTxsUr* zIjt{i0JA5K?f~*eV{fZbD{(OAlGs!@A*uom$fH`(DIoO>iH}J*7$*xEKfOac)M4al z(ju#vIlo_w^PZQ;VTI5KvTp3G+sW=jVh+X{L9#N#TJv1*5wG>gMTN@zIZSsSFh|;g zmQUfFL)d~?;A{=&w+6_E@ioBU5Kv54pi-Ax*%xvsS)2O(O~lzZT8mXyMBUy<9E|^8 zLR0AX@_iS{PLq+%^Tx1RADU1JeY)HE)3-)oJ)jQ+??W4>1AYsuHzk}ZgX3IA4v=>8kh><9?e38FEZfLlxkhNbo)l&Y ztCE|Aa#b{E#mElr-G5?K%-Qi0bu4Z{6_muC>8Lwrlkx_QX$I%df3Lm)U`cEt2yaIq zyaiYLSy|JeRNG%4pL%*rYvEU_*hZsuB^H(n4f@rDQx^Bqbz^>>|9Toap%q)j(m?sw zi@#Z}2rqGS0&Cai@>(pNTvYsG&D+&^ut5o@TTD9A` z23hWhcT)PApGz4RCFQ56&c-gcJj5WA)BpUskJRitZr)G#Y{bRomMI(%r|aXS`qOR9 z>1KD>)HIdpwCm7*ktc7_Pd-9+y?V@(s*txWw7(y48-D!#?PG{tP8W*OAu>w$GnIp% zL~+)+ceDhF+-~cG(D}jT<&kd^UQ8l``h?jrR9 zpG*rZWUrcCt^MK15cP84Ekjg2+fRAx13!6mm)`LJ6MM!}HN29Pko(hWEF;8ZIULKG z6Sce_v{pqZBigB>_PbEn1XKN)=1C6@^4d{oa`&l7`^-cH zE8AxQnL%OL%5RMp?QyRSW^pZ-;G3l7ktPYRRJay#c!DEV&8g~0C>LCU@kjgpegFo&q!-s8_~ZhyyVs(r~wR$s|! z`RH+Rf_W%An*h}QIn2&vd~6Yy;jNGRUis8y;T5{4K;*iW8fq$Rp2zNHdbyzl`l_Rq zc6XeRXyiHVkMR2;4CCgkwn83o)z#;1m9ChY^;Ip*GoPGXrZ|RR8|Ar=k%4Pv{#$XJ z3KJzpdf3SQzYn`*t*-{vJJ4DiVP5v*;i_wN?f)B?=knW&66P)uV1O4f#G5V}x9)$P zZ`5@ysV1m6n-vU)CYOEOF3AcH#^W=*Z_SL9t6J~xX5W=~QbiFZ$#kw>mOJxG=Hnrx zQ2$dd0_;MjVrSnDNn>1xlHU?H@bT%FHPZjb)qg-W`2_ppaOk~vPza$H382!X3lchp zDqRE>k*a_oB@`h65eQX5K@BKUMG)yl5CV2kkX{1Pq(pj2{u{sd-t&9kbAp_3oM-o$ z*=e8MozYPL!#q(X(U{uSymJOZeR;UTHvcX2$#E0?1bs+--{eVXR z2=;Yc?)7_O+&gX8NF392txg%@@tM6ry+i=F4}3+?bUO0+pn*e6JZ81w?`&t~oB|B9xlK zzdWJWhlMS)UXnE|i-f^$KFpDDXcBw<{fqD=PR`r={an1XgsZ=g=EiG))=7qb9{yx@ z;u(&Lv+w$d#MTnWVPh^|Uj`qsnQWn*eEqVA_;!c6eg$t5tTx+3?>s)e`Iqlwmz`dg zfhV_bXj=+Ex$iC!cYjp$D7k3Pa!2^Z*Fao6?sH~J+0jVA%;Wfb4K8BGE8fNyxrE(Y z!%8k~T?L}y!my0gy1Z=nJgKiCxuD4J<|LQo#EfVfw|zO; zY}lY5@;+)^(~<_t+3;ld`4nTc^G>ZA1}(DSlENx(7%vX%DuTn5w!_b<${L3JwG5m3 z{lM+1i{z4J*oOPi83^p*iMvL+0y~qI*GfdfSj3`VoMn}kRQi0a1rS!B=yc)FC}<^4 z{Z0Zz&_>5L$I(FuV|P+3T!QQ1V`dC*ARW5q(D8vq?gVwk>igfR=u>z9G2-Fd&!-M| zDU67e0xKs|k?fN9)9IIl9pcq9U%$Flhh@zD{Eh4V*pi`-$VVdu@4I`R%UK7E?yTP$ ztNQByL~@K>=Y=mMu}dn{;Pv1doTDwfEw@-x0E@48DL(VMXkEm!cc?NRJzn=`>i1hP zIT-%!`CeaPuto!2T?B!#(aUHcezU}v+|IgA7em#@Tz8d2;A|uySix^G$K1U)qn@noh&$^ED1U zq&r+fYnKoK{NwFkCV+S7nb)y!Fjy2r z{A|KK(tz|5huThI8~Gq~dCGC|BW^iV#&zq7^cR*VGMDC;NXI5+>sLwXVkJAgMPkC%>WiWEqJrk z_zX`pw>Q%t^_dr(T$`tcrxeSro5e$JOwCEW-DzDsc6&KbE$OAeZj@`df@V{PUNYk{ z@@Co|{+O7^V2hphG^|bBv1J2S(GXUjCQ8gQQVHn_UHWkl;9)6JW$;~iee@h5C5PJL zZ{CE4=WAqST&$sITKoLe6_hQx&9K3Scz5N-$#PbdjjM8Xz^2f_?NsIH*Y*6|j;mA{ zg$0ziTpim^YtFZ9xjUl8MvXqxb4|81?S>5&A-z$d8$J+k;C_zTRHgc-r%jA4_O$f} zw9`w^Tvo4=0yDIz==izfKu0C@`1nk-JiP1mNApd@9v#}7`{$kf8&_Q z{w6QyfaY$doWnA;l&mh-BKRI@#`93Mn=$1a?Ew}mc4v~S{qY!ZuupMXQ7eXN&0jns z;D5*3b>P#dXT-_^>~rJ?%o?WLjxHWxRTE`xe|r827wApr%KkR+n_*I4bC(zhZvk$0 zSxl}astI!1N9c-^EsQsqDMevrLd!XVL0+L$_~OM)CjF_qY(*0CQDcwV146&{hW?Im ze>!G|53DNx^m66RZYp#0j?>cI8x#4R>6%xH_oQq5-VsB4ia1_Lo{ig-L%n<_%E2>I z85wmyC}4@NsRX;SS+e-b)s(%#-sXvb_5h}4=*=(3S2fS<@1-?6@KvoT*k3RYEO~Ow z!dwtt(r;-_4x`ZB!=77eF0rPWroDQX-6j`FPN4IVQ;z=C@P6x_xS`iA_gbrn5VoJu z{gS}G{2xuhKN=|S+rdZe<8LM>p7Z6m-cgof=8%@JKr<_tWtVgiLI=OLKNg9kL@Hqi z0gHnmwt3apn=s}}!?QK`sAcbtzQsF9^6-leRlV^?`4(sQUu+E*-MnV^`PA{)TWPU| z48`ab%ToeSzP#?sJI-bk02|5vq(zOffx9MdR%Y;ZuhD7ncp%OO-0# zurLYyx#una$)kvaXV_8!$gQ6e_AJ#1Se4x9#}4r1Idb-hC7Lh5x>WkP1*R|0I-5PF zzvnGiZznCO{fIxS>`W2KT|^8J_A1;?m0W5yKHGBz`%Y;RQ`0WMrIeq_$X?1jW7dQk zDbLe%)UOzVe>s-j7LYjOKT)?C`x&G>;YL_1%U4U(hTHV4!8Y+9Fq%S*uAbL%KORKQbDGvUWRVBVF*Y#m7 zZ$GcvUVLr#qw@aj0yWZ?#x%!8HCt>N`Nx1Wh!MO*rmV#!wi^G)v%D>Z2b4IL24UQQ z@#Yn^d{~G1JVSU2p+RG4r36)U8_qEqUlAGxe}0?dNJw3U`mxPQb+qRHhiO%FGoiDdx$# zjPWhN?P!o-B0>tH)rr0kBQINa1!e`Wcy@GkmG7)e!k>*#N{4#C9l*Ot zHx9Jj-9H0SooQ;wugT-*sarKvjfmhk>gH;->@quR2=T?k$PxucxrC>FXE3oDd_CCRn4z zAo-gmBrXZ_3jM4^zP;QQK8=JrVzZ-A@)xe`f~l-nJ#`{QU)gs4q?HAyH;PV$cLjIa z_|#FGY&$G><`&=I-ZQ}92biO-tu!UHb-To^Qvu)M-QSoQ8+(}mY|2An>%yp0g+F`g z&Oh8l_LF@TWgHk&EF)ZIt22nZd^~rFM3vWoPJ2^lmrwU!9+U=1=dva}9to%Cly7Fp z3~=tI1sNf!G3dv!3fI}hUvs_vKKV#X9@f>%2uP`5>N-b!I#;T81986s9#a`rfdIN`_Qb&#u4Yxb|a0f8;MwtDZ@0?Moc&h`Ghi%O+dKuP%}yK4h@Fy{LfVj0v9)0%k#! zevhq@nE0plCr?$e!o@phz>>yvxw~P!VmbU;u6PNL`9pv;+xCw$I3vIo7z;Xt8FumYVIo18GQXbWf;~ zM6k5*aI|Pl$ZxA?$&0>R0U{3TNuaR`bYo>zc z=%64(g-jl`?Qn|kCmS;!Z9Y!!SSuk*qkx}tdY{t(H;k~8;qT={-*`9rKtt?Xnhh`p z43cjr?>)=7|KpAVn)ZueB5k0)(f_jJR3>h>GAP9aHo!%bSw7BYqew!%v+X`r(yy^Pg8QyfeTo-!zD=NAlaM;wBigf)l4$f+f{mk*|VO9oS z@eQY>)hmyB8*?ZcuGE{S=YJvsKy=KzeSTx}N#O`Swbf@{bXTiOhO{unPH|FC*qZbA zZV@$K=KtR~(v2sk%7JP0R?VH0;8ph?4LwyBsb(-U+q6*qt=~iCxNg$yleod=^@;x9 zGLwSYw-m^mUHvkT4{QhN5IzrQwdQ1Pm0Z}%Y9$wi+v1`2Bhd=>x!+@~ro{rD@}W-J zrj>`xm*$bRcLAU0%>Ynh0PqXD+4!ebJ|&ejnF?9FcrPY*_rMZRS{Z$BlKM`B!iLV^ zQOB)UQBUqtJS~BAFj@Qv*x)t0K>u(q%}*Y=%fsS{-i#?sH?c5BMf;2{u#K#eaA`?R zN^di%zwseC>heMsiT)(8M!0wft%YjziL!T_t&Yf2=tZFqJbVoUyP-X16HqksWVnUr zK1SW{^Pi*NEa!^08ayVxykN=bC;XNO!FB0u_UDKr>_%2uK=74QGGuwLc-o((-_nE} zv9`$9^tdA=Il5tsq7ALf{d|tohjOWWeY^p=0w7b>v_>R7r%@4-G%#p@%c@%*|86X! znEADu^(tTzZ0M&H<=<2{(4M^G(0>!IxY%V(N2jv+d-vey?Q1|m2VzNMq1GcYi)aa{>?nO&OeA(XxV4Bi3@89%?jwloOo^KP8e z@=L|f@5EvJ{wT+$ZAWl0luk19zN>OU+0DGCx!Ab0toOwY1WtA#(QVBKXCTPe25=4~ zdGoluYNxni-b>;|wHL}$RPXVX0IxU1p%NeRMwc8BuuM_1mA}VsufTh&I)z_+=+;`o zY%w^@9Dnwn`R=oL@%Z@o-2Iu)wDVw6T9io{m}+gmDrI3bb5$PtU77KsftD^(;V~0S zT;e_bkZ6PpvQ&gcazFT59x;@{R%5KlpXTSl@^QC!S6RDr$vbUCx+o||Tq>*Z%4sl6 z-p!I!Y-^6!K=zo0Z~YVA$>U)b6Ck`%ec|L?AoH#@ZRu)8zMO-G^fz#Y4e7fIH8`iT zmTb9|Te<_0veFJHJhGSruD3zo-}saq3F1u>{W=n0FxmL8CWJTnKPsQ+v~AaZ{ciA3 zRU_Kqq4`!8&hFuf=$KiyoLeU3?XGV!kKJE@5Jdj%2j#feOduZ!PWPE)F6mE+6AL=w zl`a2Z$;C_ID?0CANc%0eHE7E;_U_69T{o0Xu78zB=J%ue>;ndV5YV3ss2m#Pod@y2 zzMtIL3pN@TFkQQ)C8W~lWUX+(Jf-c%skU=KK8Bax3XNY$)ZO(_rX(t=_srMgYk4<- z0UYk8y{Bhl1I%`#?^65cQ$VOT*plSjAAsm`V1)&+|1Ul>7e-wwQ-{eOX*%1zyQpvT zt`071Ue?TM(73eN{`urTn&nAv;J4O;;vQ=8W!XAlr z4gdP6jW`#8F1)+n%K|UjZsW7k;(nO&m#eYAWB>J)(WdMGfWkY#RPz>+i}M>QI_?%% zZq4N!wTMXmwjynI;jgs@CT2ZAxcVe3zV1{aZ+g{cW3i7Ka&5>-hO-&9A7o8k^O7ZJ zQd$>IO*uCvIGGav24obD?e(&V6y1(|41lbM?{wN?&!02Qk*VQ$OFi}V?f3R#|EKV^ z_fBTm?ftLqA#C)QLf$BnHPknOoTVBSr&fR+HtM=?DHZeStm66uxfEh|&Q{x8Ep>H| z5U;^&`{bT(v;7nEcuSuDhz#*Q`|iVL6n~j4ZkfBW2vc1I#pBj)co1A5Z;-soseZ2exkW zPDJ>NGX@5TjnaFBs|KXtfGLVXGZVk!C}TNo{q(A(-MjIYFGTwMQ&$ANDI$04$JB0c zG*W@=jN&7eMw4|L)|n?%OttD?ma?EtU5j&`zQE9Vs>)_cJG{i5HSO$1>O8|}H^%o@ z@MF3fPGTt70#j_!xqsn|=wZMNu$DbKJNozhwr8xoY>3!rT`HNf4xVE^bd#N4B_t1k z@YENNAGICrHex6i`JnBndW{kU^_2XnBPf-! z&c@yIi8}hApQ8nzeM^LV-1R}`_>bf6<`Q+H*Be(gkbuy;fCNONq=CAgM`7YjEmU&F zwm(hIQZf65{iE@l)nwgpAn8)m8`afmlHVGz0AJplzeV*L11CSHo|TWjm@Rc)uVtai z0QuydSaDIMtASLqF);p%OKt7EyT`U5@p zxwdnk6$G!);Kjh=E+qWn@GGmkDsaheckv74uf6R=c`DA1_s8K_`|&XOXfaUlc!5OR zCw)pMk)~n~R>04vd6~T7z?dyD^8Rl<@_hAX?9|a>EPPildN)gtJOw8ach^b8Ve;-^ zpgU>l;M143WAYIhBY?EErFCsth)*$EdD z@LU}jNHuJaG%RA;-{y(1>b?1pYFt!n2bQ=A9S3KTk7f<<`c+fp>12*LZdg)Q9Pe6ZKT4NXfhMAT z@e8%WPFW}BXp&B*=&%sbX90R_3_tb!3SDm27Y3QYr0h5iq&77uu5lX2O2DFNWoQ~- zsHY<~ztCIJ6G=~R#_{fVo|2n6(Tvl!5WvaC;M@0phqrcQ#It0yGRyGv&1|gn<|{|Q z8~sMTMPm=^RN_?ALa;~2gNu&>wvuJAD7}TL=4r{R4_bxhiQJ{;R&BF+19z?5wNUc} z;$YL8_eR zF-PNcQVr2&UAIl~jz=M;R*YtVTCPz?79Yq3IvxbiW=?5mx`1Q*?(Y|#xP!WWeJ&3P zMQFSmi7BInzyL=yu4jSSBf;zo(41GYETTm z^l`XnaMyZ=Utk)PlJnRcI9uudA5Ha@3#KtC2qDC0b@0LwRp2~UggJ|1M%TCRt0=@% z%M^x;u4|_=RWr7}P8-Fn$7eM}TXo&W;~mFOwY1HOMSMCO*kcRiFeBDcnb9Nd=ZuKF zEM`fT7xXbEln-7%#LKvlRgx?k1k=0IiGQ2h-U6h~)0q_xvuK;m&DvGzE%>paKQ5`q z*{~sucya<1Mf(^vD+bACl{`l$yQx-885Qd<6&rC$VL!2;zJ}37K->goSL)r=|hF zs6@Oz5l3ZKiXEQU>hgwK746ADWMa+)g;?P|+~4LLy}vCa{cP(K(&={PoHxRYN6Ov! zit1}=&+YUt==RlAFo-D^7a6UJu5boolT{JO~=rDIi75n-%m4b}Vkq@OGH$J6rFR!+o@2HDQHWQ{(NWy z9z2)8*DTJC1nr!`;x7!E(gBw-N?p~<;d&s|p&1ws>1|CaF^drDz;>Ms&T4DP zrI&NBP2el9HAtcBz(a_I^j6yO8bWB>2QocJp&sC(w=rh=qMPh5bETl{ZaPc7i>tkN zWD(+a_0JjNc{pfgL>bK(3BTlImqZo2jA8@ZMcdZO!TdD8o!sAgV2GnEjP_>HMgz`M8o*ieeXVZ=C}}PHcQr$Z`^HQ7kUm$aU-p&z)43O+_X-w6 zbu55FmuMn3r65Kra4M+X(N!J9rW!gsD}>Yp2giEu^G;+{hq%+%WPb18SEh5T$FCSl z9)?-S8d;>3yrz;P=>iRJe8!3#)rkO=&k(=z{tnYLYi5a?@nV_(@gKmV0LChj7a z)VNGF^*yv-^WW!jykrO%Ye}t`0EDzg5t1C2xW||+ToqN47}>gmNL+e;S6iHsyZpHU zhK^H`Uq9ovd|TtWy^Sw)hF1N1E0nfJSkBDN(({J&HHjl`A(E%s=h<~DnD!QpqZs0N z&YkeW39;jxM1n$q*6vc)YT-QkCdH&Y0N%1dg5?cp7ks$E_GIBgo!*35Ec%!&yY7LI4O|1k%OJ!cd~ zu=IGv>Z$1)PI$lddf^rK6Er64vX|g%2>38=hBJt}k0fMdQA#U=im8%Dgu4@(T!-lm zcDFF4L+^@z-7iAOGeM0;P6ir!L-!e3RfqM7?hsjV>>9XA^le2hd7-QmkAHA5)&@$n z0t?J01G{!oCMNwvL@L6$H;#wms`G8x>s0DZV1Y?Iv0~kr*c*Vo?NdA3=Ky;d-SaxV z0_Q-P4KT`zywmC_ znTZQgPP$mu zj{n*X_LrX>ZiK?k>1%MT zk8egcch$-1aH~vo@tFEC(K3f`^MG&ydri0-Gxdx?&S?2E6fA%JUwIo1G)(Y2ClXKH zy%Z8B<=+x2JdDKBe()2cXe>57$U!iUIw1nGl5uG;qstY;;}2q~Kh#&~CRn7B)G3jWT|GKWP`=H^9p;M0rvjf*)|Z2R?z%lw6V z-#RdPtJ8@kR9UTiLrK|LUZgfSs4&RN>t9iQ0~jUTo#Qk)isfFrClOH(sv%k#O?!_B z<`{M}n!tW}WVBeNfL3#$#tN3lzx*FXVU5WoEpw)`&;tXpXR4L*z_)#D^nmT3Hi7z# zw3K2`QUh}qi6P9Jvq9$x55OyevKpo-YCj!y;51Iim!*T{CdGA;PY|R9e#DG)yGMDppV8?*VzF#vLu0w3Weal zN=NX*?jiO`(?%c5E*y92$W>E@Do1c>e{SQ~feUCLXXCGiry@vA*FOF=BH~WsEO4)Q zVOPV;BR~fr#IY=arz{nI+{uF6**;o{dm=EtUD{8V%exlzVoCP9W4_v1FW3X#DWYhm zVZj!^gbgDBLsPi-X*VBr_v>_pyQWw)#FKNbI63hvIg2l|`m=K9KWjXo88c|lRy>UNa@+t}e} zI+?562#@z4ZU$P4oKK0R&Y+lfKN{$~cf#>M8Z57Gjk^CU$|Ud3Nh4c6_kJH(PfN&l z05i1?PTn$p90=>t69F;!14KqhNI1#g1KjN~PMKb~oiQ!exUKALKS%BT?8_M)qhe0{ zD;Vf|Y4wcL6t0UEh!d8k?JwfKGpUQufO_kOV9yz#Nux2k5tKfnZrrdte{A{gnlq~Z z8Wf=t7X=>-R2(^$BAkWJq{npsfEI%ykFuJLaPnI?0f^0LqlusYt~pb|4>l=LD#~YQ z*jSbO<)v~Vmiv3n|N3)f$%FX;ki*zaRCIOG|H{Or|M&qW--p~clDAtq`{Zk=aFQ>|O`8^YJAg3!i2yaL; zSrK{8Hs3s&^MCHvACAR^35?fMlqB83VZ9aV$0a8=y#tBw zo}x2Q%}8&WFV_nXVKh_Pkc_~o_ZwvBFF z6YwWa-J+7KkRK97{8P#tFkXnjc=YLiE9qpx$DZiDEnzO1N%~+zV}JgR@pWrPtbj@R zNrhWy(oO||wB`-obcXa64yra6T5kOftA_(SUdYOHQ&yFr&}x6|{~CJ0y0(&c<}MnOY#e)o?NT5*z^0b`uD zO1JlSD3?S`ji*tpf6?2?U3=iW?_bx8&iSK?@<}|mFz-@!d0)0>h*Nx4@O45QCku*m z?e%b>F(H?lD{-V#zt8j&=)(Dn5@Fn3D!&fme(}od9JV~#Drua3ojik#nHGG4n+;S_ zH*2eJ9U8ro_q{+PBV&Jf*mmQe?JlXVbpx+tBRY(cv}l$ULRg&zfz=wwfF1|zLcF}4 z2!9Ds0xkgfvOkn1dTxC|q73Lp_p6|f5;T3$c8uKc!p`KAtSVkq8!D(sXj`KWTX8rsD`hl4qenjwr^*i%bQ-3!;H!SX^Bzh^jfDjR7CksP*1<7 zMyF?qto`HMz}{E3-R#iW)pSlL!Mr@Qe)&)_|%!KP9+|NswF_>?( z<-|VIR?_S0;mb|TT%B`YDzkmvl!BtV>GDqz-6Op#>6r}Cf)NNpZlSuY?@bs2O+c|& zJ(2;f^1j9M9(P7(M6H^KQIbh~fU}r4#N15g*L&i{<4V6%u=U>Xc2iHyWtxDW^%6Iw!% zb+N0UC7;sY+_wY66JbIf3zb%N$tCccTtV4)&Vte-Lt(tI#$M`do5JBIl?zPzc>JH8 z^k`7oLQ1N3B4E@K@EdQ_xgN@NqI8<@3B-F6>3jnI%iMRUL%*aTt_l|3ACna3l4^-P z?nonz8!wFJt%)&wciY%wQ9OGKlOOsp^?1>T>BM=xtGfqsd@v=8q_i@!np&Uhd+FG9 zCICs8p0b$@OaLkCgx(G)7?5`nHrg7Hi9YUiISBoBLs&qYzq9^054~R?ZS?Wlsxa-t zRBoNhK?A0S&*jKM#DtXZ%?`ZjCg`0CDo_xNg5G0RbRmH<0y9FRa~WigX(d31sxRVHOPv}Rf-i zDR+7~QG*>A(&e47NJa?q18B%eK|;Q@?lxsffk5wFPXJ<*5g~-$pW86{nD0cYvv$pl`syQ@wjnV24*HyJ3`C6U5j@IbD8}RT}uUk8h|s=rkHdvaaHO; zBOYfHiw;3;Hghwh{sK^bz5{8P2IML%f=^{5;z1#YZYg-c;{uIMMvYBth!xt-$_iBO ziv|Vtq-1J2$jEw-k7_=3SK_O#F5(mLAp(B%OFt5L)1d&zAcR^CczC?6 z2Y8r4%4}X9Y+;-FJhRfqy*|tkVku*4Tn0&gN92*C%Vpm`zEyWb8+$!dPd8(I;vGEF z&EstkpaY@xSAnzDl+e0l;6Al&QJWSmu13w~>b{H@Vso1o^dW{&fX70=XYFk_%lCm5 zJymUkAH)_+>b*2 z{k?g=NycO6Vo+RavWJevIS@55fMi5WFBazWtO)T#mM0i@|B&$b#QzUzKtE-EBZ#FT zZHwlud3!a)(|#*cW(p1}*QSO-Y+9qX=8J@Jg=4w@H^XDJ+mgi(fNr__NFcR|D>6vE z6fOT{t9~ApTPf`vh|PK`N<{bn&TwbwKQ;)Til_-3}qj!d0c-&_K#cd~oy6Gk&^L73t@pwS=*M!kC-PC=q{16FJC#Qt_ zaYE)TBvCOBu0J13w9>~F2fX&ANKdI4B9oGE&uOBgJP7;N9gays$Axxt%LrX`KqGx0!IY%iMKzA34Q!{I?O&Z8OX?a}S=(}n2R zvx0OAGDrXM=)Gz9(Di|;6>cZkn()XS#`x3*J_Ra^k%C0Lyhp|df|J<|X0_yI;D_9z zr32kkcYX~urL>lG?^GvXsR#n`_5$^xKQ@eXS*0doj!yhJokkCkanhR$2$u>*LhIDl zEdc|70mE00_sVBOP0WJ^(Dq+Fz58#UZf#(0J8hVMW={OpMXU&AH)QpegoV|sy@9qA zkb_vzsku?=j;xM+;u(~teP>(teNSm#{g=#hfP>^_h5#1i@Ve5t*n*-4JfaR z<(bH^wmMm_B-C-itQ<5|KXt3IQOG*g1hQ!6H>SUTGD7u`D$PKSsL*Tcn-OLBvNus;vV63 zAg*98So8~)vM_KYF9i2gk0>+tFQ~bgVM1sY`FX1YDcK#hDb@g zQ;M8RscI3@v~n_`0I3D_=1o)H4iBF^1+sZn-r&m0#QB6QUPDG;3T@t5laK@3gD(U6 zc*@M-94PL?kDdfV03hrBr>Z~yk*R{h=9d$jnw65TeC(BWvX?a?$}?Y_RsYE)CE6L~ zCB}AtwmjgI3#gqR&!^^Fze4ccpzV zcK_yOG(4g~WoDfN_$6qxAtf>D;1LS^h0trZWzX*Qa7uK^@fyVq-{=IJF3eo#0Vs2V z-HIOjr5%+8GPb5_a0i-TG`3uR9|ZI=?(zxQVW*!Uj&F9>sbrmFP~e-Mn>bz%PYBpI zIP#}(5u~mHgSqnm(2d>;UO!TeY7-w2jJvy;GLLpaHDb(=y>h0jcB)X!q|7f`xxZyR z+_*)KHAlCG|G?S*8PrsWTdN(5&IV9+se^U*qA_gYB~7MlaSGz$^B+P!x^d$7q~e-* ze~Pt0eLT9S*o|7I^UV1+0hCwr=M~4GiMWLf6>SO~EQ0IhUkrmjBMV&;XFAkOJ6={( zZaR<>;|$1tdvG8>4WdSb%=G)(U&%#iRXW4c82H^b>u&F=3tJMQuaTb5a9JAwNTKLz zAOp91&|myexvQt<%+JP$RxNKYfP49*i+dQmRz#N8d+UxwOf@gmA}W;Xa!BoCkm-Rv z9#$Uz7u7BRnl1rPy8P=NChsRY%b|-$u1L&a?U8U>Rr90G4l|kAZ3g%(Fhc*{WTCvw zu@RtjI=jwJOtv-HJR39*^Q!X-%uCo7^G;~eFNB~(rUji4w$tTb{Nq6H6#MP}ft_)z zriC8-xo&oQ_QjmRewX3>ulYq0RlQJTR3~uJjsJE=4z%P5fro~G3tJ_Y{~7e`Fg;xh zF1dPHi;kPB+$uaNCqdeOgG%tJv$}0m`P}xfQkS>Kf8z)Y=73D)g7ZnS()4j3*%^m- zcsF+s35ynI2DvtQ2y*n(p6`_*{QqK>_b}57?;7uliQ`3A1S$Kb1VJkt9r!5lWt|fozLGQWg=i#u|;Z0 zSt`!QLlZ6O4+)yi7dr5QpLmlngjpJZLJ7o9Q8X(A_HM=~5$yV1pS|CGLaZSG>zL3T zk`Jz{84+RFDcG#{c<)fNFxYA>Vk<1PBko2^fdOUWfdP2k5InoBr6G=NZom+BG=o%c zx`OyExa-jFmxjsd#(^=QRRx>>N1y`;3PCB}YmlJXd$$>RVf!6?8k^iA!LwZ57&r?w zJc2gZt6|9iZz>f#ML}keusd!{sjVf6uf{E8?1=TLvh>kIsafEnKAMHcLjWRWWRV|q zhDVyj)PcuO>>aj&avH#dr&$NeY1xA1%G^^c-XnqLf!7!?H%yf4i_b3XUB05b@@)ia z6}3+VBI}Iyb;`Dj={L50;`~rKCA4<3s^-F{8crI4ZNe0R5rn(@tOUTtceOHGfQLD< z1xDWxfVLnskTeb_td!7AGBeP~1Yp{2 zVl@M(3T=KIvJ6m{?4ZDNu_ZjY=>ff4+!EnjD&;f2whgfu?|1`DAQPJD9@sHAy0QGd zsJYnNqpw{QbPaOzd*urH!)pm&?o!)xPLiC}*i_4Gdi1Tsw48v+UuMp%DCd-s$pL^L z7C75bU)$&$A^<3S(6a}_C#xe{JQGeiBMaP}$LRpK{vQZ5 z6Lw=V3e*~?!PVW+wGgY1%4$RBZ_NV`a$6lS!++O5=lV@fxeCb8d<|*Z7>9n8KD_t8 z2TAmfrTHDmcN@t|%|%E1h0I5 zyaBiZ%w!-g`2uE46V%R8fRyBo(V%(!s4gg?KweDnFvgRW4cW7`lVUD>lZw41e#0GD zRm%veZ6?`gA8|;`>*KF1!f``80Efe> zo(cXL0qt3DJ^w7IVH~Ga-D<#`6O{&Bq#3X>Qly6lc)ZTO`nOFzG=&mJ8k?w zui5S!9&JwqoaqV7?Tz9tO#?y#yOtp9h&4i?2i(C{yej8kJRb#SGy)t&vS%L^$nKl} zqq+BJ1Xmr`^3w_K| zHkWUupmQ7(pva`OrFm&DjZHcla35fo*U$RF&hZyh2KPs#92#`xhFMCbbc$Rb>n zM!QQ~?sM#?^DiQ#nq00dnuwPib^ev{T7Zq>n&T`zY&%@fWVpVB6c~NyL4AtzmN73RmNKVp<{K zB+6_`12sOX0ikPWy0$|#l-}~;OWdIA%8L)^78%tUNS&#UOb}$US8S(a`yLB;1d{-g!NC(s^ zgq3DJ>Z|{5Eg5@OX*PE9Ma*3IgWMRa?%2Pyo$YPs-;<**1%r`WNJ!NAZs?qVzR!Er}70alhe}#r)?;v-A zRoUN#W2Cyh#XP!1iHeq7abO&@LUr?svM97cO;lMijll^b>Pgj2hD>HLyr;VQSZacv z{i}WuiawrZtnknDHo3`~KeKq8)t=dj~Q-7$P*L z(NXhp>T5de;`o+$^nkhwW6O(3Emu@D)b|HOVEQ7<994@YX;DzS*nbxqVxA7+*iesW zh>GU*Kt!jDghe;DEuA=~CEjX!wxhR|jOFL3;@gMT zZVGioLR@t3GxUvopcy4Pj&D8XEN7R*mZLWyqjvVz-G!4d?2#yYN9QsFD7x>#LW9b`{TKgH>*bw`v*V?qtPcW3oaDlLgSsAvt14#?zSDvBm5 zn(HSOalJnkb!;|$Xdq=1JUFK$;Kbl*n-&adYzRhO_C3)-9fW$ziRd;n_<2}+tAj?E zQL{srhVo~Ku4}(R5bC+vbkqYinpH>YDGvF#l!A1f0lJ@5qsZb1{wF&4f7CG6K~8iu zkf3y&W%u-9Ydp3jUC$|9$jJIKiZ&#Tc~$HO)o+@x)!5Zxs>@BUfEFWJ;zHuC=qX)i zj?)VBDat*2#Dq)aUgdeYAM1?US165zi7{bDiV}p_MhrUJV;9je)DdU7j#d=Tgmw_$ zAP>kR)imHFS^G4+o>LZZdCahQa%|%ZJZq>bu_n=aUXO>KW4f`diN}agSp~rmp2r8p zsW?}0nH*V5HVU6WsfEg*(0@_SwV;+`k5TEzT2PBTQRq8OER@EH<2p-RWZ)c?VrELwUjhiE6wb=zHFL!Ur2iz{iD&2MW?7jy5u z_Fzg}`c6}~RPI1ck(j@f&APufYQDOgRl8$&W}1oy?-H|tip$pvJ}(&vg)wZEbVNLN zW`uc#=({it(`n%(;~hw*GXo6ia65>~Veme;q+NNZs6M-3f)MEx zid7jRLA}kVMdDaSi5-UO=PT_GUw!M$kWHmX_CEUG=GK9W{gT2dzIm< zbpcW5DhHHwY1Nh`MDtiBe8`XARfW%Q zm(ng)piY{(BKC5NnzQc@O&?_S<*o8|`gn#joUX-j(=={U8K`}pO9%WDl0jd&_8KX| zzQJvy9T;THoxxJb0uFac+4NQ^=?}OjVvf>s!>i> zLPwQ)@H3(M&f4GZh?(MCEP|Fos2`A?YfZPfsnbQRQ8Wza@#V_TBz>Wd?^8diwkMNF zmoF8>b#ZPLEH-?)Q#_S7&3Qz#ue|kU=V}=Bb%L-VlRe*JoD3Q;>R4_b%{I?B#dwNG0w^fH3_ zPRGS_P|L%kcEDKee~i6>|3Ah;huap!v^d^NlLukJ7}n{5q&|p|1-&3bcQ=lyxJ<^2 zw4Q>Zy&-{aGsuIm-#`@|o(0R72Q|HIlrb{pVSBqLv*z9OYgcQQS`F^f2DR0{?|e^D zg?wz;OOc0U!mq`ODbbKFHI%18j98B=+;fGYrzV%BzecHMks`=-N=92^d{mm(#f}e+ zJH8~qil>W`V*I^MZyoBM`x^U|Nl@d2Oft=Py-a6nsF!Y)ia+b|mAa$Xr*W}A;XFQ! z>x}F{LrjRlNvfSxR1t%*e&;8Qa;N{%8`rC|<|Y5Bcf3GBB%;$@Cb4DF=H;|J4baM{4+Q(-5#XWJkpwWJibdU56angNex( zPhXNWAp0HndqZ+Z?$ew&L;c}v>313uLq-w((Hk|#F$lWlr+YCt(@5Ub#nW`^tz>N* z$!10hdry9_fS5>i?3X(qH+WD30Z=gqd`@5rm@AssI#2GzObZ@d)OckHCX%O&9(n_% zy+N1X@u@~{t!RwCL$`pL?Xb@DGHUU6waOCtC07t>Jc%?m5VpU5xygwnrL8biG__6r zUQcObrTt9UC9>r}i!Z6X*HY!`lbF~ESbGF)+g$dq?!06N?XpaQG}gNCXeOfIXjqW^ z2Qvi!x)7ev-QBKd*}N5d_m>h`$0Cot_%RB9cLw6zBEK&taGM=^MT9{xH$on1fyjMYU{&9?v!*{3phEYuu<>S}PP# zOw}(sx2OxKqtqwbKQudwG10H>uxC&^y;X>Y@RUV+TK|7!eR(`o`~Uwrb7sb1Fk>D2 zm_%ipBuin2CMl$yqzo-6;*wIyoUx8dxD`reZVPo&R4UpWOQjX5NQ$#nolAgJB`wp!MOb;k=e}y4icC&Y-`CArguk1&fi^$L}P z+G~EFU#J;es!HCzUmg#w={<s=aMzC{p$9ln;7W#K;UqP8uvd(LMFdGuu8 zCg@P18KjAAz^ZT5n@IL5BoH$D0ED+naIvQA!=F0XPSb(WtCtb0J7y~F>bCfL3wCa- zH1bM7?^;U~PAMDFm74o*H&3IA1KczQc#ose97|~U+S#BWsCHZb$E(56K>cGYZmMvL zYRzxrox5PEz)PTuK_qY?4GzH^S>lU?vc1NmYe}{$4dFQhEwR_drAM8=kbbU%>RWDw zCrl>_+C3-}#*~j7v3m)INUfHbGV6E%0fv>}H!muest10R+^iCX9~x4B6g1cay5Z@O@7KQt}v6g=&10AldgXGSIeiCs$2^965>o z1{c-DZn2Ro<~2S3_zfHMN$PZ3*+n<*pNZc1?Fqs}v_?FW_^tC59JLltaoRo+OnB{x z@xE(Ud9e`MqjTxLFsS>*d20%x53IgYmzk5$xW;Q$@jL%OVz>QNlm6D>j7>FZ`Banc z8`HZk!mCnj;e_ycTOjY+UQcc1fcd_^h{v6?1aET~HfZme3y~O{9Q+2%YnmjnbvvQv zXAvm>JD^yiZFc>3M>Gk&K|Md_tcgX0MNl=_`C~nK5&?50uGGKhdWuOrYotHM|Lkw# zE^t<*+SA=p`GE(Brl*D!e1Z!y`UEXXcNBjb;dTbtSDCdI!bvfo;b(t^)<8D9u2XrI zfyTaYqN~PIe;8T(luwpiE74`=Ppp;o$E|z<4P6+4BQ)|ioIXaB{=B3D=H;NWnS1|7 zPE|=L-$QJNd%svjLQ(`3gC{;h4s&d&>>Sgm*~JT*3R zvR>!HL$5(UC$p;UDtFe8{y^F5pA+_2y50|6McAZ7SV~~yj+*XBvSHeqKS2lAQrw?! ze0FRDYXzh(+@i;|ykznbz%FwgRa0)yoHu-Z{-3H8{Rq}rh^ntcTQVewFF{6aghlB~ zz=Hk%v*0xZ<$`U6t1TFX61O z;KVkzx=A(BQ?TX-JoyTHa%=iPS+a*VIBQx_7lrd~{DHc=vw^0wcZD`J)4uOtuOIigRC#d!D^r-YWf9uE&COuYj(bkE}-f4SAXa z&R|v-N>v^?v{fKcUC#&|@;yxdARDjyKOTXHDM{dlwkD&8)+a)CLqXlsRGc>YXfhLQ zF8!nPDBAWloLGI!hG#kH^OV3#IItKX*OptF#VufmzD-}FC5|pZE>BMPDz^9F4(xIK zX{AKperZ$aTea*C0bKA?+djhg4l-=KSR;W3OTqe#jFYjNz#HJiMjkNX_JrK_egO_f ze5+CN`%2Y@9pB)zqINHrD|K~c?1_c482tuq?e$)Jwta>ao%SZE@1CRaP$98h+Z0@f z;e-O%mbMZSo^axFCJBePrKRFe#ijd%RV929#w$i&y=Ss^uZ9NK zmipcF`W;!mVNkubzaQYC;)`;K_kvGJ{ZKZVQ63akrbu^`B-K$V?O$HvdX>Em+auz> znU7q(WA^Z6ohO4T`v?E~Gl~meYA@SJm~abr)0gtJ!7|U?%Rp0E-`Z%3JAuC_)+_Qd zzwU~Xa-vl4{5AkZrzdP3q5axIn5$&@FN$*Tk$OH=-mJI|aV@veHwi|cpJQjMP@6Uh z)KS5q)%P^r=+=sqzi5A2#`04GbkP?!PO>4du1A78BG_?wmSV-ER}bL{=RiUhK2j@L zM}7ZHVf*aWA%0gefmU$muuv8Ka_1JEXSqC!h}|lCgd>mSGe9qO+Qtdqll=hBiss<` zK~SZN9{2vUE9_cq9`qym0jxO-on0L}S+9#ZuJbVTwG>n%hWyT+XVa3Q14p)~VvBr3 zwC%CBC5srslv4~dw*T*$ZWbhyB;xa+wsYv)R1&EBGr4~y+WOnao6!tvj=8^v=IvZh zc;VQ8Jpy!w!V&7MSA-C@=)c3dE{>7;8Qsa-1&f>A0g;+}3V5}%-(;IEG{0$M$ z;GvzMG6q3$|DEF=Y{rITtCiOqUG1zf#}zuTe=b7XUAYZnt!?rlGb0pBS~I@S;(sXL z1QAvvPGc(aMRvj=c-_R<6T!{&!O~A(mlcNs%>F|#@5Vpf`d_(q4(BWsYZZRW&2*rG zTf|}LboU3d`Z&1h9*H%s)2yog&is`ks%t5JQ{H9nU-T#}K9T89u6lR#KIiVuj~~{2 z!Q@cFB8{5JUoG+d^b7^}d$;Jg@1Q|dOZ`@38eM0iLjLNDU{AW$kXHLCg}kf#mw2>1 zS&oFe)B^UQkMD?Cz_Hur5+5Alv3!IBAC}&JVQx2g&&sH7-b`411-UmuV3Tx+Bu8}eB7t#rdbA93;MuD6x)dZo(nbw)9j zKOVPDuqUn&uX>uhO41!fs^>h}G=7BEP`bIci{zet@r6LMd}%t7ub$-#A0mwpbNnnlGb>>e^QiO35&OCs3}>+mo4vr{AcXOnt9a=BF5$5${0+Z9wt%Rw+<)`u9p{ z_`QDnK~6!%RS8smK?kCLhMX?!6*yfG=tO+5669-YwmK`$?TRu%wO&}E@=x7zv9!F# z4Y2|cFX{le2Y;cLr3P66vY`#PCJ2)iug{4V%C224)I+vFak@5W^r}E~d=VnIo&EY# z*dFBx{M5a#PO8$r8EAN#=p(35aYG6gG<~f7btg&|hdi`~U>ogLzXTzAHJm8j=z7Wu5yV*TJL{7%qRN&|? zAmkZIu zDql-;&bDEm{iUhXKjD28cEH}zF&lI&T}}My>p)Q`|4p0?I`0O!C8@^^(T%SUo6oko z`fQz?p-aC8omjYFgzAdg4O!sVo<{0JDPOzfi%V`VM;DQ}$46!T22j5W3Dns(hgxi~ zTOUlQk@NP8_GVEk;Dl`6U>9Tq6^?I}^-gqs);T3E)gRf0>Rgx)J(JUMTkdx`U9qTK z5dEgTE)2S3t_y*#bdOk9XVv}SXG=rSp6oX1xdr8!_Z>r)Ch|+N zAD3+KYA1nCn(u~<4|@W8?iS)DZ4o1jEM3Y-a-GEod5Y4ye;?o}H|F7iXD=&W_*H0f z+nwP%zk?tEuF=XGw~6Vaui@Yab2Nc0uF1CLd><9Od%2U;h(xUlOx3PEx0?(^=*`D) zRfZyQ@$cE2d9rqvi?v|{3}nNLJ2^Fx(5T*V)ix_jQ96842jz4 zj*{+&5Y7h3Z)1s0LmD%>dNS3&LW)zf;C4SJLy4Fuy%k2t_~wX2sq=rq1xktDa?6xN zFY(&~q|Z(NlEdv6cgZu)A3HoF@+<*O&uxnPF@Ed4DHZ+Ua{i|^ApH!l)vxm&)S zBKZ#fy|2YI0flhC%jRvTC-D87)}kB8jMnKF*6&z+`rn^()2b-%7NbtTHe$6z={sLk zPfL&gC9N4fQJlS*`)xj(c_5q5E$qe6ob&NSGFxMrd-_^FYeK`j0&(4GAj~;$wSP4< zNq@~G_oTAbe{RBFt-r11UIdpK8&-Y#hfonpGvq$9Z9-q{;zM@RPp8BF#9@LsGh;34 zoJ!*v=f34bdJR>YecEvJpdp2u`67v5n;ot#aSb7y_<^?MY6kyV2CcCd5u3Lfd4mbj zm|Nb~<2sa!+$DP~w2nCc<$!%X>p??(i;15)X)p_gS`TW_`Q=3Ww}nve5=r72;u`lO z=uveR95S=&hAD-XDsI!9jj;E&^Mcf8F}C{$pxwx|yP*bKO|!6EtjUL)5^Ayzl;wUjHRg6yJ6^r3f$16jKkDbCAz( zti^E}M*ozG=v&-nro^$8D|D?Ja9)bmjGJt!;0%&_5)in%`()~7kFh048-9rvJgKQD zE&Rxg3f@qu^2d?Qx)rBFD$7lEHZqY=JQOaJ8C>IT4d{NYQ&C}3B`%fy2e1TpBca0Vu zadi$PA1Prl*a7SGBtJrdife~#brc`epq_WQGSn#f%j+hwbB3_`iiXAXbClvb}x;jfYFTLsdei#hdzWkKkiIsK*I3QXq`o8NELt7(Tj^0o#Ed*?|y zd{iouXQ)woLw?0GOwFob0W>UD#>S;atS%&;+;8{HZ&*~(+)uW1Lwhf&Xo;jCmgS@_%j?X;t z=o%4UbV&nd5(Yd;cWDai({cUj_%Y1dws9!1WI&eqG@QgP2y9U~ypADj@p)?~2_?z8 z&ZBxAE#N$?Zd6mmt;V``4&c=<_vy$u^z|h|=;yN**oX+Dmv(!*(gPe2r1*XBIHZwA z;r?P*z`MMGUt=hl45egzTTeWne4b)saMq9y!i9vbZ=XXU6WVN~5jSMODE9?CKPm&& zG@>$f?@@~%vMF3{x5fNIC_&4ESRveD0R~Y6j~w0_Q02aM8u18u>ROGOQd$=a8wWzZ zP1@%-XFHMAmgOAQ>l8serxz&H?h|IGh7T>;y|~$1HY49R*;@3jk&EW)OZQzSH4GO* z*JlK8x1}uW-qM?h)rb#3=YDa~=$YHiRzf95jKRLD|8bNB&VHujofDCw7A9z}JTGb0K6}qIYydLGUFVlsMj^<=qt5z}!wGmr5 z4|{FUSH&F}I&Dw8uc!u#TwTbxp>n)nMuP$>j*{7VZ$Jn%#&3A)K%g zb{kKxlKjK2kQ6|=gfHU+*m)d90)=LD@KK56W!n=iM9xbzY?1O@7L&VOgD9?=;kSs! zXDxA}F~`z3OYAN3%RJ!c=fFgC!9$}D%tR|)w;yr zaYLX!kI#PB(&O0y54B46?bP{%FD0Li{vj_-G^Ca7^25@yuU4g5_k$b&iTkVTZk;Wt ze$4|M`umDQ(r#uW&TCi<6@(eq4+zo^J{05z=o_U&ykTjSyCOknAE}1ieF+jg-^?xk zpe>gCV_)F}n%4cN)@au*K34s5zB2)HpH7{j_eF-Co^E^q^#ABKIZ1hdiJ)$^QA5DkB z)ffU@bzSQ&;gbhpT8nvMfe^W8`80Bsc?;z*D6>_|34-TG!NeTJUx|+|F_y$fGab<- z>-boiYqFCD`FslvDPG?j39J9Qv^ZA6VPE{WCngaAvwk5MGr=qa%uTz73w=M5 zG`XLGJxIfMt&rTJ|5_>uRg=B(1wH#5sNoDa#16Fnub|Qi2deJ8RtYzCEf~m*?}~aw zq2$NX;PY--6gK_Y5&}GUz8-z2^%Xs-@7tcL7k`~fZ(p&}rG3Efo zP@`Uf%FTxsayU9>g(CP?LZfAVY?YeCHO+`kU;j%8*P8ni-jJ!y(;y^DXD4C4SALlt zlG;M@D*kYZFw4wSZ;ib#m0{p?5$(D$2QB=!_TXxWZbvkuGEaXnp)$3XW{9Gm|K?-f zDf&$9mnhkg8a!~Hxp z+m5%rznCQIQ^~@hE#${5=SM&VT9x$mBAFQ*Ju^DTt2Rdn8!sFf3#Dg#i>01FCcI23 zRMxnKQ#Ec@TH|2Xo7+ZQUf6w<0p5Bx=0iv4{jp+TS3pD0dHxE0K&FZheLLorpaU+& zeo22Vi_*T1{PG<)i0G$8BP>w3srIdbhe0B?2t9 z2od#t(54nUe+)hEMFVhV_rV7nxZ5K{|L>AkH~fD~ia_gT|1J96K3ko=Ezrsl-2Y6l zNf`{TWd$fa3Ev1F#-hd^cG}(Jfnx0m-2H26Y zn`vN2YD&G=cdBWt!e~M$1>&8Z%SORpPudF=Ku2{sUjFc6KnYR*bp7`*Ma;%0 z*yhju`*&N6KE^Wpp8hefOm+IFhZ82+tn$sHdLQ;9XzpRQhSDa_z14NvabM!cc(5|o_yN)^u! zheog`phhp$8lHEhi@S+iuCkk*ST?}0NGPz}Z1sL-82)F*y(uz-7cP#{*2TR?Sed^&l0AygLUe7_5fimljF{U7fcHw_Z!|itP=!@!a@hqYBO% z#5`_nEC2po|B6p-xGs{8`*qZVf5w`lODkt$qp*70XH&4zGJnlfi#67r7EEZ}wIK36 zAO0lTaX!{u>@wRQ9*dBG{i1^XDn~hwS8cFb^J^M>zK=xEJvp0(b{%_qi~j%b|x1}=*t?g)}=0D5=8|z5ppCQ?|dlF2x3G;651?>Zj^T!u@yi?h; z0ai0y1L;&1;V9%r(xQuJ6F?N|Fmw(26`X8gMRI~D?6)t2U5dK4x@%5mcM=96CNqb?qQ@_a`FedSmmh?D5(JUB|E~LVa=DK2ukpBvZ;QhQDPD zIP0dAkJh2L{(kzF4^4ONR5XIUT`--dR1Vo zoqX=|x&>76hb@)VJr?(L&ITkW^*K6HOo~0mo$}!(GzuncicYj8^q7$e@5;e8wVazm zOZw`5FXgvqOaI;Yh_pc6#9+r^ZuEQ_KLqqsVYSYtIE7)`+(W)-nFozo4jsyrOspS$ zUYyxn<0X7kELgatKSB&;cV0reTV8?TRw$q1=nRb}M(bnY^?t4}+HeLN_Q*4Sg0=Nr zU#welh0Z+f98B(cEfHvfMBreaH${}5g}YT(sdc_ob5M3{d-A>RNV4aw-$@Z8X?^$_ z4M5)Tz$aBYCWY}sx!tNq<`+Cq zkLsEu3DrpHJ}*@6`J!5;qxdMY?X3_#@~NpMn6!yVEf(z|TcF2F%_%hcLna}<4-iYb zF%4aCSjCiBEUI%4=?^a^xQ^~ra}7eeU8XMb&*ebKi24FB02Ayt0?&9bp2MW$`R}e4 z+&(~I8>=gNn-}6-NZixAqSfe_?Xr)8{fENUI&*{?08JagVH6My4?O_(R&ntWMUO?5Q@ z(~02U?_N)}Rkq3qWvgVW?-fBW`w57sS%*SiRyK5p&C=$;>o?4ooA*xyHMHL zm#Uj&bqJSH;HQSet0hzyKRM)v_==!fW2vB=boFMcY4ZOLk)s?! z-n|tJArbt$^=kY>6U=!5IC-b0ZPXO!+Q7U`5Czih&xjll_|PENs33x<@8)zax;}!b zWO05%b7N%41vIoU+|akaMW@lHWaefnvA8)>1nIPOh)_7jj*V_qUx_~6 z*`ZIr$koKID`h&3ssaM%xv~;mhSki}lxPRKqzm?kC{DJburS{68Ldv0R-f%G0Ivn> zo_bePV4}DuYI>S!8V#d2Ptd56lN2gA-%h_4V6_bC6*^*LHmm6|3BW+*@uoJv0lML4 z@4ZQV-mBsfBx+jT9DSJAury!vq`tcC=rl$?U}gS2AN3*5Xwel_pG7N@xpgk+cJ$A+|3R@iPp+`0&cVTyLBoVvC?)q ztu+A^e6je`2IiW9hb!$Fi!DB<`Dq*}^-yct+WuP*vh`5M0KT<-8s^uU4+T9`M zO%3BtOo}G+bibVm_#D@MB&YA#<6!dRfMH5iR;M;7D6)6wg(NM#2vQyqbSg^KVya0% zxl9w(o{e-aFEfIMM(_3{(b}f}4kp@`a8X-k8nioR8ssELAtj#>XwDLhl;iTcI{A-3 zD&@2@!o=CMvYT{Co)Y+u7C>v;77#moNSd-2dsB?7Xva#tpe|n-2^LBJqS4>?qyaHT z>(4_fm-pkL7a%$m>~%&O6EpAUtw@jV(vgI!%icx(cZOmE7G~uT@1#K>;w!WFlA5+% zB#rgnlccilsau|Ymo-_Qo8?hcDgx??>Yq|K;VBw(7rRMt=x#0!w76a$72D()S~khU zo|`d=JRox*%IJgO7L~_)O^wH${?cQwJNU{R#tUWM!!C{E{;c60`LA-RhAp0ggZ+N`=8X@WAeiGa3y3kXK#aM?>3wT45%)b^CAGHuB9bEwYHGELY4D5CXAKb;+{G=s zP~HxXD%syyu=1Vv@Znp0NRSr?DTR~)s~c3;A~2TY|BU5`rmdwwC4`S{!`C5QKU?Tc znRSL8k1)pyS`r3D{dns<10K!v$a zLxbVpJAe;lgC&{{B%VRmxUb4qqU`esnH)1KV^MoYLFqfcCaA1uJe*k|Cd{R5fe*E6 zAqJlo!91rqrqt$tSrL$)_uA7aeETd=uAKintGHA26@YDuw-^9MPBRNghd(iBe8Tan zJQ}+oU+-3amAV94KxtmEh$7z6r)sggb$~NcPlI-}9K6JhF1Eyira( za_sY;qWOJ((6*IM;)k^q!12Zm+;y{#l21>r(*tGw9mj5;hAY*_3bjfZ} zKyf#@8sqIFG4dK2q~OF*B>1j$X8yZ+Nvh(V{RHRvbWm(=)x9Pk$Qu|A8h;!JKOntt zuWN&%FR1!Xlj#)9&nz!>T$iMNCvfv+!p1@CfnUd%ywvsZc3N_&{E2^Bxq!7toKY^Y zhAz+VyoHBCDKSJq@J|DRpE9wI1PIQlRJDB{|3o^9BhwB#R|YJg;5u#T>)7bGy+YXS ziq=N~Yt{l3HW7AYIBi6bosWQdQjRCm2d>az8?%4Gc7fWZrmS83i4*1Nntsx?rB*!X zG3q#%Nu>R;lWYa0^u@^mRcbSZfi2(b%%DFjgOHuy&?nWoaId#y<22w{yv&>;Toy{g zm2Wqjv@B~VozMD6vUuXdQj37*NH_h3PG>HXtmCrwECA$i8V@K5NdYu|k!H<uYriX_lf*Fndn+VO;NRbO=u z`S1CRLe!W(@RvQIVR)x%@L_oKi~HJD--E(cJNKj4`z5Jm{k23V+e$-BD@`;b@MG%! z#BlZI)PEiRNF(3VbTD3OCL>w)rnr=N$!l_PKG1rh4~?VaoDRs`SflEb;(ZmsQ=a%G zGT0;{pK#(7#{#Nq`##4OwqlOa6nW4o1qGAqP*j8(gt2y?R4Q;mWV*iF`2+V9YxJP! zBXtjb@QYI_Hn0EYL|E+n5gtKA$_tv`k3r6%>4W7Tch z#OJ-uX=A&-n+Lr8f)9nt)4#1BsH_n<#8_4wN!y~O_?)%{4|}__zkS8DpYfamCO)^B ziFwN|F*O{`1gwy7_tSzoH~vT+n#%DcYj+jj?WZ~Tlj;MCmP8m-VCwm~^`}%qjC@=0 z8u3QVN+ZAUG9JlqQcyAZ5!@dNK`UkYpZxGlO5{iRn_LIEYTxM{w(>6uQg2*OU2m;S zrF~tmf%}m(a6N|BjaQDEnhBQd)ZX+*x^nZ7F2oAyNAQ&b^*qiZ1_evq6q77-yTJuS z2>wE5El;PSp7+&P3OZ&Non;GX7X8`3I_y zd@gzksr3fFndK%pJh|w}z|vsW_Xt~gv0h(x9dFo|a;5a|6TJ#2IflQqZ0yPt`3VBH zF){nGJf#GFy{^}1(k6KZWRq-(>E6|boi7N^e7i_w{*)h^w6;g!s~V>i2T?%Lhf3)H zB`D!oVl)qpK?py4ILB`grSpn#{vMY}P+3tucRD{5av>95UiOf+zpz0m$pc~fd)BaJ zfxa`{W!;7v1lwsGne`_3v3>8It`z~^}tt!JS6G3|DrUIX4wglV1Zy0}h z`ET5%t2@f*X&aJ#MY>L;0+?XD%iFa?1Ro)9Ci1bR5YVsyRe|c937}!?f#&bX-yf6%m#`#lJFZcpXl&+N6n@#A zqTbnw!nHuj`ujvRnY_uE4R{=8Pl`|KaFm3?vaT7x$Wt1(z|ubA;tbGom6~{G-xDl+ z_qjb;z{)ndSr35%rr*2-fXVi8APWd#lj{f2YSo9_1f51lR5_0zxXxJ#LjE(4S-~^O zF3JoSg|E8ZJ0#sBZI0L7i+y+d+ z_25EnBfPiuG-XZ%QOoc^Dc4cW|2) zwKzX0&E*mR>xY2>qz?D405+)_ut||Ar8H!U{%z?M!gL5JPBQ?gXU9yU6OF`#LBClu&MM-7#Ev$Y7?hQ8MZ zmLzbYFX7uvt17~>Xse7winw!F*RBCh;#i6n+qV9~K&CGXu=Br6XCTvLkhMC;P0%rE_O6|f@(joO*4}tOi;>9(L()Tdv0Ra_# zmv7XnqE*7{M7$Vj-BCD4x|cs#{Aal3M#DO&N0U4@XZe+V6D=gS?M{7sn+_slaJucs~`pZYUUwY8hj-pMC4Z)_xDuQvf#T1PcZ z4*4CTl& z1~{<|LG@8*-joe+=FV?HLgmuYQc=I6Fh?CtP*2BQ2$Hd>vVeCO@&Awt1-IQX5EYQw z0Ci?%s`?)R>-f=wNE;{mEd7BTzR93*d{n0#m7FEK0MgRDHzxsT$@>s&+{%2 z+-v#5DgH1~C;507Gz6*a=3v;b`BKiT=wL+vvq`Z=ab|Hd5+W)RI#XokD$rOU){Y*( zQ8n>4NAS9A4<0I;{2&tir!Mr#K{tt2=@0bV_k{eel?dvL>Rt>d~_6^+4hCL@IogghIeEmRElIhdQPC ze-|i~0o!Z9I-?(^6DU#j^C;LIZ-FYMfQPz6G<05RCDhTHg4Fmh4=ez%54=~kh9GqV zS*tz91U0i+^;2A2`J{;aKbK1(jVIM@D#-c5aqax(#xSCvSv} z8x32T#l$XuuF@8g)&H`L2d|UGYyu+3+~E2}oBiJV<)(@Ms{dm9*Jod1MZkeCoO`xO z-5GAoZSfS~;k8@%6a3!~#WLvuOfu}cb9dBiRY18^4~bULh*7JRqe8}d1HGXnU^Y>t z)68Zy?B8bz&8^^~FOmRgSx^M~l+W~I5czQt2%+b!Cl7sRMBxUsWJ0Wu2bS@?y;{8+ zOse)8NG8_C5?u`l0%vc2{ep$T_0!-P5hTKq%LrU{&hwZETKf`#MWAk8r@@W{!X_de zU2)b`XC;)>Qbj#`c_yV$csq^n+~t6@90iu1HZZQ~z_^C~4gQY^Zm$zRY?#0UXgJoM zNCVA-XIrkND1Dac#AbzDR>L1&2`7ko7mh^@;P&+V8+Y;lcbGoG){XV}xgQci$i!l- zui655Joq$ppme2NBDdnu@&pJ7JuR_84`TRyyZl^W4|IT)gz)b-M%Dwy0lj=cfPsAh zwL4ZoAOl5%r5wV5;CWv z=>*<+OD3RYj$$jq{(-rN2uhjEf8!9eY)U9=ff@%N6GykQS&wt+h|wmZkPIU;A||Zz zeLIQTs(aB_#~t7=fTG7Fz=D?lc-^mw2aM~{#?Pj(D&D;Zj6gJ zIA_^Y=M1E30BLJhO$Ar)HVv`*dsOKES*KJ8y&Un@1=^z&h2M~8GxLlrm^ZU%Q-~vw z01!vN5^+e`N*E_TN>B>vCv{z^l^OX=qSJ(FnUG8%8Bx5@WvzryeOw_0g>_n2Sh4x# zWTk;P^eb2cI9Q{=KwSGj2I6$?l!3_63>5_u)UVV|hCK+H|CRd^#=BVfsJG>7*dtQc(XbT=mM0lA0Ga6N>J}J{IZnf6 z-Y=gFaOSASY6puZsEShOTOT3#sy_wf8$m(duIR{=?Vj(cxD-7Xmq)f2!Ve=PL%%jq zb>IDH_ztK)7!9PwY}Y<(f{Iy}lf$LnvJntqn)5MJdH~k{WKD2rT9fv^lPh%lPD7j> zD8Lchj9p^y8}g&J^zkvTXy z>)X=-l>k=3$r~SWP)c-Z(;X$_rJ^G84-e`}NU+8a{qHFE!$;D5(WTTQKshj)P0Px~ zr$J+jpbw?oWrTGUMI0!=KGab3Ik1b3X9L6X_W%9SFW^V}aOIDtH5U9WC^Q zI&GVcXXM9X@FDh7kSqfF2L)T64W^ar1u}rt6pbsn(0_OHN#pMI~7^qS>JQM5U7=oQxc_O8*4nxgDiKuVi8cUc$EkaKo` zc!NJRl&c2E*#1Q35D3c#SH3p~qAz2OaQ90-*JQ3Ym_TTu2Yl$hasbBv3;@rY4F(_< z7aBQvp(i$F)3`j7bXxv8ptXQ7W7NhK5^wi8$rh&!C$6em@TZaO!FlNKjR0}cYVrQP zyF0Ii<}=v#QBBxXSi_5I`Ke#j5Z_v2|6TtJG8v)!?s4O(`>82oK2I9s;n2bSi8=w}=D$wB^IjY9g1(5tFPYHj zr4vNN+4&+TXBH$3^a7T^uF)&S1`(vw>Z)}9$i_I;7ke2pK`A(CpmivNa-2^aOm`;9 zujVOACxQm?eH)nI8|gTih66b7)aVsSQSPd=X^_9MMi=mvhxS4A+`St$xJ`2wgk4gN zeqbav90?}sS|2?2ut@@>M+o={{lHIQ$ zSm4v3LE#z$8X&GPU~ylA#G2Lk>Y#8!vlR$y?OlX^Xp{&JRgK`ay3%_E1ohwd!&}l8 z;VYxmb-3T=NyA1e|Hp{>G#b&ITr%2 zTP^d=Di<8ql^Xf{kOPf%-x);zonPZAQr?HsTfuuK`VXW7?Ki&4fM?ruEiKHKg8SXN zsAYR9wTz*Lv+=;5jt|CSYu2Og1aKig`P0y=<+fTNm9?c(?d4v^C=^p&f_P5l>2e@F zP}Cy-L-EdYug7*1TVHI@&h)JG5XTWjDdSdRuPof)6CD+u5>RoSKZ#SBYU$`)@jI_w zoPf8z_~%e$ikI!K@(&ZZq^{Zb@Z4t(D_!1di1#<*{m+VxY=eTxU)` zxnYCm5C}vXO0Le<$mbTzXKL=FIN%tXPFitv%lj;>biEu3!XQm6_M*6Pfr#EQT^K$K&;0-T_(cr zFR%lUZBN}ReCyl#Nw*Ts7M$l4yXz+;lDc@$BPv>etO>Nq7CMp8b43WpJZr&wtg?Cq z|2vm`3U#xsN-7FZi3U`$qqPf>%HJafnqBoD1k22za6OjCV9H8@iVpIB0*JI33fLxs z=WE2vCEK+Iz}Mp`le8qQ>i~m;Fg^k>IC)vi&>V62?r6-D39AL5llH{M8TO%lkUsRV8p3lWva>+oEQJp%0bAg-^&$(YKNwxa8n~X&by@1?R zM7}hkNSfVnif6gy^LQ`xbKM^Yol1f@*QzNEny(k1dv{8HYnhVYC}14GPr*1Km+BTs zG%I{>#+(+6Y$1YJ-0@onXxuNYI>MZcdHH4L8PEsS4&fK8thtcN3!qApW$&6n<*-E4 zIKx&zhJLfEs>jVNlYjji7g`cK2t}x}=|@AVh)mXjIW*?B{Y;470&k50VWrXC(>uYN z6Wb@eD4m;O05_msM_{y)ZIjOvfrQL`z8`^|7lSNziyMW@E92A9yQ(L-(7*BCJZ1D6 zV69gcTxiyjaF7t_h1_c+?i$WgbdS!0nG&NEKQz$-xM2i! zvnBOvW~yA(C*^2Y5)-Rl^(~c$hVT9bTSn!9=`Eha0`xMXIa6vMf8A=MF`b{wO?}l# z(r#Ox4n1|D63^Ejxkna9-_}S5b}RdCE_99&{JYJUI13ovZlKZfS5n;vo;*v{_HEKi zqx2aoKrE7e$CJ~bWw&*VflXOXptap`lyZ8F4;hL-H0nam$I!gQ=|JL8RCZJ7 z+tZ*gCwGF>mVI9t8ZaAJ96tf^-&#@$Zkf9}x%EMkxD05^v&z7M)frb?sSNzy&}U)4 z@1sAgZmd*B^TFFL{~^%~!uhUDH~vaZ_v7SUt2}_((g>Ve`ZFmBIq&=Uj&LFOBGJBS zOqi?j6*~0nDE5F1QrSdsI+5o`v4=jY|MTVwd0DzTwetuuudH$(x0q;kI`zRURAfNZ zZi}#GqpbDCr1KG3AWfSIUZEP?O9$<|RHdV&cnhrOh<^{nCk2AZj?Y?Kdlt1Tk!W0` zFfBU)yb-Ypd-?2z4}YaLaH%uy0-4)_O#5?^xvqVVC7a)sQPf~-*@VWVgUGjhg2~{n zeYvvXdw@Sx5)cz9Oq@G#WjRP@d{=TnSobOjw7gW#PcNe=L%XfXya}2G%uyXxJ+JCE zm**Qz^YwTY$oZd{C!s~Z+&*434|m!kTn~cTdUnY3S750c6*U4oWoM#Jg`qmtm-+=P zz~+H$BrlSUCWs?RE+DKM+pr-Xd>3N=<})grL~!+m$kjkFY9%7HDOw1!>=%W3xkdo< zgiK)`WoGOb(7=-|h|3bxOT1V@U{83n0S(Qc&dY!lvkYN?Jp9D z0KK0Vxr1DEAdo`1cXPrGtF}jgxRJ*|Z5v|qyIXy4;eX?@`G@--Sh8&^V^2E}4L(JB z^G<0m2g$5f^#ul>)V)}xW{4=`CSupLvhfGl?oLax=TzDoMD&b)?g#Hefig~1mhmI+ z-RGtRZzv(|-uloHFo*Fh@G%YxCSc@hu!wJx(LylZnERYf)w>s}{4)zEC*WY6s$(8%UL=Bd$ADn7bPf0w zd<;ElSz{Dy7;mrY>GC)5KZO4w@I)nnZy$X4q%nKC%tWn8)OXPg1mTlD1pqub{1nYh z-Un{>{;CJ$ACSV#AQPz|KrayGsZAu8S7Y*J+dU(T4a(YSyIXp%1}xns#8gr$5z%8D($Gy z327>&MLa19pAJPhR45K9g~&E${`aHL_xrv6*Y&%ubFQn-@w~m4`+YC3`*q*%-hgBE zwE=pL4&TiKku5Uz{E_C=dxCB4&zRq4f^BVvO~>UffJAvIdIyeaD~%eVp1Yu2R+*AA*j@rzr{r9X z2eQ3Xd!$akTKp@1Mf>3iVvm^7`xRi1wCDGzghuR9Q6W|11@hp_mo*OVj8{$zJW-cl zKh4)@`>?5ig2iZ|o{+OzD78dwx)5?_Oh3DaJMngcSN~*N{->*(N`J?p3eWyqG{B%* zyh=tLG|I$HUU;GOtbt?DXJl&^6bmGmps#5hz^R{sHh*sXTddcOgj}b2u2M*y=OnBn zI0^VQUw?6FXTH-(GS%!@b9)?Jf)T8^rgJbr8&s1RRrY`-X0@=4)^_PU)UZ&h|5k(w z29W8+|38^-om;gWczuir+vH@=^7O;_-K@b?yHV|no`B}vQvg=^pui0N-k|yd>1@?m zn}}V}d>HGYM*3Uq+3gHXFz1Ws&9E5MF=!%5E0ifG`z`N8{;A2_{x}X%U zC}_OJV%iE&^ll}MRK6TetwRH-hH~#*3Yib6)EauYt zsjNjio)7>+H&|Q^mOYZR%uc??rsk$BbDIV(Dz4f7L$8*>X1nwVSM8=?rSgH29Uk;9 z8{IV{U;U(rut$`9(&r}Ty!7i zja|u;xVv=DN=uM;k}BFGCNJz(q_>p6mYP}N1xk(x_(2jnAe_#n3%hrT|5>!8-a3?I zP@7Z-oS6Nn$W8Yf8vJQdyv3XHHLFCeGTRyY*ZzZvmJiAbkJdxjJI4d=VOTj7TdlZ5 zMCAw!6K%H3LP{hKz>qIa!>6}ty%-DE{_=S=@sBxlatn>|{ge(ic`0^e>PI5G^VfGf zWl}YPzdyHrE~)XsZO-H&Z;QdIizjBEdnKeK4%)d=Fal=U;?8)M7r$dF*dil+8BKJo zSraK-`$a<7U5|xiewY!>`ca{haq4#D)GjzUB70~I4r-O)deGD^UFMbk^%U>qG`55N zmBG6Qq-Eb&d!7QuwLfAtM+pAB!k%+$u_8r7SuWu(&vBFgv*Y?kK4hvhOQPzi`H&>T z8+`IekkBNLv-q-Z()yo_Fh=@>T^t|Ly!H$-@Gq&tyq%ttH6o(u<9a78!ju#n?f_X) zRk*g}c1ad_P+R#-wA?WK8*-xm>`cEATl=b0X0qw)m&R<}XsgS~RsD)g?CowSk`x#O zXLJt0h1){mUI!ED0og+$#j69t&B)JI0uq-3lvN$aWzqAWlv()4XcfGz^%BsPmv>W2 znNWV%2SqV_OBFN_cPNiyEajdf%9o^xwDml9E`tzn&64o*WUI3^4LPX~-TR%MPfk%~;u3WBYZ#IoDkN&gU4FhJ>aUBw9kL3Aa zOA)jOP4?Y#WAwZ>7eN56}Eh{|5DVOmrNSD7tr3K)3Q1=%`K^V2QHjD}h`*&|xE$s}^;WjsozMLXiO z{O@wiBWjSdS?H+>etQz+hruCjrTD%;BoD;OI_g%M{j~;`Bur5~Wf%l(5)RRvVe%jPQ*igCOKsKaY4A;nys`dg!oi_3qz(^^!NprV?{poy) zHBFE=v6=$i-xkb!dfUkYsGc-?N=FoBYN0T#PxRkna;W7!d5nT+H>3k0dGql8{{X`; zW)J*_y-dDlH?=B#-@c}Ngn0^~RM{>l{rJL6tkn0-IxKJAk!AeVEqy?bklyCSK%2)A zCDN=a*E`uZm;P|1KOT}d+exzt>uT2o$b6jqZFh6WbHw35H0drm5 z(?pak0Ba+fU0wL!T@O6e;yPd}ZB%6z@vkF@49i38j@3A&b*&d1%+Qtsk@3?MQ zq>Vh0M~_TkU#s^m`>z|#JlV#NK;`m1NY}$Pv3CzM*Q50glK0W){{nsHMRMnA!$Bhe)F3v|Y<32Aa80fyZ^NAoY z4Lg-VV;vZjpeu8ye3@o5Cq^o?d-&1+Ds+gpnL2})XXON44~Np&I@7ZXsiN|F{}_2_ zMf=3Loa7x|>YtKoodw1gT{y5f-(`sxhOKq;j=&fYq}o_P;>X^$gCA;+Q}VTvT@`rF zF|xdpOg_q81CNh6N?-f*PXuyP%_1*Dzv%dQloqRaaqJJ z{oaD+mx%9T_lAE(Gn%3QsKQpkBFa0Qvs%7ML3D-o@ZXMF(SRT2%$IjR7ajcn14o6VGsRs@;8R2{V@^v7OHhrY&{1j$;@ISEYVxO8(UJ z${S6`Ws>WB9Y?!^F}nd(*ob9pJY=OeU({fCXIba7mts!HqxFZjl4`GN32sq>^OnE< zQxSKpI=PeHq3MJeNG}$G%*bQ@e}-^2Pu-BJ6icnhtO+0G#|WAfA@56KMFfk}ZBFFT zhZTgbhCTQtcec*4bGJtBWz_tzUj@_!&gj71)l4jGT;MxWx+LzRO8NqJWr_o`GE5@E z6cvW*;@Da{Z#)axQhjZJw?)FnFAbTFHJH1Xzlda}P2yYIiqex2&m~`(IIT6o`r{ci zQk}{5Vm#D;E7#*k5&Q#m{F5j6m=0QGz@c;mW6v$m#hd4k92(B8=~fUJ3S&&TpWRfr zDrYP3Rm*FuRn}8FQm_Ye!(s=AXu{>nXi(H6GHt=LiR+rrG$hOvjUj`i6Zug8=6V&p z*jq6!z3=`u1+Lmse3=XUZhg{Xe%9qHfnBU#x#BP)}~E*)QruZ}~Ff2E*Gvs`)ZF=?<_XGkn2**jT*97zqt%M2r> z2!0k-@Xsr_xBk*}Wlgg2zbM&i`?KeVE9m@k@3d#CYD=-gmHp6)aA}^A*a*b|S}|DI zFGh}o-dK@;nL2<~Xs-E7*&M1d1##LkDKQRS7nZ=coe-M`= z6SAJY>`!;LuQV%M`wDqgmcH2gkAI%UZ+xjW)$F}*XuJbqG>aKibi3ElymKZro3(iA z3-vEv?@#*dwnX>%?4dM4e^P4>X1Ou;t?1X?o6Ga>P1m*jTk*8RD+o6qK8OzwdrL%L z++nV1MZKZCO=PLR@Uc&cLIHgRmC_Aa=L;IR-Kx45UTZ>1D-UcD+_>%jQ;TGg$-`h>|M`3C88Jz zoSzsO;pPp?*S?u-ZIt9^zLoEAaqT@i$2}&0{<~(9$cI+>bOAlit)=mX-Cu|A>lv@W zM~*siRn=-vc|=KyC}YPBYkArVB99dD(Qr*BawETPA!-YIf6$6aj%*9W zIW#{ge*QBF@9MfQdw!&oskDSmonHi$=1nwWccXKq-APL1^nw9D1+IhodB-quZ<;aE zQZU4B)YZ{O+9gsEH7&?1LWLhGJiOhWTNAS0yAqLTHjJycmc3hQ&c`e1{Jw;Q#D-#d(6lsr4 zxE)sMne!6|y}I1&(|x^fN~Zbn?t!YJ!MtKUc2OK<^gnIW#2XD(-%UU`i%}MfVzw#7 zUOC%q<__tP(;AH6A}e#yMER7C^4G|Zffb+|Rb;#3OQc!qn$V%b>`y7i;2(H^fqR@B zmy*cUnZCM!jxmGjzMG`$U!hjTMhH1oboq~ANu`6g$X(^9M2}>rs+c659f0M`n+bcu zOyuR^gfPzYkh|6>H!T{c-r&j?rK*@$N?TW<-UMv>2P(D&ro>7{U69bXi7VYMgxDV_=e4|u(SQ7@Y zRLpfMr}D^&4>iQcQpCp(N|z*@2s%e*F~uL>1v&7$4!n^-#OOHq#$##@{m3tU>bF+B zzx;!EZVBWpEnzp8!Tj0O@_jIWXjtdc#h!I}-@KUkj2`JD29JH{QzItwSh(ahR?nle z{!+ucHL2hFaLd{pbl@Ol0;SUZ}+t**jexem_~?y`M`};FWKh@-^YF zQHXu8nZ$j)xwm_7oYn9-qBt$)x)`VO0Wo`)kXX8wpv64zfdc&5BD>|09OCsg1xZgv zOW`#6{6$oYeFX-1!!-l`7D#qqLIFyf%ur>)yDmpSeTw;5n$1upJLHa_=>}x}Cw)mX zZAt#8MUv${`OFm(E^3`(Bc-+271hDs8Qq97YE^hEo_y{*-xsgm|7CVhwVFs>xp_{Q zBG6uopxy_!Nb~zV8%WC8WF3;rrRa-_D2s`1TC`QNN5VjCq`HKGcV7Ecy@eds`4Td8 zQfI!LRZy|QlB%on(&Uj-%la$21EQ(gRaWSGnovE#Z}(n?LdNI&A? zzcmq3om-Pw=+b7#VHy9AJqp}QE*V*9`YzD+iqR7p+@GR!hHSVtV8cpN2g;}o9a4fe(8pqVbdF$dKl=G?+#D?TXP5Uwvv!Hk_)_*uzTk>@K#?TEq9Nc ztiO9~;jV%PgprIGfA})J$AJ!|6q>?Sd-M8XE>c0*Udl;Cr(EK)RfeCE$d3?f4rQ+Uv)zaE40!> zat0Jc@OF{k=$f2g+yoEON;t5%r;a0*Zc~0DiEbvm#bCueS85(p zFGc+P7m=VWN#Oa)en>{FGL%d2IgtI(kQ90OBC=`uR>8LAtv{=`pkbZGSRUal-~JPv zkdF|1fb2HE!rmOss5S|il4@;o=uT&cdncq1@U-?OsW#cUaUJsFM#q<#T?^ObjYc@w zePnlt{wY5t1iJ2{EJR283V0&vu_Y*{TQx9g%8%ZveBXf?2$TY%+u}cI{sbg`O{lel<2kbAL^?4bWkU#j})jA68|mir0&<7 zJITR`?%3fc3a(79_Jxg3s60yIFJmIE3L=TV+BKuyd$D<)CIyvjC`Y}s22`5JlME_N zXgpvjl)qW6@IZDS{T{PY+=8T<$9FpcW zF_qB77ay-EL~_LMQ~1;ywz$LFPGf5RTad1p6yz3l%D!0gJu3xW$&8q*2HXW6IDi0b zbjFvsTju$Sa5K5=MI`Cx|0=vHzET4LMzz8^M>KbZF?x&k>d+SIdHr&6@U5+eCy@bd z_~n$}zZ_(d#)?@hFu4>b`C=?z4$%ojiVtZcmkh`wlrt#Q%_%>l$5G6}09a6L-snq; zzEXmjKV2clQGX0;cfbG@AaT0SA`ePOt&zo=m(oY9^>u_x3iOH2T!Z;{=snBR6}ZT1 zrgFHp0T>goqw}2niFYa zR`WZudH&S(Bss)6(FqB&%x6y35B`1SQ}t=m@O^(Ww1c{xp};y24ARFH_!>g^J9Y1) z)!%W?v-j01ic;9lSXME`T$AMDf9#$XiLY=|5gRB~9yGq|pZ8cj=BvEXRS8kjeAl_xc)y8P ztpWKP7@sTfBd_p3O4q+sSBYv7Unj9u&2Ag%k2% z!_Q{@W+%U~B0cP#6JdhBOx$(Ho))Trkt{t+ill1e8|i*UaJlZo@{}NWl%(6p;qIEU zkSDb9v-=tSxLzA~sB-5*wxL;)d&xnHi8~f+%Ax6O2)Fw8JojJbsOX@LO*9^lc61;t ziHk2`Nc`0d&3c*@lp=JoeqaF=sYg8gPBY88{m1M&EJYUmX7VAHiQnB3)oub>&qumV zvjHY6x=rKiGJW8}$AzT+Kjzdk({8{2`NW}7#|nQH!cghh$=IlL(RzZu2 z3p?aAdzuxMz(F+@Yg3RV#A!u|A=i8L6S0ORoDb>vQtm$p+54J2*?3_QxcfOWU-h}K z^Y@c-Djri`TykV|IL37kxc^rw>4a3~3}fh}zk7OT9?>0-Zd;Bwc#kbVf;LhQVo9}+ zrTjk1S-(J(#|o3yGDhAHE$3=wlBYJNZwJR2+5sp`#h8kLPl4VsHq+}HO;`gr1y5Bq z=d;VT1i?{w!2o(#ULiL~|D70*BKFfGQm`HLH0 z8ZR&skEHS?y~mwD2QO^)q`ti5xE$XI6$FjYmknZrX4UzKT$(}+eVlMIq;qX5$|+Xe z)kiJC#8!EWdHc04<}R1@M0NO*{6qt)_eYm+Tctbd<3hAS1@;5;P{F|uAs`6Yvza-Nqygx7*B@&6%sFjWYhNH?Njv< zoEU229iM3g~%E8n~e6+dn|b@jxwE{BvtwcE#&O#-v=dfXGW9SR6pW&2Lx9)vdb}^ zd2+`c!u2>y0oMZ)Th7I@%CDuu&jnMeRPKiEd;V9JvD1)Q@MiNM@i2-lIg@Ox6tB)d zO&Kn~C0Ch8h;BAnTbfu(ASmE0%Jm-&SkQ&s&MdNOUINM)(&lP@n9D+yGG8uK!CyW7 zPD;n!B-Eyh#p5hDn#iSB$eOb+%vJ-GE&5?6iV;ko;|c4k|4hlH!^r7iR=wuUYCK_9 z!~c=_WS3<;YbbnhbBS1bG>KgL;2r5|(CNwy2LI*FT9h+ZQgDZA96q570ohWn4(%f_ z8!iAq*3)c4Xmp=71mqBrvcr}x-8hhPTQZ(=@W&4u30D2JQy@C$wXdu9s37E32^L>r zm`gr}Rl7I&(`yN(t|0NhW2KC)WlI10Jlqv>eaz0u?YeKM-$>~fSKoi%m?)j3k{)vS zo~cXn>N$qEQ@}fNMs(}-o-ryVc;$(6)|yC@k0CrAl=04n2Dgqf;`;4D+~gr!xObE( z#gqH*a8FVA9aKuk8Jcvv+dmcGNy;P&-_`yMn!eTYmE(?zv#4>9C;Ta=?hNW}pa9sj zDffnWXL+|+?$@}<3=LMqpb}y3-!1@iuLb5_V$(zqbu*RkdP`=FK~)mh1$-wX&<_mF(xWo(fnZUGtX4)qqRF1zv^M! z!-_HOYoT&mOjeET8UH$IpB~++98ce1rHzm06dE(JIwtxsbkiOzWmPd?^776Jb z^NK)o=}&S2c5c9m+ZA_Ln)f-ub;OxwP3suh~)Q(F^2w zf*Af$Q!KL0@Ergd{;BAbPvB)8L2bN9Kh*U8=jwXjPf+BxELr7er-B@3dv*cWfk_VC zqL!2%9WMtB*H~QLJ6n#kLlW_MJnf3y!=jF*JqOAt4dX+yvInN5;MOdKG_X4P`j03^ zxn8vOe_maGkY-wtOHy)o14%>=^kGS@R#`8J(xsa|{H){K#Xh+vy7oLy0jqZ(ujA0c zcTXkEaL%25(#ZfMy+5<^0XU9^4D*9-lRWsmVBpv{a(ds7X;{e4KVt}ISjdY*a}UqB zt(Q(Fyy!Qih4UWpA$BNhV}QE*CJ4j$>0*oy3x-U4>Y-Ss3Dx_0i4&G}JVqzDZ}TKd zzj;`TezQAc+o6&liS3L}+jfPL8Ti23&$hax&;m$HDHyaklU~I3mTRXWS4*YJiK0nb z=uA@Bg~m4yNXQ=(Nj>((a{PZcr;*ZE70Yq^ZtN%LR75Fw-z&2vgGw_7zYOH|-WEP3t9Fw1rjFGP-)_%qDLq`L4c8ejy(s!nl=;X}lZYIRAHTbX1>E$|{LuuqWYy5h03B-^$;Z2vWL)KeFi52GC@@Gs{y0@EF5S2Y9a@R%I3OhlpnsfWY_$>bzY~I) zBO-blwkLDl6hpZS=^nlAo9N$*n{xI?q}%mCMyruOWxJW*E~XE*PS>Cc-;Vnz(U zhPQHD!1OK;r)Pm|U$x+ZHZhe~-;~gzd+$}2wLyI7qYA%awQVx;%Tug3QYHmaTMiYN z(s1&U$xmxMq#4qg2q2wxfDaV9V@yp<@5N&APU;SZTAUJ7XL{l`%dD8f)lZ-Ow968xge=8B?h6W@4+~gRhfE2m z5k*f*-{~RplyL__xk%%_PLc~{wa$KB`u;!&3TN#K@{&(ZHUI1PgKL$Q~UkM?LDrJSff}K=HDB2_Cq4K+GbW=+#D?eW&xY1ayl) zcsOj>EfCAHAon9W_ZQ=iWzMo>;}tcF0bmAfEY5CV9|TTbaoE~Z^NHkl1fYZuZSx?X z?EiVoER?+MK+9r$@fFa{uh|T~DvfdemF+*lpg0ad@KoBX`EU!lUEz{?1aGA$Ij=~W z;TZXanKl)C`p=c0yJNnP#EcpbRr9o~Gna%731@>Ybc2W_wJs4ado$$qTq(OkniqS_ zC`ju=t7xXn&f^GrJ3wxkP}o)AENHPUeS-CuHzJc2J55IRMyZJW@7Hu{D-ACdn%;J< z@EVmd*L{)a{6&GMQ@FS%>5MCGZ!V+AYvOMeGuEv(kVPK`kAyENuu5HWDP5rRA!Ug+ zeqSk)x3Z0tN7#Ok!eW!aHyRSS?L%#LrV3G3>(!r(lrfCmd*~?1d$r5wWW+CS>YQ?R zwNRJTQB;c1r;UFkD2;9Z8~vg$hn6{$e}vb$_p}i3vs2Rjb;g}K=)+Vu3T?5jEFR^r z6u;|L&>DJuEr}N;{pfIg8hTf*9J?#5HrAZEUNSgPHr88S)-pbllNRbYBkE=t->6jb}`EsrXd=vRZNVk@ae9qn&(|RuzYo4jGEN z_B2%SqP4b_HUA91=S=f{*5c<{tjOv{ag!Ax zdS<=%*BbA@47sV^XGk>!cyz(&NG&q!;`SH{jQrL@Sm5Gp)rm%=Ar~nFRNRM`{f?7zJ;}cJk{En3`K0#9FCXY#mu@IxUFE1S%1llo$=v$!5h z`lXg)_nnsFhumhV!|1J{!U6*-D{f2vo-5|5MBi-xEuktz%B_1oNhDy5`= zP%d_s&4rv>1NvaY#}`N!z8Lo@geeN-92g@!F$TZFf_#f4UmvdfJ9T$_L65gYW%YKW zIEmYK`a~wv+m%dBgjme;?;%cRi} z{v)Xkqfk@zZcnsMG|#RbQt(j(^#?+kP-5mylPUS*Q5|4 z|09qCj-u%g6^hx|mLyG`N9sppx&NFw)MIWq7jRqRj2HSvqh<|vuKI)ANUSM%LfOcu zS5k?bx;lWjdf-}vkCbt$6uICi^SK0k*ojgYF*1zl4#>?Xt zU{}r_eb%UJt(tm^8 z7FBMB^e;@lUTn6L+*wrojB~g6x`J8Q+g9L3WWMwgEXwp>xLD{(I=!rxcZ1Sd?nd~> zvmA-}bl^!MCm~1Rz_)JdIgD0tXhyih!LIyI;o%+<7TIZ66hwQs!0s=!)iQ`H|C^)reg1vkJE9QYQCgJYUL!H@(2@yF&QO!M z$)(G+;Hj5fVz-T#Q&@33dmQc-XYjDG0DF!VU|875@w_uh)&@WuGH!78EI07Zeznv zd9LmfKfns#Zg|R~Bu~m(p^fEw#1f&}MCbQ#04Bf^*@$nBHTry{{$>=-%$?`#^HX;; zq7>o8y02CNU~_jqtw-)@F`0EUJfYoeVmr4oNkQbg2I}zSfCfg9y_B#e^8`ay9dKyk zB8?vX;QtOfrrdj6(ndDcz4dyh1Pp2$sx=*RpN1diX=8$w1&<#SlEm|Fc|>p+aoXjIl#%Jx{W6t^n04%M2V zGwJpI3l+)6a&0>a*bxyuA6AVph1Q`3^I5y&1QW_>9^x-nHN%U2Y^jXArf;(CQcPrG zwFw%0bwus28$hF4i)B^j8VFi^KPCjz;rWNKPRTV32kgP7%L6BBXNRo~K2l*1v3yOq zN?9)HWYBdot6t{br|@leB-e1*H1lkK`MnbS3Loja|9T$A`laOXjgo#vVI-S#Bs(j2 zFh?*30Rk1mm0>}f5sMRhn-`Jg%y)>Z)xZ7-{>9B|^`G|c7H7%u{_mpg48AoN8^{qZ z><68z&-GFO5EMv2bU{ZjWHkE`bfG_f>gG|46B+c}uZJI}TsP5tym2a+aW5$LnMEQ< z*c%6IxoRcdEc@slAF{D$%~E_KX0JN%q}0g*k-cPuE5PcD#L6xay*4EU0R5sT|0al1 z-WKv`O*0!g*ZfQgzox2AW^JZIbgm~m5Z{WJz}Y`5y*v})~Nnl zeY3Q)8|VV)z6_KpIv@gn^9e*Cn5v@5AhheTHC|NyUsQX{nbb1PCK8nJ*erDRrtGs1 zJIxERr;ON49B#g7xeH+X;Fcq5Q^yGKI2Di=To7UJ#k znZ(@EJ(jW6RcYKtAH~(idG6c~6xI5?WpZffmcxk7bei-|`G=W4%)6OB3Y9N6bm=j< ze{22#HuH85;88M&_O$!ULB_ge2&Ds&Fow2Qt7*44EsL?G8W#*9oV&pg!nQkGIia3L zU%zVVOkY~-gtq9X{k>BPX88m>?!~T*j%b63<@4l@`Qg?cC7fBV3Y`U+O0CJ>nR=|4 zx};z~S=n8UoZjl6wc~SNIm1o@UOY!+$Zt~ZuzGholveLYN(HOV4Uy1DZ*{e$azHBG0v#25NS5BU5KjJlA zcqQ2r6?vs31Y&g?tUAT#X%y-YPlNzFQ9O2kAGquDE5x%evSeQZ`1i`R)`h`;;oTI^ zVN3Y{QNbd+dn66bT{A4_|MA+C9?3=i6(axY9i%@uGRm7`mBHG>$zKb#^MiIt^2W{-! zN#_;_&rI3(tlj*ezLe0*b1J<_eeqC!-Ny4UTHF4=XI`ax`C38g5& z_z_0^Ry_TL;_30JdMv@pX*ybS->Sp$uT%Et{I|(3tgTrBEt}d@(8@v;7OwE+)-RZoH^#sv* zl(T+0Zq?7?yFg;d^|4?-c6s~Jl&T(cAAaCN z@w?*%si0%M5MsLum4L(iZs|G>g|F(}1klu&*#oq(s7l@DzbKq~~K7NX1H!d=R&`3dHt!zhmocQsRg13&>;!%lp&%;Cm2EWujt_ z*eG?M-$CF!Gs=@3pvK*P%PN_XH(s@AIqn#MzC~JT8!=Dulo50e!Y=F2@A5lhmywG1`xcsIEwPb|EKf{E+ho7C2j*1xs0QjP zpV_PP3Ud0LL-=kW5&myR$bUW~q&JUX%;%HN=VX%fN3vW_Xju5Ic1t;MvTUlWpb8Qz z{ux%;X~z^qUrcx}9Y*Vxhe+@xE>n)i)L0Ey#0^Bjt`dGXdI#>u^X?(IABjAlf3KXB z!(!T$q3i5X9i{A-Z>%Ds5}J}!>U~!*xt+LkZxSxYE#w~|Fyc#Ch6Ypg0a1}k2By9@_1aR&Ffq;$?7m^kbLu3OEg!CvrOnT)F4p47DGXdDa?$3A*|+Mhz0_Nz{Dzv>)~Xy&5H?q z%cr?4F1o}-JrH<9UpMgAywv9E(wiF4Rn|+fe%F2sK(!MgP|v0@^^^eB!sbD>5^=(9 zEQ$4yQq5_44S*Ua8-Dz03fi{dYe;}j-hK06trWLFB;+iiBjE&(ME&+Ye~+@G>jg=8 z*je;GSRPX8{TI%dt`FGs$M#tYz?jqJG?zS;&5~xMC&&-$|cM3iNP~?64{5@%6GC_;Yqr?4wPZFlCP4nj0jrj5sMowPsoj&TZ!=*8`%2}YDf1}$YE>n=vTHG8& zE~$R^vY6bZzl>92_xHAcx@%9~Urf{@2y@rZjzA$mw;I!|XXJALS~ut$lQ0+_Yq{%T zY^r#@dv6|X)vRCXjXm9t+9#}dWo^#M8nIuG+}9`oexcjrwglF6{Oj(GV&J6-pj9N) z5rLG-Kw=6lJ%^$-9nj^k(XY&iE4L;#?=lr;ENJl^~)*i7R`qJdM zU7*4`B^vXXSg7;p-(9POoP%m(n)qYpmlrFPM3FLah}AG`Ir7m;5>(1EP$?9yVwk!R zm{fTAf3_bSB|lVZchDZ zK+o+xCk!8$$(wg&uP!07Qcory6p3uCUUaYHec9$I*ruXBYo{|J_v+Q27<#ZS?;qFE zyw7ZbiAr0GNR>*%Nd+|iY0)<#W*h4c(-EzkCoMT5rZ=~cXgkSh=(Y!<=bO@;9@k0Q zofCW+wRZ1DRqG9Xd-JSDPH(0IFE01uSoNY!*2t)|yRag(W3_0Yvpeki+`4%Z4-h&9 zX+Y@w>*<%#_3YjX+{-s!iPR`6k5fgu`ur6&PKv0Tg>^R#1@fFp&AUI_0#wZk!Xv}mCFlYflxR-5AJo^5y=?_yt@y{*vi-y2i+ zvTxS%7R~)r&J#2h!ir|nY|7*3iGJg-BEh!kEdrG{pTqTT$1=HE{OO7v=Xd8*GQWNo z4)_bF7mA807)DeMg%97Un#?$w=_$(ib=0n1xGU=L_$eE~R_}*cjh$(5dG+9v6Wuw- zwpi7K>xx)SG?D$#zuh#!j`A$OJu7O$3s#F5=_AX`YQm8!ak(FwiQPrREj&9f7)M3u zJ$vr$@F1BXZ6<(it~)XEqy}aa?49cVNMUnto?}&t&a7Hox1{Bmhi_cQE?0POjPU4aHv;NNqmK%{rE(5J{d{4`2@?~e5v*rphM&b9rg=kGo?a@`POa&dAZEXTCt$#gL6Fyf~HGS%6 zX09k>{HWbISmU%nTwN8W1hNQI(h?~3@9Q1lN58ZS>mQ#|+pt6xGCo`TyV)NEDvk*T zGdZJj*9MO_$i{Y4X`+oY_gaKsV3_Y}UzU7oo>Mf1aPzJIIMgx3xjm`gIK3>>&+u2v zweJEcTqe;n`I_C8AhmT17ZvT{ktT};wX^G+gq-Ooc}6_*r_sO2(og-Lq10**A@s_N zZf`0S-|!~SvFuyRz3_s?cAPQJ#*peg-d((mf}4iI9F5Z{pTY}b#dc}k|Dp47tv3Eg zr`_DZ+wK@0xSu}Nz*@yTXVL)hY%#CCsfZenysPDrtZimhZU*s=Q0-)P>rS3eMRHY* zg~Fp+bH0Lv52B5NpApcqxwd+iBLGp11zPC@yKph%2nm+Kuf5Pn*G)ohiNtnkCB_>R45!n#Lei&{$F*?npr zQ#8#Vfl7e>B{OBc6+t^bub)!R4t+V)-H|?`R{w%kBDxr0JEKy6@Xae>$mN*@01Om& z_nW+qQlILQhNMWC_3OOw+-&q96B_oj{Tyhs}FRK}EYMDUEH zja>da;U|c`E9%?siTKe+$SA=jUv;W;DvVMk7NWal6J_K*hNP#P;Ho!rkBN2D)00sBHQ8HNao;=#JzlXt|;vi(^A z@%esV4VfH6a`WLC#Mu$_)oMB)b+Gu(eNw5ZQA%=Azc~*=!1%Jvu4cYT2_pvNkUaxZ85` zLB1)v+DZ;g@T8F+HVTb}2h~0`J-*O}rEHoqdB29rUo8$WUWDXj+7*(@8x5qE!^BUY zpg<{ZSSLIXLXC#ruE}eEdJzF;1C-;*;(-g*Nq%zT&XBUjkhbq|lF&`)@~-O&K+i?J zf5-#Z6yh2=0DG>$OOIzExHLhTC%@nRowBE`d2=)fGciILeRI9Cq>M8;y?02ghQkRv zCA=L!KvYrp`WcejrHPPrgdbX|=qKAmTm0gBpb%+6o(nkWGrw=M1Z*bK5wkJ}3z&LO zDN0U3a%SE4ZxSrZb_+-q$xT3?toZHu8FxQwQhQ2kkt6z~Z;9+nfd4i{M(VDx`w zY+z{#d>njjhyZ?^XZ5TA*WH5jBR(AuC#%)3lw68<*y>>$#X~up1=H1=1xM|FA1Or` znh2+&JP#i%o`(-6j_iH6S&+e|a+5ZyK$#QZ#Bt$>HPkc{RejkNs^G0>L5w9)z85NK z^hWj&w2m2kUNDKhL?0w>fr^miBLlXMn*bO)VxM&TqntowG#pMG-#SL^V?kxLcVs3w0^DaL9AE#has$f&OVHz$N68g+>EO|Kr}aHqdX zL>R-ffMxwq^Oehwgz)Y(`EPGRWDniyln$8l^bd*7bXMJik zuCq6#R8h&+adni6F&D@VcKetZf!{*Ao~Q{uHW3YLEFh4~2boMz^^aE0Z50AQvi|8Qhy2 z8GJeME-a-rPyBo3UM3W_a({;5?GBwWJ$H1cBA?_?=wq?-^27^xjbycCqsk+bA5DP(os*PJUv!@;K#)4=K z^N%}QNzpQ0j0j^I2#wgYz*E?ksXDQy-DRpm zn?GU%VG=9h<5LOyR=kFCD%IVq=BPu@!}DX+_g#oqGMTcBowgdWKUnwkm2gxkUhd)k zfXVUdJR=Bm86u)E>p0~&L!>ZVr6~vqrd88_H83O6rxng=0TZnvVwK>*&4pB+*5Qc? z*J-mU^XcOHZhgam^pm^{k?8Uj*Mk;I!wYVI8WH>VY-{#ootO9S*a|CTmWrRJh5tMA z+*p5h7FlJ$iMZ}6r|aPuze{P;_8qhviyS{r%7;GXm62lK?-5%~-cj;g`_GSg*I36O z{D+40)7H6lAMNxHKdO$_lK;*~6w#e{GDvHsU>m7xYI-$@j1&sx3o!k!HFM}~* z-dp8$n3nJHJ0%^MiSx@XE}dmXC7-L)~?p zxwObz^y4R}gRzTV#mzqN=!yM$qTaocr#=1Tz`<&!x3EpD<;|wXZl@jgeZrL1E;}eA z4c3}G9vC6$-T;2p2M7{lLJO*s+lz_4`VLWIhxNnm2H%5)@2f2y^|7XT_RF7mHRiR9 z_wl;$xx5?sQ+CW`k=4zw-JhY~T|E}U2j8j_rZSrrIk%k{gc4i}gUI4H5AgvA`qVx6 zbA__Le}m|aeqPuVa+WD5Y z#G14CFAei(8)cXP6$1y$2p$U)gB>@69S4_9!t59DUSIl8bIPfTomB!d;C(- zHYs^)4#S&fhBQX6hu7gYW+|hBAD+x+$5`v7(s83I@IVaI89kyIv~=gP~DK2KuodWu|%m#t8dTU z4M5U7@(BB?^+2n~PYj-=!;374QTOpLnoFv<|;)6m@O8U-( z*|2Svc!1&Lxj<$Z`uC(!UW&itQaQBfjoVXk*3C&a)d5M1=~v}bH(XXkj}YZlfD@5o z_iqJ>pO*-t&mwV{DVT?tYK}HLwr~*~;=d%d`rCi>3-|u?@W@ZXwVJK?khr@Y_rbSq zZ7oq{=+dm&InuoAEfbvf~8b5PV&dj(L`~SH55^yNj@bCAX8Ds2Z z$yU~=>?yRFA)&>R7D7x?2$AZjEHkoJgbEc!B`QRvNM)v-RFo`9W-3Jp34>YQ?|z;0 z|9{u_U6)hmy3TnY@AE#-b3ga;`~7Z#x*zxs-gj0Iuh0y!tI5NNimc-Kg9y+o?jq^E zF^R)SE4dw-%~$VciJEr<1;(c;3?)p7c%G!2AL;;2!SVN;x5yJ&eSs{hpzE5~$Ye!3ozk218T5o<0O+ zjHJ57B$=jAVFwR#Uw=K3D*L=JCA8ZoP9a#oPkA9}qsC#yM`3e9pCg%PM4NxlA|m3T zq6I@iEp~7uY4sW$ULp1pZn1aWCtoc}MnaPmfH?WbT~s424#i2o#$8|rsv zIKI>7w%O_p7R=2e&=`}qVB6DIgXDrLH|+UANoC>`YYuT$&0_dH8aGs{j3oV@-Gd?o zC`SE%Uy6ROqFzojw_{OJ7=e7pZvnw;xaSnBtN4HAUI6XSN~GyvFLc910+h4gh)BY)MQeLt6le^teRq;$Lwe@Ni}TUvYN zkYwytb>n|_G@;?=PlhTZ1rwf%_UVC}JV}xJ{Nv_@75fp@viJ|o9u(#{hXe2<$ol~Z z-E>vUAt3hO;V3R`qm(G7`6WUq)2)?4=K0Vz8f_a6N_HLOeAwBBYG_n2c-va-GCqzZ znQ2@XzvE)M3%Urn#?4jI(!GcX7IsYlPCP!m7;@sv@tk=1`4D01bB!H7it*j!$j)Fq z%j@6cPU6}sqc$UMq^k0Bz6QA9$ze@x2z0N}KleVnqYG>iALu+#9l{bTkOGpMjycy| z5huB|t?DG;CH%q2NK*BEiXl=KUL^)k<3Cp{nV3-;vSGDxL}K`6meQ@BVX7=>^CKYi ziSKBLj9g$xgCW0QNgsN+gq`aSD7HFr)kdkvB`Pe2rILPE3izu})lQfYCC{L&xME@ai* zC@eZoEm%MA2W>?4hFM~}%~o-5iaGm0*7!yy0KE_jQ!G!*4S$!XlO&&Iu%mT=a5UO|T6>9WLTLLkqgA#J z0nFrAK-c#qXyG_~cQqBbn#$QIUJVD@=Sae?jVnCULz&rveV#h(2gfG1!fBO@JnH|L z+*#5?P|f16j(;rn($IOh<`~{c@xR2tZZG@>KLqx=7Ak8UE557S82`W?ng3u6Moy^E zN%gXO^%={ex}neffJ-XUEJFZ@7p39bwRgx$otCQ;LH~)z>dEHpybMQlD`6Lo=GnF& z(#tOhsU>aH*Q!=Vy!1ZGvL7EuRJib+5gVhuokChkf@a-of@aHB06rZ# znTO2=<|bTUN-Q3jclb-={?UJ?qT<h>l9Ehdi!7MfF>^> zA~stoX>tm~=%CiVS&neTSvU(Jutd_qIj}_L>?6@zCDn6r|Nq_C zT!11g+N*f@Q#2ChK9#z`V4r#Z-OvYO&KC((xm>Yw2Jk{Co1h0A#q0NW{*m|~!G67KP;_7sybdtI_rmKO zWZ<{?6JhJv!}et9CQ}4Am-8d#0(0C+!S`r-auno}U4^u_)x^pte{|*$?>wERiujm_ zg-uXj6|$yBSp3fx?+=)`m%u##=X3A-OI*te5z&iT0UsC?0{aCvRpHJ!vTJO?Qy_ymBl*)J{8vKK#; zOp`&+rzzK*a};A8kZls6|LFWyA|%X_5}b8g96a95%My-qn0m?qK2Q`RlVlx>$}D=xV@iIZe_i>`&)^VnOOu7JQ6IQ3nLDSST8Tz7Z?m)c{bH zHFiw~7oXe{ebFdqxPEV)DRiE`QvhA|MwYhN5LFYJNz2j*I9VLquYmv~sSsz2Uze4# zS;9Vlh|P5I;P%g)_`6ly%Q=UT(fcex)jXzY?H+)h68G6r4;#ekGMr=n|$AC9CPW?(^>N*}+n-+p~kQ1k6Ym z(aIZUrvkHEt<8n8RzSF(Dyv$xNMZgCf9dOLsG~FGoYg_esyTCOlzyX%OnFE~S|w z$|eMGCbWZ_?pz{^OFzj3czUy#X>t7=@5gQ7Z0FS!^@hU5>R_{{m#S8!+=z;dO{QUIP3-d=g^+30$y4F=y;>7+aM=`DueW#US{#6L&$ zXb84>!e@V&F6MS-NrD35n$<`5apFKFj`QkYYBbrubsdQ^lvy<7i9m`ISSddVbn zkLHA3RYsY}@UeONWUkUnyB1oU7F$J^J+v4rxglWj-^=GuqIm1_FSvD+yxoEbIj`Z& zjZ%LOh7g1A!e-=8;u~1<$xFu`|Go6=#Eg%RXyjher@0GJFl%FlC6D>d*Vr6f-C>~| z#7;sGhTxNVZX3Kriq~1HmPbFTSBlffFO}Iytj=@Fq9^l;g<3({yt@w9+gME!z6XW^ znH)Sgsd-Q3x@*E>^J>-uxT-s1d!-*C^~XJ|V_+FuAR@`$5&y3NNFaK1#_DB!m9FRl@XM8)>R_kSXE-8I^^qo@Xd8in2G zC*xK44uFn(&CJNa<3HaL2-@;c2DA@a{4h}r0pRqZXKBdWVsW(H zCWQQ5TD}lS*(KqW!K!N8gj=v*@2-$ODTmW1k-|PuYy>a+WMUav70z_EIxMp) zy(vi=s_K3tX&j$lXdvgQIdS=BPf^5}$bo6Qpv7Gj zM_P*%+@qK$6f7%SP0v#ZZjG0Nj_8HB+M&BTSS{3B4H7tTK|Ijhq`)C&)&CJNJ1P7u?D2g>Z^K%=!q6aUX$sfKa9c z^6)1Sa~#HOaJu!R63Lj;=9Z*7UG9H!hx20!@S%?fF#E`T>>WVD<74*nXgJ~e;4f)z0lWI$4@Ub$HOMt=y{4^KEd~U53KuKM6@TUAoC=h4 zP_y;s9smI{&Be2uu?+V#FqO%@+xn|;?An7cPe4Cze>aC{K=7BcIvv`2P`biRx$T99o>_A1$M zX_NFh3LxE=X*{>ed=4pf%j;3}SdfJ*31NwYghewhKT#{56nOv9i&Gz}-ak1M?6yzy z+Rod9Gtc(le?#rQzKc6#xe}KnxgVa)Jf5XOzajHn`}5gAB$__i6G-X{xP=DmkA7umZvcd)V_?RfIK43uj}oZ3JB6gwAXV8RY4_Eb1_+674&iZM=Ozo_mB1jZ?I?O5K0!X%8L^=i_|( z3yb6puvH={vw4?FJns^US1Iug8^}~Pr_)qn=WjKc-fqEG-w~%3Op3Sd0%~ogDm|xa zo0wXolQ=xSRm#r_F3&U6*wPrbsaeZKkb~?X_-mNJaaNrTdc_E{5b)50%gn;0Z>rL) z?SeRMH2})Z#X+qD)l${R6C9&5>H?U{oNOpZ_eIKgha?Q+_q57X7w(DT;h`G+knAk{ zyK~MvfNS45b?aDr|A)=(rtE=>0SK7jTrN$j>XvvP)A;iamhV*;@YH6al?eZwPY9j= z+X4s+v5f`;H%|!E;jMgSwtVBTwTHjBT7ti<55Dh zXUy{{PKp6iMs-My$e(fQ8oO!y=lrZu@3|@(Onw{l9{XeTe(cVhh!D}Q+gSzXQ_X;h znNR=pkq7*;WHL56Y{K%H;jz*;Q$|IMCN=Kr#4)RdtDhg0^TO3T@3A`yV@#mLw$#`P z)H?&{1CXUGe>7(0oSUb5jw5bXcT`(YK$!Y$Qc5>UJksT74rNkcRWiJztMKfz4knGZ;Kf0u3F9&?`hZG0ZYvOIspk9 z6gFuz&OKOfT| zLWI_dB@n&=sHf|_3YYZIL!&B7(B%(??1!SARDc-C3U*9jSuM0GA_*waeIN&tve{vK*IN3J{k-^lp;EBH* znL{jbxs|IxEZ_X{%R128Oez|e4w0+P!>5a{MlND^tL(?l+r)I_qSCpSWP+EZaUN~^ zUjIf;g(5Hnzhxz_YT_3q_kN@%BPWxp#BH9K)om9Q(k|Q;j9?|cgb#Z9SfB0p5wS-i zO{s)D=yRRuU0ThA@nx484rNp}3{(@_n!piEv%C4AQS$lkC=?^NMpWJ!mM=owFr$AWn4skpo zJLc2XI`O35s86Eb|}6NEvql7U3=ceS-q~n^&Whk8^zTN~?t3z~puu$aFHz7aZL#9htjxwYd6?5WA6{ zn@aLpxC{e19(vZ`3FzAnwKo$kL%N}ijFTa^{ko~T%D8eDt?gL)N4d3+(^oY~eYN(8 zAlz?MRtR7!5(nX32X?eL+wMzuna!fa?com2%5Itv12Q7l$vk=)9}P*Je;L{r{1?f8 zESgI^Z4Ci<^~d}GX7*|I+AKkM!hUJ5@5OH&rAMXLM@`v}WqUmY#J>mO!y0{ZcPY8v z_8su*dqAM&9&JdSe+gGJ#TBi zPk@rt&H2H_@fNY4VsnbK0A?%kphht42Jgt#tXe1ITOwRH>Z>5Ab(4u*`$#Emt>907 z!Gzp*&VB83^95AD2LJ5JEfmuxNdct=&r-bkB9Ur!l+F%K?lj`|Gnx{(7{5?vQ-|lImL}2U<&(AS2T75N z)h-jPLr-s#j}k`h8=OV`Ndjt2Q{kPC8Ee8I!%*C`wH*Ty*jFIba@a&Z1_I;=Wm$n% zO3FmUgt3k{wyk^pzA24_HAQzPxbimH7c}aR5|q4Nk`Mtl zhZgA3;$L4GQr@`esW3C;dZ-xWJ-xOXEw{Vh5FrVm^Rszrm!~48tKyA@WUk#9q@-F~KaD1X6Oor0wx>+qAH?gVwV`c0?g@q@s| zB5TmtOS4`JYGGz>lJdvi{2&v68Wd>?pmhqqd)6>5uB&EEYmpL8 zbeSv5JZXB=t&&z_<@R*TQJgjE7g=nDf4nd($R`rj! zCYX*aq#aE_c7{Pig8HKpnu&fLz}#?%x|j+%`Wem*Mj=$e5>b zT{kN`c6$!rMDwW$+xY^so0@$=E}*Dh0&Gm7cs4H@z<)6#(9xq%L*n0Te-Y0IqCT0P zp#84HLCaml*~hc^6$?vh%SR&)nTK0Ov4Y&!6Xz1XatyNXjImz1oz2Fg=Wu7DKld{L zkFZbwzZg^$u?%9+DbCG#VOV)rBR1c}HohW0e~Sd9l;>yhOI?KS{q|#n65&{`VW{iq z1@9TBwakm8+7#ViBMpP^CWaGVI2hp?9-V;dXQW6 z|D~zJcAmfnjL8{av1Na6BIWga)oGS}w~6ID2d1gE_BPn(>eXoM#gh=sPA~*7vX)Nk zpvkf=*lf^<-3>Ot9xkn!k7V@rx=u5?dTT7dld7_2)LSU>+9#tr#I;|Nt6rLkg9Pwg z^+N3jcnidfMljYP#v8G6N&0MlnhE)7mQiA;Kr2^r(S#B7sny@@I9zBoO+=zt$@NEt zmLAOv@_-S$&GWHHtx@f{o&cgXQS`tr4Ng(~ExX$~z84Mdgz$G~55`_Ixu?XI$jDu}`IMe)sRS7`h{R{D;ItF-ZnAXaW$~~xD(@A7vGN?FSk&P4x zgZ!80Z+Or7zGfUS-!o_V;hQ-k)dU{vkHTr};roTgL(x6l4cWy3SO9sfuf}n7Cq)a&1fCuR34ai zE2$~Pn9%*QA5V8N_J_e}NpguYO&i>uGyOG~*%t`4@;0LV_Lso`1ieKpPM1B0TD^uj z6Vn1QLaf5|GbIw*m4=T4tff#Awm0B?v6EojyaHRNIZu7xqDxM*MlY*!^&hEP9TeVu zL+PM4rAK0SWgL(}##Us~=6s7T+ZDST5(9GBg8+e-!krl<+?j#Q`Bm)2Z07t$H<;)hi2f1$18R#rU zls!bhjF%X&7q_1X-=XD(?43uxV0%sa?FRsHvYMdk9G5Z0Nnaw1IBJVD8e>ufBYlX7 zBXDe3@;eWEAmVl68)@(zr9!&aXWY?-Vw z{mJ~t5r5agB#0LJu=d9gbM=@W1OjtFGx#o{2`#nEbME}jfOdCQEnv8h7 zR+|E(+e%=?WLPAqjm@(~)+AOibbtM7!W6I96`~YjE5R0fY7kZb7kx6V*!cSH zBQPxAe0w-I;;nvnh#m~U*N9iBq)NdCY~gPcviUp1M(f3vj*1-mxj~mrk2u!Y4!aC8 zbgKjkSy;u2W7rX;=|Y8RhT)7!>%Ivn9mX$typrdn`MTboIEDqc`0@idZP@)cZE@fG zgGho1eO9)HC?YHc%b@)z&0fscxGswLxk|u#>2~MYC?hs0a>S_Bc_gmBc`NmN&kW>& zCzMyvFrVKy2dSrIMA3JAc3{su3U0Dw1WO2OsgBx%p%b}#Y-BOV)A>#aovtaA4!j1? zyn?|PY>Lu|<(IQY4z$5B7iAt|9eBX1fL(`)Yo4gLhsbQ(bS8+FN{!A*>G(;_wwDga6ko5u-rXE^ z4Ps4$x3GGpK)3S8d2Bp@(%Ec@o5i;XPU85MHJ)v(o$Ibt=`ynyW2y-qwvKe3(>ynk z6Kyy;#ZTRDxNlLDaOJOvLtUoWfnOsrIMHS=to1=gneYYFFf*n~CPp;t;Mp5gX;#=x z(JsYE>fZDyXhm{l6D+kcp_4KR$=e#y4akiRz#9OruwHjip!MA7@b8uC2YFb=Oiw<`EIYETbEQzl@d zh_o^=nL0@1-ird(xV1KocpNR48IY%k%LX82|6D;%B!XOi0Fqg0LN7&bN&KS#+F&U7 z&obax@RZf%iH?Z|gxLsEf)j6f`tPlmprLb0{Tb#sAX~Mfj3A#cJyMC?Sj-H4w-pVB zef(W7NrUO~nKF9d7V>($9lJeby~F>dtUT=68c9fNLxbn9Kd`FeVtM?WXc--PHD>MZ zNhL@rZ?Jj}T!%sFp}PWAaBXTfUk`V^sz%tGrB99p+&gT^0*>ey$0 zaxXswrHb!M8ph`76P8N$reUj66)>4qgA!0U^~N;BK*0^>V}gD&V-|lu)6U4MqRw(=Qj;+iv!Wc^-9l5*m12Zg#XJ7%P0GZxqN{D#p z0+7q6A_W_OG=ck}Gqb@o4u~Xix2y<9Rk}`R5J1bO1Di`Qq|FcV1<(?d+9x3Y(ztVt z4ro&n|Ir1AQ6(<8-i!;bpN*frTS?$L66>VdJ3Et*cJ4t6-C-qCc3=#1;Pz=<=;>t? zT6rgg{{*{i0UT9oDhR7K01bd_`Uv@lVy54we)Wz z-jHd&_$dU0;$47&3~u;caKmMCX!pj$v@IkABy3yh&HGZ?E5DSg7U+*0I$yj1!*K0vHE#MKpK$Nfb>8GZiR63f^1wsQGat zzumOe##^)jNjG$?U^w#?txQIsx0M7<5LHj-wVd{{S3(TzN#~r8 zcLg9P4+PLk0o60FCEv4}AA0SWKYLfI|L71TG33<5f zH3*T7Sb@43jbwiIz={-%8U}kVmRUjlsIb(m$CNCtLA2?2PXNERgaYc1}fwQa(2=IB>_m% z4p12%z=@XzIHRcf1sfM`5|r0u#U&paTH8ql1W@GP_hsl>5Q(N4^?XPIz@o-^MUy$3uYNR7RDHK~AXE6f2g zc!?qlHKpJz1wwk@+x^gu$o8T%X8jm?6QG3WL6ji&gnr!ysQZEJoCzA>66qo#GjBHk z3j%xn#q6C8i{+t3l4`@syWP;-ag0$({3lDb^sTsx^0& z?L|aY%@fg!1QEJcC@H?v--6I}Je-hA394Mo`nDq!Xp;dyKdVEt0xE7q0HZy{v2kTY z92=JrX^5i~l4(jbHCG)3RY1^bRx2XYA`y9kNnu|M5soZA7XB#)^CiWG<4A>dfK=$2 zy<`t_mLFUE07zNyyj&$@vPAE73Qxcv0w|yH^(RMwY_M4^ul3e+?P) zZ;=AIv8|$wyz3N=dA>Z>c%;)h_n|r!Qr8l!{L&*TUr<36tC6oot`wBs%Vf648zSlr z$@Y@Ma?98Ja+lZqm1s-JV;*ErIvf!|FeQlrzM*g9$|H=w>(~h=tq<~{`{iRv!3IlX zWmHC&=cchju>7u>$?l4HsVu;7cZJdPrVVlZYeMb(wJ}1fC%l#zppq4ERI(V&OSCiC zOJsa5WZF&t;YL!Gd7kD~ZZohf0nFv#jGcFubpcSbw*uQu_pJ*F47*jhE}K_KEhTW5 z{+=jI$~#?^4<}IM%aQ!Tap$4;CsTX5?i$thum&8#qJ6^&@rla1GcJx^*DQG_4WCu z`9X~By*b#CV(fKumH>n$GGtv}utJVL6eQYsNj~)ucSdqsL>8G))7b7xiX8Ck{;7<( z$10+5$rZfMyK;xZeil0IRvfEv>s~e_^=vI)3wZ-tf|{>qvWV2JSPAZ$0(|NT#{Y=c z72f^UEBb6k@UsbtjiT}vVfcfiX3k^Kc%_GlmaCpX-}N_%v;P5+pX$a}+bp<#qL}4nZG({T7Lv#&%o(hRM~ffkF=Q@4O2oeqoi5m94DU7RiO7PXYP zz@Fz!C&;5->Sr-SkAZ|9=XaVP=W~1La--5?Qp|Qo5vv2?lsv}Vma*SYRFKd8@sQ62 zwiW2Q@MJ_z3a$`0iTcuQD=-78(aNwpBtgp9R)5mDFUkr<`T6bC{05A-nESb!hux60 zsjJ_LTKc_y;sKGN9`Pr@G|pKYVm{D{*^NY(afSPP+I&>wGQ$4efR(S=OJuKW!hpx} zwik<07{$G*EhNnyoD)nnvmE*j2n;u&2RK|TWV@|Y^mY$PXYmH%x%|@62nq9f2Gv51 zMO3MtHDe4tLcKyAx#uJ^0%6XMv;IMX=KZs{9;pV9J775461pzFfXYBhGv++(~f;*0)h?5WyY7HvTN!I>du*7CkwAFKLY*6G#pOC zT@q)=zoyo}H@4sVXGEVp=D!>70j`BdYS(1LHi~TJM)$VtK%N4{@7B$>Z$UTQ%Cy?- z6qv0DhZc1%fLfLk#WEz{E-W?XxsgcBDN+cpuq18>Y$g>~{b@2w%wQNbcvjE&h=B_? zJfZ~QT6sLFH}i=5M+>D1es7TSemOR(pV>c|0{!7gsCX)iAb1bLYQYuHc(G(2X50J&l3GWp+-oE_6V9IU zm{a1u>D2lseAmehIzBx?JKcx-!d6am9>2)269p}Z&_vTA$);*x7CL>mq4Y;H^fdWr z%>R6h0sDb~_aGb7^}ES_*}FzoL!l@K3xM#n%nw3T{sM?P97tRxI}5t*wK=^Rp!V%T zz&lmqJ$X$PpocX%(iDk@XfUnMzRH4k9lI7#&!|=R9SIzZesU(n)>kxAvwPbSWz_4o zB3b}<9W;k5u15oCC}L7AyeqgqLCuae&*B++>}CE{EQXZl<`~h+xtOi>H-Gj9oz8PH zS-0Y!@ZVhpdF&{}spFeWAhI;=QAGY?M6FRWC6_9h5;YreyY}%$WoUuu1*&RHIl`zw4n)28}fZku^xLV;5UI6ybpN6YZl=wjH>5k>Dmgh z`EGC2wauX~>Tk3iIY|me0+65LCy;`q>j?L2>+|0DOLw}PzZJJ*rs9x*SP4}sys~r# z(e;a08{)eK(}uNVE=bXa9`-=OT&(ssv`{hHUCW`sHraw%nhPSdwbWCw{6Fx|ayhK> zeA^E#EgfTQneQM5(P1ba9ZEuAG|sZ*42)$$whzd_KOpv(uDXeUBJBPGLOL5t0xpPo z7PUtky6ghDv>5ECr4y3YoJFZxBqmzXfdHHy30M?a_g7lX2BM6r#Q=2+W?mgMYBqWq zRl(TCtrnS#x9Kqz#;BnOP9W#r8e)9LjIk%pDw`jE+SLR|Qm8Ms<)Nrq8A@FQh;;~1 z6B3#-#ds0x6P!9?#m#A7Il4ZQ29P+2Pn0Q20ODxYGBIeaibi$?ut|4{0A{YlUgix# zkz$~K2-A8EL2n>)VhNpHqICG+7x>1uVn}GBJOXs6U~P+{1SOKXvnKoaNur{*?9ge5 zc>M_V?+$^D*hjdnTKk%Pnb#jBkSM3H?Ad-8&G@9){Yom5S=N<|~e#79*K-9{y z_doi&4y}4q(iTx6or^ip`H;nhpBgI(xIoS_O*G_@f0i=`8F=+T#Jh)QF&01;qmI=E z)`T0sZMrx9o$Oiu_Ucy1eJl?Mp8jj2i=6x?fQgkYMy;$QL1^1hX(2MC&z^`lBz+jt zeNewb6jIfzT9~Tl>PzSROT&9G8VtIVenE+-3{a+zmMPHRRy`71>Mq9!vv?ODX7MNj zSTLAf@wG#KDa$2 zvt>HsP)_cYm%#B(X>S~Ue$J=t`tu6tYMcf}=4^p)I8&LuRU|d9i0?CPc1mX0zs~oI zD0R_XRJ9>l#aj@pi|LJG%lVhS1Ygp8;Hmb8s5-E%%*UH9H+WIV8jMSM@dlaPO+Rcp z`8j`++Kob0>22+KPC6&bx2!#VUTy6*r!gMVA0dStKUX1A92l~_)gNQ?hXYopsUDi3@8ea)nQ8}>qMo>1yfX70~kH-{zUslK-ZJ)C^) znF^28e%>6trwr|%e7OvnD~!(C7mRCsm(uX@k-_-P{9)hbW@U%C*z z>eyo(Nyev|uZ1sSx6VjxC{}6()f~p4co`I{jvxXbsTL|Cv%6{}HGQ-%Yw#15YL_R3 zblv!f5hF8s3|>N%V_G#{^V)whyk9HVl)u@r%nWY=4~`B$6k_;>ftJH}EJ ztzvSuR4xR_3;j52#`y|~ac0|&33JArS}zIXevI697cJRW$NC^6heYf)$evT*HVI=`i&G#)6sm)rJiJalThtyo9xhzeG*1oWh&z!hPWl zrMuf=zm>f5d-_~Nn}5d+6@Hvw*6-%v=}Tg1q5Zr&dQ&{BwD?mlju{eF9^!(h)g9#T=n31LSm(OpQJ3}srzL%Usj~dV>OJ6QrwTpc4W}!HnQ9ASXbAIng zs`Siqb49G|DD1dD|IZlL3Y8D<8O$5TH|>v$8r!h@+)U@K!d1+1D4foxjc;x^yF8^o zB1Kwcc(%hh30psLHKZAmv~SN@?4`+)yU;;&Di zsNYL|8SUWiq4~BrQ$IytM60(vSiXmr=s?yESTg(9m1+GwNcLjk5$!3%q5}p~g}l60 zhjL_EL0uHmwTIbPKPKL~S)>SaI!$Z>wZI=S8lu$QalaK)UQJhCLekD{`ECG3)e<1!%~0z z`QRTWFC^|Ck0Fh34k#bQ9=Y}0c`@Tw^pD`EREwKS3miyMNl3ncca7C&KhsnjGP!=P z*No3^IL+fVUH)D($J_{a+R|Qde3&t^Zs#0+@&a@kO2<8GFo$7X&tvgslDfRgVpd4k z2bP&|_1q6&)@nTK*dI81!K__oZTe9)CFh)|`L+3V-O(9C4-Wq@tjOXcTn?c@_%`ba zb>it_A(;3(m^qZo<0eKPxMNH9bv=d!#SZvOo%5z5v^O#(a&G$T?g4z#>WzpL zogmE?OvP9)d4rfq>k`X*VTW1L{Y5dRy|7D9&F<0)L0(+Gnz^z6onLIy=wgkj(u{Qo z(PDRD^^HofYZCNiyFjG9@3>jZhyr{CtR&4U9f$R|)())Roe*YVcANxH1VBMY={b(KEt#@8MdYli;)F2%PNu}KPoK#peRaE@#+sI>`@zr=t>(R; zp1bs+F!JvK|Hg!C;9ieCmJx0~YMIJ7vC|%T%Goxs6N^AeEHT&$@`AVQETINP;1f;3 zwzg@Re13u5GZQ`;Psh^p&itAmY%fko0 zGJ2e{&OzUnCz^^(=Ay1HUqTu~&Os1^^kzO}yxv0K$3LeRZe=Xl{X{e{mm1uaiq%i@ zyn`8P)-w3Xi!T%I=A^{=97^r4L5>y9_i6!Q_HG^b0+P+Y$9VN(h`AIxy9XH z&zMH*I!pIg#LgZ#5R4{y`N{t(z5I?&EB|il=VRv+*K*$*TJLw-QDB(qgcf-JSs}PR>qfXy*ljH`J6O5 zqdqCx@ug6_iZ?hQy6`y>+w3b$wyJ(oVnfFVIg$948QCer)4Zv)cr%w{jDeFW zj1^_n$z>6{ruq`ie=!ya-~WoZ>v9%rj{7B767<^bsY|ox(|Oo_J4I}|J%{0aA#?S{ z;>8SyOCF1r1d2!UYMd?5wClGN6q#w$6|cz0#fl!d>4S>uA496c0YTxKp*ifn`f>5r zR*6wXKnyhYxFWgzZKSM-a06u7vzc#Z#uhim*R3UJk1gskM;{T6OPI@l*+VDDXD1t+ zLLA0drAx5+4NA{RMFCzDg<$AOMUkDZOfX3YE{hg)ABWm$K9If6kh_k4&Uo_*G4% z3`r#vO6iz?FF}oW(1VZ(GfSe1ko9%OOYDs_9q8(4$Szxi*1Kj>wgFWd*{fia9j&%< z4>Ql&f@m|~O|lIisEq%S+CPbE2ILbbbKtG!z+2&dwk7jk^d7RYH}l!O&~cjV=z#7& z$B6rvGj%WahQDDZ^hckpk}JwMk81iT6NB~6D1K({ymD01gS}p=!0pOKgzwGmvzK~P z`wQ7Hw-c|UeX3b5^><0`mU+{>=0_wZ2jO2# zZFM`Mdq|2#D=V--1>xrC!sbTZBzU`X5@13MmyWU)ixotNPIKlGSt4-`E}wg`oqvs2E^5Sz1?`5GiP@ z;4hQ(D}?M^8$#M3JA_j%Vk0bxUZsY1C)KzLf$&17=Bv@QyF8QBxDzXjnF$|xPz+v1 zR%F&R?w1wCUDIBIFJ^S8CA(f_>Rt=Ma^H$4vtEMK8}Jf7PV8MC>^0wr_JuU(z0AC+ z(mM-{%%^yD^QZbc2UC&b{lq7vqMu&=63zUN*2kuG>ZECAwgY7)GQ$oRs+2aTAtRJCBp-ev~=yUoUHE_IM(gQovLYA<=!4 z!g$Q_IdI_|rRaOCWeP|;#?7{{E8~>qOG*bBPhHHsqUgUOw!%kRLp3=`mQP7t<+Yox z>!v8E_mCUkY;!gl6||O|pg9ar95Po}L%rB$Z8xp3LNtxt|HSYo3B1#oY8?@mzLU-= z8E;lloqJH7{cR1idTGS5v~zOk91Go+>Kk91*RMV!TGW4j+)d*E0w%23ex}s=46<#p zwhLdtswBjlYytDKuj*ie3sNC@E-s%$Q?81aSZthsLR)unzc$9-uT69pTMFyuO1e_) zxs|>A{)}#L&nr#TbBVUgLpAxefBz3t?*Y|R6Lk#}dM5!9DMAPkQ0XNaiUf#CNdPH| zAiXz1nh$7z0BR7G5_%|+5}HVFiin6x2}lHMi??%?~ud&z^%*Ux^B9_+p- zJlJ`ye;`-CHy!hWxNcc?@cpx@-X&(%nxn42nKf8~i58GgPw26}6)J1{%SSe^vZi?d ze)CMaRN=>Ui8CApJ=cec&(2w5V}pX^IKof|pRWgqojo|FsJntt%?I?*fxZ1{et&G- zTUzZ6P{ri)DuC5?AvmI0yGGU^@>VfS5s0Wezu*3|FX7q?5gJB->ztd1XJ5tqxs`6z zxm}(FRTLN=i2YgFIX&GB{U^I%F;@1_L`Usc;5z1<>DMWun0_mMrha!RpAe>0E9iQl zwG+GfyxjKh7MIX}b`K4zvaqk)n#OgcuA_ckXZ4hVGhPSI+;;mPBmNJBKJ#FN*m5@H#n}b+d8XsUQdu8_*jYQa z!&V$dZ!r)$CTy_I>&Oj0UI_}CHvQllr4325vRi@F?-{-A*YEzh zlz?e#`dAoJICE$hV;bfbPk=9=8U!{_Jxq!d~GCy%0Hsef)aAEt2~sD)G6VR55d~#l6W!LqeRyF8m$&kX^SAfzs?=?Gd+U zN7y15AG&V^dUe*0<)2ezc1;uoTde>Es1WUB`7mdX-IsTn{4(p=4Li^rE*1Rx^H_Qo zWS!~gE|2t&W);@14bAc?5MwhjKMM2mZ92e!nv5TrqV(|~_$()gMw zG5IU#CP;8X2M@=pDBvit1PsEy`krv?NdA1J2h;nq0_HM&2HgH18^ zj0@93e@G96FF|w≶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�_oZC!)^Hrha>e5Z=FD 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

    -_)jihBh2xg}xP8Y&(>*~n^hsV*JE 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

      8Wfnwt>XlB&5~bgJ>Vn0tlG=tU6kZns06MM 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૞uWE$pcPuUAa;ts1 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

      >0sIq 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≪b;>(MVl`?Fx;CSG9?Cl!q}z=0^E=J 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 Ys(=hkcp;En;GbnSV6ATo_yzKR0HpJp-2eap diff --git a/src/circumplex/instruments/models.py b/src/circumplex/instruments/models.py index a99b2ac..cef70c3 100644 --- a/src/circumplex/instruments/models.py +++ b/src/circumplex/instruments/models.py @@ -320,8 +320,8 @@ def score( def norm_standardize( self, data: pd.DataFrame, - scales: Iterable[str | int], sample_id: int, + scales: Iterable[str | int] | None = None, prefix: str = "", suffix: str = "_z", *, @@ -333,10 +333,11 @@ def norm_standardize( ---------- data DataFrame containing at least circumplex scales. - scales - The variable names or column numbers for the scales in `data`. sample_id The ID of the normative sample to use for standardization. + scales + The variable names or column numbers for the scales in `data`. If None, + all scales in the instrument are standardized. prefix Prefix to add to standardized scale names. suffix @@ -366,6 +367,8 @@ def norm_standardize( f"'{self.abbrev}'." ) raise ValueError(msg) + if scales is None: + scales = self.scale_abbrevs scores = pd.DataFrame(index=data.index, columns=[], dtype=float) for scale in scales: diff --git a/src/circumplex/utils/__init__.py b/src/circumplex/utils/__init__.py index cdf008b..e9d712c 100644 --- a/src/circumplex/utils/__init__.py +++ b/src/circumplex/utils/__init__.py @@ -6,8 +6,11 @@ QUADRANTS, Degree, Radian, + cosine_form, degrees_to_radians, + octants, radians_to_degrees, + sort_angles, ) from .tidying_functions import ipsatize, norm_standardize, score @@ -17,9 +20,12 @@ "QUADRANTS", "Degree", "Radian", + "cosine_form", "degrees_to_radians", "ipsatize", "norm_standardize", + "octants", "radians_to_degrees", "score", + "sort_angles", ] diff --git a/src/circumplex/utils/angles.py b/src/circumplex/utils/angles.py index 227f17c..22685c3 100644 --- a/src/circumplex/utils/angles.py +++ b/src/circumplex/utils/angles.py @@ -7,7 +7,8 @@ from __future__ import annotations -from typing import TYPE_CHECKING +from enum import IntEnum, auto +from typing import TYPE_CHECKING, Any import numpy as np @@ -39,6 +40,48 @@ """ +class AngleStart(IntEnum): + """Enumeration for angle starting positions.""" + + EAST = 0 # 0 degrees + NE = auto() # 45 degrees + NORTH = auto() # 90 degrees + NW = auto() # 135 degrees + WEST = auto() # 180 degrees + SW = auto() # 225 degrees + SOUTH = auto() # 270 degrees + SE = auto() # 315 degrees + + +def octants(start: AngleStart | int = AngleStart.EAST) -> NDArray[Shape["8"], Float]: + """Get octant angles starting from a specified position. + + Parameters + ---------- + start + Starting position for the octants (default is 90 degrees). + + Returns + ------- + np.ndarray + Array of octant angles in degrees starting from the specified position. + + Examples + -------- + >>> octants(AngleStart.ONE) + array([ 0., 45., 90., 135., 180., 225., 270., 315.]) + >>> octants(AngleStart.FIVE) + array([180., 225., 270., 315., 0., 45., 90., 135.]) + + """ + if isinstance(start, int): + start = AngleStart(start) + + base_angles = np.array([0, 45, 90, 135, 180, 225, 270, 315], dtype=float) + start_index = start + return np.roll(base_angles, -start_index) + + class Degree(float): """Angular measurement in degrees. @@ -139,3 +182,38 @@ def radians_to_degrees(radians: float | np.ndarray) -> float | np.ndarray: """ return np.degrees(radians) + + +def cosine_form( + theta: NDArray[Shape[Any], Float], ampl: float, disp: float, elev: float +) -> NDArray[Shape[Any], Float]: + """ + Cosine function with amplitude, displacement and elevation parameters. + + This is the mathematical model used in the Structural Summary Method. + + Parameters + ---------- + theta + Angular positions in radians. + ampl + Amplitude of the cosine curve. + disp + Angular displacement in radians. + elev + Elevation (mean level) of the cosine curve. + + Returns + ------- + np.ndarray + Predicted values at each theta position. + """ + return elev + ampl * np.cos(theta - disp) + + +def sort_angles( + angles: NDArray[Shape[Any], Float], scores: NDArray[Shape[Any], Float] +) -> tuple[NDArray[Shape[Any], Float], NDArray[Shape[Any], Float]]: + """Sort angles and corresponding scores in ascending order.""" + sorted_indices = np.argsort(angles) + return np.array(angles)[sorted_indices], np.array(scores)[sorted_indices] diff --git a/src/circumplex/utils/tidying_functions.py b/src/circumplex/utils/tidying_functions.py index 81fa515..7edbbc0 100644 --- a/src/circumplex/utils/tidying_functions.py +++ b/src/circumplex/utils/tidying_functions.py @@ -157,9 +157,9 @@ def score( def norm_standardize( data: pd.DataFrame, - scales: Iterable[str | int], instrument: Instrument | str, sample_id: int, + scales: Iterable[str | int] | None = None, prefix: str = "", suffix: str = "_z", *, @@ -206,7 +206,7 @@ def norm_standardize( if isinstance(scales, str): msg = "Input 'scales' must be a sequence of column names." raise TypeError(msg) - if not isinstance(scales, Iterable): + if not isinstance(scales, Iterable) and scales is not None: msg = "Input 'scales' must be a sequence of column names or indices." raise TypeError(msg) @@ -219,8 +219,8 @@ def norm_standardize( return instrument.norm_standardize( data, - scales, int(sample_id), + scales=scales, prefix=prefix, suffix=suffix, append=append, diff --git a/tests/test_tidying_functions.py b/tests/test_tidying_functions.py index c5074b8..5ff8b9f 100644 --- a/tests/test_tidying_functions.py +++ b/tests/test_tidying_functions.py @@ -229,7 +229,12 @@ def test_norm_standardize_invalid_scales_type(self): """Test that non-iterable scales raises TypeError.""" data = pd.DataFrame({"scale1": [1, 2]}) with pytest.raises(TypeError, match="Input 'scales' must be a sequence"): - norm_standardize(data, "scale1", "csig", 1) + norm_standardize( + data, + "csig", + 1, + scales="scale1", + ) def test_norm_standardize_invalid_instrument_type(self): """Test that invalid instrument type raises TypeError.""" @@ -237,7 +242,7 @@ def test_norm_standardize_invalid_instrument_type(self): with pytest.raises( TypeError, match="Input 'instrument' must be an Instrument instance" ): - norm_standardize(data, ["scale1"], 123, 1) # type: ignore[invalid-argument-type] + norm_standardize(data, 123, 1, scales=["scale1"]) # type: ignore[invalid-argument-type] def test_norm_standardize_delegates_to_instrument(self): """Test norm_standardize delegates to instrument.norm_standardize method.""" @@ -252,9 +257,9 @@ def test_norm_standardize_delegates_to_instrument(self): result = norm_standardize( data, - ["scale1", "scale2"], mock_instrument, 1, + scales=["scale1", "scale2"], prefix="pre_", suffix="_post", append=False, @@ -262,8 +267,8 @@ def test_norm_standardize_delegates_to_instrument(self): mock_instrument.norm_standardize.assert_called_once_with( data, - ["scale1", "scale2"], 1, + scales=["scale1", "scale2"], prefix="pre_", suffix="_post", append=False, @@ -278,9 +283,14 @@ def test_norm_standardize_converts_sample_id_to_int(self): {"scale1_z": [-1.0, 1.0]} ) - norm_standardize(data, ["scale1"], mock_instrument, "1") # type: ignore[invalid-argument-type] + norm_standardize( + data, + mock_instrument, + "1", # type: ignore[invalid-argument-type] + scales=["scale1"], + ) # Check that int(sample_id) was passed call_args = mock_instrument.norm_standardize.call_args - assert call_args[0][2] == 1 - assert isinstance(call_args[0][2], int) + assert call_args[0][1] == 1 + assert isinstance(call_args[0][1], int) From 3479f57454cf9e4889cc7c8358cb7d2fcfa86a64 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:09:49 +0000 Subject: [PATCH 93/97] Add Python version specification file --- .python-version | 1 + 1 file changed, 1 insertion(+) create mode 100644 .python-version diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 From 77a4c16fd931ea9e807f805668b41333148e4f5f Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:14:43 +0000 Subject: [PATCH 94/97] Fix item retrieval logic in Instrument class and refine scale type checks --- src/circumplex/instruments/models.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/circumplex/instruments/models.py b/src/circumplex/instruments/models.py index cef70c3..671d57b 100644 --- a/src/circumplex/instruments/models.py +++ b/src/circumplex/instruments/models.py @@ -208,7 +208,7 @@ def info_scales( scale_branch = tree.add( f"{scale.abbrev} ({scale.angle}°): {scale.label}" ) - if items: + if items and self.items is not None: for item_id in scale.items: scale_branch.add( f"[dim]{item_id}. {self.items[item_id - 1].text}" @@ -218,7 +218,7 @@ def info_scales( text = [f"The {self.abbrev} contains {self.n_scales} scales:"] for scale in self.scales: text.append(f" {scale.abbrev}: {scale.label} ({scale.angle}°)") - if items: + if items and self.items is not None: for item_id in scale.items: text.append(f" {item_id}. {self.items[item_id - 1].text}") return "\n".join(text) @@ -372,7 +372,7 @@ def norm_standardize( scores = pd.DataFrame(index=data.index, columns=[], dtype=float) for scale in scales: - if isinstance(scale, (int, np.integer, float, np.floating)): + if isinstance(scale, (int, np.integer)): scale_abbrev = self.scales[scale].abbrev else: scale_abbrev = scale From aa942d00f053810b8d70644e2ebe4181fe14b259 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:16:32 +0000 Subject: [PATCH 95/97] Remove LICENSE.md file as part of project restructuring --- LICENSE | 624 ++++++++++++++++++++++++++++++++++++++++++++++++++--- LICENSE.md | 595 -------------------------------------------------- 2 files changed, 595 insertions(+), 624 deletions(-) delete mode 100644 LICENSE.md diff --git a/LICENSE b/LICENSE index 089e1dc..64441c7 100644 --- a/LICENSE +++ b/LICENSE @@ -1,29 +1,595 @@ -BSD 3-Clause License - -Copyright (c) 2024, Andrew Mitchell -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -3. Neither the name of the copyright holder nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +GNU General Public License +========================== + +_Version 3, 29 June 2007_ +_Copyright © 2007 Free Software Foundation, Inc. <>_ + +Everyone is permitted to copy and distribute verbatim copies of this license +document, but changing it is not allowed. + +## Preamble + +The GNU General Public License is a free, copyleft license for software and other +kinds of works. + +The licenses for most software and other practical works are designed to take away +your freedom to share and change the works. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change all versions of a +program--to make sure it remains free software for all its users. We, the Free +Software Foundation, use the GNU General Public License for most of our software; it +applies also to any other work released this way by its authors. You can apply it to +your programs, too. + +When we speak of free software, we are referring to freedom, not price. Our General +Public Licenses are designed to make sure that you have the freedom to distribute +copies of free software (and charge for them if you wish), that you receive source +code or can get it if you want it, that you can change the software or use pieces of +it in new free programs, and that you know you can do these things. + +To protect your rights, we need to prevent others from denying you these rights or +asking you to surrender the rights. Therefore, you have certain responsibilities if +you distribute copies of the software, or if you modify it: responsibilities to +respect the freedom of others. + +For example, if you distribute copies of such a program, whether gratis or for a fee, +you must pass on to the recipients the same freedoms that you received. You must make +sure that they, too, receive or can get the source code. And you must show them these +terms so they know their rights. + +Developers that use the GNU GPL protect your rights with two steps: **(1)** assert +copyright on the software, and **(2)** offer you this License giving you legal permission +to copy, distribute and/or modify it. + +For the developers' and authors' protection, the GPL clearly explains that there is +no warranty for this free software. For both users' and authors' sake, the GPL +requires that modified versions be marked as changed, so that their problems will not +be attributed erroneously to authors of previous versions. + +Some devices are designed to deny users access to install or run modified versions of +the software inside them, although the manufacturer can do so. This is fundamentally +incompatible with the aim of protecting users' freedom to change the software. The +systematic pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we have designed +this version of the GPL to prohibit the practice for those products. If such problems +arise substantially in other domains, we stand ready to extend this provision to +those domains in future versions of the GPL, as needed to protect the freedom of +users. + +Finally, every program is threatened constantly by software patents. States should +not allow patents to restrict development and use of software on general-purpose +computers, but in those that do, we wish to avoid the special danger that patents +applied to a free program could make it effectively proprietary. To prevent this, the +GPL assures that patents cannot be used to render the program non-free. + +The precise terms and conditions for copying, distribution and modification follow. + +## TERMS AND CONDITIONS + +### 0. Definitions + +“This License” refers to version 3 of the GNU General Public License. + +“Copyright” also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + +“The Program” refers to any copyrightable work licensed under this +License. Each licensee is addressed as “you”. “Licensees” and +“recipients” may be individuals or organizations. + +To “modify” a work means to copy from or adapt all or part of the work in +a fashion requiring copyright permission, other than the making of an exact copy. The +resulting work is called a “modified version” of the earlier work or a +work “based on” the earlier work. + +A “covered work” means either the unmodified Program or a work based on +the Program. + +To “propagate” a work means to do anything with it that, without +permission, would make you directly or secondarily liable for infringement under +applicable copyright law, except executing it on a computer or modifying a private +copy. Propagation includes copying, distribution (with or without modification), +making available to the public, and in some countries other activities as well. + +To “convey” a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through a computer +network, with no transfer of a copy, is not conveying. + +An interactive user interface displays “Appropriate Legal Notices” to the +extent that it includes a convenient and prominently visible feature that **(1)** +displays an appropriate copyright notice, and **(2)** tells the user that there is no +warranty for the work (except to the extent that warranties are provided), that +licensees may convey the work under this License, and how to view a copy of this +License. If the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + +### 1. Source Code + +The “source code” for a work means the preferred form of the work for +making modifications to it. “Object code” means any non-source form of a +work. + +A “Standard Interface” means an interface that either is an official +standard defined by a recognized standards body, or, in the case of interfaces +specified for a particular programming language, one that is widely used among +developers working in that language. + +The “System Libraries” of an executable work include anything, other than +the work as a whole, that **(a)** is included in the normal form of packaging a Major +Component, but which is not part of that Major Component, and **(b)** serves only to +enable use of the work with that Major Component, or to implement a Standard +Interface for which an implementation is available to the public in source code form. +A “Major Component”, in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system (if any) on which +the executable work runs, or a compiler used to produce the work, or an object code +interpreter used to run it. + +The “Corresponding Source” for a work in object code form means all the +source code needed to generate, install, and (for an executable work) run the object +code and to modify the work, including scripts to control those activities. However, +it does not include the work's System Libraries, or general-purpose tools or +generally available free programs which are used unmodified in performing those +activities but which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for the work, and +the source code for shared libraries and dynamically linked subprograms that the work +is specifically designed to require, such as by intimate data communication or +control flow between those subprograms and other parts of the work. + +The Corresponding Source need not include anything that users can regenerate +automatically from other parts of the Corresponding Source. + +The Corresponding Source for a work in source code form is that same work. + +### 2. Basic Permissions + +All rights granted under this License are granted for the term of copyright on the +Program, and are irrevocable provided the stated conditions are met. This License +explicitly affirms your unlimited permission to run the unmodified Program. The +output from running a covered work is covered by this License only if the output, +given its content, constitutes a covered work. This License acknowledges your rights +of fair use or other equivalent, as provided by copyright law. + +You may make, run and propagate covered works that you do not convey, without +conditions so long as your license otherwise remains in force. You may convey covered +works to others for the sole purpose of having them make modifications exclusively +for you, or provide you with facilities for running those works, provided that you +comply with the terms of this License in conveying all material for which you do not +control copyright. Those thus making or running the covered works for you must do so +exclusively on your behalf, under your direction and control, on terms that prohibit +them from making any copies of your copyrighted material outside their relationship +with you. + +Conveying under any other circumstances is permitted solely under the conditions +stated below. Sublicensing is not allowed; section 10 makes it unnecessary. + +### 3. Protecting Users' Legal Rights From Anti-Circumvention Law + +No covered work shall be deemed part of an effective technological measure under any +applicable law fulfilling obligations under article 11 of the WIPO copyright treaty +adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention +of such measures. + +When you convey a covered work, you waive any legal power to forbid circumvention of +technological measures to the extent such circumvention is effected by exercising +rights under this License with respect to the covered work, and you disclaim any +intention to limit operation or modification of the work as a means of enforcing, +against the work's users, your or third parties' legal rights to forbid circumvention +of technological measures. + +### 4. Conveying Verbatim Copies + +You may convey verbatim copies of the Program's source code as you receive it, in any +medium, provided that you conspicuously and appropriately publish on each copy an +appropriate copyright notice; keep intact all notices stating that this License and +any non-permissive terms added in accord with section 7 apply to the code; keep +intact all notices of the absence of any warranty; and give all recipients a copy of +this License along with the Program. + +You may charge any price or no price for each copy that you convey, and you may offer +support or warranty protection for a fee. + +### 5. Conveying Modified Source Versions + +You may convey a work based on the Program, or the modifications to produce it from +the Program, in the form of source code under the terms of section 4, provided that +you also meet all of these conditions: + +* **a)** The work must carry prominent notices stating that you modified it, and giving a +relevant date. +* **b)** The work must carry prominent notices stating that it is released under this +License and any conditions added under section 7. This requirement modifies the +requirement in section 4 to “keep intact all notices”. +* **c)** You must license the entire work, as a whole, under this License to anyone who +comes into possession of a copy. This License will therefore apply, along with any +applicable section 7 additional terms, to the whole of the work, and all its parts, +regardless of how they are packaged. This License gives no permission to license the +work in any other way, but it does not invalidate such permission if you have +separately received it. +* **d)** If the work has interactive user interfaces, each must display Appropriate Legal +Notices; however, if the Program has interactive interfaces that do not display +Appropriate Legal Notices, your work need not make them do so. + +A compilation of a covered work with other separate and independent works, which are +not by their nature extensions of the covered work, and which are not combined with +it such as to form a larger program, in or on a volume of a storage or distribution +medium, is called an “aggregate” if the compilation and its resulting +copyright are not used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work in an aggregate +does not cause this License to apply to the other parts of the aggregate. + +### 6. Conveying Non-Source Forms + +You may convey a covered work in object code form under the terms of sections 4 and +5, provided that you also convey the machine-readable Corresponding Source under the +terms of this License, in one of these ways: + +* **a)** Convey the object code in, or embodied in, a physical product (including a +physical distribution medium), accompanied by the Corresponding Source fixed on a +durable physical medium customarily used for software interchange. +* **b)** Convey the object code in, or embodied in, a physical product (including a +physical distribution medium), accompanied by a written offer, valid for at least +three years and valid for as long as you offer spare parts or customer support for +that product model, to give anyone who possesses the object code either **(1)** a copy of +the Corresponding Source for all the software in the product that is covered by this +License, on a durable physical medium customarily used for software interchange, for +a price no more than your reasonable cost of physically performing this conveying of +source, or **(2)** access to copy the Corresponding Source from a network server at no +charge. +* **c)** Convey individual copies of the object code with a copy of the written offer to +provide the Corresponding Source. This alternative is allowed only occasionally and +noncommercially, and only if you received the object code with such an offer, in +accord with subsection 6b. +* **d)** Convey the object code by offering access from a designated place (gratis or for +a charge), and offer equivalent access to the Corresponding Source in the same way +through the same place at no further charge. You need not require recipients to copy +the Corresponding Source along with the object code. If the place to copy the object +code is a network server, the Corresponding Source may be on a different server +(operated by you or a third party) that supports equivalent copying facilities, +provided you maintain clear directions next to the object code saying where to find +the Corresponding Source. Regardless of what server hosts the Corresponding Source, +you remain obligated to ensure that it is available for as long as needed to satisfy +these requirements. +* **e)** Convey the object code using peer-to-peer transmission, provided you inform +other peers where the object code and Corresponding Source of the work are being +offered to the general public at no charge under subsection 6d. + +A separable portion of the object code, whose source code is excluded from the +Corresponding Source as a System Library, need not be included in conveying the +object code work. + +A “User Product” is either **(1)** a “consumer product”, which +means any tangible personal property which is normally used for personal, family, or +household purposes, or **(2)** anything designed or sold for incorporation into a +dwelling. In determining whether a product is a consumer product, doubtful cases +shall be resolved in favor of coverage. For a particular product received by a +particular user, “normally used” refers to a typical or common use of +that class of product, regardless of the status of the particular user or of the way +in which the particular user actually uses, or expects or is expected to use, the +product. A product is a consumer product regardless of whether the product has +substantial commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + +“Installation Information” for a User Product means any methods, +procedures, authorization keys, or other information required to install and execute +modified versions of a covered work in that User Product from a modified version of +its Corresponding Source. The information must suffice to ensure that the continued +functioning of the modified object code is in no case prevented or interfered with +solely because modification has been made. + +If you convey an object code work under this section in, or with, or specifically for +use in, a User Product, and the conveying occurs as part of a transaction in which +the right of possession and use of the User Product is transferred to the recipient +in perpetuity or for a fixed term (regardless of how the transaction is +characterized), the Corresponding Source conveyed under this section must be +accompanied by the Installation Information. But this requirement does not apply if +neither you nor any third party retains the ability to install modified object code +on the User Product (for example, the work has been installed in ROM). + +The requirement to provide Installation Information does not include a requirement to +continue to provide support service, warranty, or updates for a work that has been +modified or installed by the recipient, or for the User Product in which it has been +modified or installed. Access to a network may be denied when the modification itself +materially and adversely affects the operation of the network or violates the rules +and protocols for communication across the network. + +Corresponding Source conveyed, and Installation Information provided, in accord with +this section must be in a format that is publicly documented (and with an +implementation available to the public in source code form), and must require no +special password or key for unpacking, reading or copying. + +### 7. Additional Terms + +“Additional permissions” are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. Additional +permissions that are applicable to the entire Program shall be treated as though they +were included in this License, to the extent that they are valid under applicable +law. If additional permissions apply only to part of the Program, that part may be +used separately under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + +When you convey a copy of a covered work, you may at your option remove any +additional permissions from that copy, or from any part of it. (Additional +permissions may be written to require their own removal in certain cases when you +modify the work.) You may place additional permissions on material, added by you to a +covered work, for which you have or can give appropriate copyright permission. + +Notwithstanding any other provision of this License, for material you add to a +covered work, you may (if authorized by the copyright holders of that material) +supplement the terms of this License with terms: + +* **a)** Disclaiming warranty or limiting liability differently from the terms of +sections 15 and 16 of this License; or +* **b)** Requiring preservation of specified reasonable legal notices or author +attributions in that material or in the Appropriate Legal Notices displayed by works +containing it; or +* **c)** Prohibiting misrepresentation of the origin of that material, or requiring that +modified versions of such material be marked in reasonable ways as different from the +original version; or +* **d)** Limiting the use for publicity purposes of names of licensors or authors of the +material; or +* **e)** Declining to grant rights under trademark law for use of some trade names, +trademarks, or service marks; or +* **f)** Requiring indemnification of licensors and authors of that material by anyone +who conveys the material (or modified versions of it) with contractual assumptions of +liability to the recipient, for any liability that these contractual assumptions +directly impose on those licensors and authors. + +All other non-permissive additional terms are considered “further +restrictions” within the meaning of section 10. If the Program as you received +it, or any part of it, contains a notice stating that it is governed by this License +along with a term that is a further restriction, you may remove that term. If a +license document contains a further restriction but permits relicensing or conveying +under this License, you may add to a covered work material governed by the terms of +that license document, provided that the further restriction does not survive such +relicensing or conveying. + +If you add terms to a covered work in accord with this section, you must place, in +the relevant source files, a statement of the additional terms that apply to those +files, or a notice indicating where to find the applicable terms. + +Additional terms, permissive or non-permissive, may be stated in the form of a +separately written license, or stated as exceptions; the above requirements apply +either way. + +### 8. Termination + +You may not propagate or modify a covered work except as expressly provided under +this License. Any attempt otherwise to propagate or modify it is void, and will +automatically terminate your rights under this License (including any patent licenses +granted under the third paragraph of section 11). + +However, if you cease all violation of this License, then your license from a +particular copyright holder is reinstated **(a)** provisionally, unless and until the +copyright holder explicitly and finally terminates your license, and **(b)** permanently, +if the copyright holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + +Moreover, your license from a particular copyright holder is reinstated permanently +if the copyright holder notifies you of the violation by some reasonable means, this +is the first time you have received notice of violation of this License (for any +work) from that copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + +Termination of your rights under this section does not terminate the licenses of +parties who have received copies or rights from you under this License. If your +rights have been terminated and not permanently reinstated, you do not qualify to +receive new licenses for the same material under section 10. + +### 9. Acceptance Not Required for Having Copies + +You are not required to accept this License in order to receive or run a copy of the +Program. Ancillary propagation of a covered work occurring solely as a consequence of +using peer-to-peer transmission to receive a copy likewise does not require +acceptance. However, nothing other than this License grants you permission to +propagate or modify any covered work. These actions infringe copyright if you do not +accept this License. Therefore, by modifying or propagating a covered work, you +indicate your acceptance of this License to do so. + +### 10. Automatic Licensing of Downstream Recipients + +Each time you convey a covered work, the recipient automatically receives a license +from the original licensors, to run, modify and propagate that work, subject to this +License. You are not responsible for enforcing compliance by third parties with this +License. + +An “entity transaction” is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an organization, or +merging organizations. If propagation of a covered work results from an entity +transaction, each party to that transaction who receives a copy of the work also +receives whatever licenses to the work the party's predecessor in interest had or +could give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if the predecessor +has it or can get it with reasonable efforts. + +You may not impose any further restrictions on the exercise of the rights granted or +affirmed under this License. For example, you may not impose a license fee, royalty, +or other charge for exercise of rights granted under this License, and you may not +initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging +that any patent claim is infringed by making, using, selling, offering for sale, or +importing the Program or any portion of it. + +### 11. Patents + +A “contributor” is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The work thus +licensed is called the contributor's “contributor version”. + +A contributor's “essential patent claims” are all patent claims owned or +controlled by the contributor, whether already acquired or hereafter acquired, that +would be infringed by some manner, permitted by this License, of making, using, or +selling its contributor version, but do not include claims that would be infringed +only as a consequence of further modification of the contributor version. For +purposes of this definition, “control” includes the right to grant patent +sublicenses in a manner consistent with the requirements of this License. + +Each contributor grants you a non-exclusive, worldwide, royalty-free patent license +under the contributor's essential patent claims, to make, use, sell, offer for sale, +import and otherwise run, modify and propagate the contents of its contributor +version. + +In the following three paragraphs, a “patent license” is any express +agreement or commitment, however denominated, not to enforce a patent (such as an +express permission to practice a patent or covenant not to sue for patent +infringement). To “grant” such a patent license to a party means to make +such an agreement or commitment not to enforce a patent against the party. + +If you convey a covered work, knowingly relying on a patent license, and the +Corresponding Source of the work is not available for anyone to copy, free of charge +and under the terms of this License, through a publicly available network server or +other readily accessible means, then you must either **(1)** cause the Corresponding +Source to be so available, or **(2)** arrange to deprive yourself of the benefit of the +patent license for this particular work, or **(3)** arrange, in a manner consistent with +the requirements of this License, to extend the patent license to downstream +recipients. “Knowingly relying” means you have actual knowledge that, but +for the patent license, your conveying the covered work in a country, or your +recipient's use of the covered work in a country, would infringe one or more +identifiable patents in that country that you have reason to believe are valid. + +If, pursuant to or in connection with a single transaction or arrangement, you +convey, or propagate by procuring conveyance of, a covered work, and grant a patent +license to some of the parties receiving the covered work authorizing them to use, +propagate, modify or convey a specific copy of the covered work, then the patent +license you grant is automatically extended to all recipients of the covered work and +works based on it. + +A patent license is “discriminatory” if it does not include within the +scope of its coverage, prohibits the exercise of, or is conditioned on the +non-exercise of one or more of the rights that are specifically granted under this +License. You may not convey a covered work if you are a party to an arrangement with +a third party that is in the business of distributing software, under which you make +payment to the third party based on the extent of your activity of conveying the +work, and under which the third party grants, to any of the parties who would receive +the covered work from you, a discriminatory patent license **(a)** in connection with +copies of the covered work conveyed by you (or copies made from those copies), or **(b)** +primarily for and in connection with specific products or compilations that contain +the covered work, unless you entered into that arrangement, or that patent license +was granted, prior to 28 March 2007. + +Nothing in this License shall be construed as excluding or limiting any implied +license or other defenses to infringement that may otherwise be available to you +under applicable patent law. + +### 12. No Surrender of Others' Freedom + +If conditions are imposed on you (whether by court order, agreement or otherwise) +that contradict the conditions of this License, they do not excuse you from the +conditions of this License. If you cannot convey a covered work so as to satisfy +simultaneously your obligations under this License and any other pertinent +obligations, then as a consequence you may not convey it at all. For example, if you +agree to terms that obligate you to collect a royalty for further conveying from +those to whom you convey the Program, the only way you could satisfy both those terms +and this License would be to refrain entirely from conveying the Program. + +### 13. Use with the GNU Affero General Public License + +Notwithstanding any other provision of this License, you have permission to link or +combine any covered work with a work licensed under version 3 of the GNU Affero +General Public License into a single combined work, and to convey the resulting work. +The terms of this License will continue to apply to the part which is the covered +work, but the special requirements of the GNU Affero General Public License, section +13, concerning interaction through a network will apply to the combination as such. + +### 14. Revised Versions of this License + +The Free Software Foundation may publish revised and/or new versions of the GNU +General Public License from time to time. Such new versions will be similar in spirit +to the present version, but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Program specifies that +a certain numbered version of the GNU General Public License “or any later +version” applies to it, you have the option of following the terms and +conditions either of that numbered version or of any later version published by the +Free Software Foundation. If the Program does not specify a version number of the GNU +General Public License, you may choose any version ever published by the Free +Software Foundation. + +If the Program specifies that a proxy can decide which future versions of the GNU +General Public License can be used, that proxy's public statement of acceptance of a +version permanently authorizes you to choose that version for the Program. + +Later license versions may give you additional or different permissions. However, no +additional obligations are imposed on any author or copyright holder as a result of +your choosing to follow a later version. + +### 15. Disclaimer of Warranty + +THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER +EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE +QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE +DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + +### 16. Limitation of Liability + +IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY +COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS +PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, +INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE +OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE +WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + +### 17. Interpretation of Sections 15 and 16 + +If the disclaimer of warranty and limitation of liability provided above cannot be +given local legal effect according to their terms, reviewing courts shall apply local +law that most closely approximates an absolute waiver of all civil liability in +connection with the Program, unless a warranty or assumption of liability accompanies +a copy of the Program in return for a fee. + +_END OF TERMS AND CONDITIONS_ + +## How to Apply These Terms to Your New Programs + +If you develop a new program, and you want it to be of the greatest possible use to +the public, the best way to achieve this is to make it free software which everyone +can redistribute and change under these terms. + +To do so, attach the following notices to the program. It is safest to attach them +to the start of each source file to most effectively state the exclusion of warranty; +and each file should have at least the “copyright” line and a pointer to +where the full notice is found. + + + Copyright (C) 2018 Jeffrey Girard + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + +If the program does terminal interaction, make it output a short notice like this +when it starts in an interactive mode: + + ssm Copyright (C) 2018 Jeffrey Girard + This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type 'show c' for details. + +The hypothetical commands `show w` and `show c` should show the appropriate parts of +the General Public License. Of course, your program's commands might be different; +for a GUI interface, you would use an “about box”. + +You should also get your employer (if you work as a programmer) or school, if any, to +sign a “copyright disclaimer” for the program, if necessary. For more +information on this, and how to apply and follow the GNU GPL, see +<>. + +The GNU General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may consider it +more useful to permit linking proprietary applications with the library. If this is +what you want to do, use the GNU Lesser General Public License instead of this +License. But first, please read +<>. diff --git a/LICENSE.md b/LICENSE.md deleted file mode 100644 index 64441c7..0000000 --- a/LICENSE.md +++ /dev/null @@ -1,595 +0,0 @@ -GNU General Public License -========================== - -_Version 3, 29 June 2007_ -_Copyright © 2007 Free Software Foundation, Inc. <>_ - -Everyone is permitted to copy and distribute verbatim copies of this license -document, but changing it is not allowed. - -## Preamble - -The GNU General Public License is a free, copyleft license for software and other -kinds of works. - -The licenses for most software and other practical works are designed to take away -your freedom to share and change the works. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change all versions of a -program--to make sure it remains free software for all its users. We, the Free -Software Foundation, use the GNU General Public License for most of our software; it -applies also to any other work released this way by its authors. You can apply it to -your programs, too. - -When we speak of free software, we are referring to freedom, not price. Our General -Public Licenses are designed to make sure that you have the freedom to distribute -copies of free software (and charge for them if you wish), that you receive source -code or can get it if you want it, that you can change the software or use pieces of -it in new free programs, and that you know you can do these things. - -To protect your rights, we need to prevent others from denying you these rights or -asking you to surrender the rights. Therefore, you have certain responsibilities if -you distribute copies of the software, or if you modify it: responsibilities to -respect the freedom of others. - -For example, if you distribute copies of such a program, whether gratis or for a fee, -you must pass on to the recipients the same freedoms that you received. You must make -sure that they, too, receive or can get the source code. And you must show them these -terms so they know their rights. - -Developers that use the GNU GPL protect your rights with two steps: **(1)** assert -copyright on the software, and **(2)** offer you this License giving you legal permission -to copy, distribute and/or modify it. - -For the developers' and authors' protection, the GPL clearly explains that there is -no warranty for this free software. For both users' and authors' sake, the GPL -requires that modified versions be marked as changed, so that their problems will not -be attributed erroneously to authors of previous versions. - -Some devices are designed to deny users access to install or run modified versions of -the software inside them, although the manufacturer can do so. This is fundamentally -incompatible with the aim of protecting users' freedom to change the software. The -systematic pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we have designed -this version of the GPL to prohibit the practice for those products. If such problems -arise substantially in other domains, we stand ready to extend this provision to -those domains in future versions of the GPL, as needed to protect the freedom of -users. - -Finally, every program is threatened constantly by software patents. States should -not allow patents to restrict development and use of software on general-purpose -computers, but in those that do, we wish to avoid the special danger that patents -applied to a free program could make it effectively proprietary. To prevent this, the -GPL assures that patents cannot be used to render the program non-free. - -The precise terms and conditions for copying, distribution and modification follow. - -## TERMS AND CONDITIONS - -### 0. Definitions - -“This License” refers to version 3 of the GNU General Public License. - -“Copyright” also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - -“The Program” refers to any copyrightable work licensed under this -License. Each licensee is addressed as “you”. “Licensees” and -“recipients” may be individuals or organizations. - -To “modify” a work means to copy from or adapt all or part of the work in -a fashion requiring copyright permission, other than the making of an exact copy. The -resulting work is called a “modified version” of the earlier work or a -work “based on” the earlier work. - -A “covered work” means either the unmodified Program or a work based on -the Program. - -To “propagate” a work means to do anything with it that, without -permission, would make you directly or secondarily liable for infringement under -applicable copyright law, except executing it on a computer or modifying a private -copy. Propagation includes copying, distribution (with or without modification), -making available to the public, and in some countries other activities as well. - -To “convey” a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through a computer -network, with no transfer of a copy, is not conveying. - -An interactive user interface displays “Appropriate Legal Notices” to the -extent that it includes a convenient and prominently visible feature that **(1)** -displays an appropriate copyright notice, and **(2)** tells the user that there is no -warranty for the work (except to the extent that warranties are provided), that -licensees may convey the work under this License, and how to view a copy of this -License. If the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - -### 1. Source Code - -The “source code” for a work means the preferred form of the work for -making modifications to it. “Object code” means any non-source form of a -work. - -A “Standard Interface” means an interface that either is an official -standard defined by a recognized standards body, or, in the case of interfaces -specified for a particular programming language, one that is widely used among -developers working in that language. - -The “System Libraries” of an executable work include anything, other than -the work as a whole, that **(a)** is included in the normal form of packaging a Major -Component, but which is not part of that Major Component, and **(b)** serves only to -enable use of the work with that Major Component, or to implement a Standard -Interface for which an implementation is available to the public in source code form. -A “Major Component”, in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system (if any) on which -the executable work runs, or a compiler used to produce the work, or an object code -interpreter used to run it. - -The “Corresponding Source” for a work in object code form means all the -source code needed to generate, install, and (for an executable work) run the object -code and to modify the work, including scripts to control those activities. However, -it does not include the work's System Libraries, or general-purpose tools or -generally available free programs which are used unmodified in performing those -activities but which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for the work, and -the source code for shared libraries and dynamically linked subprograms that the work -is specifically designed to require, such as by intimate data communication or -control flow between those subprograms and other parts of the work. - -The Corresponding Source need not include anything that users can regenerate -automatically from other parts of the Corresponding Source. - -The Corresponding Source for a work in source code form is that same work. - -### 2. Basic Permissions - -All rights granted under this License are granted for the term of copyright on the -Program, and are irrevocable provided the stated conditions are met. This License -explicitly affirms your unlimited permission to run the unmodified Program. The -output from running a covered work is covered by this License only if the output, -given its content, constitutes a covered work. This License acknowledges your rights -of fair use or other equivalent, as provided by copyright law. - -You may make, run and propagate covered works that you do not convey, without -conditions so long as your license otherwise remains in force. You may convey covered -works to others for the sole purpose of having them make modifications exclusively -for you, or provide you with facilities for running those works, provided that you -comply with the terms of this License in conveying all material for which you do not -control copyright. Those thus making or running the covered works for you must do so -exclusively on your behalf, under your direction and control, on terms that prohibit -them from making any copies of your copyrighted material outside their relationship -with you. - -Conveying under any other circumstances is permitted solely under the conditions -stated below. Sublicensing is not allowed; section 10 makes it unnecessary. - -### 3. Protecting Users' Legal Rights From Anti-Circumvention Law - -No covered work shall be deemed part of an effective technological measure under any -applicable law fulfilling obligations under article 11 of the WIPO copyright treaty -adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention -of such measures. - -When you convey a covered work, you waive any legal power to forbid circumvention of -technological measures to the extent such circumvention is effected by exercising -rights under this License with respect to the covered work, and you disclaim any -intention to limit operation or modification of the work as a means of enforcing, -against the work's users, your or third parties' legal rights to forbid circumvention -of technological measures. - -### 4. Conveying Verbatim Copies - -You may convey verbatim copies of the Program's source code as you receive it, in any -medium, provided that you conspicuously and appropriately publish on each copy an -appropriate copyright notice; keep intact all notices stating that this License and -any non-permissive terms added in accord with section 7 apply to the code; keep -intact all notices of the absence of any warranty; and give all recipients a copy of -this License along with the Program. - -You may charge any price or no price for each copy that you convey, and you may offer -support or warranty protection for a fee. - -### 5. Conveying Modified Source Versions - -You may convey a work based on the Program, or the modifications to produce it from -the Program, in the form of source code under the terms of section 4, provided that -you also meet all of these conditions: - -* **a)** The work must carry prominent notices stating that you modified it, and giving a -relevant date. -* **b)** The work must carry prominent notices stating that it is released under this -License and any conditions added under section 7. This requirement modifies the -requirement in section 4 to “keep intact all notices”. -* **c)** You must license the entire work, as a whole, under this License to anyone who -comes into possession of a copy. This License will therefore apply, along with any -applicable section 7 additional terms, to the whole of the work, and all its parts, -regardless of how they are packaged. This License gives no permission to license the -work in any other way, but it does not invalidate such permission if you have -separately received it. -* **d)** If the work has interactive user interfaces, each must display Appropriate Legal -Notices; however, if the Program has interactive interfaces that do not display -Appropriate Legal Notices, your work need not make them do so. - -A compilation of a covered work with other separate and independent works, which are -not by their nature extensions of the covered work, and which are not combined with -it such as to form a larger program, in or on a volume of a storage or distribution -medium, is called an “aggregate” if the compilation and its resulting -copyright are not used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work in an aggregate -does not cause this License to apply to the other parts of the aggregate. - -### 6. Conveying Non-Source Forms - -You may convey a covered work in object code form under the terms of sections 4 and -5, provided that you also convey the machine-readable Corresponding Source under the -terms of this License, in one of these ways: - -* **a)** Convey the object code in, or embodied in, a physical product (including a -physical distribution medium), accompanied by the Corresponding Source fixed on a -durable physical medium customarily used for software interchange. -* **b)** Convey the object code in, or embodied in, a physical product (including a -physical distribution medium), accompanied by a written offer, valid for at least -three years and valid for as long as you offer spare parts or customer support for -that product model, to give anyone who possesses the object code either **(1)** a copy of -the Corresponding Source for all the software in the product that is covered by this -License, on a durable physical medium customarily used for software interchange, for -a price no more than your reasonable cost of physically performing this conveying of -source, or **(2)** access to copy the Corresponding Source from a network server at no -charge. -* **c)** Convey individual copies of the object code with a copy of the written offer to -provide the Corresponding Source. This alternative is allowed only occasionally and -noncommercially, and only if you received the object code with such an offer, in -accord with subsection 6b. -* **d)** Convey the object code by offering access from a designated place (gratis or for -a charge), and offer equivalent access to the Corresponding Source in the same way -through the same place at no further charge. You need not require recipients to copy -the Corresponding Source along with the object code. If the place to copy the object -code is a network server, the Corresponding Source may be on a different server -(operated by you or a third party) that supports equivalent copying facilities, -provided you maintain clear directions next to the object code saying where to find -the Corresponding Source. Regardless of what server hosts the Corresponding Source, -you remain obligated to ensure that it is available for as long as needed to satisfy -these requirements. -* **e)** Convey the object code using peer-to-peer transmission, provided you inform -other peers where the object code and Corresponding Source of the work are being -offered to the general public at no charge under subsection 6d. - -A separable portion of the object code, whose source code is excluded from the -Corresponding Source as a System Library, need not be included in conveying the -object code work. - -A “User Product” is either **(1)** a “consumer product”, which -means any tangible personal property which is normally used for personal, family, or -household purposes, or **(2)** anything designed or sold for incorporation into a -dwelling. In determining whether a product is a consumer product, doubtful cases -shall be resolved in favor of coverage. For a particular product received by a -particular user, “normally used” refers to a typical or common use of -that class of product, regardless of the status of the particular user or of the way -in which the particular user actually uses, or expects or is expected to use, the -product. A product is a consumer product regardless of whether the product has -substantial commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - -“Installation Information” for a User Product means any methods, -procedures, authorization keys, or other information required to install and execute -modified versions of a covered work in that User Product from a modified version of -its Corresponding Source. The information must suffice to ensure that the continued -functioning of the modified object code is in no case prevented or interfered with -solely because modification has been made. - -If you convey an object code work under this section in, or with, or specifically for -use in, a User Product, and the conveying occurs as part of a transaction in which -the right of possession and use of the User Product is transferred to the recipient -in perpetuity or for a fixed term (regardless of how the transaction is -characterized), the Corresponding Source conveyed under this section must be -accompanied by the Installation Information. But this requirement does not apply if -neither you nor any third party retains the ability to install modified object code -on the User Product (for example, the work has been installed in ROM). - -The requirement to provide Installation Information does not include a requirement to -continue to provide support service, warranty, or updates for a work that has been -modified or installed by the recipient, or for the User Product in which it has been -modified or installed. Access to a network may be denied when the modification itself -materially and adversely affects the operation of the network or violates the rules -and protocols for communication across the network. - -Corresponding Source conveyed, and Installation Information provided, in accord with -this section must be in a format that is publicly documented (and with an -implementation available to the public in source code form), and must require no -special password or key for unpacking, reading or copying. - -### 7. Additional Terms - -“Additional permissions” are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. Additional -permissions that are applicable to the entire Program shall be treated as though they -were included in this License, to the extent that they are valid under applicable -law. If additional permissions apply only to part of the Program, that part may be -used separately under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - -When you convey a copy of a covered work, you may at your option remove any -additional permissions from that copy, or from any part of it. (Additional -permissions may be written to require their own removal in certain cases when you -modify the work.) You may place additional permissions on material, added by you to a -covered work, for which you have or can give appropriate copyright permission. - -Notwithstanding any other provision of this License, for material you add to a -covered work, you may (if authorized by the copyright holders of that material) -supplement the terms of this License with terms: - -* **a)** Disclaiming warranty or limiting liability differently from the terms of -sections 15 and 16 of this License; or -* **b)** Requiring preservation of specified reasonable legal notices or author -attributions in that material or in the Appropriate Legal Notices displayed by works -containing it; or -* **c)** Prohibiting misrepresentation of the origin of that material, or requiring that -modified versions of such material be marked in reasonable ways as different from the -original version; or -* **d)** Limiting the use for publicity purposes of names of licensors or authors of the -material; or -* **e)** Declining to grant rights under trademark law for use of some trade names, -trademarks, or service marks; or -* **f)** Requiring indemnification of licensors and authors of that material by anyone -who conveys the material (or modified versions of it) with contractual assumptions of -liability to the recipient, for any liability that these contractual assumptions -directly impose on those licensors and authors. - -All other non-permissive additional terms are considered “further -restrictions” within the meaning of section 10. If the Program as you received -it, or any part of it, contains a notice stating that it is governed by this License -along with a term that is a further restriction, you may remove that term. If a -license document contains a further restriction but permits relicensing or conveying -under this License, you may add to a covered work material governed by the terms of -that license document, provided that the further restriction does not survive such -relicensing or conveying. - -If you add terms to a covered work in accord with this section, you must place, in -the relevant source files, a statement of the additional terms that apply to those -files, or a notice indicating where to find the applicable terms. - -Additional terms, permissive or non-permissive, may be stated in the form of a -separately written license, or stated as exceptions; the above requirements apply -either way. - -### 8. Termination - -You may not propagate or modify a covered work except as expressly provided under -this License. Any attempt otherwise to propagate or modify it is void, and will -automatically terminate your rights under this License (including any patent licenses -granted under the third paragraph of section 11). - -However, if you cease all violation of this License, then your license from a -particular copyright holder is reinstated **(a)** provisionally, unless and until the -copyright holder explicitly and finally terminates your license, and **(b)** permanently, -if the copyright holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - -Moreover, your license from a particular copyright holder is reinstated permanently -if the copyright holder notifies you of the violation by some reasonable means, this -is the first time you have received notice of violation of this License (for any -work) from that copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - -Termination of your rights under this section does not terminate the licenses of -parties who have received copies or rights from you under this License. If your -rights have been terminated and not permanently reinstated, you do not qualify to -receive new licenses for the same material under section 10. - -### 9. Acceptance Not Required for Having Copies - -You are not required to accept this License in order to receive or run a copy of the -Program. Ancillary propagation of a covered work occurring solely as a consequence of -using peer-to-peer transmission to receive a copy likewise does not require -acceptance. However, nothing other than this License grants you permission to -propagate or modify any covered work. These actions infringe copyright if you do not -accept this License. Therefore, by modifying or propagating a covered work, you -indicate your acceptance of this License to do so. - -### 10. Automatic Licensing of Downstream Recipients - -Each time you convey a covered work, the recipient automatically receives a license -from the original licensors, to run, modify and propagate that work, subject to this -License. You are not responsible for enforcing compliance by third parties with this -License. - -An “entity transaction” is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an organization, or -merging organizations. If propagation of a covered work results from an entity -transaction, each party to that transaction who receives a copy of the work also -receives whatever licenses to the work the party's predecessor in interest had or -could give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if the predecessor -has it or can get it with reasonable efforts. - -You may not impose any further restrictions on the exercise of the rights granted or -affirmed under this License. For example, you may not impose a license fee, royalty, -or other charge for exercise of rights granted under this License, and you may not -initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging -that any patent claim is infringed by making, using, selling, offering for sale, or -importing the Program or any portion of it. - -### 11. Patents - -A “contributor” is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The work thus -licensed is called the contributor's “contributor version”. - -A contributor's “essential patent claims” are all patent claims owned or -controlled by the contributor, whether already acquired or hereafter acquired, that -would be infringed by some manner, permitted by this License, of making, using, or -selling its contributor version, but do not include claims that would be infringed -only as a consequence of further modification of the contributor version. For -purposes of this definition, “control” includes the right to grant patent -sublicenses in a manner consistent with the requirements of this License. - -Each contributor grants you a non-exclusive, worldwide, royalty-free patent license -under the contributor's essential patent claims, to make, use, sell, offer for sale, -import and otherwise run, modify and propagate the contents of its contributor -version. - -In the following three paragraphs, a “patent license” is any express -agreement or commitment, however denominated, not to enforce a patent (such as an -express permission to practice a patent or covenant not to sue for patent -infringement). To “grant” such a patent license to a party means to make -such an agreement or commitment not to enforce a patent against the party. - -If you convey a covered work, knowingly relying on a patent license, and the -Corresponding Source of the work is not available for anyone to copy, free of charge -and under the terms of this License, through a publicly available network server or -other readily accessible means, then you must either **(1)** cause the Corresponding -Source to be so available, or **(2)** arrange to deprive yourself of the benefit of the -patent license for this particular work, or **(3)** arrange, in a manner consistent with -the requirements of this License, to extend the patent license to downstream -recipients. “Knowingly relying” means you have actual knowledge that, but -for the patent license, your conveying the covered work in a country, or your -recipient's use of the covered work in a country, would infringe one or more -identifiable patents in that country that you have reason to believe are valid. - -If, pursuant to or in connection with a single transaction or arrangement, you -convey, or propagate by procuring conveyance of, a covered work, and grant a patent -license to some of the parties receiving the covered work authorizing them to use, -propagate, modify or convey a specific copy of the covered work, then the patent -license you grant is automatically extended to all recipients of the covered work and -works based on it. - -A patent license is “discriminatory” if it does not include within the -scope of its coverage, prohibits the exercise of, or is conditioned on the -non-exercise of one or more of the rights that are specifically granted under this -License. You may not convey a covered work if you are a party to an arrangement with -a third party that is in the business of distributing software, under which you make -payment to the third party based on the extent of your activity of conveying the -work, and under which the third party grants, to any of the parties who would receive -the covered work from you, a discriminatory patent license **(a)** in connection with -copies of the covered work conveyed by you (or copies made from those copies), or **(b)** -primarily for and in connection with specific products or compilations that contain -the covered work, unless you entered into that arrangement, or that patent license -was granted, prior to 28 March 2007. - -Nothing in this License shall be construed as excluding or limiting any implied -license or other defenses to infringement that may otherwise be available to you -under applicable patent law. - -### 12. No Surrender of Others' Freedom - -If conditions are imposed on you (whether by court order, agreement or otherwise) -that contradict the conditions of this License, they do not excuse you from the -conditions of this License. If you cannot convey a covered work so as to satisfy -simultaneously your obligations under this License and any other pertinent -obligations, then as a consequence you may not convey it at all. For example, if you -agree to terms that obligate you to collect a royalty for further conveying from -those to whom you convey the Program, the only way you could satisfy both those terms -and this License would be to refrain entirely from conveying the Program. - -### 13. Use with the GNU Affero General Public License - -Notwithstanding any other provision of this License, you have permission to link or -combine any covered work with a work licensed under version 3 of the GNU Affero -General Public License into a single combined work, and to convey the resulting work. -The terms of this License will continue to apply to the part which is the covered -work, but the special requirements of the GNU Affero General Public License, section -13, concerning interaction through a network will apply to the combination as such. - -### 14. Revised Versions of this License - -The Free Software Foundation may publish revised and/or new versions of the GNU -General Public License from time to time. Such new versions will be similar in spirit -to the present version, but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Program specifies that -a certain numbered version of the GNU General Public License “or any later -version” applies to it, you have the option of following the terms and -conditions either of that numbered version or of any later version published by the -Free Software Foundation. If the Program does not specify a version number of the GNU -General Public License, you may choose any version ever published by the Free -Software Foundation. - -If the Program specifies that a proxy can decide which future versions of the GNU -General Public License can be used, that proxy's public statement of acceptance of a -version permanently authorizes you to choose that version for the Program. - -Later license versions may give you additional or different permissions. However, no -additional obligations are imposed on any author or copyright holder as a result of -your choosing to follow a later version. - -### 15. Disclaimer of Warranty - -THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER -EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE -QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE -DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - -### 16. Limitation of Liability - -IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY -COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS -PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, -INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE -OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE -WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - -### 17. Interpretation of Sections 15 and 16 - -If the disclaimer of warranty and limitation of liability provided above cannot be -given local legal effect according to their terms, reviewing courts shall apply local -law that most closely approximates an absolute waiver of all civil liability in -connection with the Program, unless a warranty or assumption of liability accompanies -a copy of the Program in return for a fee. - -_END OF TERMS AND CONDITIONS_ - -## How to Apply These Terms to Your New Programs - -If you develop a new program, and you want it to be of the greatest possible use to -the public, the best way to achieve this is to make it free software which everyone -can redistribute and change under these terms. - -To do so, attach the following notices to the program. It is safest to attach them -to the start of each source file to most effectively state the exclusion of warranty; -and each file should have at least the “copyright” line and a pointer to -where the full notice is found. - - - Copyright (C) 2018 Jeffrey Girard - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -Also add information on how to contact you by electronic and paper mail. - -If the program does terminal interaction, make it output a short notice like this -when it starts in an interactive mode: - - ssm Copyright (C) 2018 Jeffrey Girard - This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type 'show c' for details. - -The hypothetical commands `show w` and `show c` should show the appropriate parts of -the General Public License. Of course, your program's commands might be different; -for a GUI interface, you would use an “about box”. - -You should also get your employer (if you work as a programmer) or school, if any, to -sign a “copyright disclaimer” for the program, if necessary. For more -information on this, and how to apply and follow the GNU GPL, see -<>. - -The GNU General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may consider it -more useful to permit linking proprietary applications with the library. If this is -what you want to do, use the GNU Lesser General Public License instead of this -License. But first, please read -<>. From 69f66dfbc1612105b7946fe8907876d72ec816e5 Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:17:33 +0000 Subject: [PATCH 96/97] Update license references to use consistent casing for LICENSE file --- README.md | 6 +++--- docs/index.md | 2 +- mkdocs.yml | 2 +- pyproject.toml | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 85350d1..95a22ce 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ [![Tests status][tests-badge]][tests-link] [![Linting status][linting-badge]][linting-link] [![Documentation status][documentation-badge]][documentation-link] -[![License][license-badge]](./LICENSE.md) +[![License][license-badge]](./LICENSE) [tests-badge]: https://github.com/MitchellAcoustics/circumplex/actions/workflows/tests.yml/badge.svg @@ -51,7 +51,7 @@ We welcome contributions from the community. If you're interested in contributin ## License -This project is licensed under the GNU GPLv3 License. For more information, please see the `license.md` file. +This project is licensed under the GNU GPLv3 License. For more information, please see the `LICENSE` file. ## Project layout @@ -60,7 +60,7 @@ This project is licensed under the GNU GPLv3 License. For more information, plea docs/ index.md # The documentation homepage. about.md # The about page. - license.md # The license page. + LICENSE # The license page. tutorials/ # Tutorial pages. Introduction to SSM Analysis.ipynb ... # Other markdown pages, images and other files. diff --git a/docs/index.md b/docs/index.md index 13b134f..4b36573 100644 --- a/docs/index.md +++ b/docs/index.md @@ -4,7 +4,7 @@ [![Tests status][tests-badge]][tests-link] [![Linting status][linting-badge]][linting-link] [![Documentation status][documentation-badge]][documentation-link] -[![License][license-badge]](./LICENSE.md) +[![License][license-badge]](./LICENSE) [tests-badge]: https://github.com/MitchellAcoustics/python-circumplex/actions/workflows/tests.yml/badge.svg diff --git a/mkdocs.yml b/mkdocs.yml index 13679ef..1776040 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -63,7 +63,7 @@ nav: - Contrast: api/utils/contrast.md - Tidying Functions: api/utils/tidying_functions.md - Visualization: api/plots.md - - License: LICENSE.md + - License: LICENSE markdown_extensions: - admonition diff --git a/pyproject.toml b/pyproject.toml index 661924e..056e97c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -65,7 +65,7 @@ keywords = [ "structural summary method", ] license = "MIT" -license-files = ["LICENSE.md"] +license-files = ["LICENSE"] name = "circumplex" readme = "README.md" requires-python = ">=3.11" From 0b05add4992e59f19884ba3cbc802d0d8fe364fe Mon Sep 17 00:00:00 2001 From: Andrew Mitchell Date: Sun, 9 Nov 2025 19:26:34 +0000 Subject: [PATCH 97/97] Update license references to use consistent casing and improve documentation clarity --- docs/index.md | 4 ++-- {docs/tutorials => examples}/Intro_to_SSM_Analysis.ipynb | 0 {docs/tutorials => examples}/Random_exs.ipynb | 0 .../using-instruments-v1.ipynb | 0 mkdocs.yml | 2 +- src/circumplex/visualization/plots.py | 9 ++++----- 6 files changed, 7 insertions(+), 8 deletions(-) rename {docs/tutorials => examples}/Intro_to_SSM_Analysis.ipynb (100%) rename {docs/tutorials => examples}/Random_exs.ipynb (100%) rename docs/tutorials/using-instruments.ipynb => examples/using-instruments-v1.ipynb (100%) diff --git a/docs/index.md b/docs/index.md index 4b36573..d914143 100644 --- a/docs/index.md +++ b/docs/index.md @@ -4,7 +4,7 @@ [![Tests status][tests-badge]][tests-link] [![Linting status][linting-badge]][linting-link] [![Documentation status][documentation-badge]][documentation-link] -[![License][license-badge]](./LICENSE) +[![License][license-badge]](./license.md) [tests-badge]: https://github.com/MitchellAcoustics/python-circumplex/actions/workflows/tests.yml/badge.svg @@ -13,7 +13,7 @@ [linting-link]: https://github.com/MitchellAcoustics/python-circumplex/actions/workflows/linting.yml [documentation-badge]: https://github.com/MitchellAcoustics/python-circumplex/actions/workflows/docs.yml/badge.svg [documentation-link]: https://github.com/MitchellAcoustics/python-circumplex/actions/workflows/docs.yml -[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg +[license-badge]: https://img.shields.io/badge/License-GPL%20v3-blue.svg ## Overview diff --git a/docs/tutorials/Intro_to_SSM_Analysis.ipynb b/examples/Intro_to_SSM_Analysis.ipynb similarity index 100% rename from docs/tutorials/Intro_to_SSM_Analysis.ipynb rename to examples/Intro_to_SSM_Analysis.ipynb diff --git a/docs/tutorials/Random_exs.ipynb b/examples/Random_exs.ipynb similarity index 100% rename from docs/tutorials/Random_exs.ipynb rename to examples/Random_exs.ipynb diff --git a/docs/tutorials/using-instruments.ipynb b/examples/using-instruments-v1.ipynb similarity index 100% rename from docs/tutorials/using-instruments.ipynb rename to examples/using-instruments-v1.ipynb diff --git a/mkdocs.yml b/mkdocs.yml index 1776040..b439a5a 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -63,7 +63,7 @@ nav: - Contrast: api/utils/contrast.md - Tidying Functions: api/utils/tidying_functions.md - Visualization: api/plots.md - - License: LICENSE + - License: license.md markdown_extensions: - admonition diff --git a/src/circumplex/visualization/plots.py b/src/circumplex/visualization/plots.py index 3c97751..033ed00 100644 --- a/src/circumplex/visualization/plots.py +++ b/src/circumplex/visualization/plots.py @@ -836,11 +836,10 @@ def plot_curve( Which rows to plot. If None, plots all profiles. angle_labels Labels for each angle on x-axis. If None, shows degree symbols (e.g., "90°"). - colors - Colors for profiles. Can be: - - Seaborn palette name: "Set2", "husl", "deep", etc. - - List of color specifications: ['red', 'blue'] or ['#FF0000', '#0000FF'] - - None: single blue color + c_scores + Color for observed scores (points and lines). + c_fit + Color for fitted curve. base_size Base font size in points for labels and text. drop_lowfit

      rK8Lx~qQ29&3hO9N>eVu)!{coPnxGiYnG%3ML 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

    YTaddD_TJ;>FIW{U=Dam$eFD%f0HK-48Z9 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