From f9826cff3a7e082f02457e3b4a1642e126ed6f53 Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 01:31:46 +0200 Subject: [PATCH 1/6] feat: add aa.plot_comparison grouped comparison barplot (prototype #311) Top-level aa.plot_comparison(df_eval, group=, condition=, value=, baseline=50, annotate=True, ax=None) draws a grouped method x condition barplot from a tidy eval frame: automatic bar offsets/widths for N groups, optional per-bar value labels, and an optional dashed chance/baseline line with a label. Returns the Axes. Replaces the fully-manual matplotlib (x +/- w/2 offsets + per-bar ax.text loop + axhline) of a hand-built grouped barplot (gamma-secretase cell 28). House colors via plot_get_clist; follows plotting.md (no plt.show/tight_layout/ plot_settings in library code; returns the Axes). Full ripple: numpydoc + Examples include; executed example notebook examples/plotting/plot_comparison.ipynb (inline backend, display_df + plt.show); 33 unit tests (bar count = groups x conditions, baseline drawn when set, annotations present, bad input -> ValueError); re-exported in aaanalysis/__init__.py __all__; api.rst autosummary; release-notes Unreleased entry; cheat-sheet row. Part of #305 / prototype for #311. Co-Authored-By: Claude Opus 4.8 (1M context) --- aaanalysis/__init__.py | 4 +- aaanalysis/plotting/__init__.py | 4 +- aaanalysis/plotting/_plot_comparison.py | 218 +++++++++++++++++ docs/_cheatsheet/content.py | 1 + docs/source/api.rst | 1 + docs/source/index/release_notes.rst | 4 + examples/plotting/plot_comparison.ipynb | 224 ++++++++++++++++++ .../plotting_tests/test_plot_comparison.py | 180 ++++++++++++++ 8 files changed, 634 insertions(+), 2 deletions(-) create mode 100644 aaanalysis/plotting/_plot_comparison.py create mode 100644 examples/plotting/plot_comparison.ipynb create mode 100644 tests/unit/plotting_tests/test_plot_comparison.py diff --git a/aaanalysis/__init__.py b/aaanalysis/__init__.py index 4fc1edee..282b97a8 100644 --- a/aaanalysis/__init__.py +++ b/aaanalysis/__init__.py @@ -9,7 +9,8 @@ from .explainable_ai import TreeModel from .protein_design import AAMut, AAMutPlot, SeqMut, SeqMutPlot, SeqOpt, SeqOptPlot from .plotting import (plot_get_clist, plot_get_cmap, plot_get_cdict, - plot_settings, plot_legend, plot_gcfs, plot_rank) + plot_settings, plot_legend, plot_gcfs, plot_rank, + plot_comparison) from .metrics import (comp_auc_adjusted, comp_bic_score, comp_kld, comp_per_protein_ap, comp_detection_metrics, comp_bootstrap_ci, comp_smooth_scores) @@ -65,6 +66,7 @@ "plot_legend", "plot_gcfs", "plot_rank", + "plot_comparison", "comp_auc_adjusted", "comp_bic_score", "comp_kld", diff --git a/aaanalysis/plotting/__init__.py b/aaanalysis/plotting/__init__.py index df692aad..bdc2ff63 100644 --- a/aaanalysis/plotting/__init__.py +++ b/aaanalysis/plotting/__init__.py @@ -2,7 +2,7 @@ Plotting utilities: shared styling, colors, and legends for every ``*Plot`` class. Public objects: plot_get_clist, plot_get_cmap, plot_get_cdict, plot_settings, -plot_legend, plot_gcfs, plot_rank. +plot_legend, plot_gcfs, plot_rank, plot_comparison. A cross-cutting subpackage (not a pipeline stage): ``plot_settings`` sets the house rcParams, the ``plot_get_*`` helpers supply the color list / map / dict, and ``plot_legend`` / ``plot_gcfs`` / ``plot_rank`` are reused by the paired plot classes @@ -18,6 +18,7 @@ from ._plot_gcfs import plot_gcfs from ._plot_legend import plot_legend from ._plot_rank import plot_rank +from ._plot_comparison import plot_comparison __all__ = [ @@ -28,4 +29,5 @@ "plot_legend", "plot_gcfs", "plot_rank", + "plot_comparison", ] diff --git a/aaanalysis/plotting/_plot_comparison.py b/aaanalysis/plotting/_plot_comparison.py new file mode 100644 index 00000000..6ec1caa8 --- /dev/null +++ b/aaanalysis/plotting/_plot_comparison.py @@ -0,0 +1,218 @@ +""" +This is a script for the frontend of the plot_comparison function — a grouped +method x condition comparison barplot with value labels and a chance/baseline line. +""" +from typing import Optional, List, Dict, Union, Tuple +import numpy as np +import pandas as pd +import seaborn as sns +from matplotlib import pyplot as plt +from matplotlib.axes import Axes + +from aaanalysis import utils as ut +from ._plot_get_clist import plot_get_clist + + +# I Helper Functions +def _resolve_order(values: List, order: Optional[List], name: str) -> List: + """First-appearance order by default; otherwise validate the explicit order covers all values.""" + seen = list(dict.fromkeys(values)) + if order is None: + return seen + ut.check_list_like(name=name, val=order) + missing = set(seen) - set(order) + if missing: + raise ValueError(f"'{name}' is missing values present in the data: {sorted(map(str, missing))}") + # Keep only the groups that actually occur, in the requested order. + return [g for g in order if g in set(seen)] + + +def _resolve_colors(group_order: List, colors: Optional[Union[List, Dict]]) -> Dict: + """Build a {group: color} map: explicit list/dict wins, else the house categorical palette.""" + n = len(group_order) + if colors is None: + palette = plot_get_clist(n_colors=max(n, 2)) + return {g: palette[i] for i, g in enumerate(group_order)} + if isinstance(colors, dict): + missing = [g for g in group_order if g not in colors] + if missing: + raise ValueError(f"'colors' dict is missing colors for groups: {missing}") + return {g: colors[g] for g in group_order} + ut.check_list_like(name="colors", val=colors) + if len(colors) < n: + raise ValueError(f"'colors' (n={len(colors)}) should provide at least one color " + f"per group (n_groups={n}).") + return {g: colors[i] for i, g in enumerate(group_order)} + + +# II Main Functions +def plot_comparison(df_eval: pd.DataFrame, + group: str = "group", + condition: str = "condition", + value: str = "value", + baseline: Optional[Union[int, float]] = 50, + baseline_label: Optional[str] = None, + annotate: bool = True, + group_order: Optional[List[str]] = None, + condition_order: Optional[List[str]] = None, + colors: Optional[Union[List[str], Dict[str, str]]] = None, + bar_width: Union[int, float] = 0.8, + ax: Optional[Axes] = None, + figsize: Tuple[Union[int, float], Union[int, float]] = (7, 4.2), + xlabel: Optional[str] = None, + ylabel: str = "Score", + title: Optional[str] = None, + ylim: Optional[Tuple[Union[int, float], Union[int, float]]] = None, + fontsize_annotations: Union[int, float] = 10, + ) -> Axes: + """ + Plot a grouped method x condition comparison barplot with value labels and a baseline line. + + Draws the recurring "benchmark result" figure from a tidy eval frame in one call: + each ``condition`` is a cluster on the x-axis, each ``group`` a colored bar within it + (auto offsets / widths for *N* groups), with optional per-bar value labels and an + optional dashed chance / baseline line. Replaces the manual ``x ± w/2`` offsets, the + per-bar ``ax.text`` annotation loop, and the manual ``axhline`` of a hand-built grouped + barplot. + + .. versionadded:: 1.1.0 + + Parameters + ---------- + df_eval : pd.DataFrame, shape (n_rows, n_cols) + Tidy (long-form) evaluation frame with one row per (``group``, ``condition``) + cell; must contain the ``group``, ``condition``, and ``value`` columns. Repeated + (``group``, ``condition``) rows are averaged. + group : str, default="group" + Column whose distinct values become the colored bars within each cluster (the legend). + condition : str, default="condition" + Column whose distinct values become the x-axis clusters. + value : str, default="value" + Column with the numeric bar heights (e.g. balanced accuracy in percent). + baseline : int or float, optional + y-value of a dashed horizontal chance / baseline line. If ``None``, no line is drawn. + baseline_label : str, optional + Text label for the baseline line. If ``None`` and ``baseline`` is set, a label + ``"chance ()"`` is generated; pass ``""`` to draw the line without a label. + annotate : bool, default=True + If ``True``, write each bar's value above it (rounded to integer). + group_order : list of str, optional + Order of the groups (bar order within each cluster). Defaults to first-appearance order. + condition_order : list of str, optional + Order of the conditions (x-axis clusters). Defaults to first-appearance order. + colors : list of str or dict, optional + Bar colors: a list aligned to ``group_order``, or a ``group -> color`` dict. + Defaults to the house categorical palette (:func:`plot_get_clist`). + bar_width : int or float, default=0.8 + Total width of each condition cluster (split evenly across the groups). Must be in (0, 1]. + ax : matplotlib.axes.Axes, optional + Axes to draw on. If ``None``, a new figure and axes are created. + figsize : tuple, default=(7, 4.2) + Figure size when ``ax`` is ``None``. + xlabel : str, optional + x-axis label (none by default; the cluster tick labels carry the conditions). + ylabel : str, default="Score" + y-axis label. + title : str, optional + Axes title. + ylim : tuple, optional + y-axis limits ``(bottom, top)``. If ``None``, the top is extended above the tallest + bar / baseline to leave room for the value labels. + fontsize_annotations : int or float, default=10 + Font size of the per-bar value labels. + + Returns + ------- + ax : matplotlib.axes.Axes + The axes with the grouped comparison barplot. + + See Also + -------- + * :func:`aaanalysis.plot_get_clist` for the house categorical palette. + * :func:`aaanalysis.plot_eval_heatmap` for a heatmap view of a wider eval grid. + + Examples + -------- + .. include:: examples/plot_comparison.rst + """ + # Check input + ut.check_str(name="group", val=group) + ut.check_str(name="condition", val=condition) + ut.check_str(name="value", val=value) + ut.check_df(name="df_eval", df=df_eval, cols_required=[group, condition, value]) + if len(df_eval) == 0: + raise ValueError("'df_eval' (0 rows) should contain at least one row.") + ut.check_number_val(name="baseline", val=baseline, accept_none=True, just_int=False) + ut.check_str(name="baseline_label", val=baseline_label, accept_none=True) + ut.check_bool(name="annotate", val=annotate) + ut.check_list_like(name="group_order", val=group_order, accept_none=True) + ut.check_list_like(name="condition_order", val=condition_order, accept_none=True) + ut.check_number_range(name="bar_width", val=bar_width, min_val=0, max_val=1, just_int=False) + if bar_width == 0: + raise ValueError("'bar_width' should be greater than 0.") + ut.check_ax(ax=ax, accept_none=True) + ut.check_figsize(figsize=figsize, accept_none=True) + ut.check_str(name="xlabel", val=xlabel, accept_none=True) + ut.check_str(name="ylabel", val=ylabel, accept_none=True) + ut.check_str(name="title", val=title, accept_none=True) + ut.check_number_range(name="fontsize_annotations", val=fontsize_annotations, min_val=0, + just_int=False) + if ylim is not None: + ut.check_lim(name="ylim", val=ylim) + + # Resolve orders + colors + group_order = _resolve_order(df_eval[group].tolist(), group_order, "group_order") + condition_order = _resolve_order(df_eval[condition].tolist(), condition_order, "condition_order") + dict_group_color = _resolve_colors(group_order, colors) + + # Build the (group x condition) value grid (mean over any repeated cells) + grid = (df_eval.groupby([group, condition])[value].mean() + .unstack(condition) + .reindex(index=group_order, columns=condition_order)) + + # Draw + if ax is None: + _, ax = plt.subplots(figsize=figsize) + n_groups = len(group_order) + n_cond = len(condition_order) + x = np.arange(n_cond) + each_w = bar_width / n_groups + heights_max = float(np.nanmax(grid.values)) if grid.size else 0.0 + for j, g in enumerate(group_order): + offset = (j - (n_groups - 1) / 2) * each_w + heights = grid.loc[g].values.astype(float) + bars = ax.bar(x + offset, heights, each_w, label=str(g), color=dict_group_color[g]) + if annotate: + for b, h in zip(bars, heights): + if np.isnan(h): + continue + ax.text(b.get_x() + b.get_width() / 2, h + 0.01 * max(heights_max, 1), + f"{h:.0f}", ha="center", va="bottom", + fontsize=fontsize_annotations, weight="bold") + + # Baseline / chance line + if baseline is not None: + ax.axhline(baseline, ls="--", color="black", lw=1) + if baseline_label is None: + baseline_label = f"chance ({baseline:g})" + if baseline_label != "": + ax.text(n_cond - 1 + 0.5 * bar_width, baseline + 0.01 * max(heights_max, 1), + baseline_label, ha="right", va="bottom", + fontsize=max(fontsize_annotations - 1, 1)) + + # Cosmetics + ax.set_xticks(x) + ax.set_xticklabels(condition_order) + if xlabel is not None: + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + if title is not None: + ax.set_title(title) + if ylim is not None: + ax.set_ylim(ylim) + elif annotate and heights_max > 0: + top = max(heights_max, baseline if baseline is not None else heights_max) + ax.set_ylim(top=top * 1.15) + ax.legend() + sns.despine(ax=ax) + return ax diff --git a/docs/_cheatsheet/content.py b/docs/_cheatsheet/content.py index 801adc7f..f6c65fb7 100644 --- a/docs/_cheatsheet/content.py +++ b/docs/_cheatsheet/content.py @@ -230,6 +230,7 @@ ("BIC score · KL divergence", "comp_bic_score(X, labels) · comp_kld", None), ("Per-protein / detection (v1.1)", "comp_per_protein_ap · comp_detection_metrics", None), ("Plot style, fonts & standalone legend", "plot_settings(font_scale) · plot_legend(ax)", None), + ("Grouped comparison barplot + chance line", "plot_comparison(df_eval, baseline=50)", None, "v1.1"), ]}, {"name": "Protein Design", "tag": "mutations · design", "under_construction": True, diff --git a/docs/source/api.rst b/docs/source/api.rst index 6b8adb47..21d1fe4d 100755 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -124,6 +124,7 @@ Utility Functions comp_smooth_scores display_df options + plot_comparison plot_gcfs plot_get_cdict plot_get_clist diff --git a/docs/source/index/release_notes.rst b/docs/source/index/release_notes.rst index bc2e9618..43313e02 100644 --- a/docs/source/index/release_notes.rst +++ b/docs/source/index/release_notes.rst @@ -191,6 +191,10 @@ Added - **plot_rank**: Standalone per-protein max-score-vs-rank scatter with group coloring and optional threshold lines (pairs with the new ``aa.metrics`` functions). +- **plot_comparison**: Grouped method × condition comparison barplot from a tidy eval + frame, with automatic bar offsets / widths for *N* groups, optional per-bar value + labels, and an optional dashed chance / baseline line (replaces hand-built grouped + barplots with manual offsets, ``ax.text`` loops, and ``axhline``). **Golden Pipelines** diff --git a/examples/plotting/plot_comparison.ipynb b/examples/plotting/plot_comparison.ipynb new file mode 100644 index 00000000..74d621e4 --- /dev/null +++ b/examples/plotting/plot_comparison.ipynb @@ -0,0 +1,224 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b5f4c5c7", + "metadata": {}, + "source": [ + "The ``aa.plot_comparison()`` function draws the recurring \"benchmark result\" figure from a tidy (long-form) evaluation frame: each ``condition`` becomes an x-axis cluster, each ``group`` a colored bar within it (with automatic bar offsets and widths for *N* groups), with per-bar value labels and an optional dashed chance / baseline line. One call replaces the manual ``x ± w/2`` offsets, the per-bar ``ax.text`` loop, and the manual ``axhline`` of a hand-built grouped barplot." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "24e447bf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T23:28:15.619571Z", + "iopub.status.busy": "2026-06-30T23:28:15.619309Z", + "iopub.status.idle": "2026-06-30T23:28:17.409444Z", + "shell.execute_reply": "2026-06-30T23:28:17.409244Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (6, 3)\n" + ] + }, + { + "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", + "
 groupconditionvalue
1Scale-basedNo expansion61
2Scale-basedRandom60
3Scale-baseddPULearn75
4CPPNo expansion71
5CPPRandom74
6CPPdPULearn94
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import aaanalysis as aa\n", + "\n", + "aa.options[\"verbose\"] = False\n", + "\n", + "# Tidy eval frame: one row per (group, condition) cell.\n", + "df_eval = pd.DataFrame({\n", + " \"group\": [\"Scale-based\"] * 3 + [\"CPP\"] * 3,\n", + " \"condition\": [\"No expansion\", \"Random\", \"dPULearn\"] * 2,\n", + " \"value\": [61, 60, 75, 71, 74, 94],\n", + "})\n", + "aa.display_df(df_eval, n_rows=10, show_shape=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a0efdae9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T23:28:17.410535Z", + "iopub.status.busy": "2026-06-30T23:28:17.410456Z", + "iopub.status.idle": "2026-06-30T23:28:17.466216Z", + "shell.execute_reply": "2026-06-30T23:28:17.465982Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aa.plot_settings()\n", + "aa.plot_comparison(df_eval=df_eval, baseline=50,\n", + " ylabel=\"Balanced accuracy [%]\",\n", + " title=\"Feature engineering x data expansion\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36eb7fc7", + "metadata": {}, + "source": [ + "**Further parameters.** ``plot_comparison`` also accepts: ``group`` / ``condition`` / ``value`` — the column names of the tidy frame; ``baseline_label`` — text for the baseline line (auto ``\"chance (50)\"`` by default, ``\"\"`` to hide); ``annotate`` — toggle the per-bar value labels; ``group_order`` / ``condition_order`` — explicit bar / cluster order; ``colors`` — a list aligned to the groups or a ``group -> color`` dict (defaults to the house palette of ``aa.plot_get_clist``); ``bar_width`` — total cluster width; ``figsize``; ``xlabel``; ``ylim``; ``fontsize_annotations``; and ``ax`` to draw onto an existing axes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "98ded14f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T23:28:17.467262Z", + "iopub.status.busy": "2026-06-30T23:28:17.467199Z", + "iopub.status.idle": "2026-06-30T23:28:17.508721Z", + "shell.execute_reply": "2026-06-30T23:28:17.508490Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aa.plot_settings()\n", + "aa.plot_comparison(df_eval=df_eval, baseline=50, baseline_label=\"random (50%)\",\n", + " colors={\"Scale-based\": \"tab:gray\", \"CPP\": \"tab:red\"},\n", + " group_order=[\"Scale-based\", \"CPP\"],\n", + " ylabel=\"Balanced accuracy [%]\", ylim=(0, 108))\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/unit/plotting_tests/test_plot_comparison.py b/tests/unit/plotting_tests/test_plot_comparison.py new file mode 100644 index 00000000..7c6936ca --- /dev/null +++ b/tests/unit/plotting_tests/test_plot_comparison.py @@ -0,0 +1,180 @@ +"""This is a script to test the plot_comparison() grouped comparison barplot (#311).""" +import matplotlib +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import pandas as pd +import pytest + +import aaanalysis as aa +from aaanalysis.plotting import plot_comparison + +aa.options["verbose"] = False + + +# Helper functions +def _df(groups=("Scale-based", "CPP"), conditions=("No expansion", "Random", "dPULearn")): + rows = [] + base = {"Scale-based": 60, "CPP": 80} + for g in groups: + for k, c in enumerate(conditions): + rows.append({"group": g, "condition": c, "value": base.get(g, 70) + k}) + return pd.DataFrame(rows) + + +@pytest.fixture(autouse=True) +def _close_figs(): + yield + plt.close("all") + + +class TestPlotComparison: + """Normal cases for plot_comparison.""" + + def test_returns_axes(self): + ax = plot_comparison(df_eval=_df()) + assert isinstance(ax, plt.Axes) + + def test_bar_count_groups_times_conditions(self): + # 2 groups x 3 conditions = 6 bars + ax = plot_comparison(df_eval=_df()) + assert len(ax.patches) == 6 + + def test_bar_count_three_groups(self): + ax = plot_comparison(df_eval=_df(groups=("A", "B", "C"))) + assert len(ax.patches) == 9 + + def test_baseline_drawn_when_set(self): + ax = plot_comparison(df_eval=_df(), baseline=50) + assert len(ax.lines) == 1 + + def test_baseline_none_no_line(self): + ax = plot_comparison(df_eval=_df(), baseline=None) + assert len(ax.lines) == 0 + + def test_baseline_label_default_text(self): + ax = plot_comparison(df_eval=_df(), baseline=50) + assert any("chance" in t.get_text() for t in ax.texts) + + def test_baseline_label_custom(self): + ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="random (50%)") + assert any("random (50%)" == t.get_text() for t in ax.texts) + + def test_baseline_label_empty_suppresses_text(self): + ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="") + # 6 value labels, no baseline text + assert len(ax.texts) == 6 + + def test_annotate_true_writes_value_labels(self): + ax = plot_comparison(df_eval=_df(), annotate=True, baseline=None) + assert len(ax.texts) == 6 + + def test_annotate_false_no_value_labels(self): + ax = plot_comparison(df_eval=_df(), annotate=False, baseline=None) + assert len(ax.texts) == 0 + + def test_legend_labels_are_groups(self): + ax = plot_comparison(df_eval=_df()) + labels = [t.get_text() for t in ax.get_legend().get_texts()] + assert set(labels) == {"Scale-based", "CPP"} + + def test_group_order_controls_bar_order(self): + ax = plot_comparison(df_eval=_df(), group_order=["CPP", "Scale-based"]) + labels = [t.get_text() for t in ax.get_legend().get_texts()] + assert labels == ["CPP", "Scale-based"] + + def test_condition_order_controls_ticks(self): + order = ["dPULearn", "Random", "No expansion"] + ax = plot_comparison(df_eval=_df(), condition_order=order) + assert [t.get_text() for t in ax.get_xticklabels()] == order + + def test_colors_list(self): + ax = plot_comparison(df_eval=_df(), colors=["tab:gray", "tab:red"]) + assert len(ax.patches) == 6 + + def test_colors_dict(self): + ax = plot_comparison(df_eval=_df(), colors={"Scale-based": "tab:gray", "CPP": "tab:red"}) + assert len(ax.patches) == 6 + + def test_custom_columns(self): + df = _df().rename(columns={"group": "method", "condition": "setting", "value": "acc"}) + ax = plot_comparison(df_eval=df, group="method", condition="setting", value="acc") + assert len(ax.patches) == 6 + + def test_aggregates_repeated_cells(self): + df = pd.concat([_df(), _df()], ignore_index=True) # duplicate (group, condition) rows + ax = plot_comparison(df_eval=df) + assert len(ax.patches) == 6 + + def test_passing_existing_ax(self): + fig, ax_in = plt.subplots() + ax_out = plot_comparison(df_eval=_df(), ax=ax_in) + assert ax_out is ax_in + + def test_labels_and_title(self): + ax = plot_comparison(df_eval=_df(), xlabel="X", ylabel="Balanced accuracy [%]", + title="Bench") + assert ax.get_xlabel() == "X" + assert ax.get_ylabel() == "Balanced accuracy [%]" + assert ax.get_title() == "Bench" + + def test_ylim_respected(self): + ax = plot_comparison(df_eval=_df(), ylim=(0, 108)) + assert ax.get_ylim() == (0, 108) + + def test_bar_width_and_figsize_and_fontsize(self): + ax = plot_comparison(df_eval=_df(), bar_width=0.6, figsize=(8, 5), + fontsize_annotations=8) + assert len(ax.patches) == 6 + + +class TestPlotComparisonErrors: + """Negative cases: bad input must raise ValueError.""" + + def test_missing_column_raises(self): + df = _df().drop(columns=["value"]) + with pytest.raises(ValueError): + plot_comparison(df_eval=df) + + def test_empty_df_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df().iloc[0:0]) + + def test_non_df_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=[1, 2, 3]) + + def test_bad_group_type_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), group=123) + + def test_bad_baseline_type_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), baseline="50") + + def test_bad_annotate_type_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), annotate="yes") + + def test_bar_width_out_of_range_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), bar_width=1.5) + + def test_bar_width_zero_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), bar_width=0) + + def test_incomplete_group_order_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), group_order=["CPP"]) + + def test_colors_list_too_short_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), colors=["tab:gray"]) + + def test_colors_dict_missing_group_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), colors={"CPP": "tab:red"}) + + def test_bad_ylim_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), ylim=(10,)) From c4f16d700c0268e978ce88b8d9d665085e67599d Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 04:55:11 +0200 Subject: [PATCH 2/6] =?UTF-8?q?fix(plot=5Fcomparison):=20review=20pass=20?= =?UTF-8?q?=E2=80=94=20fractional=20labels,=20legend,=20(fig,ax)=20return?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Value labels used a hardcoded {:.0f} that collapsed fractional metrics (AUC in [0,1]) to '0'/'1'; add auto-precision + an annotation_fmt override. - Legend was drawn inside the axes and overlapped the tallest bars / their value labels; move it outside (upper right) for a publication-clean figure. - Return (fig, ax) to match the sibling plot_rank instead of a bare Axes. - Reject non-distinct group/condition/value columns with a clear ValueError (was a cryptic pandas groupby error); validate annotation_fmt. - Fix a broken See Also cross-reference (plot_eval_heatmap -> pipe.plot_eval, plot_rank); extend headroom slightly when annotate is False. - Update tests to unpack (fig, ax) and cover the new behaviors; re-execute the example notebook with embedded outputs. Co-Authored-By: Claude Opus 4.8 (1M context) --- aaanalysis/plotting/_plot_comparison.py | 52 +++++++-- examples/plotting/plot_comparison.ipynb | 100 +++++++++--------- .../plotting_tests/test_plot_comparison.py | 87 ++++++++++----- 3 files changed, 152 insertions(+), 87 deletions(-) diff --git a/aaanalysis/plotting/_plot_comparison.py b/aaanalysis/plotting/_plot_comparison.py index 6ec1caa8..e82e7e2f 100644 --- a/aaanalysis/plotting/_plot_comparison.py +++ b/aaanalysis/plotting/_plot_comparison.py @@ -8,6 +8,7 @@ import seaborn as sns from matplotlib import pyplot as plt from matplotlib.axes import Axes +from matplotlib.figure import Figure from aaanalysis import utils as ut from ._plot_get_clist import plot_get_clist @@ -45,6 +46,17 @@ def _resolve_colors(group_order: List, colors: Optional[Union[List, Dict]]) -> D return {g: colors[i] for i, g in enumerate(group_order)} +def _auto_annotation_fmt(values: np.ndarray) -> str: + """Pick a value-label format: no decimals for integers, else 2 decimals for small + (fractional, e.g. AUC in [0, 1]) values and 1 decimal for larger scales.""" + vals = values[~np.isnan(values)] + if vals.size == 0 or np.allclose(vals, np.round(vals)): + return "{:.0f}" + if float(np.max(np.abs(vals))) < 10: + return "{:.2f}" + return "{:.1f}" + + # II Main Functions def plot_comparison(df_eval: pd.DataFrame, group: str = "group", @@ -53,6 +65,7 @@ def plot_comparison(df_eval: pd.DataFrame, baseline: Optional[Union[int, float]] = 50, baseline_label: Optional[str] = None, annotate: bool = True, + annotation_fmt: Optional[str] = None, group_order: Optional[List[str]] = None, condition_order: Optional[List[str]] = None, colors: Optional[Union[List[str], Dict[str, str]]] = None, @@ -64,7 +77,7 @@ def plot_comparison(df_eval: pd.DataFrame, title: Optional[str] = None, ylim: Optional[Tuple[Union[int, float], Union[int, float]]] = None, fontsize_annotations: Union[int, float] = 10, - ) -> Axes: + ) -> Tuple[Figure, Axes]: """ Plot a grouped method x condition comparison barplot with value labels and a baseline line. @@ -95,7 +108,11 @@ def plot_comparison(df_eval: pd.DataFrame, Text label for the baseline line. If ``None`` and ``baseline`` is set, a label ``"chance ()"`` is generated; pass ``""`` to draw the line without a label. annotate : bool, default=True - If ``True``, write each bar's value above it (rounded to integer). + If ``True``, write each bar's value above it. + annotation_fmt : str, optional + Python format string for the value labels (e.g. ``"{:.1f}"``). If ``None``, it is + chosen from the data: no decimals for integer-valued scores, two decimals for + fractional metrics (e.g. AUC in ``[0, 1]``), one decimal otherwise. group_order : list of str, optional Order of the groups (bar order within each cluster). Defaults to first-appearance order. condition_order : list of str, optional @@ -123,13 +140,16 @@ def plot_comparison(df_eval: pd.DataFrame, Returns ------- + fig : matplotlib.figure.Figure + The figure. ax : matplotlib.axes.Axes The axes with the grouped comparison barplot. See Also -------- * :func:`aaanalysis.plot_get_clist` for the house categorical palette. - * :func:`aaanalysis.plot_eval_heatmap` for a heatmap view of a wider eval grid. + * :func:`aaanalysis.plot_rank` for a per-protein rank scatter of a deployed predictor. + * :func:`aaanalysis.pipe.plot_eval` for a viridis evaluation-grid view of a wider sweep. Examples -------- @@ -139,12 +159,16 @@ def plot_comparison(df_eval: pd.DataFrame, ut.check_str(name="group", val=group) ut.check_str(name="condition", val=condition) ut.check_str(name="value", val=value) + if len({group, condition, value}) < 3: + raise ValueError(f"'group', 'condition', and 'value' should be three distinct columns, " + f"got group={group!r}, condition={condition!r}, value={value!r}.") ut.check_df(name="df_eval", df=df_eval, cols_required=[group, condition, value]) if len(df_eval) == 0: raise ValueError("'df_eval' (0 rows) should contain at least one row.") ut.check_number_val(name="baseline", val=baseline, accept_none=True, just_int=False) ut.check_str(name="baseline_label", val=baseline_label, accept_none=True) ut.check_bool(name="annotate", val=annotate) + ut.check_str(name="annotation_fmt", val=annotation_fmt, accept_none=True) ut.check_list_like(name="group_order", val=group_order, accept_none=True) ut.check_list_like(name="condition_order", val=condition_order, accept_none=True) ut.check_number_range(name="bar_width", val=bar_width, min_val=0, max_val=1, just_int=False) @@ -172,12 +196,16 @@ def plot_comparison(df_eval: pd.DataFrame, # Draw if ax is None: - _, ax = plt.subplots(figsize=figsize) + fig, ax = plt.subplots(figsize=figsize) + else: + fig = ax.figure n_groups = len(group_order) n_cond = len(condition_order) x = np.arange(n_cond) each_w = bar_width / n_groups heights_max = float(np.nanmax(grid.values)) if grid.size else 0.0 + if annotation_fmt is None: + annotation_fmt = _auto_annotation_fmt(grid.values) for j, g in enumerate(group_order): offset = (j - (n_groups - 1) / 2) * each_w heights = grid.loc[g].values.astype(float) @@ -187,7 +215,7 @@ def plot_comparison(df_eval: pd.DataFrame, if np.isnan(h): continue ax.text(b.get_x() + b.get_width() / 2, h + 0.01 * max(heights_max, 1), - f"{h:.0f}", ha="center", va="bottom", + annotation_fmt.format(h), ha="center", va="bottom", fontsize=fontsize_annotations, weight="bold") # Baseline / chance line @@ -210,9 +238,13 @@ def plot_comparison(df_eval: pd.DataFrame, ax.set_title(title) if ylim is not None: ax.set_ylim(ylim) - elif annotate and heights_max > 0: - top = max(heights_max, baseline if baseline is not None else heights_max) - ax.set_ylim(top=top * 1.15) - ax.legend() + elif heights_max > 0: + top = heights_max if baseline is None else max(heights_max, baseline) + ax.set_ylim(top=top * (1.15 if annotate else 1.05)) + # Legend outside the axes (upper right): a grouped barplot fills the plot area, so an + # inside legend would overlap the tallest bars / their value labels. + ax.legend(loc="upper left", bbox_to_anchor=(1.01, 1.0), frameon=False) sns.despine(ax=ax) - return ax + # ``ax.figure`` is typed ``Figure | SubFigure | None`` by the matplotlib stubs, + # but a top-level Axes here always belongs to a real Figure. + return fig, ax # pyright: ignore[reportReturnType] diff --git a/examples/plotting/plot_comparison.ipynb b/examples/plotting/plot_comparison.ipynb index 74d621e4..edc67c22 100644 --- a/examples/plotting/plot_comparison.ipynb +++ b/examples/plotting/plot_comparison.ipynb @@ -14,10 +14,10 @@ "id": "24e447bf", "metadata": { "execution": { - "iopub.execute_input": "2026-06-30T23:28:15.619571Z", - "iopub.status.busy": "2026-06-30T23:28:15.619309Z", - "iopub.status.idle": "2026-06-30T23:28:17.409444Z", - "shell.execute_reply": "2026-06-30T23:28:17.409244Z" + "iopub.execute_input": "2026-07-01T02:53:16.560476Z", + "iopub.status.busy": "2026-07-01T02:53:16.560404Z", + "iopub.status.idle": "2026-07-01T02:53:21.468428Z", + "shell.execute_reply": "2026-07-01T02:53:21.468214Z" } }, "outputs": [ @@ -32,70 +32,70 @@ "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", "
 groupconditionvaluegroupconditionvalue
1Scale-basedNo expansion611Scale-basedNo expansion61
2Scale-basedRandom602Scale-basedRandom60
3Scale-baseddPULearn753Scale-baseddPULearn75
4CPPNo expansion714CPPNo expansion71
5CPPRandom745CPPRandom74
6CPPdPULearn946CPPdPULearn94
\n" @@ -130,16 +130,16 @@ "id": "a0efdae9", "metadata": { "execution": { - "iopub.execute_input": "2026-06-30T23:28:17.410535Z", - "iopub.status.busy": "2026-06-30T23:28:17.410456Z", - "iopub.status.idle": "2026-06-30T23:28:17.466216Z", - "shell.execute_reply": "2026-06-30T23:28:17.465982Z" + "iopub.execute_input": "2026-07-01T02:53:21.469446Z", + "iopub.status.busy": "2026-07-01T02:53:21.469351Z", + "iopub.status.idle": "2026-07-01T02:53:21.572469Z", + "shell.execute_reply": "2026-07-01T02:53:21.572257Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApcAAAGBCAYAAAAzC5qKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeqNJREFUeJzt3QeYE1UXBuDDNurSe++9NwUEBKVIkY4K0kERRRBQRBBFUEREQSlSRESKIigIgvRmAZSONOm997LAsvmf7+jNP5uyJZtt2e99npAlk0xmJpPk5Nx7z01ms9lsQkRERETkBX7eWAkREREREYNLIiIiIvIqZi6JiIiIyGsYXBIRERGR1zC4JCIiIiKvYXBJRERERF7D4JKIiIiIvIbBJRERERF5DYNLIiIiIkp6wWWyZMmidbl27Vq8bu+dO3fk2LFj8boNScHjjz+ur/eQIUPE1+D8MefzoUOHJKmLreNx5coVOXfunNfWR7GD7weixCNAEpkiRYpI1qxZI71fQED87dqcOXPkjTfekHfffVe6d+8eb9tBRBEbO3asvPfeezJv3jzJnj07DxcRUVIMLt966y3p3LmzJPRtPH36dHxvRpIwc+ZMzRJnzpxZfE2uXLlk3759+ne+fPnie3N80muvvRbfm0BRxPcDUeKR6IJLIqu8efP67AEJDAyU4sWLx/dmECUIfD8QJR6Jps8lERERESV8SSa4vHfvnowbN06qVasm6dKlk5QpU0qxYsWkX79+cvbsWbeP27Fjh7zwwgtSokQJSZs2rQQFBUm2bNmkUaNGMn/+/HD3RR9LDDY4fvy4/r9Hjx76f9wOM2bM0P/nzp070g7r1sFAZr1vvvmmLFy4ULc7efLkkj9/fvn2229jvI8RuXHjhgwfPlwqVKggwcHBkjp1ailTpoy88847LgdNmX189tln5fbt2/L222/rNqRIkUIyZcokTZs2lY0bN7p9vlWrVknjxo0lR44cuv3ly5eXCRMmSFhYmP3YRDagxxxH9KGz2Wzy5ZdfyiOPPKLbjwuOz1dffaXLvLHPxvnz57WvbcmSJSVVqlT62CpVqsiYMWMkJCTE6f6Rva7uBjBYH3fp0iXp06ePFChQQB+LcxPHfvfu3W63E+dtnTp1JEuWLLpvOB5z5861Px+ePyq6du2q98e+/vPPP07Lhw0bpsvTpEkjBw8elKjatm2bPPfcc5InTx49B3DszTkQkfXr10uHDh2kUKFCul84HmhKbdWqlaxevTrcfdG1xnou1atXT/+P89fA+fHTTz9J69attVsCtgUXHB88z19//SWe2Llzp3Tq1Emz7thGvC8aNGggCxYscLov+oNiu/z8/Fy+b77++mtdjj7mGzZs0NvWrVunt+G9g88EvAcLFiyo70GcJ/hcimhAVHSOY0zPx82bN8szzzyj60dmMkOGDPLoo4/Khx9+KDdv3ozWgB6cYy+99JIULlxYnxufgVjXp59+Knfv3nW6vzkHvvjiC103zmd8NuOxuEZ/eQ7KJPKQLZHApuLy1VdfRfuxZ86csZUvX14fnyxZMlv+/PltFStWtKVIkUJvy5gxo+3XX391etzEiRNtfn5+ep8MGTLYKlSoYCtevLgtefLk9u1566237Pf/8ssvbTVq1LAvL1y4sP4ftwO2HbfnypXL5XYePXrUvl78bbzzzjt626OPPmrz9/e3ZcmSxVauXDlbYGCgbf/+/THax4js27dP14PH43mLFi2qzxsQEKC35cuXT+9jZfaxQYMGttKlS+vfOXPm1GNnjgvWtWTJEqfne++99+z7ny1bNlvlypVtadOm1f+3bNnSvsyqdu3aetvgwYOdjmPWrFltHTp00L/Tp0+vxwPXZj0DBw70yj4Djm2mTJn0PnhdSpUqZStZsqS+FrgN6zh79my4x0T2ulrPh3/++cfpcc8++6yeS+b1xmPN+ZoqVSrb1q1bwz3fw4cPbT169LCvM0+ePLZKlSrZzxFzjLGPUXHjxg1bwYIF9TE1a9a0hYWF2Zf99ttvuk9YNmPGDFtUzZo1S/ffvOdwDmTOnFn///jjj7s8HvDmm2/al+E4Yr/w/jOvGy6TJ0+23//999/X96ZZhnMV/1+6dKkux74899xz9uU4ztiWAgUK2I8x1v3zzz/bomP8+PH245ImTRp9X+TNm9f+PO3atbOFhoba74+/cX5gWZEiRWx37tyxLzt06JAtODhYl7377rv229euXau34fx74okn9O/s2bPrMUmZMqX+H++rNWvWOG1fdI9jTM7HBQsW2NeL1xjPhX007xm8h65fv26/v7v3gzlvzOcL9hHrwnvX3L9MmTK2kydPhntMp06ddBneEzge2FY8P46b9RicOHEiWq8xEdlsPh9c4kuievXq+tjHHnvMHozBtWvXbF27drV/uFm//A8ePGj/khsxYoTt/v379mWXL1+2tW3b1h5IXLlyJdxz4ssZy6ZOnRru9pgGl7i0aNHCFhISordfuHAhRvsYkVu3bumXCh7XrFkz2+nTp+3LsI7GjRu7/MIz+2i+0JYvX25fhgC4bNmy9mDLCvfD7fiA/+yzzzQQAqz7lVdesa8zOsGlCRDHjRtn/8K+e/eu7fnnn7cHB+YYxmSfT506ZQ8s8UV19erVcAHAI488Yg/ArCJ7XSMLLnEpVqyY7c8//7Qvw2ufO3du+z5YISgwX77fffed/Xacv61atbKvM6rBpWMQ+fnnn+ttCAgQhOG29u3bR3ldhw8ftgcI/fr1s927d09vx2s3cuTIcOeA9XiYYArnzvTp0+3nDiCgMEEpfmxYl4FZ38qVK8Pdbs5jHCvHABI/LhD4YDkCzqhC4IrAKSgoKNw5CatWrdLtwzqHDBkS7nE4hxCIYln//v31tgcPHtjPq1q1aoVblzke5ofmJ598Yt9vvNY4L8zxwOdDTI+jJ+cjHp8jRw69/aOPPgq3/QhCEdRhGV53w937YdOmTfYgFe8/a0C6fft2e5CJH5c4bo7BpfmBd+DAAfuy33//3R649+nTJ4qvMBEl2uAysguCDauFCxfas2cIHhwhMDMf0m+88Ua4DIP5BewKfs2a5/zjjz/iLLjEF7AjT/cxImPHjrV/IFs/+A0EV2Y/keF13EdckJlwhNvM8ps3b9pvr1q1qt42YMAAl9vz1FNPeRRc9u7d22ldly5dsmdHrBlUT/e5b9++etvTTz/tctvPnTtnz8CazFhUXteoBJeO2SAYM2aM/ceEqy9znNuO8OPJBP7RCS4BwRAehwAI74uOHTvq/wsVKqTZzah66aWX9HEIYlzp0qWLy+OBDDQCNgTIrmzYsMH+OMcfV+6CS2QtEbCYYM7RzJkz9XEIhqPKtCwg2HMF54YJaHGOWk2bNs3+YwnB29ChQ+0tEo4ZOWtwiSDdEX5gmeDfGrx5ehw9OR/xnjCPsf4YM6ZMmWJr3ry5Xkf2fkArCW6rX7++y+0+cuSIPWP7zTffOAWX2GdXP7rx2RHdHxBE9C+/xFjnskaNGm4v6J9l9eOPP+p18+bNtf+QI/S5ef755/XvxYsX229/+eWXtcSNu/6B6Gdm4H5xAf0Q0XfKkaf7GBGzTvSX8vf3d1qOvmfoi+ZunXjMU0895XQ7+q4a169f12uUbfrzzz/1b/SZcqVv377iCfTxdIQ+buhvCNY+lJ7us3mcOcaO0O8MffocHxfZ6xqZnDlzSsWKFd0eY+u+bdq0Sfvdoj8Z+pY5Qn83nPOeQF9U9C29deuW9h1EeSisD/1G0e80qpYsWaLX7kqNuTs30D8PfVpnzZrltfcqatVinR988EGE60Sfxsj6ggL67qH/dkTnCd4vKKmF/oGOfRu7desmLVq0kIcPH0q7du3k/fff19unT5/utg83oL+1I/S9NMd40aJFXjuO0TkfsZ/oXwnt27eXP/74I9xxRL9QvK9wHRH06167dm2EnxHo/4ljB+jb7Khy5coua5y62m4i8tFSRNGtc7lnzx77lzo60rty9epVe4dwJDOsHf0xgGfLli26nsOHD+sFndP3799vv09Uvly8AUFIbOxjROucOnVquC8gKzOrifVYGBkzZtRgzJH1ttDQUL3++++/dZsw8MNdkIUvAE9goIArZjvMNni6zwiozAAuDL7AgCpXzMAAV8fK3esaG/uGH2euXpeYHGMMJkFAggFQpi4ngrLorA8B1cmTJ/Xv0qVLu7xPuXLl9Lx1NRDLOuhl7969cuTIER30sWvXrnCDP6LzXsUPDARbWCdeN6wTA5cQJJptNevEc0fEHH8wgY4rZuCXq/NkypQp+iPBDJ7Cj4FmzZq5XReCPXfnSNmyZfXacaBVTI5jdM5HHNtRo0bpYMmlS5fqBcEmBprVr19fB/VFFDQb2L779+/r35UqVXJ7PyzDD4YDBw7EaLuJyEeDy+gy2TF8GVi/EFxBVgAjFDEq3IzEHDRokNNIa/wSRiYBQUhcchcUxGQf3THrxBeZq5HAVq5+2SMoj4wJEjDCFBBcuhPZ9roT2XZYAxVP9tk8xjGAiOxxUXldIxOVY2zE5jEGjNAtVaqUPQONQDA6zI+fiLYR+4vsGbJVjq/hxx9/rAGt9fgiUMIIfIx8/uabb6K1PQ8ePJDBgwfL+PHjw400RlCE1pGqVau6HN3tjvU8+e233zw6T5Dtq169uv15IzvG+IHnjjnG1u2K6XGMzvkIyErix84nn3wiK1eu1HPghx9+0AueExU5MJI7oiATlR0MjA6P7Nx2HIEele12V1WCiNxLdM3i0WWaiT///HP9kIjsYg0skSFFYNmwYUOZPHmyfilgHmL8WkZpFE+5+7By/NKM7X2MyjqRDY1sfTgmMWGey/pF4cjVl4K3ebLP1m4IyGhH9jiU2YkPsX2MUW4JgaXJ4HXp0iVcwBgZayDkbhtx/NAM7QgZY5SAQkCEsjYoJ4RtwXqQSUUpnuhCRm306NGaFcPfs2fP1owljtH27dvlxRdf9Oj4o0tGVN6jCLhclZBCYGmOMZq88VnkTkSfJyaoNN1DYus4RgalxFDuCe+n5cuXa8sUsow4Bj///LM0adIkwuDO2u3CGig7MudidLppEJHnfD64xC9u0/TqDrJ9aG46c+aM/baRI0fqdceOHWXZsmX6BYOsgekndOrUqWhvi5nv3NUXJFifPy72MabrRHYPtf4uXrwoMWH6yaIfF7oduOKuud+bPNnn9OnTa5/KyB6HwBPBSXQCLm8yxxhNm65q/sXkGKPJ1NQZRWYLz4V+tD179ozyOtAP0ExxieDNFTRpOjZRIsOIbBsMHTpU+3mihiSa5E12LrrvVbxH8OMS0DqBH5bo54hMockyR3ed5ty6fPmyvWuFK7/++qsGco6vEbbJBLToG4kfvOiSgf6baI1w5cSJE25/MJj+n8g2x9ZxjAiCduwn6lwCjiuaw9GXFO8v1F015yTOL3dQi9N8rm7dutXt/UxNUmRKiSj2+XxwaQZ04MPywoULLu+DAQ4oJI3CzcbRo0cj7Mczbdo0+9+OX3gms+D4i9vMf41f6a62xQwMiat9jMo6sZ+ughHsM/p7YSDHgAEDJCbQz9I08aHguSv4go9tnu4zsiuAJlRXfdGQUUFfMvRJHDt2rMSHxx57TLNU+FJ31bSJc9WTbh7oI4gBGVgvBjshCMMgEzQfz5s3z+3gEFdQpNv0LXQVMLnaPjT3I8jy9L1q+h5b36voQ2v+72qdeI1RhN/dOl3B4BB0HTAtDK6gZaRmzZpahB8/BA1sC1pR8LmByQCQscT7AVk4DIQxP4Qd4Rhai8Ib+BGHQVfQpk0brxzH6MIPduwnmr5d/dg2A+DMfkSUEa5bt67+7e69hewusqPgapAhEcUCWyLhaZ1LlFhBAV08FqVA9uzZY1+GMimm/AlK0yxbtsy+zJRlQUFd1DE0UEMNpTdMcWBXJXfM81nL45gac6Z2JkqdmFqJ2EaUwTH1At2VIkKRZ2/uY0SwraZ0zZNPPmk7fvy4fRnqMKIuoynjsWvXrhiXWzLllFD+BeVHTEFu7Ju11El0SxE5Fls2TEkh6/nk6T7jOUwdQryuFy9etC87duyYvVh3unTpbOfPn4/y6xpZKSJ3j7OWorEypZawrYsWLbLfjvJV1uLq0SlFZMowocyMtWaoKcaNfbYex4igHAwKp+NxKH5vyhjhXEDpJ+v7wxwP1C1EOR5Twgg1aA1sjzn33ZXKMbUMrWXD8DjzXHg9b9++bV+GfbEW9MfF+pwRmTt3rt4fnx2jRo2y1/GEjRs3al1YU3PR1euGskd79+613/7FF1/o7fhMsdaWtL7+KF7+ww8/hNs3U9YLNSlNbdWYHEdPzkfsuymO/8wzz4R7PrzupkwQCv2b4+Tu/YCalNY6l9byVzt27ND9NLV1zf6CeQ53tVjNZ1l0S3MRUSKsc+nJDD2oIWidrQEfNpgZI3Xq1Pbb8AFutXjxYnsAiWACwRsuZjYTzEyCOn74GwWRrUydP3zgIdgbPny4fRmCIPOc+CJFHU1TgBsf4AjKohtcerqPkcEXlvnCw7HALCYIuk2ha+yfY2DtaXAJqMFpluF5UfvSBBumTie+9GMruPR0n02NQhOo4Mserzt+mJgvPbwOKDhuFdfBJWpdYhYVswwzw1SpUsUeGJtaozivowK1IU290G+//TbcMnyJlyhRQpfhNXIsXu4OiombmqA4Ztg+E/CjjqgJ+qzHA4GnNZjCscdzm2OP94EJZKxBNaAAuQnc8F40s2lZz0Vsj5nxxexvnTp17OvfuXOnLaowC5VZBwJv7J+ZEcq8b60/QPBD0XzmfPjhh+HWhaC7bt269seZH6vW19/MkoXnwD6Y8xiv/e7du8Otz9Pj6On5iNvx2YrbsY8oTI/3mvnMwjZYZxGK6H399ddf29dl6hOboBIXfHaj3qUVg0ui2JMkgkuTnRk9erQGKfiywAcmvrRat25tW79+vcvH4Nc5Cvnigxj3N18GKDyMAuCmkDGyXFb4pY9CxLg/PugwpZvV7NmzdSYdfKnjUq1aNZ2+DDwNLj3dx8igmDP2E1802FYETjgeCKBdfanGJLg0GUxMWYdpGvFFiC80ZDIxvSIegwAuNoNLT/bZQAHx1157Tb+Q8brjyw4z/vTq1cvpiy0+gksTkGD2FZxzOJb4AsfsTgiY58yZY/8ijgyyvOZcRSbPFUwuYH6gIVMXVZiR5oUXXtDXCOcAgt1hw4ZpFttVcAmrV6+21atXTycSwHmPH2x4j02YMEEfZ37wde/e3em58DgENLhYpwT9/vvvdR2YLQbrxMw0eK/jvYrjaAJTzOAVHZhRBtkyZOVwjuB5cZ7jR6h1YgFk7EzhdQT+rgr747wywRh+nDq+/sgIopA6ZslBAIeAC0XvHYu0x+Q4xuR8xAw6yFKjqDuOBc5HbCMKmDtmvCN7X2PmJGQusS6cN9h2bBMmDUDheEcMLoliTzL8ExvN7UTeZEaOokO+Y20+8g5UQHjllVe0v9uKFSt4WBOpdevWaR9fM1DHDHghIoorPj+ghxIHFM7GgCN3pXpQZBlczQBCURt4g6LaGDCCkdw8xkREFFsYXFKCULRoUR0hi5Gw1qL1GJWK0cMYHYuRve6mAKTIS/1gijuUuunfv3+4ItkIPFHjEAE8SsK4mh6SiIgoqtgsTgkCmrpRLgf1IzEvNcq2INDBtIkowYLyTh999JEGRuQZBJaoj4ji2ji2OMY4rijVgnqICEBRRiiq5aooYWKzOBHFNwaXlGCgwPSkSZO03idqDSIIwrzbaMrt1auX1vijmEEhbMx/jj6VKLKNPnloLkc/S8xVjdqDlLgxuCSi+MbgkoiIiIi8hn0u4wBmxMBAFVwTERER+TIGl3Fg//79OqUaromIiIh8GYNLIiIiImJwSUREREQJDzOXREREROQ1DC6JiIiIyGsYXBIRERGR1zC4JCIiIiKvYXBJRERERF7D4JKIiIiIvIbBJRERERF5DYNLIiIiIvIaBpdERERE5DUMLomIiIjIaxhcEhEREZHXMLgkIiIiIq9hcElERERESTu4/OeffyR16tTSt29ft/dZtWqV1KtXT7JmzSpp0qSRKlWqyLRp08Rms7m8f2hoqEyZMkUqVaokadOmlYwZM0rDhg1l7dq1sbgnRERERL4l0QWX58+fl2bNmsmdO3fc3mfixIkaWG7YsEEqVKggderUkb1790qPHj2kc+fOTvcPCwuTDh06yIsvvihHjx6VJ598UsqUKSMrV66UJ554Qr788stY3isiIiIi35CogssdO3bIY489Jvv27XN7nwMHDkjv3r0lffr0smXLFlm+fLksXrxYH1OoUCGZOXOmzJs3L9xjpk+fLt9++61UrFhRDh8+LD/88IOsX79eVqxYIcmTJ5dXXnlFTpw4EQd7SERERJS4JYrg8urVqzJw4EB59NFH5dChQ1KgQAG39x01apRmIl9//XUpV66c/fa8efPKhAkT9O+PP/443GNGjhyp159//rlkyJDBfjuylmh6DwkJkfHjx8fCnhERERH5lkQRXI4bN04++ugjyZIli/z000/SsWNHt/ddsmSJXrdq1cppGZq7kdH8888/tXkd0Fx+5MgRyZEjh1SvXt3pMW3atNFrZD+JiIiIyAeCy9y5c2u28eDBg9K0aVO390PAePHiRUmRIoUULVrUabm/v78UL15c/961a5de7969W6/Rx9KVkiVLSrJkyXQQETKYRERERORegCQC3bt3j9L9Tp8+rdfIQiIgdAXL4OzZs+EekytXLpf3R6CKbCea5i9cuKDN667cu3dPL67cunUrSttPRERElNgliuAyqm7fvq3XqVKlcnuflClThgv4ovoYBJcRBYnotzls2DCPt52IiDyX/82ffeLwHfuwcXxvAlHSaBaPKjR7RxUG/Xj6GFcGDRok169fd3nByHMiIqL4hi5hr776qpQqVUpb5dA6lydPHnnqqad04Ordu3fjbdvWrVunrY64oPZ0bHv33Xf1uVCFJik5duyY/ThjkHRs8KngMjg4WK8jenOYZSis7uljXEHJIhRfd3WJ6HFERJ7CF0P9+vX1c6xYsWKyYMECp/ucOXNGP4fy58/PA53EvfPOO1r7GZVRTp06JQULFpTy5cuLn5+f/PLLL1rGD+fRtm3b4ntTKZHzqeDS9Js8d+6c2/vggxZy5swZ7jGmD6arwBJN4njzZc+ePRa2mogo+vDZhAoYq1ev1pnF8Nn2zDPPyG+//Rbufq+99prcvHmThziJ++qrr+S9997Tbl7ff/+9XLlyRYPITZs2yfHjx7VyCsr9nTx5Uho0aKCDY4k85VPBJaZsRLCI2Xsw046jhw8fyv79+8ONDi9btqxe//333y7XiTccFClSRJsPiIgSApRHQ1CAJk40Jy5cuFA/40aPHm2/D2YZc5w0gpKm999/X69ReaV169ZOXcJKlCihpf4wZfKlS5fks88+i6ctJV/gU8ElNG78b2doV81D+KBFH0j8yjejxgsXLqzNAJiB56+//nJ6DH7hQZMmTWJ924mIotNvygQFUKtWLb02mcv79+/r7GLuyqxR0oHWN8w+B4888ojb+6GWdPPmzfXvzZs3x9n2URINLjGQJbYu3vbyyy9LQECAjBgxQqd/NBA84oMW3nrrrXCP6dOnj73kEcoNGWvWrNEC7uhP2a9fP69vKxGRp0yXnu3bt4drZUHWCTV5MfEEagNzdjEKDAx0mmjEHVQ9QUve3LlznZbt3LlTXnjhBZ1KGS15mNEOM9nNnz/fbZ9gzHKH2fIweAjbkTlzZqlbt65MnTpVM+3Rgefv1KmTlgTE93KmTJm0Cd9VMim60DWuW7du2v0N+4YfbUOGDJFr1665vD8GHH3zzTdaexvvRTwG4ytQY7tnz5763nMFU1I//fTTmiE2x+Pxxx+XiRMn6g9CV27cuCHDhw/X/rLoX506dWr90Yg+tO62D9Dt4bnnntMBW+gOgcdgpsLYiL0cJbPZbLbI7hSdEdXRenIPR4RhhBfeAAgKx44d67QczUJvvPGGBpl40XBQESii7BBe9EmTJoW7Pw40fq2hmQkd3+vUqaMZzg0bNggOz6xZs6Rdu3Ye7ydeYGRLt27dqvOXExHFFL5w0F0HP4hr1qwp+/bt08DSBJyYcaxly5b6+YXP2nz58tmznb6IpYgihhHRyGrjXMAsd127dpUaNWpE+fsdwQ8CxQcPHmiAgyAKE5dgYJBJ2pimd1i0aJH2AUb9ZwRdGDyE71p0WTMlAPG9Onv2bPtj0L0D37+A58F3uIGgCN/5CEixPpz7ly9f1sSRWdfMmTOjFa+YWALBMn6Qoe419guB4p49e3R7MRAO24X3j7W/M1pJ165dq//HfRAk4nigzyogANy4caMGhAa6GphkFsZ94IL3rHlfIl5ZtWpVuH1AVz6M5Md9cDu2FTENfgAgfsJ2YTCWmSDGwHHt0qWLHkf8CMDjsA48H54H+wSYIAYtuPGSuUSAFVuX2IB5xXFi442D1D5KAWGmnRkzZtjnF7fCYB388hkzZoy+UPhlgSwARmHisTEJLImIYgN+CC9dulQqV66sX4QIGMxARZRGwxeztf8lJW0YIY6gDN+7X3/9tdSuXVvHKSBI+vDDD/W70l1G6/fff9eR5AhU3nzzTf1Bg25kCKSmT5+u36EffPCBdj0zzfAIbBBYvvTSSxp0IeuIGfHwN/oJw5w5c9yOd7BatmyZPj+CK7QmIluHpA36HCMYQxYQ60Kw6Al0GUDWEAmlAwcO6LbixxqylwjIOnToEO7+o0aN0sASASVaSBEwY1ppBLr4f44cOTSAxjExsM0DBw7Uv5EVRiCLx+CxiDkQMCLgM13xAOtAZhTb0KxZM10/tm/Hjh167PHa4RggE2qteIMprZGFxeuFVlcMcsZz4Ro1uU1gGe+ZS5w4SKd6s4MvThScVNFNiydGzFwSUWzDRzmyJWh+dFf9AvBl5otliZi5jBySJi+++KL8+uuvLpcjSOvRo4dmIa0TiyBzhuxY27Zt5bvvvnN6HJrK0cz97LPPauCEgUHt27fXYBZBkDUDCci44VxFQIf743ERZS6R/UNA9cknn2j1A1fBZ6NGjTRAw/OhuTw6mUtYsWKF1KtXL9xyBHKoB4o4BVlIUw8T13/88YcGuqa7ndXw4cNl6NChOp7DDCJG8I7R+MgiIuPqOIsgHoMapGjGRosDYP3IFqPFE0GrY1YWASUCYASYyCwjkIdevXppCy0ylCa7aoWsNaoHxGbmMsoz9KRLl05/6XgL1kdERJ7BFx8yFxiggSYwfDHjywYZDse6vWjJwRcvWmMimo2MfBta8BAkIVBDdQFkGpHRQiAHyEiiafvbb7/V8yl37txafQXdygCBqSsY4zBgwAApUKCA/h+ZNJS/wnnoGFgCmqCRNUUmDeuPCLJ22F54/vnnXd4HwS+yiGjyRWkuBMHRgaZwx8ASEBxioBwCtJ9//tkeXCI4xzFzN810qv/eY9Z9w7HBsUBWt3PnzppRRF9U4+2333Zaz48//qjXCL5dNffjPY2R/2h1Rbc+E1yafrV4HldwPxNcxpYoBZfoPGtGV3sLOs26m6ebiIgihmwDMkDI/KDfG76Ag4KCtL+5tZ8X4EsQWSkEFEQonI4LMncIgNAXE02zGKCCABPNxG3atNHsHJpizUATazBkhXMLF1fBD5qYcUFTLdaLFkt04zABbWSDS3Bfo0WLFm7vh4AVTKYwOiIaC4FyhQgu0UxuhcE4CBRRJxSDd7B/uEZ/5/PnzzvtG44PmsURvKNvKC6IgzAgCj/6kHlFgOxq35EVxg9EV0xdb7PfCOhNv8/SpUu7fAxeR3wmxFbXxCgHl7HRCdzar4CIiKIHmYwffvhBBymiyQzZF/SxdAwsiSKCLBuydrigaRZNpshcImhCly5rFjw6s82hPzAGrzhOL4h+wcgsYjmCs8hgcK3hOEGAK2b0NPo74jlcweh266QoZqY+V8wyaxYSWVnsGwbLmSAZ8OMOgWqFChW0G4GrDC8G96KCA/p3IjBEqwMuyGoiQ4llpmXX7DuarnGJyn5bj6m71wvbidfdDKyKDVFuFo8ObDBGMqJvAQuPExHFDtMXKzKxmaGghA8/QNBcjGbSwYMHu70fMo1TpkzRHy3IVqLrhamjaoIqlACKDDJ9GIiCzB36GaL/JcZtYF0mw4nyPVEJLtE3E9CP0lRDiApkEd0FoybLady6dcvtekyAh3jGQNcT7COOF8aPYB/RNxMj2JHRnDp1qsvg0mRfcUGMhAHD6H6AIBiZRwSreD70WTX7jv+jyTuqtbbR3cDAc7j7PMBgq0RTRB0dfZFCxihG9NVAxI8SGejjQURERHEP2UdkEKPSLQLf2ybjhaLqKGFj+vtZm6itMHIc/RExQhyBC0ZTI7BEPUv0T8SgF4zZMIElApuoBoro9wgYBBPR1M54HjRdm0wrqsO4q1LjOKAtoqZ0M8+6mYwAGV0zSAb9MNHfEV0I0J/V1BM99V95JitsFwbsoIsAIE5CAI7HY7sxihsQSJqA1ux7RCPqkdHE8TfTdSKhZ8ommRq4jvCjwZMykPESXKIcAUY5YUcRwaPGGvpU4pcD5r9FCpiIiIjilhkIgyAEQVdEMGoa844jA4aMHIJNM5AF3/OuoAwQvutRiQB9+cz0y+jb52ogCvobmn6ckQU5yHaa0cwop+QKnhuJLAR4CP6iC/2VXQViCCxRhskMUgLr1NJo4naE5vO5/xWgt+4bMsI4HngtXLUkWAcUmSo6CD5h2rRpToP0zPqRRa1SpYoOqDJatWplf05XFXmQWY1tXgkucaBQugAHGgce0Tmylei8i06o2DnHWXGIiIgo9iFwMQEHZqJDeRvHsRRoKsYIYjPSGgNPTAYTI5kRNGLAD/oyWoMm1Mw0ZQoxmAxMQW8EWdaBMHgO9Ck0dS4hstHigL6ggHqcmHnKOpMNMpYYMQ0Ihk0po+jGMDg+iF0MBJtovsYyHBO0ylr3Dd57771wfS5R6gkj1//5r3+kdd+wDvR1RPYX5ZSs/R2RxTXdFVD9wTRtY8ZBDKZG1hnBrSkYD8hUYp04vlivNbhErW8042PiFmST0Z3B7CdKFKHEUYKoc4mdQHrcHRQDxfRCiK7RGdgRXhQcnKicRL6IdS6JyJ19xf/fpy0hK7E//GjZhIZ1LiOGgAz1KJE1NF/7aF3Mli2bZsUQEKG5GoEKaj+iWLoVAhKUz0Fzt5nxBaOSzcho1HU0NSMR1CCTiPUic4nBZuiriTgA/RsRT2BgD5qIEWihfmVkM/QgwMR0h9h2DHjBOhGbmCAZTchoIXU1aj2yOpdovkf2En1Akf20NkVjMhY0f1vLJ2LmoXnz5tn7gqLMEJrtTVazXr169oLyaOJGEzhg4I7JIiNwxzFEoI5EHAJvjBbHMUDrr4FsMzKY6BKAmuPYPlyjaRuvF44RuiSa2pgG+tjiNvS7RN9NPA7N9aiBi0AV+4TEX2zVuYxScImDikgYJ5arGmmIilG4F4U7HdPWSK/jAOJxCEKTIgaXROQOg0uKSwhWMBoc/QbxnYzvaAQfCDQxTzdmdjF9/RyhJuann36qA1EQ2KHJHNlCBIjo/maFoAWZPTQrI6hBcIkpIFGbFSOtEdwgGYUgEX0ekRmNKLg0hcgRYyCIRFCLPo54PIIoZGOjM5rdGlyifidiHLSwYsYfJMJwDDCPObKHCLitEJShiwCal60BM1pvsa7GjRtrv0dkGjFIBwOaDBw7ZG/RfI99wHFBcIoBO4ixHMsRAQJXZIcx0AfPh6ASGU0USe/fv789q+oIQSsyvSgzheAUY2Ewkxdm8MJgpHgPLtERF83cGLqPFwNpdUTOVjiYGB2FiB6RPjqV4oRCGh3RPOo7WadCSkoYXBKROwwuicjXRCm4BETMSJPjFwb6HCBQbN68ebg+A4iIEWCaqvVm1Rjog34Zrir1JwUMLonIHQaXRJRkg0tAXwv0q0QaGSnWatWqacoVI8MN9KFAfwuke9EXAVMnWTvAJkUMLonIHQaXRJSkg0sDnXQ//vhjvaCvATqbYhRXUg8i3WFwSUTuMLgkIl/jUSkidARFaQJ0LEXlf1SXR4dSjEQ7c+aM97eSiIiIiBKFGNW5xOioCRMm6JB9DG1HkzlGbg0ZMsReV4mIiIiIko5oBZcoEDp58mSdpgjXpjgq5tPERPAoOYAJ2zHYB+WHMHTeWmCUiIiIiHxblIJLFPlE4U/MrYlalqgkj+vSpUtL586ddaAPoN4VShZh0nsM5kHdKUzdhJpaREREROT7ohRcohAq5g5FoU38/cUXX2i9S/wfdSzN1EwGShShqRzTDKEYKQqIVq5cObb2gYiIiIgS02hxVJpHH0oUQ7dOgXTt2jWtuI8q/cePH3f5WASXo0ePljFjxug0REkRR4sTkTscLU5ESTJziZqVmBrKGlgCpnzEnOJmblFXMO0j5gPFNERERERE5NuiFFxiwA6auTERutWKFSt0kI+Z6D2ykeVERERE5NuiNB8jalpiCsf69evrZO6YWP3ChQs64TmgHyYRERERUZQyl23bttU5wzEaHIXTf/31Vw0sUXZo0aJF0qRJEx5JIiIiIopa5hLq1aunF5Qlunjxova3xEw9RERERETRDi7tDwgIkBw5ckT3YURERESUBESpWdzf319q167t1SeuWbOmBqpERERE5DuiFN2hFGYUymFGW2ysk4iIkp7EUi80MiX2/zutcmxCzemZM2fKTz/9JLt27ZLLly9LihQptG71E088IT179pSiRYs6PS5ZsmRu1xkYGChp0qTRdWDwb58+fSRbtmzh7jNjxgzp0qWLy8dj3cmTJ9fZ/cqWLSvPPvusTsCC5BYlPlFOHaKW5fTp0732xBHVxiQiIiLvW7JkiQZ4ly5d0v9nzJhRp3a+cuWKlhxEsDl+/Hidhe+tt95yW54wa9as4W578OCBrgOThmzdulVn8lu2bJk88sgjLtdRo0YNp2RTSEiITsiCx+GCAHjx4sUc3+HLwSVGiffo0cNrT4wTKaJfQUREROQ9mClvwIAB9iowQ4cOlVKlStmXnz17VkaMGCETJ06UwYMHy927d52mdwYEnZ07d3b5HAhOGzduLKdOnZJ27dppLWxkJB2h6owrYWFh8tlnn8lrr72mtbWxPe+//34M9poSbHCJ2XkYCBIRESVOCOYGDhyofyOoHDZsmNN9MFh3woQJ2jSNoPKDDz6Q5s2bS6VKlaL8PGjSnjx5sgaYR44c0Uxpq1atovx4Pz8/6du3r/z+++/y/fffawYUWVQ0u5OPBZfHjh2L/S0hIiIir0NL4QsvvCAPHz7UetWuAkurIUOGaP/IkydPyieffCKzZ8+O1vM99dRT2ocTzdybNm2KVnBptGjRQoNLNLUfPHgwXIaVEj4O1yYiIvLxrOW+ff8OFDLZy4gEBQXZx1hUq1Yt2s+Hls7g4GANLm/evOnBFoukS5fO/ren66D4w+CSiIjIh61atUqvMfK6bt26UXrMk08+6fHzXb9+XSdbgTx58ni0DjO9dEzWQQm8ziURERElTvv379fr/PnzS9q0aWP9+dCUbqDvZXTdu3dPBxVBuXLlJFeuXF7dPop9zFwSERH5MPRbhCxZssTacyAgxACeWbNmyUcffaS3PfPMM1K+fPko9wtF/c2//vpLR4ejnyWa10eOHBlr20yxh8ElERGRD0udOrW9FqU3oE6mu2LoRtOmTWXq1Klul0dWgQbli8aNG6eDgyjxYXBJRETkw1BiCEzh9JhyVUQdo8PTp08vpUuXlkaNGknVqlUjXIdjEXWUIEIQnD17dqlcubK0adPG6Tko8WBwSURE5MOKFSum1yhsjsE21pHY7iAQvXXrlvbTjE4R9ahyV0SdkviAnvv373t3S4iIiMjrmjVrpteoc7lmzZooPQZN2gUKFNA5xvl9T3EWXCLN3rt3b51DlIiIiBImBIlmju/Ro0fr4JmIIJg0/SVLlCihdS+J4iS4vHr1qpYKQL8KlAoYO3asva5VQvHjjz9KnTp1tAkAnYMLFSqkAfH58+fd1gKrV6+e9vNIkyaNVKlSRaZNmxbpG5GIiCghw3c0BtH88ccfkc7VjULrR48e1X6Qb7/9dpxtI/kOv5j0l+jWrZvWzNq9e7f0799fcufOLS1btpTFixdr+j0+vfPOO7ot69ev17lOMeLs7t27Mn78eA2GDx06FO7+CJQRWG7YsEEqVKigQenevXulR48eMe5bQkREFJ8w7eOgQYP0bwSM7dq1k7///ttpqufnn39eA1HzPYrBNURxFlxWr15dpkyZIufOnZM5c+ZI/fr1JSwsTBYuXKgT3aPo6euvv+508sYFPOfw4cN15BmC4I0bN+p2oQZX69atNXPZp08f+/0PHDigGU2MdNuyZYssX75cA2RMl4Vs58yZM2XevHlxvh9ERETegozlmDFjdKaeuXPn6shudHFDCyRGgKP5HPOIoxl81KhRMnToUB58ip/R4mhufvbZZ/WCoO2bb77RC7KZOIlRqb9SpUrStWtXee6556I0Si2mEByiKRsT3yMItpZKwJtr/vz5sm7dOvvteBMhMEYwjKymkTdvXpkwYYI0bNhQPv74Y2nbtm2sbzsREUVfif3/zp1NEevXr5+9BiW+BzHN4rZt2yRVqlRa8BzTPvbs2VMTK0SeSmaLpQ6F6K+BX0Yffvih3L592x6IInPYt29fqVixosQWFF7Fczz++OOydu3acMt+++03eeyxx3Su0hMnTuht6GOJ/qKYIsuUbDDQvJ85c2a5du2aZmmzZcsW7e3BGxcBNgY/xeZ+E1His694CUkMGLwRUbzNLX7nzh1tJkcWENM2oU4W4tdMmTJpdhBTQ2GgzEsvvRRr/TIbNGigHZHxq+y1117TIBLbtXr1avusAuiwDMi2IrBEVhMlFxyh+aB48eL6965du2Jle4mIiIh8hVeCSwSPK1eulI4dO2pmr0OHDvLDDz/oXKNIv2PU9tmzZ+XMmTPavIz0O/prohBrbEAwOGPGDAkODtaOyfny5dP+l0j3Y5T7ggUL5OWXX9b7nj59Wq/R78TddFRmdgPsgzvYV8yL6uqCAJuIEgd8duCzwNUFAx4++OADp9sxCIKIiLzQ5xL9KtG/EplKBF6mhR1Ny8gQdurUKVwzcsaMGbW/B0aVo4/m119/rf0dYwOmlkJgi4E4yJQic4rmaQS4eE6MCEfnZdNkj4DXnZQpU+p1REEisrTDhg2LhT0horiEvtam6DTcvHlTC0/jRya6yOBzD55++mn7D1KOqCUi8kJwiY6/5kMWQSXqQmLACwbuWAfRuFKtWjW9jq2MHvo2oqwQspUY/Y1AEh48eKClGDDQyJQaQrN3VKFZ3x2sF4GzKzt27JDatWt7sCdE8ZvBM91IXPWpNtPC4QcbWgvw4xGZvcSubt26ejHQxQfB5VdffaWfc3v27NEfq4sWLYrX7SQi8rng0vQ/xOAYBJQILCPK/lmhqRili8yMAd726quvavM3vhxNYAmBgYE6O8HmzZu1RBGW16xZU5ehBqY7Zhm+WNzBYCVcXInocUSJNYNnoF8zliG49DUoX/bZZ59Jo0aNtC83fqCidFnOnDmlV69e+tmAer/4HCQiohgGl2+++aYGlYULF472Y0uVKiW//PKLxAZ82GMGAmQkEcA6QjMWvigQXP7111/aPA8YCe4OMjOALxSipCKyDB6gr7Uv14DFpAuYCs/0D0dgiQDz+PHjMmnSJL0NgxRxHFCdgoiIYjCgB53aEViawTyO0BcTxccx0CUuXb9+XbcJQWRAgOvY2dyOLw1kW1DwHaPJ0dTnCCPaUaIIypQpE8tbT5Q4Mnjm/fPKK6/47PsCn134DEPtW/ThhtDQUN1/dIO5fPmyzuyF2/Bjm4iIvDBaHH0JMSgGUyteuHAh3DIM8kF/rZIlS+r94gpqVqI/FD7wly5d6vI+K1as0GvTZN64cWO9xihyRwicEbCiTqUZNU6U1Dhm8OCjjz6SgwcP6jJfhNJlCCAxjay1rzlaXfDjGj9MUWwaU+BisCA+c4iIKAbBJebmrlWrltaQxIcrioxbYTopNCMjG4jm6Yianb0J9S1RQxNQbgid761ZyPfee09WrVolGTJksM8ZjvshmzlixAgdAGRg35CZgdgqm0SUGDN4piRP+/bt9XPAF61fv16vTaYW8Dm3fft2+49ptJCgLzc+WyIa8EdElJR4HFyaAumYYvHUqVNOBchRlgfTSrVq1UouXboUayWHXMF8qE2aNNHtwhcivvww3zmms3rnnXe0v9j333+vGU4oW7asflEiQ4kvT4w0R5kRZF0PHz6s2Qlr9oIoKXGVwcOgOfwgwwA5X/X7779r323rlLAYBIhZtoYPH67/R8YSxwZdAzAfMxERxWD6R5QhwYhsBHAoVu4OfumjTyOalJHtjCvYLXwRYPDBzp07daAPMqnIomJ2Hlfzpv700086Fzq+MJCRQL1OZDVRFB4ZUU9x+kdKzPB+QRP4pk2b7BUe3E044FimKDHDPiCAtn5uoQUGAxKvXLmiP0RRzgyfg999951WzPAEp38kIl/j8WhxFE1Hxi+iwBLSp0+vQRo+hOMSvvzQ59NdnT5XkK3EhYgizuBZSxQBaj5isgH8eItqSbKEDtPCOg5Wyp49uyxfvlxr2uJHI0oyodXD08CSiMgXeRxcojM7mrujAs3nvvKFQ/FTqBv3wX3//PNPzoYSx06ePKmvQ4oUKey3LVy40OnHHAbTOd6emJnZuxxhNp4NGzbE+fYQEfl8cFm6dGmtebd27Vqd7cYdNKWhWckUKyeKbqFuDCbBVKGUcDJ4RERE7njckRDzhqNfI4qQm9I+jtatWyetW7fWrEbHjh09fSryYSjSjWyXuWCwBKCvLM4vDKYy5xrFXwYPPxIjgtfHF6Z+JCKieMxcPv/88zozBQJL1LlEBgp9MDESG9knlADCLBb40sHMFdHp+0hJk2OhbtRHnTx5stYhxUAKzBlPREREPhpcmqLj/fv3l6lTp2ogiYsVRlgjCJ0wYUKMRltT0izUjX69GIXbpk2bCLteELmT/82fE/zBWRbfG0BElJCCy9SpU8sXX3wh7777rvz888/atxI133A76l42bNhQZ/Ah8qRQN7LhuBAREVESCS6t5Tm6devmjVVREi/UjeLcRERElMSDy6hAsfXcuXPH1dORD0y1R96TGAp1l9i/L743gYiI4ju4vHPnjpaI2b17t/7tOLduaGio3o7ActeuXdqfjiiqhbqJiIgoCQWXmNaxevXqcuDAAadlGCFunR6OZWTIk0LdRERElPh4PIR73Lhxsn//fg0iMZIXhbARRCLz1K5dOy2ajnl5ActRZoYookLdpmg6ERERJcHM5eLFizWwRLN4+/bt5eHDh5IhQwbJmTOn1r8EzCeOEeO//fabNo8TRXeqPWtBfiIiIvLhzOXhw4clU6ZMGlgC+suVL19eA0mjZMmSMmXKFO1rOXbsWO9sMRERERH5XnCJTFO+fPnC3VaiRAm5ceNGuGLqyFxmzZrVPhqYiIiIiHyXx8FlunTpnJq6CxYsqNfoi2mFQtgYMU5EREREvs3j4BJN3piR58KFC/bbChcurIN6tm/f7jRYg9M/EhEREfk+jwf0PPXUU7Jx40Zp2bKlzi2OJvEqVarossmTJ8uLL76oA3x++OEHbSYvXbq0N7ebEhgW6SYiIqIYZS5feuklnXEHxa/LlCmjc0Oj+bt27dpy4sQJnVu8cuXK8swzz+io8qZNm/KIExEREfm4GPW5xHzQtWrVkowZM0ry5MntWUvUK8Q80du2bdMSRWguHzhwoDe3m4iIiIh8bfrHIkWKaP1Ba79LZCz37Nkj06dPl6NHj0rx4sWlW7duEhwc7I3tJSIiIiJfDC7feOMNDSQ7duyopYassmTJwkwlERERURLkcXCJmXnQzxJTPQYFBXl3q4iIiIgoafW5RLF09KVMlSqVd7eIiIiIiJJecFmpUiU5cOCAnD9/3rtbRERERERJL7icNm2apE2bVmrWrKlN5Ciojikhw8LC3F6IiIiIyLd53Oeya9eu2iSOoBJ/Rwa1LkNDQz19OiIiIiLy5eBy06ZN9r8x5SMRERERkcfB5dq1a3n0iIiIiMg7wSWmeaSE78MPP5Tx48fLzZs3pXHjxvLFF19oX1mjS5cuMmPGDPnzzz91uk4iIiKieBnQQwnfqFGjZNCgQRIQEKDzvs+dO1f69+9vXz5z5kwdjEVEREQU75lLBCbRhdl8KG48ePBAg8vs2bPL7t27JUWKFDqj0o4dOzSL+frrr+s88EREREQJIrjs3LmzjgCPCgz4wX0ZXMadXbt2ydWrV6V169b2ed0x1zsgwERgiWbyc+fOydatW+Nwyygq3RZQQ7Zbt27aXaFgwYLy+eefy5NPPsmDR0REvhtcopnVXXCJepfXrl3T0kO4T7NmzSRNmjQx2U6KpmPHjtkzmI899pgGmw0aNNDgJWPGjPLdd99JmzZtpE6dOjy28dxtIV++fPZuC6lTp5ZJkyZJixYtZP/+/VK1alX9MdC8eXM5ePCg5MyZk68XERH5ZnBpghd3QkJC5KeffpJXXnlFzp49Kxs3bvT0qcgDd+7c0etFixZJ8eLFJU+ePDJ//ny9/eeff9ZghhJmt4X169fLvn37pF27djJ79mz5+OOPtRvDN998IwMHDuTLRkRESXNAD74s27ZtK7NmzZItW7bI6NGjY+upyM3xhwIFCmjWEhcEmUuXLpUzZ87wmCWQbgvIKqPbQmBgoHZbQDO4qSFbvXp1vcYsWID3ERERkST10eL169fXZj9kYCju5M6dW6+RDUPg4u/vL+XLl9fbTp8+zZcigXVbQD9LdFO4fPmyPfhH9wXrNV83IiLy6Wbx6MCXI5r5KO4gkET/vW3btsn169c1eEEfPkCwTwm32wKaygE/CgClpODu3bvxuMVEREQJJHOJ/pZ79+7lgJ44ljJlSundu7dcvHhRypYtK5UqVdL+fBg9njVr1rjeHIpGt4WwsDBd9vDhQ3t207ymREREPpu5PHLkSISlh+7du6eZsnfeeUfu379v7zdGcWfEiBEaqHz55Zea9eratat8+umnfAkSYLcFk23GewalhwB9Mq3X5jFEREQ+GVwWKVIkSvdDoIkvzzfffNPTpyIPoZ8lRiTj4s66det4fBNotwVUWOjZs6f89ttv+n+UJSIiIvLZZnEEjZFdAM2xKElUpUoViWtoEsZ0h8gOoRkyQ4YM0rBhQ7cB1apVq6RevXrabIy6nNjmadOm2feFKC66LTz77LNSqFAhrXv56KOPyltvvaWBaIcOHfgCEBGR72YuzWwvblccECCZMmWy9y2LaxhA9MQTT2ifz/z580ujRo10m5cvXy4rVqyQH3/8UYu7GxMnTpSXX35ZgoKC5PHHH9frNWvWSI8ePTSDxDm4Ka66LeDcQy1SnHubN2/WfpmYoSdHjhx8EYiIKMFLZvPBtBxmBkImCIMkXnvtNa2xiSZimD59uk6rly5dOjl//rwkT55cp9orWbKkNk0iq1muXDm974kTJ6Ru3bpy+PBhndEGdTs9gaZPbA+mWaxYsaL4on3FS0hCV2J/0q1YkFRfn/xv/iwJ3bKFAyQxSMrvHyKK49Hiq1evlvbt29tHthoI4BCYIVMY15CVRGBZq1Yt+eSTT+yBJSA7hKZxNJFv375db0OfRGSQMAuKCSwBs9hMmDBB/8YsKUREREQUi3Uu3377bfnggw/072HDhknhwoXtyzAPMgYiYCo7jBgfOnSoxBVkGeGNN95wuXzZsmXh/r9kyRK9btWqldN9n3zySUmfPr3OnIJMZ7Zs2SSuJYrsS3xvABERESXuzOWCBQvk/fffl2TJkkn37t01ALMaO3as9O3bV/z8/DTwXLt2rcSVv/76S6+rVasmV65ckUmTJumoW8xzPm/evHBZVgSMGFRh5nZ2hKwn6g8CsqFEREREFAuZSwRsCCwxGKFTp05Oy9HHEBc0M3fp0kUHKtSpU0diG2pqHj9+XINF9HFs166dXLp0yb4czdzo94hsJQZImCn18Df2xxUzkAKDg9xBXU9cXLl161YM94qIiIjIx4NLDFJBUWdXgaUVlqPG5R9//CFx4caNG3qN7GSLFi20lAv6VBYrVkx2794tffr00SZujBTftGmT3L59W++fKlUqt+s0M6NEFCSOHDlSM7SUtCSGLgvAbgtERJTgm8VROiWq/Q8xb/LNmzclLoSEhNinzEMf0F9++UUzqKhbiWbylStX6nYjwMS8ztbBPpEx0/K5MmjQIC2G7eqCfqdERERESYHHwWWuXLl00A6aoSOCDCJK+WTJkkXiAopNG6hbiXqbVihBZIpRY6R7cHCwPVh2xyxDgOoOShqhlJGrS0SPIyIiIvIlHgeXKDOEbOR7770X4f0++ugjnRu5du3aEhcQzCHQAxSfdsXcjoE8CJLh3Llzbtd55swZvc6ZM2csbDERERGR7/A4uMTIa2QF0dcQg2ZQfBxBJJqjMUJ7w4YN0rlzZxkyZIg2PaOYeVzAc5UqVUr/NoN1HJlAEtM8ZsyYUQPMO3fuuJx1CJlXM+dzmTJlYnXbiYiIiJJscIn5kDECHCOsUVcSUy1mzpxZR2mjCRwjw2fOnKn3RSFz9HuMK02aNNHrWbNmOS3DhESmziWmeYTGjRvbyys5Qh9N9JvE9nP6PSIiIqJYnKGnV69emqGsX7++BAYGauBmLqhviaZwBGe9e/eWuISalqi7uWrVKi3ybma4xDUKuqMOJgb7NG3aNFzfTMz1vGXLFvt6MP0jMrTw1ltvxek+EBERESW5GXqgevXqmgnEoBcEY5cvX9ZBNYUKFYq3gSzIMM6dO1datmwpgwcPlq+++kqbtFGK6NChQ9oUPmfOHAkKCrJnYRGEYkafGjVqaEYT5YfWrFmjpYoQrGJdRERERBTLc4vDP//8o8EYakki2ETh9F9//VWzmvEF84djRh0UcEd5op9//lmLnPfo0UOLq1epUiXc/TGvOEoTIbjcvHmzlg8qWbKkzJgxwz6/OBERERHFYuby5MmT8txzz2kxcoy8zpAhg30ZArKlS5fKI488olnEfPnySVxD0/f06dOjfP+nn35aL0REREQUx5lLzMmNouS///67Duox5XqsTdMoCYTAE4N94qqIOhERERElwuASJYgQUKIZ+ciRI/byP8aUKVPk2LFjUrNmTS3xM3r0aG9sLxERERH5YnCJJm+UHZo/f75O7+gK6khi4AxGkrsq80NEREREvsXj4BIjw4sXLx7p/OIoUF60aFGXBcqJiIiIyLd4HFxiTm6U6YmKsLAwzV4SEfmKU5O6SsiJXZIQzbt2TWZdvaJ/z756Vcoe2C+VDh6wXy6HhuqynXfvSstjR/W2508clxP37+vtIWFh0uHEcbkbFhav+0FESSy4RNkh1IzcuXNnhPfD1In79u3TLCcREcWuK6GhMufqVXkm/b/VOw7cC5H+WbLK1qLF7JdMAQFyLyxMXj19WrplzCR/FCkq1VOllv7/DcxM4ecnT6dNJ19cvsyXi4jirhRR+/btdaR427ZttT6kq+ARwWfr1q3172eeecbTpyIiijd3j+2Qq2umSej18xKYOa9kaviqBGX5t7Ta3UN/yuXlE+XhrcuSpvQTkrFeT7393pkDcnXdV/Lg0gmxPQyVVEWrS6aneksyP3/NeAZXaCQ3ty8V2/278l4KfxmaLbs+7vSD+/LOuXOy426IZArwlwFZskq94GB5YLPJ+EuXZPGN6/LQJtI0bVrpkyWLBCZL5rS9c65dlTpp0tiXHbh3TxoFp3W63+Y7dySdv580TvvvshczZZKZV6/IoXv3pHDy5NIobVppeOSwvJApo6T284/VY0xEvsXj4LJ79+5aQxIFyTH7DUaNo3g6ZuVB2aE9e/ZoIfXQ0FBdjqkiiYgSk4e3rsrFH9+XzI1ek5RFH5UbW36US4tHS86u43X5vTP7JUfHMfLwzg05O+NVSVWilqTIXVIu/vSRpH+svaQpXVceXDsn52b2k5BjOyRlwUr6uJBj2yRnl88k9OYl+emrVzVYrJAylfQ9fUaqpkolE3PnkT1370qPUyelQspCsuD6Nfnzzh2Zly+/IMx79cxp+frKFemeKZPTNi+6cUPG5cz17/bbbPLPvXvy9dUr8vrZM5I5IED6Zs4itdOkkaP370vBoOT2x/knSyZ5AoP0dgSXqf38pEyKFLLq5i1pli5dnB1zIkrCwSX6UC5evFhnwFm+fLnOxrNx40b7cjOfd61atbSIOkaWExElJneP/ClBWQtKqmLV9f9pKz8tKfKUti9PW7Wl+CVPrZegLPk1uym5S0q2Z0ZIYIYcEnbvtoTdviZ+KYPl4e1r9selKd9I/FKkkaAUaaR4iuRy4v4Dyex/X5uwZ+fNK0HJkknFVKlkZt58GuQtun5DhmTLpsEh9MyUWUZeOO8UXJ5/8EAvRZP/GzRee/hQA8Rn02eQaqlTy++3b2vT9/f588ldW5ik8Auf+cT/rf0sS6ZIIdvu3mFwSURxN0NP9uzZdV7xLVu2aKCJZnAztzhGiDdq1Ehq164dk6cgIoo3CAj9g/8fwCXzD5TkOYvZ/++XIvX/74ym47CH+ue903vlwry3xRb2UIKyFxZb6AP85Lbf1T/V/5upkYkME5tcfvhQ0vv7S5Df/7vCl/rvR/m50AfS58xpeyd5rMm5QVzkfGioriPgvyZx9K38Ou//Z0d7PE0aqZoqpfx6+7akSOYnIWH/3ybA/1NZnj9LQIDsCQmJ3kEjoiQvRsGlUbVqVb0QEfkSBJYPj26z/x/9J6+unyEZanV0+5jQG5fkyvIJkr3jJ5rNhDNf9Y70ubIGBGim8X5YmD3AnHHlitRKnVozlh/nyCllU6bU22+HPZSrof8GslZIRFrDRfSfXH3rpryYKbP9tvs2myRP5ifZAgNk0Y3r9tvRhH7iwX0pEBRkvw2xp8ejPokoyYqzz427d+/G1VMREXlFyoKV5cGFo3Ln0Gax2cLk5taf5N6J3ZIs4P8BmKOw+3c0r5gsILlmLm/uXC4PLhzTwDQiOQMDpXSKlDL+8iUdwLPtzh354vIlCfb3lyZp08qEy5c0+ESzNQb9jLhw3mkd2QIC5frDh/p4SOPnJ1MuX5YVN29ImM0mK2/elN0hIfJEmjTySKpUcik0VBZdv64B5+TLlyVPYKAU+q9JHS49DNV1EhHFWeYS/Sp/+eUX2b17t9y5c0frWVphMA9uP3XqlKxbt04uXboUk6cjIopT/qnSSZaWQ3S0+KXFYyQoW0HJ3GxghI8JypxXgqs0k3MzXxNJ5qfN6KmKPyYPLp+M9Pk+zplThp0/JzUP/aNN2qNz5tSm6Z4ZM8nYS5ekxbGjcicsTKqkSiXvZ8/h9HjcN09QkOwNCZFyKVNK9sBA+TRnLhlz8aIMOntW8gYFyfhcuXXd8EXuPPp8w8+f176fn/w3EMjYfTdEWqbnYB4iiqPgMiQkRBo2bBhuEE9EQWgyFyUziIgSuhR5y0iOzuOcbs/90vRw/8/e7kP732g2d9d07vg4a59IZC8n53aeThfN5G9kzaqXyDwVHCxrb93S4BJqpUmjF1fQpxMj0F25+fChljGqmdr1Y4mIvN4sPnHiRB0hjsCxQIECUqlSJf07f/78Uq1aNZ1v3IwYr169uqxevdrTpyIioih6PkNGWXXrpjZ1x8RPN25Iq/TpdLQ6EVF0ePypsWDBAs1Gjho1SkeJI4OJckMVK1bU+pbHjh3TEkXp06fXZnMEoEREFLswWvz59Bnku2tXPV4Hpn9ceuOGdM/oXEeTiCjWgktM65guXTrp16+f/j958uRStmxZzWYa9erVk/Hjx2tR9bFjx3r6VEREFA3PZsggHTJk9PiYYfrH2fnyhStLREQU630uETBi5h1///9PC1aqVCn5888/5ezZs5Ijx7+dzTE95CuvvCIrV66UpA5zrFtlyJBBM7rov7p3716n+yMLDA8un5KwB+FrzQWkyyb+KMx857qE3rgYbplfUEoJzJhLR6rev3DUab0oj5LMP0AeXD2rRZ7DrTc4k/inziAPQ25J6LVz4dcbkFwCM//bH+z++cP2bg+AAQQFg4L0S+n0gwc6YtUqk7+/ZAsM1BIqx+8/CP+cyUSKJv+3nt/BeyES6tCaly8oUKefQ3Fo1AK0SufvL7kCAzXTcuT+fad9RRFoOHzvntzd9v+SMoBjj9fg/Pnzcvr06fDrTZdOChUqJA8ePNDMuyPMRoVz/8GV0xJ2P3wlhIC0WXQgyMO7N/8tqm09hoEpJDBTbv373rlDLgeDYCQyZnUJC7kVbpl/mowSkCajhN27Iw+u/jsHtLX+opmSEK85Xnur22Fh2rx57sEDueJwDJHpQl8/jELG7Czh1isiJf47hihr49jUmjswUNL6+8vF0FC9WAX7+engEjwGj3VUPHly8UuWTI7dv6+DVKyvT968eSVz5sw6CPDEiRPhHodZwFBHFwMId+zY4bTe0qVLS1BQkBw5csTpGAekyST+aTLoscUxDrevAUF6/PUYnj+io8Ot8Lrh9Qu9cUFn5LHyT5VeAtJm1nMB50S49fr5S1DWf1tu7l88LraH4c//Ww8fSho3xzCtn5/kDgrSecAPR3B+H71/T+461KzEa4rXFnONn3NYL4LG/EFBWn4I/SodFUmeXKePPHH/vtz6b6CmeX1y5col2bJlk6tXr8rRo+E/X1KmTCklSpTQv7dv366fEeZzjIiSEJuHMmbMaCtTpky420aMGGHz8/OzrV69OtztlStXtgUHB9uSqq1bt+JT3+nSvn17Xf7PP/+4XG4E5SzmtCxTk/62fAOX2DLW6+m0LEX+CrosT995Ltebu/dsXZ6ycFWnZRnqdNNlmZu96bQsKFshXYaL+Ac4LV+Uv4Btb7Hitlbp0jkt654xoy6bkSeP07JsAQG6DBf87bgcj8EyrMNxGZ4Ly/DcjssCkyWzr7dE8uROy+fNm6fHd8yYMU7LmjZtqssuXLjg8hhev35dl+NYOy7Da4JjhNfI6RjmLPb/Y+hivTlfmKLLUpd83GlZuhrP6bKsbYY5LQtIn8O+Xr+UaZ2Wz8mbT49DpwwZnJY9lz69LpufL7/TstR+fvZjWCgoyGn5+Fy5dFnfzFmcltVPE6zL1hQs5HJfdxQpqsurpEzptGzq1Kl6fHHtuKx27dq6LCQkxOV6T548qctbt27ttCx9rY56jLK0fNv5fMmU134MkwU5b1P2TmN1WZoKjZ2WBVdupsuyPz/aaRleD7NevE6Oy6fkzq3HoVemTE7LmgSn1WXLChR0ua/mtSmXIoXTsg+z59BlQ7Jmc1pWI1VqXbalcBGX6/21UGFdXid1GqdleL8A3j+OyypUqPD/z63/zhciSnqS4R9PgtJHHnlE5w8/c+aMZnng22+/lXbt2sknn3wiffv2td+3WLFiWo7o9u3wWbKkYtu2bTrgadasWfZf9dHJXObqMTnBZy7Hrxub4DOXORfM93rmMtcLUxJF5nLx7xMTfOaywA8LvJ65rPHe4gSfufzptwmJInNpXh9mLokoMh4Hl4MHD5aRI0dKy5YtZerUqfolffDgQSlevLh+uGNKSAzw+e2336RmzZoaYDo2Cye14HLr1q0eNRHlf/NnSeiWLRwgCV2J/d4//xLDawN8fRKuxPDaxNb7h4h8k8e9tXv37q0jwX/88UfJnTu33Lt3T7MJ5cuXl7///luDqdatW8tTTz2lo8qfeOIJ7245EREREflOcJk9e3ZZunSpNi0iQ4nR4jBp0iT9P7KUCDxv3bqlzVtvv/22N7ebiIiIiHxt+sdHH31Um8J37twZri8mmn/HjRunIwnRTN6/f38dXUhEREREvi1GwSX4+flJhQoVwt2GgBIZTCIiIiJKWlghl4iIiIi8hsElEREREXkNg0siIiIi8hoGl0RERETkNQwuiYiIiMhrGFwSERERkdcwuCQiIiIir2FwSURERERxW0R96NChMX4izC8+bNiwGK+HiIiIiBJ5cDlixAgNDj1ls9kYXBIRERElAVEKLmvVquUyuDx79qzOLQ4lS5aU8uXLS4YMGeTu3bvy999/y5YtW3RZnTp1pGDBgt7ediIiIiJKjMHlunXrnG47f/68VKpUSXLnzi2zZ8+WmjVrOt1n165d0qpVK9m5c6dMnTrVO1tMRERERL43oOftt9/WzOUPP/zgMrCEsmXLysKFC+Xq1asyePDgmGwnEREREflycLlkyRIpVqyYVK5cOcL7lSpVSi+rVq3y9KmIiIiIyNeDyxs3bkiKFCmiPKDn3r17Et/atGmjfUdnzJjhcjkC4Hr16knWrFklTZo0UqVKFZk2bZpuPxERERHFYnCZP39+2bNnjxw/fjzC+6G/JQb3FClSROITgsT58+e7XT5x4kQNLDds2CAVKlTQQUh79+6VHj16SOfOneN0W4mIiIiSXHDZtm1bCQ0NlRYtWsixY8fcBpZYjmxhfAZoGNHet29ft8sPHDggvXv3lvTp0+sI9+XLl8vixYtl3759UqhQIZk5c6bMmzcvTreZiIiIyGdHi7vSp08fmTt3ruzYsUOKFi2qg3pKly6tzcloMt++fbts2rRJwsLC5LHHHpOePXtKfLh//74899xz4u/vrxlJbJejUaNG6Xa+/vrrUq5cOfvtefPmlQkTJkjDhg3l448/1oCaiIiIiGIhuEyXLp2sWLFCunXrpn0V165dG65kkemniMAOTc6BgYESHzBKfdu2bfLNN99os7ir4BKDkwBlkxw9+eSTmtH8888/tfxStmzZ4mS7iYiIiJJUcAl58uTRABOBFwI0NC+j7FCmTJl0JDmCNWQz4wuC3jFjxsizzz4rzz//vMs+lwgYL168qIOTkIF1hIxn8eLFNQuLup3ol0lEREREsRBcGhhVjUtCcunSJenYsaMWeZ80aZLb+50+fVqvc+TI4XaKSywD1PV0B6Ph3Y2Iv3XrVjS3noiIiCgJB5cmmNu/f79cu3ZNmjRpos3it2/f1j6Y8aFr166alVyzZo02a7uDbYRUqVK5vU/KlCkjDRJHjhwpw4YNi9E2ExERESXZ0eLG6tWrpVq1atoXsXbt2tK8eXO9HSPIkTUcMmRInNeJxCAcjPbGAB1sU0TQ7B1VGPTjzqBBg+T69esuL+vXr4/W9hMRERElycwlgjiMGncVdJ08eVJHjSOjd+jQIfn2228lLqCm5oABA6RixYoyfPjwSO8fHBys13fv3nV7H7Msoixs8uTJ9eJKfGVviYiIiBJN5hKjrlE70s/PT9544w3ZvXu3ZjAN9MFEcIfM4Pfffy+zZ8+WuDBw4EAJCQnRZu4uXbroQB5z2bp1q95nypQp+n9c58qVS287d+6c23WeOXNGr3PmzBkn+0BERESU5DKXqPuIjOVnn30mL7/8st6GQNPaTxFlgNBc/sILL8hXX30l7du3l9hm+kX++uuvenHljz/+0EtAQIBuGwJMDOw5evSoFChQINx9Hz58qH1JoUyZMrG+/URERERJMnOJfoQZM2aUXr16RXg/1MHMkiWLFluPC6i1iT6eri7NmjXT+yDQxf/NHOONGzfW6wULFjitb+XKldpvslKlSvZR40RERETk5eAStSELFizotnyPgeWYh/zmzZuSUCHziizmiBEjdPpH48SJE/LKK6/o32+99VY8biERERGRjweXKO+D4Csq0OQcUTmg+Fa2bFn54IMPNENZo0YNLZT+9NNPS8mSJeXw4cM6dWXLli3jezOJiIiIfDe4rFy5sly4cEFnwYkIZu7BgBjcPyFD2aJFixZpcLl582Zt9kdwiaZzjIonIiIiolgc0IOBMMuWLZPu3btrUFauXDmXNTAxYhtN47iObwsXLoxwObKVuBARERFRHAeXGBzTrl07mTNnjtaURJbv1KlTuqxt27ZabxKjrDFwpmnTptK6dWtPn4qIiIiIkkIR9a+//lry5MkjY8eO1WDSmD9/vl6jxmWPHj3k008/jfmWEhEREZFvB5cIHjEDz2uvvaZN5Hv27NFBMalTp5ZixYpJo0aNJG/evN7bWiIiIiLy3eDSyJo1q3Tq1CncbZhbHPUtiYiIiCjp8Hi0OISGhsqQIUMkX758OuWi4+hrzM4zaNAguX//fky3k4iIiIh8ObhEwNigQQNtFsdAnoMHD4ZbfvbsWZ2K8aOPPpIWLVp4Y1uJiIiIyFeDS8wpvnbtWsmcObPMmjVLR4s7TsOI0j/Zs2eXX375Rb788ktvbC8RERER+WJwOXfuXPHz89OBPM8995xOn2iF/6Nm5I8//qj/nz59esy3loiIiIh8M7g8cOCAFC1aVGtcRqRq1apSoEAB2b17t6dPRURERES+Hlwia5k8efIo3Rfzij98+NDTpyIiIiIiXw8ukY3cu3evXLx4McL7Xb16VQuss94lERERke/zi8n0jw8ePJCuXbvKvXv33JYqwhzkGFmOgupERERE5Ns8LqL+8ssvy5QpU2Tp0qU6UrxDhw5Srlw5SZMmjdy8eVNn65k9e7YcOnRIm8UHDBjg3S0nIiIiIt8JLlEgfcGCBdKmTRs5evSoDB8+3Ok+NptNMmXKJD/88IPkyJEjpttKRERERL48/WONGjW03+XkyZNlyZIlmqW8fPmyzi2OkeRoCu/VqxengSQiIiJKImI8tziavAcOHKgXIiIiIkraYjS3OBERERGRVzOXYWFhWlD92rVrOjoc/SzdqVWrVkyfjoiIiIh8NbjEaPEhQ4ZoP8vIJEuWTINPIiIiIvJdHgeXP/30k/Ts2TPK948oo0lERERESbzP5bhx4/T6iSeekK1bt8qdO3e0iTyiCxERERH5No8zl9u2bdOC6ahhGRwc7N2tIiIiIqKklbnElI7FihVjYElEREREMQ8uixQpIidOnPD04URERETkgzwOLjGX+MWLF+W7777z7hYRERERUdLrc9mnTx/55Zdf5IUXXpBz585JkyZNJFeuXBIUFOT2MX5+rNlORERE5Ms8jvZQEP3q1aty8+ZN6devn84ljjnFAwMDXV4iCjqJiIiIKIlnLjdt2mT/mzUsiYiIiChGweXatWt5BImIiIjIO8Fl7dq1PX0oEREREfkojrAhIiIiovjPXBr79u2T3bt326d/tAoNDdXbT506JUuXLpW9e/fG9OmIiIiIyBeDSwSSnTp1kjlz5kR6Xwz4SZYsmadPRURERES+3iw+ffp0mT17tgaOKDWULVs2/Tt9+vSSI0cOvc2MIi9fvrx8+eWX3txuIiIiIvKl4HLu3LmajUQx9du3b8vBgwc1oGzcuLE2g9+4cUMmT54syZMnlzNnzmiRdSIiIiLybR4Hl7t27dKi6R988IH4+/tLmjRppHTp0vYSRSia3qNHD/noo4/kwoUL8tlnn3lzu4mIiIjIl4LL69evS4ECBSRlypT220qVKqVZykuXLtlvQ4CJwHPJkiUx31oiIiIi8s3gEllLx7nCCxUqZB9BbqBZvHDhwnLkyJGYbCcRERER+XJwmS9fPg0YQ0JC7LcVLFhQB/GgNJHVvXv39EJEREREvs3j4PLxxx+XW7duyeuvv26vb1muXDm9RnkiM1J8//79Otgnd+7c3tpmIiIiIvK14LJ37946aGfixImSN29ezUyWLVtWm8b/+OMPadCggQwYMECeeOIJDT6rV68ucW3WrFkaBGfIkEG3NU+ePNK5c2c5cOCAy/vPmzdPatSoIRkzZpR06dJJrVq1ZMGCBXG+3URERERJLrhEEPntt99qEHbz5k3tWwnjxo3TEkWrV6+WTz/9VM6ePauDfoYOHSpxBVnT9u3bS4cOHeT333+XkiVLSqNGjSQgIEC+/vprqVixom6f1RtvvCHPPPOM7Ny5UwPMRx55RDZt2iStW7eO020nIiIiSrJzizdr1kz7XSJDaCCIW7lypdSvX1+KFCkiTz/9tGzYsME+2CcuoLg7muZz5swp27Ztk99++00WLlwohw4dksGDB+uUlAg+UZ8TVq1aJaNHj9Z+pJiicvHixbJixQr566+/JHPmzDJ8+HDZvHlznG0/ERERUZIMLgEz8jRt2jTcbXXq1JFly5Zpf0sEdcgUxqVp06bp9Ycffqi1Nw3U40SgiJJJ58+f16ASUKvTXKOJ30Az/4gRI/TvMWPGxOk+EBERESXJ4DIhQh/LEiVKyGOPPea0DE32xYoV079RkxNN+sisYnYhZFkdtWrVSh+zdOlS+8AlIiIiInItQKLAW30O33vvPYkLP/74o9tlDx8+lK1bt+rfGOCDZnDchmZ7FHt3hGZxzJt+7tw5OXz4sDb1ExEREVEMgks0DSN7F5MBNnh8XAWXEcHo9uPHj2vQWLduXfnll1/09ly5crl9TI4cOTS4xOAkd8FlRLU8UbKJiIiIKCmIUnCJkjwxCS4TijVr1mhdTtMfM1WqVPZBPfjbHTPFZURB4siRI2XYsGFe32YiIiIinwsu161bJ4kd5jZv27atZhd79eol3bp1sw/yiaqI+lwOGjRI+vXr53LZjh07pHbt2h5sNREREZEPBpeJ3eeffy6vvfaa9q1E8XfU4jSCg4P1+u7du24fb5a56pNpoM6nqfXpKKLHEREREfmSOBktjubkuXPnSlwLDQ2Vnj17yquvvqpZRzRdf/bZZ+Ga+E1fS/SndAejygF1M4mIiIgoljKXmM0GtSF3796thckdm40R3OF2lPtBQPfcc89JXEG2sXnz5loMHX0mZ86cqbPtOMLsPZi5B8XgQ0JCJEWKFOGWX7p0SS5cuKB9MuOyEDwRERFRkgou//nnH60jieARo8Ejg7I/cQXN3yawzJIli/a3rFq1qsv7IpjEqHHcF/dzDEDnz5+v+/fUU09Fq38mERERUVLkcbP4J598oiOts2fPriWGMH0iIAibMmWK1sY0ZXswFeSxY8ckrrz//vsaLKKv49q1a90GlkafPn30GgNyMEWksWvXLnn77bftA3aIiIiIKJYylyjrg6bun376SSpVqqS3ffzxx3Lt2jXp3r27/n/gwIHSsGFDnWsc9STxd2y7evWqPdBFH0n0s3SnQ4cO0qBBA50PHSPIUQOzTJkymslE9hOB6f3793UdZh+JiIiIKBaCSwxyQVO3NeiqUKGCBmQIzNCEjL6OkyZN0vm9J0+eHCfBJcommXqUBw8e1Is7lStX1uASxo8fr//H9mIdaC5/9NFHpX///i6nhSQiIiIiLwaXGKyDaRGtihYtKsuXL9f+mMWLF7cPmClQoID89ddfEhdatGgRpT6gjpCF7dKli16IiIiIKI77XGbKlElHUlsVLFhQr//++2+n+168eNHTpyIiIiIiXw8u0QSOQTrbtm0Ll7lE1nDz5s3hMpxHjx5lIXEiIiKiJMDj4BJTKZoSPeiniBqX6KMYGBioA2M2bNigfR8xyvry5ctSuHBh7245EREREflOcNmuXTt5/PHHtbkbM+Ag0EyfPr20b99ea1/WqVNH0qVLpyWL0J+xR48e3t1yIiIiIvKd4BKjwZcuXar1LJGxNAXGMb0igk4Em+aCLGfXrl29ud1ERERE5GvTP6Jcz7vvvqsXA4XLUQMT/S7R1xKjxsuXL++NbSUiIiIiXw4uI/LII4/ohYiIiIiSDq8Hl6dPn5bt27drczgKrGOWHCIiIiJKGqIdXGLO7j179khwcLDOuINZegCjxTGwB/OKY4YewECeNm3a6OjxDBkyeH/riYiIiChxBpcojN66detw0yn6+fnJW2+9JcOGDZO+fftqSSLr7Dj4e968eXLkyBH5448/9P5ERERE5LuiFO1hJh6UFjpw4IAEBQVJxYoVpUyZMho8jhgxQgNMzB0eEBCgg3vQLL5z5055//33JVWqVDr14+zZs2N/b4iIiIgo4WcuP/30Uw0wmzRpIjNmzJCMGTPq7YcPH5bGjRvLqFGj9P8IMLt3725/HALQYsWKacZz/vz50qFDh9jaDyIiIiJKLJnLZcuW6cw7X3/9tT2whEKFCsno0aM1g5k8eXLp3Lmz02NbtmwpWbNm1UwmEREREfm2KAWXJ06ckIIFC7oclFOjRg29xvSOaBZ3JX/+/DqTDxERERH5tigFl1evXnU72htTPgJGj7uDrGdISIin20hEREREvhRcotnbXVbSjAA30z8SERERUdLF2kBERERE5DUMLomIiIgo7ouoX79+XTZs2ODRciwjIiIiIt8X5eASUz6ikLormOYxouVERERElDREObi0TuvoCQSgREREROTbohRcHj16NPa3hIiIiIiSRnCZL1++2N8SIiIiIkr0OFqciIiIiLyGwSUREREReQ2DSyIiIiLyGgaXREREROQ1DC6JiIiIyGsYXBIRERGR1zC4JCIiIiKvYXBJRERERF7D4JKIiIiIvIbBJRERERF5DYNLIiIiIvIaBpdERERE5DUMLomIiIjIaxhcEhEREZHXMLgkIiIiIq9hcElEREREXsPgkoiIiIi8hsGlxcGDB+X555+XfPnyScqUKaVIkSIyePBguXXrlveOOBEREZEPY3D5ny1btkilSpVk9uzZkiNHDmncuLHcvn1bPvjgA6levbpcv349fl8pIiIiokSAwaWIPHjwQJ555hnNUM6YMUM2bdok8+fPl8OHD8vTTz8tu3fvlkGDBsX3a0VERESU4DG4FJG5c+fKsWPHpF69etKpUyf7wUHT+PTp0yV16tTy5ZdfyrVr1+LztSIiIiJK8BhcisiSJUv0YLRq1crpAGXKlEnq1q0r9+/fl+XLl8f9K0RERESUiDC4FNFmbyhbtqzLg1SqVCm93rVrV1y+NkRERESJTkB8b0BCcPr0ab3OlSuXy+UY4ANnz551u4579+7pxZVLly7p9b59+zzavnvnDklCtzckRBK6u9u2eX2dieG1Ab4+CVdieG1i+v4pXry4pEqVyqvbQ0QJF4NLER0VDu4+/ND3EiIqSTRy5EgZNmxYhAcbZY58VWtJBCpVkqSKr0/ClShemxi+f7Zu3SoVK1b06uYQUcLF4FJE/P39JSwsLNKDFdF9MJq8X79+bjOXGzdulMKFC9sDVV+CoLt27dqyfv16SZMmTXxvDjng65NwJZXXBplLIko6GFyKSHBwsFy5ckXu3r3r8iCZ2yP68E+ePLleXEmbNq0ULFhQfNWNGzf0unz58rqvlLDw9Um4+NoQkS/igB5LX0t3fSrPnDmj1zlz5ozL14aIiIgo0WFwaRkl/vfff7s8SOZ2d6PJiYiIiOhfDC5FdKpHWLBggTi6fPmyrF27VlKkSCFPPvmk03IiIiIi+j8GlyLSvHlzyZcvn/z8888yefLkcH0tu3XrpqPJe/ToIZkzZ7YcOiIiIiJylMxms9mcbk2CNmzYIA0bNtSAEiUzMADn999/1/6WlStX1uylL4/mjOmghHTp0sn169c5oCcB4uuTcPG1ISJfxMzlf2rVqiVbtmyR1q1by4kTJ3RKSARM77zzjqxZs4aBZQQwSh7Hyd1oeYpffH0SLr42ROSLmLkkIiIiIq9h5pKIiIiIvIbBJRERERF5DYNLIiIiIvIaBpdERERE5DUMLj2wbt06SZYsmV4WLVoU4X3Hjh2r9+vcubOnrxF5iXnNrl27FivngqtLQECAZMiQQapUqSIffPCB3LlzR5LCcUmI+/Xuu++6fZ2CgoK0jm316tVl1KhRWtvW1eucP3/+SJ/XPI/jex6Pxe1YFxGRLwuI7w1I7F544QWpUaMGC6wncalTp9Zi/I5u3bolhw4dkr/++ksv+DGCmqmpUqWKl+0k0Rq21apVC3coHjx4oLNxbdy4Uf744w+ZPXu2/Prrr6zbSkTkAQaXMXThwgV58cUXXU4dSQnLvn379Dpt2rReXzeyXrNmzXK7fMWKFdKsWTOtpTp+/Hh54403vL4NFDU1a9aUGTNmuFyGHwKoebt7924ZNmyYjBkzhoeViCia2CweA1myZNEiyD/88EOEgQUlDMWLF9eLn1/cn/b169eXl19+Wf+OrCsFxZ/ChQvLwIED9e/vv/+eLwURkQcYXMZAzpw55f3339e/e/fuLadPn47W48+fPy8DBgyQYsWKSYoUKSR9+vRSu3ZtmTlzpkR3Vs779+/L559/LlWrVpXg4GBtpsW0lbgNTX5GWFiYPPbYY9r36+mnn3Zaz8SJE3VZ7ty5tZkQ0HcMt61atUrmzJkj5cuXl5QpU0qePHl0GbI9rhw/flz69u0rpUuX1m1CvzYcM8yCtHnz5nD3PXbsmD7Hk08+KVeuXJFXX31V53tH8I5r/P/SpUtOz7F161Zp06aNFCpUSO+LgP+pp56ShQsXRrlv4c2bNzVLVaZMGd0vbCuO42effabHNaLtxH3Mvka0nVCgQAG9NsfV+Pvvv3Xu+qJFi+rrhnMB6+rUqZM92+rY96979+5y8uRJPf45cuTQfS9SpIi8/fbbTv0F4eHDh5oxrVChgj4HHvPKK6/I1atXxR3sO/oMo78opj5FU37ZsmVl+PDh2tzv6vgieMeyN998U/sYYl+wXcgA4pxGn9NBgwbpMqyvVKlSugzb5wlP9isy2F7z/kwIcG699NJLev6YcxxdMNB87+51mzRpktStW1fvGxgYqJ8t6AqAY4XPAKvHH39cX7vt27frZwLeA8jEjxw5UpdjGYJuTI2L8wvHB68rjnWXLl30PUFEFA7mFqfoWbt2LSI/W7ly5WwPHz601axZU/9fv359p/t++umnuqxTp07hbt+xY4ctc+bMuixnzpy2li1b2p588klb8uTJ9Tb8/8GDB1Hanlu3btkee+wxfVy6dOls9erVszVt2lT/xm1PPPGELSQkxH7/w4cP29KkSaPL5syZY7993759tpQpU9r8/Px0Hw1sO+7bvHlzvS5SpIitdevWtqJFi+r/06dPb9u8eXO4bdq0aZMtbdq0urxEiRK2Fi1a2Bo2bGjLmjWr3hYYGGjbuHGj/f5Hjx7V28uXL28rXLiwLVWqVLa6devamjRpon9jWalSpWz37t2zP2b9+vW2oKAgXVa5cmXdJhyHZMmS6W2jR48Ot024DZerV6/abztx4oStYMGCenvGjBltzZo1szVq1Mh+fGrUqGG7ceOG2+00rxeOm7vtNLD/WN62bVv7bYsWLbLvQ4UKFWytWrXS88C8dtiOf/75x+nce/zxx/X8wbHHenHu4ZhiGV5/q9DQUNvTTz9tXx/OjQYNGui2Y1tdHZdr167ZqlSpYn8MjgmODY4RbitevLjt1KlTTsc3T548emxwPBo3bmyrU6eO/fUYPHiwrhPrw/bivMS5hmUDBw60RVd09+udd95x+V509OGHH+r9cH47Hvd8+fJFul3ungePxe3W91ZkcI6bcwHnG95H1atX12OKYzd58uRw98d5Zz6PcG489dRT+llStmxZ+/Ho2bNnuMfUrl1bby9WrJi+vngO/L1kyRJdjmW5c+e2Pfroo3qOYf34LMiQIYMuy549u+3SpUtR3ici8n0MLmMYXDoGaxMnTow0uESgZ75oevXqFS4QwbpM0DZkyJAobU+3bt30/ggyrB/yV65c0S93LOvXr1+4x0ydOlVvz5Ili+3ixYu2+/fv2ypVqmQPAqxMcInL66+/rgE14HrAgAF6e8mSJcMFwxUrVtTb8UVtdefOHQ1SHIMsE7SZQPHkyZPhjon5Ivv222/ttyMIw22OX7C//PKL3h4cHKz7ZbgKoqpVq6a34Qv15s2b9tsvXLigX+JY9vzzz7vdznnz5tmDDsftDAsL08B0y5Yttnbt2untKVKksG3fvl3XhW3Lli2b3j537txw+4BtrFq1qi574403nM49XBA4XL582b4MAb4JMBHcGxMmTLC/RmfOnLHffuDAAQ0aXB2XZ599Vm/DMcCxMHCMcKywDIG8lVlPgQIFbMeOHbPf/sknn9iXIUA6fvy4fdmsWbPsP4rMeRVV0d2vqASXeG0QlOF+w4cPj9fgEu9fvD/xGOwrzidr0IkfbwEBAbZt27bZb//ss8/s56b1fIbZs2frMjzm+vXrTsElAsvTp0/rbXgu83zW13Xv3r32x+Fzo1ChQi7f50SUtDG49EJwCQhwcFvq1Klthw4dijC4/Oabb8JlPh399ddf9mwMgrGI4EsVXxYIpFxlDxCkITOGTJL1CwWQ6cHzdOzYUQNK/I1gyzFjaoJLfGFZv+AA248vdyxfvny53nb79m1b165dNYh0lX1duHCh3h/Bk6ugzZrRNLp06eIUcCMjittWrVrldP8pU6bYvvvuu3DHzzHYwPPg/wjwsM2O8EWLLBgyRCZYctxOa7AX2QU/GtatWxfutenQoYPumytjx451CsKtz4esqyPzY2LatGlOxwkBiaMFCxY4HResF5kx7LsJNqxwrExQbH2tzHq++uqrcPc/f/68fZn1x4EJsP39/XXZ2bNnbdER3f0yQR8y1e3btw93QdYbmWOTZUXW3PqjLz6Cy48++kjvjx8mrowaNUqXY/uNSZMm6ft6zZo1Lh9jAmdrkGiCy5deesnlY8xxxOeWo2HDhjn9ACMiYp9LL5YkQl8/9HdDXznHfk1Wps7dM88843JwSaVKlbQfJvqu/fnnnxE+7/r16yU0NFT7nGXKlMlpOfpOlitXTvtLbdq0KdyyadOmaZ8s9PH88MMPJV26dNqnErUZXXnuuee0/5UVtt+U4EGfTEBfui+//FL7PVrXhb6I2PdffvlF/+/Yn9Gs75FHHnG6HX01wdqfsE6dOnrdsmVL7Wf3888/25ejD2Pbtm21/1hkrwNGcbsqDYTnRH80vJY4zhFtJ/r7tW/fXvuXQt68ecXf31//Rv/N33//Xfbv3699aq2vDY799OnTw6377NmzOrocpXDcHSf0d8UlsuOEdaHfJkbIY5S0o6ZNm2pfWCvsK2IKbKtZnxWOlXnN16xZ47TcscwPzjHruW2F/oA4dhASEiJR5cl+GUeOHNFSQ9bLkiVLtI9lgwYN9H2B4+/u8XFl9erVeo3+va40adLE6TXo2bOn/PTTT/b3hjmuu3bt0v0yn0uuzil8hkQENUCj8r4kImJw6UUIqDJmzCi//fabjB492u39zpw5Y6+3545ZZu7rzokTJ/R6w4YNbgtEmwDV3NfImjWrfUAKBka89957ERaJxoATVxBIgeOAJtR1RNBdsWJFDQIQZOBLb/Lkybrc1aAlDBxBwOHIBKnWoB0BcePGjeXGjRsyYcIE/bJFwXJ8GU+ZMkXu3bsnEYnJ6+C4naYUUatWrfT/LVq0kL179+rjUX4I24ofAa4gOOjQoYMOKEKghS9sBDmmvJWr44T9dMXxOJnXJFeuXE4/DAD7gCDXW8cF8B6wsj4vjpMjV9sVGU/2y8CPv/9abewX/PjCOpctWybdunWz/zBwPK5RGWhnBidh0EtMmPdr165dXb6vMRjKBNrWQXsYMIbBOBjQg+ODHwP4gYkfXBi85m4/XP04jeycc/W+JCJinUsvwuhJBDnI8A0dOlQaNWrk8n7R+YLC6NCImA91ZDoxOjwirjJdyPYZyKL16tXLbebS8QvXcX+sj8MoeFMjECOIEQTiGoEmttlVwfHoBhoY1Y2ME7IyKO+DzClGoSPjgwtGyqMoNkbKRrTdnrwOUdlOBOM4vnhdkE1CoP3VV1/Zl+M4PPvss1ryBuvDSGwEpzhOeMzhw4f19XAlugFZRPvq+HrH9Px09eMgtkRnv2IC51pUM3TXr1+P8AdAVJn3NlpEHAN2RwgucdzxwxafO/jBhWAR5xEy+Pjhgkw0Ak7HH5lGZCW6PPkRQERJE4NLL0Ow8OOPP8q8efOkY8eO0q5dO7dNSWiecweBBWTLli3SgNY0N0a31ub8+fP1MQg6kbFEIIaSPCg148qpU6dc3n706FG9RvkcQHMuAks0sy9evNip2RJ1Qb0JQRkuKJOCDBSa3dFMvmfPHs2SmrqFsfk6uINA8ZNPPtFC+yjcjYwkzhFAFwQEljj+yJiZTJSBx8WUyd6hbBGCFccAAsEZMl9xfVziY79iAmWAEFwhK4jgEee2OwcPHgz3fvAU3tsHDhyQ1157TerVqxfp/bHPKE2FwPL111/X7KXjD0Jfm+KTiBImNovHAtSYwxfDjh07ZNy4cU7L0Y8PvvvuO5fNSWjGxpc3vsAc+6g5QjYCX3orV650OW81Mi1oEkNtS/T5M/DFi/5ZgCZkZNTQPxFfSI59Mw1kCV1lsExNSWRYANkTwBeiq/5wCKRi2pSGIBJ9+9DsZ23+xj6gSRpNgOAuS2N9HZD1xPocoZkU3Q0QuJj7egIZyyeeeEL/Rh1MU+fSHCf0vXUMLL11nLJnz65ZK5wHZn1WmIrSNJUamKEG5xT6XroK0LAuZGIBmbD44Ml+xQS6daC+K+CHozt4bU3/3JgeG+v56Qp+pOHHC2pNmtnCTM3Zd955xymwxPmGwBPYjE1EsYnBZSxAExY6z4OrwupopkI/xZ07d2qRcWt/KWSL0P8OkO2KrFkcGUc0pV68eFGDFFwbCLoQ2KDZGF96aDo30I8Lt6H/WcOGDbUIOfpcIljE87tq/kNAYfYLcF9sPzI1CF4fffTRcP3qMIgFX3gGvtDQVI2+qdEdwOEIQST6tKHPH4pyW4tw4wvUfCFjMI07CHwxKAcDORz3GccRrxNeGxR9dzWwJTqQQcU2Y739+vULd5wweMT6wwCDLVCE3AyQislxMl0UAE3sJqtmsn4ozu0IGTcUpsf5g2NgLQqPQWY4VtgPHDvzmseH6O5XTCEzDsgKmuDa6ty5c/oexOuF4+auj3JU4b2L5vgvvvhCJzewdgHAD0X8UEFm0zwPAmAzCAmtJ1b4oWs+V7xxThERRYgD5r1TisiV7t2728t4OJYlQbkhU8MuV65cWjwbxa9NUW4Uh7bWaIwIah2icLWp7YhyNHi8KViOYtt79uxxqg+YI0cOraVnLUptCme/8MILTqWI8ubNq9co2dKmTRute2fq31nLL6G2oym7gvqFKISO7cF+4jYUuEbJF2ttQ1PiB7dFVN6lT58+9tv+/vtve4Hp/Pnza2Fn1H405VZQTiayOpd4XlNEPVOmTLoOFP82dUtRmsnx/tbtdCxR42o7jZEjR9q3YeXKlVrv0WwrXitTwB3bgdtKly6t12XKlInyuWdeK5TAcnUu4vzCMTLF6VGn0JQVsu4nzgtT9xTHAscEx8ZsG4qoW2tZuju+UVlmXkMc2+iKzn5FtYh6RIYOHWovV4TzBuc13gs4T0yNUZx31veVYd4TqIWKbXN3sZZrQiFzlBEz7zOcIyigb8o3OX5OoJ6tOdaoUYoSSyghhv/juJj3LEo1OZYi+vHHH13uc0SvHcpOYRm2i4jIYHAZi8ElgizzYe7qCw01Kvv27auFpVGLEl/c+GJCsePoQj1HzEiDLxIEA6i3ifqT/fv3D1er8ODBg/aZZFx9mezatcv+JWlm6LAGLF988YXWF8SXOb5cUeDbVX1N1CxE3Tx8yWPfUPAZgeuYMWO0iDyOHda5YsUKj4NLQL0+1IpE4IvtRnCN+pnjxo1zCs7dfUni/wgaEPSiyDm2AcECCuI71umMSXCJdZmZUnBc8JohKEcdQ7P9CDwwAwrqVOL+ZkYcvG4xCS4BdQoxywrOD6wXz4tzwxTCdjwud+/etX388cdaEB/nDI4tfligYDZmhXIUH8FldPbLG8EloED9iy++qAE2fhzgnMGPG/wwQGDobmYtE1xGdnGsE4qi8Aii8Xi8l/BDBAXsZ8yY4fRc+LGGCRLwmuE9h/vjfdqjRw+d6cnU3bXWzmRwSUTelgz/RJzbpKQOgwS+/vpr+fTTT7UZnIiIiMgd9rkkIiIiIq9hcElEREREXsPgkoiIiIi8hn0uiYiIiMhrmLkkIiIiIq9hcElEREREXsPgkoiIiIi8hsElEREREXkNg0siIiIi8hoGl0RERETkNQwuiYiIiMhrGFwSERERkXjL/wAVCiWQBvv4MAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -150,7 +150,7 @@ ], "source": [ "aa.plot_settings()\n", - "aa.plot_comparison(df_eval=df_eval, baseline=50,\n", + "fig, ax = aa.plot_comparison(df_eval=df_eval, baseline=50,\n", " ylabel=\"Balanced accuracy [%]\",\n", " title=\"Feature engineering x data expansion\")\n", "plt.tight_layout()\n", @@ -162,7 +162,7 @@ "id": "36eb7fc7", "metadata": {}, "source": [ - "**Further parameters.** ``plot_comparison`` also accepts: ``group`` / ``condition`` / ``value`` — the column names of the tidy frame; ``baseline_label`` — text for the baseline line (auto ``\"chance (50)\"`` by default, ``\"\"`` to hide); ``annotate`` — toggle the per-bar value labels; ``group_order`` / ``condition_order`` — explicit bar / cluster order; ``colors`` — a list aligned to the groups or a ``group -> color`` dict (defaults to the house palette of ``aa.plot_get_clist``); ``bar_width`` — total cluster width; ``figsize``; ``xlabel``; ``ylim``; ``fontsize_annotations``; and ``ax`` to draw onto an existing axes." + "**Further parameters.** ``plot_comparison`` also accepts: ``group`` / ``condition`` / ``value`` — the column names of the tidy frame; ``baseline_label`` — text for the baseline line (auto ``\"chance (50)\"`` by default, ``\"\"`` to hide); ``annotate`` — toggle the per-bar value labels; ``annotation_fmt`` — format string for the value labels (auto-selected precision by default); ``group_order`` / ``condition_order`` — explicit bar / cluster order; ``colors`` — a list aligned to the groups or a ``group -> color`` dict (defaults to the house palette of ``aa.plot_get_clist``); ``bar_width`` — total cluster width; ``figsize``; ``xlabel``; ``ylim``; ``fontsize_annotations``; and ``ax`` to draw onto an existing axes." ] }, { @@ -171,16 +171,16 @@ "id": "98ded14f", "metadata": { "execution": { - "iopub.execute_input": "2026-06-30T23:28:17.467262Z", - "iopub.status.busy": "2026-06-30T23:28:17.467199Z", - "iopub.status.idle": "2026-06-30T23:28:17.508721Z", - "shell.execute_reply": "2026-06-30T23:28:17.508490Z" + "iopub.execute_input": "2026-07-01T02:53:21.573608Z", + "iopub.status.busy": "2026-07-01T02:53:21.573513Z", + "iopub.status.idle": "2026-07-01T02:53:21.616415Z", + "shell.execute_reply": "2026-07-01T02:53:21.616208Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,7 +191,7 @@ ], "source": [ "aa.plot_settings()\n", - "aa.plot_comparison(df_eval=df_eval, baseline=50, baseline_label=\"random (50%)\",\n", + "fig, ax = aa.plot_comparison(df_eval=df_eval, baseline=50, baseline_label=\"random (50%)\",\n", " colors={\"Scale-based\": \"tab:gray\", \"CPP\": \"tab:red\"},\n", " group_order=[\"Scale-based\", \"CPP\"],\n", " ylabel=\"Balanced accuracy [%]\", ylim=(0, 108))\n", diff --git a/tests/unit/plotting_tests/test_plot_comparison.py b/tests/unit/plotting_tests/test_plot_comparison.py index 7c6936ca..0f025126 100644 --- a/tests/unit/plotting_tests/test_plot_comparison.py +++ b/tests/unit/plotting_tests/test_plot_comparison.py @@ -30,100 +30,125 @@ def _close_figs(): class TestPlotComparison: """Normal cases for plot_comparison.""" - def test_returns_axes(self): - ax = plot_comparison(df_eval=_df()) - assert isinstance(ax, plt.Axes) + def test_returns_fig_ax(self): + fig, ax = plot_comparison(df_eval=_df()) + assert isinstance(fig, plt.Figure) and isinstance(ax, plt.Axes) def test_bar_count_groups_times_conditions(self): # 2 groups x 3 conditions = 6 bars - ax = plot_comparison(df_eval=_df()) + fig, ax = plot_comparison(df_eval=_df()) assert len(ax.patches) == 6 def test_bar_count_three_groups(self): - ax = plot_comparison(df_eval=_df(groups=("A", "B", "C"))) + fig, ax = plot_comparison(df_eval=_df(groups=("A", "B", "C"))) assert len(ax.patches) == 9 def test_baseline_drawn_when_set(self): - ax = plot_comparison(df_eval=_df(), baseline=50) + fig, ax = plot_comparison(df_eval=_df(), baseline=50) assert len(ax.lines) == 1 def test_baseline_none_no_line(self): - ax = plot_comparison(df_eval=_df(), baseline=None) + fig, ax = plot_comparison(df_eval=_df(), baseline=None) assert len(ax.lines) == 0 def test_baseline_label_default_text(self): - ax = plot_comparison(df_eval=_df(), baseline=50) + fig, ax = plot_comparison(df_eval=_df(), baseline=50) assert any("chance" in t.get_text() for t in ax.texts) def test_baseline_label_custom(self): - ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="random (50%)") + fig, ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="random (50%)") assert any("random (50%)" == t.get_text() for t in ax.texts) def test_baseline_label_empty_suppresses_text(self): - ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="") + fig, ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="") # 6 value labels, no baseline text assert len(ax.texts) == 6 def test_annotate_true_writes_value_labels(self): - ax = plot_comparison(df_eval=_df(), annotate=True, baseline=None) + fig, ax = plot_comparison(df_eval=_df(), annotate=True, baseline=None) assert len(ax.texts) == 6 def test_annotate_false_no_value_labels(self): - ax = plot_comparison(df_eval=_df(), annotate=False, baseline=None) + fig, ax = plot_comparison(df_eval=_df(), annotate=False, baseline=None) assert len(ax.texts) == 0 + def test_integer_values_labelled_without_decimals(self): + fig, ax = plot_comparison(df_eval=_df(), baseline=None) + assert all("." not in t.get_text() for t in ax.texts) + + def test_fractional_values_keep_precision(self): + # AUC-like values in [0, 1] must NOT collapse to "0"/"1" integer labels. + df = pd.DataFrame([{"group": g, "condition": c, "value": v} + for g, c, v in [("A", "x", 0.62), ("A", "y", 0.71), + ("B", "x", 0.83), ("B", "y", 0.90)]]) + fig, ax = plot_comparison(df_eval=df, baseline=None) + labels = sorted(t.get_text() for t in ax.texts) + assert labels == ["0.62", "0.71", "0.83", "0.90"] + + def test_annotation_fmt_override(self): + fig, ax = plot_comparison(df_eval=_df(), baseline=None, annotation_fmt="{:.1f}") + assert all("." in t.get_text() for t in ax.texts) + assert any(t.get_text() == "60.0" for t in ax.texts) + def test_legend_labels_are_groups(self): - ax = plot_comparison(df_eval=_df()) + fig, ax = plot_comparison(df_eval=_df()) labels = [t.get_text() for t in ax.get_legend().get_texts()] assert set(labels) == {"Scale-based", "CPP"} def test_group_order_controls_bar_order(self): - ax = plot_comparison(df_eval=_df(), group_order=["CPP", "Scale-based"]) + fig, ax = plot_comparison(df_eval=_df(), group_order=["CPP", "Scale-based"]) labels = [t.get_text() for t in ax.get_legend().get_texts()] assert labels == ["CPP", "Scale-based"] def test_condition_order_controls_ticks(self): order = ["dPULearn", "Random", "No expansion"] - ax = plot_comparison(df_eval=_df(), condition_order=order) + fig, ax = plot_comparison(df_eval=_df(), condition_order=order) assert [t.get_text() for t in ax.get_xticklabels()] == order def test_colors_list(self): - ax = plot_comparison(df_eval=_df(), colors=["tab:gray", "tab:red"]) + fig, ax = plot_comparison(df_eval=_df(), colors=["tab:gray", "tab:red"]) assert len(ax.patches) == 6 def test_colors_dict(self): - ax = plot_comparison(df_eval=_df(), colors={"Scale-based": "tab:gray", "CPP": "tab:red"}) + fig, ax = plot_comparison(df_eval=_df(), colors={"Scale-based": "tab:gray", "CPP": "tab:red"}) assert len(ax.patches) == 6 def test_custom_columns(self): df = _df().rename(columns={"group": "method", "condition": "setting", "value": "acc"}) - ax = plot_comparison(df_eval=df, group="method", condition="setting", value="acc") + fig, ax = plot_comparison(df_eval=df, group="method", condition="setting", value="acc") assert len(ax.patches) == 6 def test_aggregates_repeated_cells(self): df = pd.concat([_df(), _df()], ignore_index=True) # duplicate (group, condition) rows - ax = plot_comparison(df_eval=df) + fig, ax = plot_comparison(df_eval=df) assert len(ax.patches) == 6 + def test_repeated_cells_use_mean(self): + # Two rows for the same (group, condition) with different values -> the mean. + df = pd.DataFrame([{"group": "A", "condition": "x", "value": 60}, + {"group": "A", "condition": "x", "value": 80}]) + fig, ax = plot_comparison(df_eval=df, baseline=None) + assert ax.patches[0].get_height() == pytest.approx(70) + def test_passing_existing_ax(self): - fig, ax_in = plt.subplots() - ax_out = plot_comparison(df_eval=_df(), ax=ax_in) - assert ax_out is ax_in + fig_in, ax_in = plt.subplots() + fig_out, ax_out = plot_comparison(df_eval=_df(), ax=ax_in) + assert ax_out is ax_in and fig_out is fig_in def test_labels_and_title(self): - ax = plot_comparison(df_eval=_df(), xlabel="X", ylabel="Balanced accuracy [%]", - title="Bench") + fig, ax = plot_comparison(df_eval=_df(), xlabel="X", ylabel="Balanced accuracy [%]", + title="Bench") assert ax.get_xlabel() == "X" assert ax.get_ylabel() == "Balanced accuracy [%]" assert ax.get_title() == "Bench" def test_ylim_respected(self): - ax = plot_comparison(df_eval=_df(), ylim=(0, 108)) + fig, ax = plot_comparison(df_eval=_df(), ylim=(0, 108)) assert ax.get_ylim() == (0, 108) def test_bar_width_and_figsize_and_fontsize(self): - ax = plot_comparison(df_eval=_df(), bar_width=0.6, figsize=(8, 5), - fontsize_annotations=8) + fig, ax = plot_comparison(df_eval=_df(), bar_width=0.6, figsize=(8, 5), + fontsize_annotations=8) assert len(ax.patches) == 6 @@ -147,6 +172,10 @@ def test_bad_group_type_raises(self): with pytest.raises(ValueError): plot_comparison(df_eval=_df(), group=123) + def test_duplicate_columns_raise(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), group="group", condition="group") + def test_bad_baseline_type_raises(self): with pytest.raises(ValueError): plot_comparison(df_eval=_df(), baseline="50") @@ -155,6 +184,10 @@ def test_bad_annotate_type_raises(self): with pytest.raises(ValueError): plot_comparison(df_eval=_df(), annotate="yes") + def test_bad_annotation_fmt_type_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), annotation_fmt=2) + def test_bar_width_out_of_range_raises(self): with pytest.raises(ValueError): plot_comparison(df_eval=_df(), bar_width=1.5) From dc71975eab047867b37e50e1e245422365b83b77 Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 05:19:43 +0200 Subject: [PATCH 3/6] round2(plot_comparison): dedupe explicit order + numeric value guard Fix two correctness edge cases found in adversarial review: - A repeated entry in group_order/condition_order created a duplicate grid axis label, raising a cryptic TypeError (group_order) or silently drawing an extra x-tick + wrong bar count (condition_order). _resolve_order now de-duplicates the explicit order. - A non-numeric 'value' column produced a cryptic pandas 'mean' TypeError; the Validate block now raises a clear ValueError up front. Adds 4 regression tests (dup group/condition order, partial grid, non-numeric). Co-Authored-By: Claude Opus 4.8 (1M context) --- aaanalysis/plotting/_plot_comparison.py | 11 +++++--- .../plotting_tests/test_plot_comparison.py | 27 +++++++++++++++++++ 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/aaanalysis/plotting/_plot_comparison.py b/aaanalysis/plotting/_plot_comparison.py index e82e7e2f..7245d2a6 100644 --- a/aaanalysis/plotting/_plot_comparison.py +++ b/aaanalysis/plotting/_plot_comparison.py @@ -21,11 +21,13 @@ def _resolve_order(values: List, order: Optional[List], name: str) -> List: if order is None: return seen ut.check_list_like(name=name, val=order) - missing = set(seen) - set(order) + seen_set = set(seen) + missing = seen_set - set(order) if missing: raise ValueError(f"'{name}' is missing values present in the data: {sorted(map(str, missing))}") - # Keep only the groups that actually occur, in the requested order. - return [g for g in order if g in set(seen)] + # Keep only the values that actually occur, in the requested order, de-duplicated + # (a repeated entry would otherwise create a duplicate grid axis label). + return [g for g in dict.fromkeys(order) if g in seen_set] def _resolve_colors(group_order: List, colors: Optional[Union[List, Dict]]) -> Dict: @@ -165,6 +167,9 @@ def plot_comparison(df_eval: pd.DataFrame, ut.check_df(name="df_eval", df=df_eval, cols_required=[group, condition, value]) if len(df_eval) == 0: raise ValueError("'df_eval' (0 rows) should contain at least one row.") + if not pd.api.types.is_numeric_dtype(df_eval[value]): + raise ValueError(f"'{value}' column of 'df_eval' should be numeric " + f"(the bar heights), got dtype '{df_eval[value].dtype}'.") ut.check_number_val(name="baseline", val=baseline, accept_none=True, just_int=False) ut.check_str(name="baseline_label", val=baseline_label, accept_none=True) ut.check_bool(name="annotate", val=annotate) diff --git a/tests/unit/plotting_tests/test_plot_comparison.py b/tests/unit/plotting_tests/test_plot_comparison.py index 0f025126..83c55e62 100644 --- a/tests/unit/plotting_tests/test_plot_comparison.py +++ b/tests/unit/plotting_tests/test_plot_comparison.py @@ -142,6 +142,27 @@ def test_labels_and_title(self): assert ax.get_ylabel() == "Balanced accuracy [%]" assert ax.get_title() == "Bench" + def test_duplicate_group_order_deduped(self): + # A repeated entry in the explicit order must not create a duplicate bar row. + fig, ax = plot_comparison(df_eval=_df(), group_order=["Scale-based", "Scale-based", "CPP"]) + assert len(ax.patches) == 6 + labels = [t.get_text() for t in ax.get_legend().get_texts()] + assert labels == ["Scale-based", "CPP"] + + def test_duplicate_condition_order_deduped(self): + fig, ax = plot_comparison(df_eval=_df(), + condition_order=["No expansion", "No expansion", "Random", "dPULearn"]) + assert len(ax.patches) == 6 + assert [t.get_text() for t in ax.get_xticklabels()] == ["No expansion", "Random", "dPULearn"] + + def test_missing_cell_partial_grid(self): + # A (group, condition) combination absent from df_eval leaves a gap, no crash / label. + df = pd.DataFrame([{"group": "A", "condition": "x", "value": 60}, + {"group": "B", "condition": "y", "value": 70}]) + fig, ax = plot_comparison(df_eval=df, baseline=None) + assert len(ax.patches) == 4 # 2 groups x 2 conditions + assert len(ax.texts) == 2 # only the 2 present cells are labelled + def test_ylim_respected(self): fig, ax = plot_comparison(df_eval=_df(), ylim=(0, 108)) assert ax.get_ylim() == (0, 108) @@ -211,3 +232,9 @@ def test_colors_dict_missing_group_raises(self): def test_bad_ylim_raises(self): with pytest.raises(ValueError): plot_comparison(df_eval=_df(), ylim=(10,)) + + def test_non_numeric_value_column_raises(self): + df = _df() + df["value"] = df["value"].astype(str) + with pytest.raises(ValueError): + plot_comparison(df_eval=df) From 14edef31dc6144569f548c2ad0570667982733fd Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 05:26:14 +0200 Subject: [PATCH 4/6] round3(plot_comparison): baseline label to legend + xtick_rotation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plot-quality pass — rendered percent/fractional, 2-5 groups, tall bars, long condition names under plot_settings + default rcParams: - The free-floating 'chance (...)' baseline text obscured the bars whenever the baseline sat near the bar heights (e.g. AUC vs 0.5). Move it into the (already-outside) legend via the axhline label, so it can never overlap data. - Add an additive xtick_rotation arg (default 0, output unchanged) so long condition names can be right-aligned/rotated to stay legible. Updates the baseline-label tests to assert the legend entry; adds positive+ negative xtick_rotation tests. 46 tests green. Co-Authored-By: Claude Opus 4.8 (1M context) --- aaanalysis/plotting/_plot_comparison.py | 25 ++++++++++------ .../plotting_tests/test_plot_comparison.py | 29 ++++++++++++++----- 2 files changed, 37 insertions(+), 17 deletions(-) diff --git a/aaanalysis/plotting/_plot_comparison.py b/aaanalysis/plotting/_plot_comparison.py index 7245d2a6..51dc39cd 100644 --- a/aaanalysis/plotting/_plot_comparison.py +++ b/aaanalysis/plotting/_plot_comparison.py @@ -79,6 +79,7 @@ def plot_comparison(df_eval: pd.DataFrame, title: Optional[str] = None, ylim: Optional[Tuple[Union[int, float], Union[int, float]]] = None, fontsize_annotations: Union[int, float] = 10, + xtick_rotation: Union[int, float] = 0, ) -> Tuple[Figure, Axes]: """ Plot a grouped method x condition comparison barplot with value labels and a baseline line. @@ -107,8 +108,9 @@ def plot_comparison(df_eval: pd.DataFrame, baseline : int or float, optional y-value of a dashed horizontal chance / baseline line. If ``None``, no line is drawn. baseline_label : str, optional - Text label for the baseline line. If ``None`` and ``baseline`` is set, a label - ``"chance ()"`` is generated; pass ``""`` to draw the line without a label. + Legend label for the baseline line. If ``None`` and ``baseline`` is set, a label + ``"chance ()"`` is generated; pass ``""`` to draw the line without a + legend entry. Placing it in the legend keeps it from overlapping the bars. annotate : bool, default=True If ``True``, write each bar's value above it. annotation_fmt : str, optional @@ -139,6 +141,9 @@ def plot_comparison(df_eval: pd.DataFrame, bar / baseline to leave room for the value labels. fontsize_annotations : int or float, default=10 Font size of the per-bar value labels. + xtick_rotation : int or float, default=0 + Rotation (degrees) of the x-axis cluster tick labels; use e.g. ``30`` to keep + long ``condition`` names from overlapping. Rotated labels are right-aligned. Returns ------- @@ -186,6 +191,7 @@ def plot_comparison(df_eval: pd.DataFrame, ut.check_str(name="title", val=title, accept_none=True) ut.check_number_range(name="fontsize_annotations", val=fontsize_annotations, min_val=0, just_int=False) + ut.check_number_val(name="xtick_rotation", val=xtick_rotation, just_int=False) if ylim is not None: ut.check_lim(name="ylim", val=ylim) @@ -223,19 +229,20 @@ def plot_comparison(df_eval: pd.DataFrame, annotation_fmt.format(h), ha="center", va="bottom", fontsize=fontsize_annotations, weight="bold") - # Baseline / chance line + # Baseline / chance line (labelled in the legend so it never overlaps the bars) if baseline is not None: - ax.axhline(baseline, ls="--", color="black", lw=1) if baseline_label is None: baseline_label = f"chance ({baseline:g})" - if baseline_label != "": - ax.text(n_cond - 1 + 0.5 * bar_width, baseline + 0.01 * max(heights_max, 1), - baseline_label, ha="right", va="bottom", - fontsize=max(fontsize_annotations - 1, 1)) + ax.axhline(baseline, ls="--", color="black", lw=1, + label=baseline_label if baseline_label != "" else "_nolegend_") # Cosmetics ax.set_xticks(x) - ax.set_xticklabels(condition_order) + if xtick_rotation: + ax.set_xticklabels(condition_order, rotation=xtick_rotation, ha="right", + rotation_mode="anchor") + else: + ax.set_xticklabels(condition_order) if xlabel is not None: ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) diff --git a/tests/unit/plotting_tests/test_plot_comparison.py b/tests/unit/plotting_tests/test_plot_comparison.py index 83c55e62..4cdfd76d 100644 --- a/tests/unit/plotting_tests/test_plot_comparison.py +++ b/tests/unit/plotting_tests/test_plot_comparison.py @@ -53,16 +53,16 @@ def test_baseline_none_no_line(self): def test_baseline_label_default_text(self): fig, ax = plot_comparison(df_eval=_df(), baseline=50) - assert any("chance" in t.get_text() for t in ax.texts) + assert any("chance" in t.get_text() for t in ax.get_legend().get_texts()) def test_baseline_label_custom(self): fig, ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="random (50%)") - assert any("random (50%)" == t.get_text() for t in ax.texts) + assert any("random (50%)" == t.get_text() for t in ax.get_legend().get_texts()) - def test_baseline_label_empty_suppresses_text(self): + def test_baseline_label_empty_suppresses_legend_entry(self): fig, ax = plot_comparison(df_eval=_df(), baseline=50, baseline_label="") - # 6 value labels, no baseline text - assert len(ax.texts) == 6 + # Only the groups appear in the legend, no baseline entry. + assert [t.get_text() for t in ax.get_legend().get_texts()] == ["Scale-based", "CPP"] def test_annotate_true_writes_value_labels(self): fig, ax = plot_comparison(df_eval=_df(), annotate=True, baseline=None) @@ -91,12 +91,12 @@ def test_annotation_fmt_override(self): assert any(t.get_text() == "60.0" for t in ax.texts) def test_legend_labels_are_groups(self): - fig, ax = plot_comparison(df_eval=_df()) + fig, ax = plot_comparison(df_eval=_df(), baseline=None) labels = [t.get_text() for t in ax.get_legend().get_texts()] assert set(labels) == {"Scale-based", "CPP"} def test_group_order_controls_bar_order(self): - fig, ax = plot_comparison(df_eval=_df(), group_order=["CPP", "Scale-based"]) + fig, ax = plot_comparison(df_eval=_df(), baseline=None, group_order=["CPP", "Scale-based"]) labels = [t.get_text() for t in ax.get_legend().get_texts()] assert labels == ["CPP", "Scale-based"] @@ -144,7 +144,8 @@ def test_labels_and_title(self): def test_duplicate_group_order_deduped(self): # A repeated entry in the explicit order must not create a duplicate bar row. - fig, ax = plot_comparison(df_eval=_df(), group_order=["Scale-based", "Scale-based", "CPP"]) + fig, ax = plot_comparison(df_eval=_df(), baseline=None, + group_order=["Scale-based", "Scale-based", "CPP"]) assert len(ax.patches) == 6 labels = [t.get_text() for t in ax.get_legend().get_texts()] assert labels == ["Scale-based", "CPP"] @@ -172,6 +173,14 @@ def test_bar_width_and_figsize_and_fontsize(self): fontsize_annotations=8) assert len(ax.patches) == 6 + def test_xtick_rotation_applied(self): + fig, ax = plot_comparison(df_eval=_df(), xtick_rotation=30) + assert all(t.get_rotation() == 30 for t in ax.get_xticklabels()) + + def test_xtick_rotation_default_horizontal(self): + fig, ax = plot_comparison(df_eval=_df()) + assert all(t.get_rotation() == 0 for t in ax.get_xticklabels()) + class TestPlotComparisonErrors: """Negative cases: bad input must raise ValueError.""" @@ -238,3 +247,7 @@ def test_non_numeric_value_column_raises(self): df["value"] = df["value"].astype(str) with pytest.raises(ValueError): plot_comparison(df_eval=df) + + def test_bad_xtick_rotation_type_raises(self): + with pytest.raises(ValueError): + plot_comparison(df_eval=_df(), xtick_rotation="45") From 61eb2b1a36b3a7431cd48cb8e3c7a0624493cf43 Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 05:27:27 +0200 Subject: [PATCH 5/6] round4(plot_comparison): hoist loop-invariant label pad, avoid double copy Efficiency/clarity micro-pass (output byte-identical): - Hoist the constant 0.01*max(heights_max,1) label gap out of the per-bar annotation loop (was recomputed for every bar). - grid.loc[g].to_numpy(dtype=float) instead of .values.astype(float) (one conversion, no redundant intermediate copy). Co-Authored-By: Claude Opus 4.8 (1M context) --- aaanalysis/plotting/_plot_comparison.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/aaanalysis/plotting/_plot_comparison.py b/aaanalysis/plotting/_plot_comparison.py index 51dc39cd..a8501272 100644 --- a/aaanalysis/plotting/_plot_comparison.py +++ b/aaanalysis/plotting/_plot_comparison.py @@ -215,17 +215,18 @@ def plot_comparison(df_eval: pd.DataFrame, x = np.arange(n_cond) each_w = bar_width / n_groups heights_max = float(np.nanmax(grid.values)) if grid.size else 0.0 + label_pad = 0.01 * max(heights_max, 1) # loop-invariant gap between a bar top and its label if annotation_fmt is None: annotation_fmt = _auto_annotation_fmt(grid.values) for j, g in enumerate(group_order): offset = (j - (n_groups - 1) / 2) * each_w - heights = grid.loc[g].values.astype(float) + heights = grid.loc[g].to_numpy(dtype=float) bars = ax.bar(x + offset, heights, each_w, label=str(g), color=dict_group_color[g]) if annotate: for b, h in zip(bars, heights): if np.isnan(h): continue - ax.text(b.get_x() + b.get_width() / 2, h + 0.01 * max(heights_max, 1), + ax.text(b.get_x() + b.get_width() / 2, h + label_pad, annotation_fmt.format(h), ha="center", va="bottom", fontsize=fontsize_annotations, weight="bold") From 66d1870cd79e8827b4a65a93b42f46ae36e33d93 Mon Sep 17 00:00:00 2001 From: Stephan Breimann Date: Wed, 1 Jul 2026 05:30:45 +0200 Subject: [PATCH 6/6] round5(plot_comparison): notebook covers xtick_rotation + legend baseline wording Docs/tests completeness pass: - Refresh the executed example notebook for the round-3 behavior (baseline label now a legend entry) and demonstrate the new xtick_rotation param. - Update the 'Further parameters' prose (baseline_label is a legend label; add xtick_rotation). Re-executed with embedded outputs; nbmake green. Docstring checker 0 defects, doc/signature drift 0; full plotting + api meta-test gate 507 passed. Co-Authored-By: Claude Opus 4.8 (1M context) --- examples/plotting/plot_comparison.ipynb | 98 ++++++++++++------------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/examples/plotting/plot_comparison.ipynb b/examples/plotting/plot_comparison.ipynb index edc67c22..6ab8b59b 100644 --- a/examples/plotting/plot_comparison.ipynb +++ b/examples/plotting/plot_comparison.ipynb @@ -14,10 +14,10 @@ "id": "24e447bf", "metadata": { "execution": { - "iopub.execute_input": "2026-07-01T02:53:16.560476Z", - "iopub.status.busy": "2026-07-01T02:53:16.560404Z", - "iopub.status.idle": "2026-07-01T02:53:21.468428Z", - "shell.execute_reply": "2026-07-01T02:53:21.468214Z" + "iopub.execute_input": "2026-07-01T03:30:09.242260Z", + "iopub.status.busy": "2026-07-01T03:30:09.242073Z", + "iopub.status.idle": "2026-07-01T03:30:10.968437Z", + "shell.execute_reply": "2026-07-01T03:30:10.968228Z" } }, "outputs": [ @@ -32,70 +32,70 @@ "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", "
 groupconditionvaluegroupconditionvalue
1Scale-basedNo expansion611Scale-basedNo expansion61
2Scale-basedRandom602Scale-basedRandom60
3Scale-baseddPULearn753Scale-baseddPULearn75
4CPPNo expansion714CPPNo expansion71
5CPPRandom745CPPRandom74
6CPPdPULearn946CPPdPULearn94
\n" @@ -130,16 +130,16 @@ "id": "a0efdae9", "metadata": { "execution": { - "iopub.execute_input": "2026-07-01T02:53:21.469446Z", - "iopub.status.busy": "2026-07-01T02:53:21.469351Z", - "iopub.status.idle": "2026-07-01T02:53:21.572469Z", - "shell.execute_reply": "2026-07-01T02:53:21.572257Z" + "iopub.execute_input": "2026-07-01T03:30:10.969494Z", + "iopub.status.busy": "2026-07-01T03:30:10.969405Z", + "iopub.status.idle": "2026-07-01T03:30:11.030314Z", + "shell.execute_reply": "2026-07-01T03:30:11.030103Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -162,7 +162,7 @@ "id": "36eb7fc7", "metadata": {}, "source": [ - "**Further parameters.** ``plot_comparison`` also accepts: ``group`` / ``condition`` / ``value`` — the column names of the tidy frame; ``baseline_label`` — text for the baseline line (auto ``\"chance (50)\"`` by default, ``\"\"`` to hide); ``annotate`` — toggle the per-bar value labels; ``annotation_fmt`` — format string for the value labels (auto-selected precision by default); ``group_order`` / ``condition_order`` — explicit bar / cluster order; ``colors`` — a list aligned to the groups or a ``group -> color`` dict (defaults to the house palette of ``aa.plot_get_clist``); ``bar_width`` — total cluster width; ``figsize``; ``xlabel``; ``ylim``; ``fontsize_annotations``; and ``ax`` to draw onto an existing axes." + "**Further parameters.** ``plot_comparison`` also accepts: ``group`` / ``condition`` / ``value`` — the column names of the tidy frame; ``baseline_label`` — the legend label for the baseline line (auto ``\"chance (50)\"`` by default, ``\"\"`` to hide); ``annotate`` — toggle the per-bar value labels; ``annotation_fmt`` — format string for the value labels (auto-selected precision by default); ``group_order`` / ``condition_order`` — explicit bar / cluster order; ``colors`` — a list aligned to the groups or a ``group -> color`` dict (defaults to the house palette of ``aa.plot_get_clist``); ``bar_width`` — total cluster width; ``xtick_rotation`` — degrees to rotate the cluster tick labels (e.g. ``30`` for long ``condition`` names); ``figsize``; ``xlabel``; ``ylim``; ``fontsize_annotations``; and ``ax`` to draw onto an existing axes." ] }, { @@ -171,16 +171,16 @@ "id": "98ded14f", "metadata": { "execution": { - "iopub.execute_input": "2026-07-01T02:53:21.573608Z", - "iopub.status.busy": "2026-07-01T02:53:21.573513Z", - "iopub.status.idle": "2026-07-01T02:53:21.616415Z", - "shell.execute_reply": "2026-07-01T02:53:21.616208Z" + "iopub.execute_input": "2026-07-01T03:30:11.031407Z", + "iopub.status.busy": "2026-07-01T03:30:11.031328Z", + "iopub.status.idle": "2026-07-01T03:30:11.074072Z", + "shell.execute_reply": "2026-07-01T03:30:11.073813Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -193,7 +193,7 @@ "aa.plot_settings()\n", "fig, ax = aa.plot_comparison(df_eval=df_eval, baseline=50, baseline_label=\"random (50%)\",\n", " colors={\"Scale-based\": \"tab:gray\", \"CPP\": \"tab:red\"},\n", - " group_order=[\"Scale-based\", \"CPP\"],\n", + " group_order=[\"Scale-based\", \"CPP\"], xtick_rotation=20,\n", " ylabel=\"Balanced accuracy [%]\", ylim=(0, 108))\n", "plt.tight_layout()\n", "plt.show()"