From 4b04c1cb19fa8e4e184802d6913d403d94ad5f3e Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 8 May 2024 06:42:59 -0400 Subject: [PATCH 01/39] add ipython image --- auroris/report/_report.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/auroris/report/_report.py b/auroris/report/_report.py index bd00929..b07c1c8 100644 --- a/auroris/report/_report.py +++ b/auroris/report/_report.py @@ -2,9 +2,12 @@ from datetime import datetime from typing import ByteString, List, Optional, Union +from io import BytesIO from matplotlib import pyplot as plt from matplotlib.figure import Figure from PIL.Image import Image as ImageType +from PIL import Image as PILImage +from IPython.core.display import Image as IpythonImage from pydantic import BaseModel, ConfigDict, Field, PrivateAttr from auroris import __version__ @@ -71,13 +74,15 @@ def log_new_column(self, name: str): def log_image( self, - image_or_figure: Union[ImageType, Figure, ByteString], + image_or_figure: Union[ImageType, Figure, ByteString, IpythonImage], title: Optional[str] = None, description: Optional[str] = None, ): """Logs an image. Also accepts Matplotlib figures, which will be converted to images.""" self._check_active_section() - if isinstance(image_or_figure, Figure): + if isinstance(image_or_figure, IpythonImage): + image = PILImage.open(BytesIO(image_or_figure.data)) + elif isinstance(image_or_figure, Figure): image = fig2img(image_or_figure) plt.close(image_or_figure) else: From 9096b3039dd808d8b66aa97325bfdaad331747c9 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 8 May 2024 06:43:21 -0400 Subject: [PATCH 02/39] minor fix --- auroris/curation/actions/_discretize.py | 2 +- auroris/visualization/_distribution.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index d9be8f9..965f06f 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -82,7 +82,7 @@ class Discretization(BaseAction): inplace: bool = False allow_nan: bool = True label_order: Literal["ascending", "descending"] = "ascending" - log_scale: bool = True + log_scale: bool = False def transform( self, diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py index 8bd47c6..07900bd 100644 --- a/auroris/visualization/_distribution.py +++ b/auroris/visualization/_distribution.py @@ -42,11 +42,11 @@ def visualize_continuous_distribution( for threshold in bins: if log_scale and lower != -np.inf: lower = np.log(lower) + if log_scale and threshold != np.inf: threshold = np.log(threshold) mask = (xs > lower) & (xs <= threshold) - lower = threshold # Update xs to make sure they cover the range even if the # coordinates don't fully cover it @@ -75,6 +75,7 @@ def _format(val): ax.fill_between(masked_xs, ys[mask], alpha=0.5, label=label) ax.plot([threshold, threshold], [ylim[0], ys[mask][-1]], "k--") + lower = threshold ax.legend() return fig From 42b833c602e2cfb600ecb681441cd991d60529b5 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 9 May 2024 10:47:49 -0400 Subject: [PATCH 03/39] allow image export to remote path --- auroris/report/_report.py | 6 ++-- auroris/report/broadcaster/_html.py | 14 ++++++--- auroris/utils.py | 44 +++++++++++++++++++++++++---- 3 files changed, 50 insertions(+), 14 deletions(-) diff --git a/auroris/report/_report.py b/auroris/report/_report.py index b07c1c8..ef8d685 100644 --- a/auroris/report/_report.py +++ b/auroris/report/_report.py @@ -2,16 +2,14 @@ from datetime import datetime from typing import ByteString, List, Optional, Union -from io import BytesIO from matplotlib import pyplot as plt from matplotlib.figure import Figure from PIL.Image import Image as ImageType -from PIL import Image as PILImage from IPython.core.display import Image as IpythonImage from pydantic import BaseModel, ConfigDict, Field, PrivateAttr from auroris import __version__ -from auroris.utils import fig2img +from auroris.utils import fig2img, ipyimg2img class AnnotatedImage(BaseModel): @@ -81,7 +79,7 @@ def log_image( """Logs an image. Also accepts Matplotlib figures, which will be converted to images.""" self._check_active_section() if isinstance(image_or_figure, IpythonImage): - image = PILImage.open(BytesIO(image_or_figure.data)) + image = ipyimg2img(image_or_figure) elif isinstance(image_or_figure, Figure): image = fig2img(image_or_figure) plt.close(image_or_figure) diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index a855d65..e25f62c 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -1,5 +1,6 @@ import base64 import os +import re import pathlib from copy import deepcopy from importlib import resources @@ -8,7 +9,7 @@ import fsspec from auroris.report import CurationReport -from auroris.utils import img2bytes +from auroris.utils import img2bytes, save_image, path2url from ._base import ReportBroadcaster @@ -61,9 +62,14 @@ def broadcast(self): src = f"data:image/png;base64,{image_data}" else: # Save as separate file - path = dm.fs.join(self._image_dir, f"{image_counter}.png") - image.image.save(path) - src = os.path.relpath(path, self._destination) + filename = ( + f"{re.sub(r'[^\w\-\.]', '_', image.title)}.png" + if image.title is not None + else f"{image_counter}.png" + ) + path = dm.fs.join(self._image_dir, filename) + save_image(image.image, path, self._destination) + src = path2url(path, self._destination) image.image = src image_counter += 1 diff --git a/auroris/utils.py b/auroris/utils.py index fb59f38..868a0d4 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -1,10 +1,16 @@ +import os from io import BytesIO import numpy as np from matplotlib.figure import Figure from PIL import Image from PIL.Image import Image as ImageType +from IPython.core.display import Image as IpythonImage +import fsspec +from google.cloud import storage + from sklearn.utils.multiclass import type_of_target +import datamol as dm def is_regression(values: np.ndarray): @@ -19,12 +25,17 @@ def is_regression(values: np.ndarray): def fig2img(fig: Figure) -> ImageType: """Convert a Matplotlib figure to a PIL Image""" - fig.canvas.draw() - return Image.frombytes( - "RGBA", - fig.canvas.get_width_height(), - fig.canvas.buffer_rgba(), - ) + if isinstance(fig, Figure): + fig.canvas.draw() + return Image.frombytes( + "RGBA", + fig.canvas.get_width_height(), + fig.canvas.buffer_rgba(), + ) + + +def ipyimg2img(fig: IpythonImage) -> ImageType: + return Image.open(BytesIO(fig.data)) def img2bytes(image: ImageType): @@ -33,3 +44,24 @@ def img2bytes(image: ImageType): image.save(image_bytes, format="PNG") image_bytes = image_bytes.getvalue() return image_bytes + + +def path2url(path: str, destination: str): + if not os.path.isfile(path): + if path.startswith("gs://"): + return path.replace("gs://", "https://storage.googleapis.com/") + else: + raise ValueError("Only GCP path is supported.") + else: + return os.path.relpath(path, destination) + + +def save_image(image: ImageType, path: str, destination: str): + """Save image to local and remote path""" + if dm.fs.is_local_path(destination): + image.save(path) + else: + # Lu: couldn't find a way to save image directly to remote path + image_bytes = img2bytes(image) + with fsspec.open(path, "wb") as f: + f.write(image_bytes) From f1f3abbf02ea9f7c69d2557d33d75a8e71021c86 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 9 May 2024 10:48:18 -0400 Subject: [PATCH 04/39] minor changes --- auroris/curation/actions/_ac_stereoisomer.py | 4 ++-- auroris/curation/actions/_distribution.py | 4 +--- auroris/curation/actions/_outlier.py | 2 +- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 10357c3..5ae4c2e 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -54,7 +54,7 @@ class StereoIsomerACDetection(BaseAction): Automatic detection of outliers. """ - stereoisomer_id_col: str + stereoisomer_id_col: str = "MOL_molhash_id_no_stereo" y_cols: List[str] threshold: float = 2.0 prefix: str = "AC_" @@ -80,7 +80,7 @@ def transform( col_with_prefix = self.get_column_name(col) report.log_new_column(col_with_prefix) - has_cliff = dataset[col_with_prefix].notna() + has_cliff = dataset[col_with_prefix] == True num_cliff = has_cliff.sum() if num_cliff > 0: diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py index 97f225b..9b001ae 100644 --- a/auroris/curation/actions/_distribution.py +++ b/auroris/curation/actions/_distribution.py @@ -27,9 +27,7 @@ def transform( ): if report is not None: for y_col in self.y_cols: - fig = visualize_continuous_distribution( - data=dataset[y_col], label_name=y_col, log_scale=self.log_scale - ) + fig = visualize_continuous_distribution(data=dataset[y_col], log_scale=self.log_scale) report.log_image(fig, title=f"Data distribution - {y_col}") return dataset diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index 5731bb3..cfdf5d0 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -150,7 +150,7 @@ def transform( report.log_new_column(is_outlier_col_label) fig = visualize_distribution_with_outliers(values=values, is_outlier=is_outlier) - report.log_image(fig) + report.log_image(fig, title=f"Outlier detection - {column}") return dataset From 9d365ae49ad14a509123d296dd6c43daa67993d1 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:21:52 -0400 Subject: [PATCH 05/39] change loglevel --- auroris/report/broadcaster/_logger.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/auroris/report/broadcaster/_logger.py b/auroris/report/broadcaster/_logger.py index b6daa9a..317f740 100644 --- a/auroris/report/broadcaster/_logger.py +++ b/auroris/report/broadcaster/_logger.py @@ -34,7 +34,8 @@ class LoggerBroadcaster(ReportBroadcaster): def __init__(self, report: CurationReport): super().__init__(report) self.logger = logging.getLogger() - self.logger.setLevel(logging.DEBUG) + # Lu: debug level might log other irrelevant debugging logs + self.logger.setLevel(logging.INFO) handler = logging.StreamHandler(sys.stdout) handler.setFormatter(ColoredFormatter()) @@ -51,18 +52,22 @@ def broadcast(self): self.render_log(log) for image in section.images: self.render_image(image) + self.on_report_end(self._report) def render_log(self, message: str): - self.logger.debug(f"[LOG]: {message}") + self.logger.info(f"[LOG]: {message}") def render_image(self, image: AnnotatedImage): width, height = image.image.size - self.logger.debug(f"[IMG]: Dimensions {width} x {height}") + self.logger.info(f"[IMG]: Dimensions {width} x {height}") def on_section_start(self, section: Section): self.logger.info(f"===== {section.title} =====") def on_report_start(self, report: CurationReport): self.logger.critical("===== Curation Report =====") - self.logger.debug(f"Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}") - self.logger.debug(f"Version: {report.auroris_version}") + self.logger.info(f"Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}") + self.logger.info(f"Version: {report.auroris_version}") + + def on_report_end(self, report: CurationReport): + self.logger.critical("===== Curation Report END =====") From 2ab83d7f0394a6837e79141a00ad65634f02baa1 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:22:30 -0400 Subject: [PATCH 06/39] update chemspace viz --- auroris/curation/actions/_mol.py | 32 +++++++++++++++++++++++------ auroris/visualization/_chemspace.py | 28 +++++++++++++------------ 2 files changed, 41 insertions(+), 19 deletions(-) diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index dcff30c..aca6c01 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -11,6 +11,11 @@ from auroris.types import VerbosityLevel from auroris.visualization import visualize_chemspace +try: + from molfeat.trans.pretrained.hf_transformers import PretrainedHFTransformer +except: + PretrainedHFTransformer = None + def curate_molecules( mols: List[Union[str, dm.Mol]], @@ -228,6 +233,8 @@ class MoleculeCuration(BaseAction): remove_stereo: bool = False count_stereoisomers: bool = True count_stereocenters: bool = True + y_cols: Optional[List[str]] = None + fast: Optional[bool] = True def transform( self, @@ -264,12 +271,25 @@ def transform( smiles_col = self.get_column_name("smiles") smiles = dataset[smiles_col].dropna().values - with dm.without_rdkit_log(): - # Temporary disable logs because of deprecation warning - X = np.array([dm.to_fp(smi) for smi in smiles]) - - fig = visualize_chemspace(X=X) - report.log_image(fig, "Distribution in Chemical Space") + if PretrainedHFTransformer and not self.fast: + featurizer = "ChemBERTa-77M-MTR" + transformer = PretrainedHFTransformer(kind=featurizer, notation="smiles", dtype=float) + X = transformer(smiles) + report.log( + "`ChemBERTa-77M-MTR` embedding is used to compute the distributionin chemical space." + ) + else: + featurizer = "ECFP" + with dm.without_rdkit_log(): + # Temporary disable logs because of deprecation warning + X = np.array([dm.to_fp(smi) for smi in smiles]) + report.log("Default `ecfp` fingerprint is used to compute the distributionin chemical space.") + + # list of data per column + y = dataset[self.y_cols].T.values.tolist() if self.y_cols else None + + fig = visualize_chemspace(X=X, y=y, labels=self.y_cols) + report.log_image(fig, title=f"Distribution in Chemical Space - {featurizer}") if self.count_stereocenters: # Plot all compounds with undefined stereocenters for visual inspection diff --git a/auroris/visualization/_chemspace.py b/auroris/visualization/_chemspace.py index 16d6246..e662a22 100644 --- a/auroris/visualization/_chemspace.py +++ b/auroris/visualization/_chemspace.py @@ -15,7 +15,7 @@ def visualize_chemspace( X: Union[List[np.ndarray], np.ndarray], y: Optional[Union[List[np.ndarray], np.ndarray]] = None, labels: Optional[List[str]] = None, - n_cols: int = 3, + n_cols: int = 2, fig_base_size: float = 8, w_h_ratio: float = 0.5, dpi: int = 150, @@ -39,36 +39,38 @@ def visualize_chemspace( if umap is None: raise ImportError("Please run `pip install umap-learn` to use UMAP visualizations for the chemspace.") - if isinstance(X, np.ndarray): - X = [X] if isinstance(y, np.ndarray): - y = [y] + y = list(y) + if y is None: - y = [None for _ in range(len(X))] - if len(X) != len(y): - raise ValueError("X and y must have the same length.") + y = [None] if labels is None: - labels = ["" for i in range(len(X))] + labels = ["" for _ in range(len(y))] + + if len(y) != len(labels): + raise ValueError("`labels` and `y` must have the same length.") + + embedding = umap.UMAP(**umap_kwargs).fit_transform(X) + umap_0, umap_1 = embedding[:, 0], embedding[:, 1] with create_figure( - n_plots=len(X), + n_plots=len(y), n_cols=n_cols, fig_base_size=fig_base_size, w_h_ratio=w_h_ratio, dpi=dpi, seaborn_theme=seaborn_theme, ) as (fig, axes): - for idx, (X_i, y_i, label) in enumerate(zip(X, y, labels)): - embedding = umap.UMAP(**umap_kwargs).fit_transform(X_i) - umap_0, umap_1 = embedding[:, 0], embedding[:, 1] - + for idx, (y_i, label) in enumerate(zip(y, labels)): ax = sns.scatterplot( x=umap_0, y=umap_1, hue=y_i, ax=axes[idx], ) + ax.set_xlabel("Component 0") + ax.set_xlabel("Component 1") ax.set_title(label) return fig From 8412c9ad7a7391ae1cf0c3e69f9e59ef11ff6f59 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:23:18 -0400 Subject: [PATCH 07/39] add dup logger --- auroris/curation/actions/_deduplicate.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index 30cb7aa..d10e94a 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -67,10 +67,14 @@ def transform( verbosity: VerbosityLevel = VerbosityLevel.NORMAL, parallelized_kwargs: Optional[Dict] = None, ): - return deduplicate( + dataset_dedup = deduplicate( dataset, deduplicate_on=self.deduplicate_on, y_cols=self.y_cols, keep=self.keep, method=self.method, ) + if report is not None: + num_duplicates = dataset.shape[0] - dataset_dedup.shape[0] + report.log(f"Deduplication merged and removed {num_duplicates} duplicated molecules from dataset") + return dataset_dedup From 041cc7a0519db624a78f37978b29352596002838 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:23:39 -0400 Subject: [PATCH 08/39] simplify distribution viz --- auroris/visualization/_distribution.py | 34 +++++++++++++++++--------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py index 07900bd..c49a469 100644 --- a/auroris/visualization/_distribution.py +++ b/auroris/visualization/_distribution.py @@ -3,6 +3,7 @@ import numpy as np import seaborn as sns from scipy import stats +import matplotlib.pyplot as plt from auroris.visualization.utils import create_figure @@ -82,8 +83,7 @@ def _format(val): def visualize_distribution_with_outliers( - values: np.ndarray, - is_outlier: Optional[List[bool]] = None, + values: np.ndarray, is_outlier: Optional[List[bool]] = None, title: str = "Probability Plot" ): """Visualize the distribution of the data and highlight the potential outliers.""" @@ -98,14 +98,26 @@ def visualize_distribution_with_outliers( values = values[sorted_ind] is_outlier = is_outlier[sorted_ind] - with create_figure(n_plots=2) as (fig, axes): - sns.scatterplot( - x=np.arange(len(values)), - y=values, - hue=is_outlier, - palette={1.0: "red", 0.0: "navy", 0.5: "grey"}, - ax=axes[0], - ) - stats.probplot(values, dist="norm", plot=axes[1]) + fig = plt.figure() + res = stats.probplot(values, dist="norm", plot=plt, fit=True) + x = res[0][0] + y = res[0][1] + + # Specify the indices of data points to highlight + highlight_indices = np.argwhere(is_outlier == True).flatten() + highlight_color = "red" + + # Plot the probability plot + # plt.plot(x, y, "bo") # Blue circles for regular points + + # Overlay specific points with different colors + for idx in highlight_indices: + plt.plot( + x[idx], y[idx], marker="o", markersize=8, color=highlight_color + ) # Red circles for highlighted points + + plt.xlabel("Theoretical quantiles") + plt.ylabel("Ordered Values") + plt.title(title) return fig From d1f41de2eb5e4f42c6a53fa65a86f587b74eca83 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:24:18 -0400 Subject: [PATCH 09/39] update outlier logs --- auroris/curation/actions/_outlier.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index cfdf5d0..af66dd8 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -145,11 +145,17 @@ def transform( is_outlier_col_label = self.get_column_name(column) dataset[is_outlier_col_label] = is_outlier + num_outliers = sum(is_outlier) if report is not None: report.log_new_column(is_outlier_col_label) - - fig = visualize_distribution_with_outliers(values=values, is_outlier=is_outlier) + report.log( + f"Found {num_outliers} potential outliers " + f"with respect to the {column} column for review." + ) + fig = visualize_distribution_with_outliers( + values=values, is_outlier=is_outlier, title=f"Probability Plot - {column}" + ) report.log_image(fig, title=f"Outlier detection - {column}") return dataset From f841f12e6532b55fbef794f733764e6f7205304a Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 15 May 2024 14:24:40 -0400 Subject: [PATCH 10/39] minor changes --- auroris/curation/_curator.py | 2 +- auroris/curation/actions/_ac_stereoisomer.py | 8 +++++--- auroris/report/broadcaster/_html.py | 2 ++ 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 57025a8..66b6322 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -38,7 +38,7 @@ def _serialize_verbosity(self, value: VerbosityLevel): def transform(self, dataset: pd.DataFrame) -> Tuple[pd.DataFrame, CurationReport]: report = CurationReport() - dataset = dataset.copy(deep=True) + dataset = dataset.copy() action: BaseAction for action in self.steps: diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 5ae4c2e..53069ec 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -51,7 +51,7 @@ def detect_streoisomer_activity_cliff( class StereoIsomerACDetection(BaseAction): """ - Automatic detection of outliers. + Automatic detection of activity shift between stereoisomers. """ stereoisomer_id_col: str = "MOL_molhash_id_no_stereo" @@ -92,10 +92,12 @@ def transform( legends = (col + dataset.loc[has_cliff, col].astype(str)).tolist() image = dm.to_image([dm.to_mol(s) for s in to_plot], legends=legends, use_svg=False) - report.log_image(image) + report.log_image( + image_or_figure=image, title="Detection of activity shifts among stereoisomers" + ) else: report.log( - "Found no activity cliffs among stereoisomers with respect to the {col} column." + f"Found no activity cliffs among stereoisomers with respect to the {col} column." ) return dataset diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index e25f62c..97396c9 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -87,3 +87,5 @@ def broadcast(self): path = dm.fs.join(self._destination, "index.html") with fsspec.open(path, "w") as fd: fd.write(html) + + return path From 1f25fa57e196a0629cb3d409dcdab65ae1b17eb4 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 01:37:30 -0400 Subject: [PATCH 11/39] fix serialization --- auroris/cli.py | 5 ++-- auroris/curation/_curator.py | 48 ++++++++++++++++++++++++++++++++---- 2 files changed, 46 insertions(+), 7 deletions(-) diff --git a/auroris/cli.py b/auroris/cli.py index 0bbcb89..0bc3301 100644 --- a/auroris/cli.py +++ b/auroris/cli.py @@ -2,6 +2,7 @@ import pandas as pd import typer +from typing import Optional from auroris.curation import Curator from auroris.report.broadcaster import HTMLBroadcaster @@ -9,9 +10,9 @@ @app.command() -def curate(config_path: str, dataset_path: str, destination: str, overwrite: bool = False): +def curate(config_path: str, destination: str, dataset_path: Optional[str] = None, overwrite: bool = False): # Load data - dataset = pd.read_csv(dataset_path) + dataset = pd.read_csv(dataset_path) if dataset_path else None curator = Curator.from_json(config_path) # Run curation diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 66b6322..e8d7734 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -1,10 +1,11 @@ import json -from typing import List, Tuple, Union +from typing import List, Tuple, Union, Optional +from os import PathLike import fsspec import pandas as pd from loguru import logger -from pydantic import BaseModel, Field, field_serializer, field_validator +from pydantic import BaseModel, Field, field_serializer, field_validator, ValidationError from auroris.curation.actions._base import ACTION_REGISTRY, BaseAction from auroris.report import CurationReport @@ -21,8 +22,9 @@ class Curator(BaseModel): # This is the recommended way to add all subclasses in the type. # See e.g. https://github.com/pydantic/pydantic/issues/2200 # and https://github.com/pydantic/pydantic/issues/2036 - steps: List[Union[tuple(ACTION_REGISTRY)]] = Field(..., discriminator="name") # type: ignore + data_path: Optional[Union[str, PathLike]] = None + steps: List[Union[tuple(ACTION_REGISTRY)]] = Field(..., discriminator="name") # type: ignore verbosity: VerbosityLevel = VerbosityLevel.NORMAL parallelized_kwargs: dict = Field(default_factory=dict) @@ -36,7 +38,28 @@ def _validate_verbosity(cls, v): def _serialize_verbosity(self, value: VerbosityLevel): return value.name - def transform(self, dataset: pd.DataFrame) -> Tuple[pd.DataFrame, CurationReport]: + @field_validator("data_path", mode="before") + def _validate_data_path(cls, value: Union[str, PathLike]): + try: + pd.read_csv(value, nrows=5) + return value + except: + raise ValueError( + f"Dataset cann't be loaded by `panda.read_csv('{value}')`." + f"Consider to directly pass the loaded the data to `Curator.curate()`." + ) + + @field_serializer("verbosity") + def _serialize_verbosity(self, value: Union[str, PathLike]): + return value.name + + def _load_data(self): + return pd.read_csv(self.data_path) + + def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFrame, CurationReport]: + if dataset is None: + dataset = self._load_data() + report = CurationReport() dataset = dataset.copy() @@ -57,6 +80,13 @@ def transform(self, dataset: pd.DataFrame) -> Tuple[pd.DataFrame, CurationReport def __call__(self, dataset): return self.transform(dataset) + @classmethod + def _get_action(cls, name: str): + for action in ACTION_REGISTRY: + if action.__name__ == name: + return action + return None + @classmethod def from_json(cls, path: str): """Loads a curation workflow from a JSON file. @@ -66,6 +96,9 @@ def from_json(cls, path: str): """ with fsspec.open(path, "r") as f: data = json.load(f) + + steps = [cls._get_action(name)(**args) for step in data["steps"] for name, args in step.items()] + data["steps"] = steps return cls.model_validate(data) def to_json(self, path: str): @@ -74,6 +107,11 @@ def to_json(self, path: str): Args: path: The destination to save to """ + serialization = self.model_dump(exclude="steps") + # # save steps in defined order + serialization["steps"] = [{step.name: step.model_dump()} for step in self.steps] with fsspec.open(path, "w") as f: - json.dump(self.model_dump(), f) + json.dump(serialization, f) + # with fsspec.open(path, "w") as f: + # json.dump(self.model_dump(), f) return path From a9669a6ebf8eda1f20d47fcadcb4b40603e39b35 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 14:53:19 -0400 Subject: [PATCH 12/39] add more docstrings --- auroris/curation/_curator.py | 11 +- auroris/curation/actions/_ac_stereoisomer.py | 23 +++- auroris/curation/actions/_deduplicate.py | 6 + auroris/curation/actions/_discretize.py | 34 +++++- auroris/curation/actions/_distribution.py | 15 ++- auroris/curation/actions/_mol.py | 33 +++++- auroris/curation/actions/_outlier.py | 118 ++++++++++--------- auroris/report/broadcaster/_html.py | 10 +- auroris/utils.py | 11 +- auroris/visualization/_distribution.py | 15 ++- auroris/visualization/utils.py | 2 +- 11 files changed, 196 insertions(+), 82 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index e8d7734..2f7969c 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -5,7 +5,7 @@ import fsspec import pandas as pd from loguru import logger -from pydantic import BaseModel, Field, field_serializer, field_validator, ValidationError +from pydantic import BaseModel, Field, field_serializer, field_validator from auroris.curation.actions._base import ACTION_REGISTRY, BaseAction from auroris.report import CurationReport @@ -16,6 +16,13 @@ class Curator(BaseModel): """ A curator is a collection of actions that are applied to a dataset. Can be serialized. + + Args: + data_path: Data path. + The data must be loadable by `pd.read_csv` with default parameters. + steps: List of curation actions. + Check all the available action . + """ # To know which Action object to create, we need a discriminated union. @@ -43,7 +50,7 @@ def _validate_data_path(cls, value: Union[str, PathLike]): try: pd.read_csv(value, nrows=5) return value - except: + except Exception: raise ValueError( f"Dataset cann't be loaded by `panda.read_csv('{value}')`." f"Consider to directly pass the loaded the data to `Curator.curate()`." diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 53069ec..7ecf336 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -15,9 +15,19 @@ def detect_streoisomer_activity_cliff( dataset: pd.DataFrame, stereoisomer_id_col: str, y_cols: List[str], - threshold: float = 1.0, + threshold: float = 2.0, prefix: str = "AC_", -): +) -> pd.DataFrame: + """ + Detect activity cliff among stereoisomers based on classification label or pre-defined threshold for continuous values. + + Args: + dataset: Dataframe + stereoisomer_id_col: Column which identifies the stereoisomers + y_cols: List of columns for bioactivities + threshold: Threshold to identify the activity cliff. Currently, the difference of zscores between isomers are used for identification. + prefix: Prefix for the adding columns + """ dataset_ori = dataset.copy(deep=True) ac_cols = {y_col: [] for y_col in y_cols} group_index_list = np.array( @@ -52,6 +62,13 @@ def detect_streoisomer_activity_cliff( class StereoIsomerACDetection(BaseAction): """ Automatic detection of activity shift between stereoisomers. + + Args: + stereoisomer_id_col: Column which identifies the stereoisomers. + y_cols: List of columns for bioactivities. + threshold: Threshold to identify the activity cliff. Currently, the difference of zscores between isomers are used for identification. + prefix: Prefix for the adding columns. + mol_col: Column for molecule strings """ stereoisomer_id_col: str = "MOL_molhash_id_no_stereo" @@ -80,7 +97,7 @@ def transform( col_with_prefix = self.get_column_name(col) report.log_new_column(col_with_prefix) - has_cliff = dataset[col_with_prefix] == True + has_cliff = dataset[col_with_prefix].__eq__(True) num_cliff = has_cliff.sum() if num_cliff > 0: diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index d10e94a..893a1c7 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -53,6 +53,12 @@ def deduplicate( class Deduplication(BaseAction): """ Automatic detection of outliers. + + Args: + deduplicate_on: A subset of the columns to deduplicate on (can be default). + y_cols: The columns to aggregate. + keep: Whether to keep the first or last copy of the duplicates. + method: The method to aggregate the data. """ deduplicate_on: Optional[Union[str, List[str]]] = None diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index 965f06f..3241bbf 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -17,7 +17,8 @@ def discretize( allow_nan: bool = True, label_order: Literal["ascending", "descending"] = "ascending", ) -> np.ndarray: - """Thresholding of array-like or scipy.sparse matrix into binary or multiclass labels. + """ + Thresholding of array-like or scipy.sparse matrix into binary or multiclass labels. Args: X : The data to discretize, element by element. @@ -76,6 +77,37 @@ def discretize( class Discretization(BaseAction): + """ + Thresholding bioactivity columns to binary or multiclass labels. + + Args: + X : The data to discretize, element by element. + scipy.sparse matrices should be in CSR or CSC format to avoid an + un-necessary copy. + + thresholds: Interval boundaries that include the right bin edge. + + inplace: Set to True to perform inplace discretization and avoid a copy + (if the input is already a numpy array or a scipy.sparse CSR / CSC + matrix and if axis is 1). + + allow_nan: Set to True to allow nans in the array for discretization. Otherwise, + an error will be raised instead. + + label_order: The continuous values are discretized to labels 0, 1, 2, .., N with respect to given + threshold bins [threshold_1, threshold_2,.., threshould_n]. + When set to 'ascending', the class label is in ascending order with the threshold + bins that `0` represents negative class or lower class, while 1, 2, 3 are for higher classes. + When set to 'descending' the class label is in ascending order with the threshold bins. + Sometimes the positive labels are on the left side of provided threshold. + E.g. For binarization with threshold [0.5], the positive label is defined + by`X < 0.5`. In this case, `label_order` should be `descending`. + + log_scale: Whether visualize distribution in log scale. + See more in + + """ + input_column: str prefix: str = "CLS_" thresholds: List[float] diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py index 9b001ae..9b0efd7 100644 --- a/auroris/curation/actions/_distribution.py +++ b/auroris/curation/actions/_distribution.py @@ -1,7 +1,6 @@ -from typing import Dict, List, Optional +from typing import Dict, List, Optional, Sequence import pandas as pd -from pydantic import Field from auroris.curation.actions._base import BaseAction from auroris.report import CurationReport @@ -12,11 +11,17 @@ class ContinuousDistributionVisualization(BaseAction): """ Visualize a continuous distribution + + Args: + y_cols: List of columns for bioactivity for visualization + log_scale: Whether visualize distribution in log scale. + bins: The bin boundaries to color the area under the KDE curve. + """ y_cols: Optional[List[str]] = None log_scale: bool = False - kwargs: Dict = Field(default_factory=dict) + bins: Optional[Sequence[float]] = None def transform( self, @@ -27,7 +32,9 @@ def transform( ): if report is not None: for y_col in self.y_cols: - fig = visualize_continuous_distribution(data=dataset[y_col], log_scale=self.log_scale) + fig = visualize_continuous_distribution( + data=dataset[y_col], log_scale=self.log_scale, bins=self.bins + ) report.log_image(fig, title=f"Data distribution - {y_col}") return dataset diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index aca6c01..d2d7684 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -13,7 +13,7 @@ try: from molfeat.trans.pretrained.hf_transformers import PretrainedHFTransformer -except: +except Exception: PretrainedHFTransformer = None @@ -26,6 +26,24 @@ def curate_molecules( count_stereocenters: bool = True, **parallelized_kwargs, ): + """ + Curate a list of molecules. + + Args: + mols: List of molecules + progress: Whether show curation progress + remove_salt_solvent: Whether remove salt and solvent from molecule + remove_stereo: Whether remove stereo chemistry information from molecule + count_stereoisomers: Whether count the number of stereoisomers of molecule + count_stereocenters: Whether count the number of stereocenters of molecule + parallelized_kwargs: Additional argument for the parallelizarion process. + See more about + + Returns: + mol_dict: Dictionary of molecule and additional metadata + num_invalid: Number of invalid molecules + + """ fn = partial( _curate_molecule, remove_salt_solvent=remove_salt_solvent, @@ -191,10 +209,11 @@ def _get_mol_dict( def _num_stereo_centers(mol: dm.Mol) -> Tuple[int]: - """Get the number of defined and undefined stereo centers of a given molecule - by accessing the all and only defined stereo centers. - It's to facilitate the analysis of the stereo isomers. - None will be return if there is no stereo centers in the molecule. + """ + Get the number of defined and undefined stereo centers of a given molecule + by accessing the all and only defined stereo centers. + It's to facilitate the analysis of the stereo isomers. + None will be return if there is no stereo centers in the molecule. Args: mol: Molecule @@ -218,7 +237,9 @@ def _num_stereo_centers(mol: dm.Mol) -> Tuple[int]: class MoleculeCuration(BaseAction): """ - Attributes: + Automated molecule curation and chemistry space distribution + + Args: input_column: The name of the column that has the molecules (either `dm.Mol` objects or SMILES). remove_salt_solvent: When set to 'True', all disconnected salts and solvents will be removed from molecule. In most of the cases, it is recommended to remove the salts/solvents. diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index af66dd8..0a008aa 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -18,52 +18,6 @@ OutlierDetectionMethod: TypeAlias = Literal["iso", "lof", "svm", "ee", "zscore"] -def detect_outliers(X: np.ndarray, method: OutlierDetectionMethod = "zscore", **kwargs: Any): - """Functional interface for detecting outliers - - Args: - X: The observations that we want to classify as inliers or outliers. - method: The method to use for outlier detection. - **kwargs: Keyword arguments for the outlier detection method. - """ - - if X.ndim != 1: - raise ValueError("X must be a 1D array for outlier detection.") - - detector_cls = _OUTLIER_METHODS[method] - detector = detector_cls(**kwargs) - indices = np.flatnonzero(~np.isnan(X)) - - in_ = X[indices].reshape(-1, 1) - out_ = detector.fit_predict(in_) - - is_inlier = np.full_like(X, np.nan) - is_inlier[indices] = out_.flatten() - - is_outlier = is_inlier == -1 - return is_outlier - - -def modified_zscore(data: np.ndarray, consistency_correction: float = 1.4826): - """ - The modified z score is calculated from the median absolute deviation (MAD). - These values must be multiplied by a constant to approximate the standard deviation. - - The modified z score might be more robust than the standard z score because it relies - on the median (MED) for calculating the z score. - - modified Z score = (X-MED) / (consistency_correction*MAD) - - """ - median = np.nanmedian(data) - - deviation_from_med = np.array(data) - median - - mad = np.nanmedian(np.abs(deviation_from_med)) - mod_zscore = deviation_from_med / (consistency_correction * mad) - return mod_zscore - - class ZscoreOutlier(OutlierMixin): """ Detect outliers by the absolute value of the Z-score. @@ -122,9 +76,70 @@ def fit_predict(self, X: np.ndarray) -> np.ndarray: return self.predict(X) +_OUTLIER_METHODS: Dict[OutlierDetectionMethod, OutlierMixin] = { + "iso": IsolationForest, + "lof": LocalOutlierFactor, + "svm": OneClassSVM, + "ee": EllipticEnvelope, + "zscore": ZscoreOutlier, +} + + +def detect_outliers(X: np.ndarray, method: OutlierDetectionMethod = "zscore", **kwargs: Any): + """Functional interface for detecting outliers + + Args: + X: The observations that we want to classify as inliers or outliers. + method: The method to use for outlier detection. + **kwargs: Keyword arguments for the outlier detection method. + """ + + if X.ndim != 1: + raise ValueError("X must be a 1D array for outlier detection.") + + detector_cls = _OUTLIER_METHODS[method] + detector = detector_cls(**kwargs) + indices = np.flatnonzero(~np.isnan(X)) + + in_ = X[indices].reshape(-1, 1) + out_ = detector.fit_predict(in_) + + is_inlier = np.full_like(X, np.nan) + is_inlier[indices] = out_.flatten() + + is_outlier = is_inlier == -1 + return is_outlier + + +def modified_zscore(data: np.ndarray, consistency_correction: float = 1.4826): + """ + The modified z score is calculated from the median absolute deviation (MAD). + These values must be multiplied by a constant to approximate the standard deviation. + + The modified z score might be more robust than the standard z score because it relies + on the median (MED) for calculating the z score. + + modified Z score = (X-MED) / (consistency_correction*MAD) + + """ + median = np.nanmedian(data) + + deviation_from_med = np.array(data) - median + + mad = np.nanmedian(np.abs(deviation_from_med)) + mod_zscore = deviation_from_med / (consistency_correction * mad) + return mod_zscore + + class OutlierDetection(BaseAction): """ - Automatic detection of outliers. + Automatic detection of outliers + + Args: + method: Method name for outlier detection. + columns: Column names to detect outliers + prefix: Prefix for added column names + """ method: OutlierDetectionMethod @@ -159,12 +174,3 @@ def transform( report.log_image(fig, title=f"Outlier detection - {column}") return dataset - - -_OUTLIER_METHODS: Dict[OutlierDetectionMethod, OutlierMixin] = { - "iso": IsolationForest, - "lof": LocalOutlierFactor, - "svm": OneClassSVM, - "ee": EllipticEnvelope, - "zscore": ZscoreOutlier, -} diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 97396c9..6e5c7f9 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -1,5 +1,4 @@ import base64 -import os import re import pathlib from copy import deepcopy @@ -20,7 +19,14 @@ class HTMLBroadcaster(ReportBroadcaster): - """Render a simple HTML page""" + """ + Render a simple HTML page + + Args: + report: Curation report object. + destination: Destination folder for exporting the report. + embed_images: Whether embed image bytes in HTML report. + """ def __init__( self, diff --git a/auroris/utils.py b/auroris/utils.py index 868a0d4..41d28fb 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -7,13 +7,13 @@ from PIL.Image import Image as ImageType from IPython.core.display import Image as IpythonImage import fsspec -from google.cloud import storage from sklearn.utils.multiclass import type_of_target import datamol as dm -def is_regression(values: np.ndarray): +def is_regression(values: np.ndarray) -> bool: + """Whether the input values are for regreesion""" target_type = type_of_target(values) if target_type == "continuous": return True @@ -35,6 +35,7 @@ def fig2img(fig: Figure) -> ImageType: def ipyimg2img(fig: IpythonImage) -> ImageType: + """Convert Ipython image to PIL image""" return Image.open(BytesIO(fig.data)) @@ -47,6 +48,10 @@ def img2bytes(image: ImageType): def path2url(path: str, destination: str): + """ + Convert path to an local or remote url for html report. + Currently, only GCP is supported. + """ if not os.path.isfile(path): if path.startswith("gs://"): return path.replace("gs://", "https://storage.googleapis.com/") @@ -62,6 +67,8 @@ def save_image(image: ImageType, path: str, destination: str): image.save(path) else: # Lu: couldn't find a way to save image directly to remote path + # convert to bytes image_bytes = img2bytes(image) + # save bytes as image to remote path with fsspec.open(path, "wb") as f: f.write(image_bytes) diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py index c49a469..6ae6883 100644 --- a/auroris/visualization/_distribution.py +++ b/auroris/visualization/_distribution.py @@ -85,7 +85,15 @@ def _format(val): def visualize_distribution_with_outliers( values: np.ndarray, is_outlier: Optional[List[bool]] = None, title: str = "Probability Plot" ): - """Visualize the distribution of the data and highlight the potential outliers.""" + """ + Visualize the distribution of the data and highlight the potential outliers. + + Args: + values: Values for visulization. + is_outlier: List of outlier flag. + title: Title of plot + + """ if is_outlier is None: # Import here to prevent ciruclar imports @@ -104,12 +112,9 @@ def visualize_distribution_with_outliers( y = res[0][1] # Specify the indices of data points to highlight - highlight_indices = np.argwhere(is_outlier == True).flatten() + highlight_indices = np.argwhere(is_outlier.__eq__(True)).flatten() highlight_color = "red" - # Plot the probability plot - # plt.plot(x, y, "bo") # Blue circles for regular points - # Overlay specific points with different colors for idx in highlight_indices: plt.plot( diff --git a/auroris/visualization/utils.py b/auroris/visualization/utils.py index 690cb97..f4f4503 100644 --- a/auroris/visualization/utils.py +++ b/auroris/visualization/utils.py @@ -15,7 +15,7 @@ def create_figure( dpi: int = 150, seaborn_theme: Optional[str] = "whitegrid", ): - """Creates a figure with the desired size""" + """Creates a figure with the desired size and layout""" if seaborn_theme is not None: sns.set_theme(style=seaborn_theme) From 582070a0a0b3a38414679360b0b2f810072286f0 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 22:16:50 -0400 Subject: [PATCH 13/39] fix docstring and extension --- auroris/curation/_curator.py | 23 ++-- auroris/curation/actions/_ac_stereoisomer.py | 24 ++-- auroris/curation/actions/_base.py | 9 +- auroris/curation/actions/_deduplicate.py | 21 ++-- auroris/curation/actions/_discretize.py | 52 ++++---- auroris/curation/actions/_distribution.py | 20 ++- auroris/curation/actions/_mol.py | 59 +++++---- auroris/curation/actions/_outlier.py | 14 +-- docs/index.md | 35 +++++- docs/tutorials/getting_started.ipynb | 124 ++++++++++++------- mkdocs.yml | 3 +- 11 files changed, 219 insertions(+), 165 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 2f7969c..de571d2 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -17,21 +17,22 @@ class Curator(BaseModel): A curator is a collection of actions that are applied to a dataset. Can be serialized. - Args: - data_path: Data path. - The data must be loadable by `pd.read_csv` with default parameters. - steps: List of curation actions. - Check all the available action . - """ # To know which Action object to create, we need a discriminated union. # This is the recommended way to add all subclasses in the type. # See e.g. https://github.com/pydantic/pydantic/issues/2200 # and https://github.com/pydantic/pydantic/issues/2036 - data_path: Optional[Union[str, PathLike]] = None - - steps: List[Union[tuple(ACTION_REGISTRY)]] = Field(..., discriminator="name") # type: ignore + data_path: Optional[Union[str, PathLike]] = Field( + default=None, + description="Data path. The data must be loadable by `pd.read_csv` with default parameters.", + ) + + steps: List[Union[tuple(ACTION_REGISTRY)]] = Field( + ..., + discriminator="name", + description="List of curation actions. Check all the available action .", + ) verbosity: VerbosityLevel = VerbosityLevel.NORMAL parallelized_kwargs: dict = Field(default_factory=dict) @@ -56,10 +57,6 @@ def _validate_data_path(cls, value: Union[str, PathLike]): f"Consider to directly pass the loaded the data to `Curator.curate()`." ) - @field_serializer("verbosity") - def _serialize_verbosity(self, value: Union[str, PathLike]): - return value.name - def _load_data(self): return pd.read_csv(self.data_path) diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 7ecf336..c1a4bb0 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -1,9 +1,11 @@ from typing import Dict, List, Optional +from pydantic import Field import datamol as dm import numpy as np import pandas as pd + from auroris.curation.actions._base import BaseAction from auroris.curation.actions._outlier import modified_zscore from auroris.report import CurationReport @@ -62,20 +64,18 @@ def detect_streoisomer_activity_cliff( class StereoIsomerACDetection(BaseAction): """ Automatic detection of activity shift between stereoisomers. - - Args: - stereoisomer_id_col: Column which identifies the stereoisomers. - y_cols: List of columns for bioactivities. - threshold: Threshold to identify the activity cliff. Currently, the difference of zscores between isomers are used for identification. - prefix: Prefix for the adding columns. - mol_col: Column for molecule strings """ - stereoisomer_id_col: str = "MOL_molhash_id_no_stereo" - y_cols: List[str] - threshold: float = 2.0 - prefix: str = "AC_" - mol_col: str = "MOL_smiles" + stereoisomer_id_col: str = Field( + default="MOL_molhash_id_no_stereo", description="Column which identifies the stereoisomers." + ) + y_cols: List[str] = Field(..., description="List of columns for bioactivities.") + threshold: float = Field( + default=2.0, + description=" Threshold to identify the activity cliff. Currently, the difference of zscores between isomers are used for identification.", + ) + prefix: str = Field(default="AC_", description="Prefix for the adding columns.") + mol_col: str = Field(default="MOL_smiles", description="Column for molecule strings.") def transform( self, diff --git a/auroris/curation/actions/_base.py b/auroris/curation/actions/_base.py index 589e211..8df6ca9 100644 --- a/auroris/curation/actions/_base.py +++ b/auroris/curation/actions/_base.py @@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Dict, Optional import pandas as pd -from pydantic import BaseModel, model_validator +from pydantic import BaseModel, model_validator, Field from auroris.types import VerbosityLevel @@ -16,14 +16,9 @@ class BaseAction(BaseModel, abc.ABC): """ An action in the curation process. - - Args: - prefix: If the action adds columns, use this prefix. - completed: If the action has completed. - dep_action: Name of dependent action. """ - prefix: str = None + prefix: str = Field(default=None, description="If the action adds columns, use this prefix.") @property def name(self) -> str: diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index 893a1c7..bd18e50 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -1,4 +1,5 @@ from typing import Dict, List, Literal, Optional, Union +from pydantic import Field import pandas as pd @@ -53,18 +54,18 @@ def deduplicate( class Deduplication(BaseAction): """ Automatic detection of outliers. - - Args: - deduplicate_on: A subset of the columns to deduplicate on (can be default). - y_cols: The columns to aggregate. - keep: Whether to keep the first or last copy of the duplicates. - method: The method to aggregate the data. """ - deduplicate_on: Optional[Union[str, List[str]]] = None - y_cols: Optional[Union[str, List[str]]] = None - keep: Literal["first", "last"] = "first" - method: Literal["mean", "median"] = "median" + deduplicate_on: Optional[Union[str, List[str]]] = Field( + default=None, description="A subset of the columns to deduplicate on (can be default)." + ) + y_cols: Optional[Union[str, List[str]]] = Field(default=None, description="The columns to aggregate.") + keep: Literal["first", "last"] = Field( + default="first", description="Whether to keep the first or last copy of the duplicates." + ) + method: Literal["mean", "median"] = Field( + default="median", description="The method to aggregate the data." + ) def transform( self, diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index 3241bbf..9af9083 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -1,4 +1,5 @@ from typing import Dict, List, Literal, Optional, Union +from pydantic import Field import numpy as np import pandas as pd @@ -79,42 +80,37 @@ def discretize( class Discretization(BaseAction): """ Thresholding bioactivity columns to binary or multiclass labels. + """ - Args: - X : The data to discretize, element by element. - scipy.sparse matrices should be in CSR or CSC format to avoid an - un-necessary copy. - - thresholds: Interval boundaries that include the right bin edge. - - inplace: Set to True to perform inplace discretization and avoid a copy + input_column: str = Field(..., description="Column to be discretized.") + prefix: str = "CLS_" + thresholds: List[float] = Field(..., description="Interval boundaries that include the right bin edge.") + inplace: bool = Field( + default=False, + description="""Set to True to perform inplace discretization and avoid a copy (if the input is already a numpy array or a scipy.sparse CSR / CSC - matrix and if axis is 1). - - allow_nan: Set to True to allow nans in the array for discretization. Otherwise, - an error will be raised instead. - - label_order: The continuous values are discretized to labels 0, 1, 2, .., N with respect to given + matrix and if axis is 1).""", + ) + allow_nan: bool = Field( + default=True, + description="Set to True to allow nans in the array for discretization. Otherwise, an error will be raised instead.", + ) + label_order: Literal["ascending", "descending"] = Field( + default="ascending", + description="""The continuous values are discretized to labels 0, 1, 2, .., N with respect to given threshold bins [threshold_1, threshold_2,.., threshould_n]. When set to 'ascending', the class label is in ascending order with the threshold bins that `0` represents negative class or lower class, while 1, 2, 3 are for higher classes. When set to 'descending' the class label is in ascending order with the threshold bins. Sometimes the positive labels are on the left side of provided threshold. E.g. For binarization with threshold [0.5], the positive label is defined - by`X < 0.5`. In this case, `label_order` should be `descending`. - - log_scale: Whether visualize distribution in log scale. - See more in - - """ - - input_column: str - prefix: str = "CLS_" - thresholds: List[float] - inplace: bool = False - allow_nan: bool = True - label_order: Literal["ascending", "descending"] = "ascending" - log_scale: bool = False + by`X < 0.5`. In this case, `label_order` should be `descending`.""", + ) + log_scale: bool = Field( + default=False, + description="""Whether visualize distribution in log scale. + See more in """, + ) def transform( self, diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py index 9b0efd7..755ec8d 100644 --- a/auroris/curation/actions/_distribution.py +++ b/auroris/curation/actions/_distribution.py @@ -1,5 +1,5 @@ from typing import Dict, List, Optional, Sequence - +from pydantic import Field import pandas as pd from auroris.curation.actions._base import BaseAction @@ -10,18 +10,16 @@ class ContinuousDistributionVisualization(BaseAction): """ - Visualize a continuous distribution - - Args: - y_cols: List of columns for bioactivity for visualization - log_scale: Whether visualize distribution in log scale. - bins: The bin boundaries to color the area under the KDE curve. - + Visualize a continuous distribution. """ - y_cols: Optional[List[str]] = None - log_scale: bool = False - bins: Optional[Sequence[float]] = None + y_cols: Optional[List[str]] = Field( + default=None, description="List of columns for bioactivity for visualization." + ) + log_scale: bool = Field(default=False, description="Whether visualize distribution in log scale.") + bins: Optional[Sequence[float]] = Field( + default=None, description="The bin boundaries to color the area under the KDE curve." + ) def transform( self, diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index d2d7684..bfdc410 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -1,5 +1,6 @@ from functools import partial from typing import Dict, List, Optional, Tuple, Union +from pydantic import Field import datamol as dm import numpy as np @@ -25,23 +26,21 @@ def curate_molecules( count_stereoisomers: bool = True, count_stereocenters: bool = True, **parallelized_kwargs, -): +) -> Tuple: """ Curate a list of molecules. Args: - mols: List of molecules - progress: Whether show curation progress - remove_salt_solvent: Whether remove salt and solvent from molecule - remove_stereo: Whether remove stereo chemistry information from molecule - count_stereoisomers: Whether count the number of stereoisomers of molecule - count_stereocenters: Whether count the number of stereocenters of molecule - parallelized_kwargs: Additional argument for the parallelizarion process. - See more about + mols: List of molecules. + progress: Whether show curation progress. + remove_salt_solvent: Whether remove salt and solvent from molecule. + remove_stereo: Whether remove stereo chemistry information from molecule. + count_stereoisomers: Whether count the number of stereoisomers of molecule. + count_stereocenters: Whether count the number of stereocenters of molecule. Returns: mol_dict: Dictionary of molecule and additional metadata - num_invalid: Number of invalid molecules + num_invalid: Number of invßßalid molecules """ fn = partial( @@ -237,25 +236,31 @@ def _num_stereo_centers(mol: dm.Mol) -> Tuple[int]: class MoleculeCuration(BaseAction): """ - Automated molecule curation and chemistry space distribution - - Args: - input_column: The name of the column that has the molecules (either `dm.Mol` objects or SMILES). - remove_salt_solvent: When set to 'True', all disconnected salts and solvents - will be removed from molecule. In most of the cases, it is recommended to remove the salts/solvents. - remove_stereo: Whether remove stereochemistry information from molecule. - If it's known that the stereochemistry do not contribute to the bioactivity of interest, - the stereochemistry information can be removed. + Automated molecule curation and chemistry space distribution. """ - input_column: str - prefix: str = "MOL_" - remove_salt_solvent: bool = True - remove_stereo: bool = False - count_stereoisomers: bool = True - count_stereocenters: bool = True - y_cols: Optional[List[str]] = None - fast: Optional[bool] = True + input_column: str = Field( + ..., description="The name of the column that has the molecules (either `dm.Mol` objects or SMILES)." + ) + prefix: str = Field(default="MOL_", description="Prefix for added column names") + remove_salt_solvent: bool = Field( + default=True, description="When set to 'True', all disconnected salts and solvents" + ) + remove_stereo: bool = Field( + default=False, + description="Whether remove stereochemistry information from molecule. If it's known that the stereochemistry do not contribute to the bioactivity of interest, the stereochemistry information can be removed.", + ) + count_stereoisomers: bool = Field( + default=True, description="Whether count the number of stereoisomers of molecule." + ) + count_stereocenters: bool = Field( + default=True, description="Whether count the number of stereocenter of molecule." + ) + y_cols: Optional[List[str]] = Field(default=None, description="Column names for bioactivities") + fast: Optional[bool] = Field( + default=True, + description="Whether compute molecule features with default ECFP for visualizing distribution in chemical space.", + ) def transform( self, diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index 0a008aa..4cbd572 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -133,18 +133,12 @@ def modified_zscore(data: np.ndarray, consistency_correction: float = 1.4826): class OutlierDetection(BaseAction): """ - Automatic detection of outliers - - Args: - method: Method name for outlier detection. - columns: Column names to detect outliers - prefix: Prefix for added column names - + Automatic detection of outliers. """ - method: OutlierDetectionMethod - columns: List[str] - prefix: str = "OUTLIER_" + method: OutlierDetectionMethod = Field(..., description="Method name for outlier detection.") + columns: List[str] = Field(..., description="Column names to detect outliers.") + prefix: str = Field(default="OUTLIER_", description="Prefix for added column names.") kwargs: Dict = Field(default_factory=dict) def transform( diff --git a/docs/index.md b/docs/index.md index e80fbeb..290df24 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,4 +1,37 @@ # Introduction -Welcome to the Auroris documentation! +Welcome to the Auroris - Simplifying Drug Discovery Data Curation +--- + +## What is Auroris? + +Auroris is a comprehensive Python library designed to assist researchers, scientists in managing, cleaning, and preparing data relevant to drug discovery. The library offers a range of features and techniques to handle diverse data types commonly encountered in drug discovery, including chemical structures, biological assays, and potentially to be extended to cell imaging data, genomic data, and clinical trial information. + + +## Where to next? +--- + +**:fontawesome-solid-rocket: Quickstart** + +Dive deeper into the Auroris code and learn about how to curate data for your ML-powered drug discovery program. + +[:material-arrow-right: Let's get started](./tutorials/getting_started.ipynb) + +--- + +**:fontawesome-solid-code: API Reference** + +Explore the technical documentation here to delve into the inner workings of the code. Gain insights into the intricate details of how different methods and classes function. + +[:material-arrow-right: Let's get started](./api/curator.md) + +--- + +**:fontawesome-solid-comments: Community** + +We're excited to have you join us in revolutionizing drug discovery data curation! Explore Polaris, provide feedback, share your use cases, and collaborate with us to enhance and expand the capabilities of Polaris for the benefit of the drug discovery community. + +[:material-arrow-right: Let's get started](https://discord.gg/vBFd8p6H7u) + +--- \ No newline at end of file diff --git a/docs/tutorials/getting_started.ipynb b/docs/tutorials/getting_started.ipynb index 4a03831..d3f1e09 100644 --- a/docs/tutorials/getting_started.ipynb +++ b/docs/tutorials/getting_started.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "id": "976c5af4-2819-4cd6-8a57-072441eb9305", "metadata": { "editable": true, @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "id": "a8f88963-f561-4cdc-8bfb-0a3045743e98", "metadata": { "editable": true, @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "id": "5483a1fd-b22e-43e5-92f4-e6e8f4f3e629", "metadata": { "editable": true, @@ -142,7 +142,7 @@ " \n", " \n", " 0\n", - " <rdkit.Chem.rdchem.Mol object at 0x1570f9d90>\n", + " <rdkit.Chem.rdchem.Mol object at 0x288ce21f0>\n", " 1\n", " n-pentane\n", " -3.18\n", @@ -152,7 +152,7 @@ " \n", " \n", " 1\n", - " <rdkit.Chem.rdchem.Mol object at 0x1570f9ee0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x288ce11c0>\n", " 2\n", " cyclopentane\n", " -2.64\n", @@ -162,7 +162,7 @@ " \n", " \n", " 2\n", - " <rdkit.Chem.rdchem.Mol object at 0x1570f9f50>\n", + " <rdkit.Chem.rdchem.Mol object at 0x288ce2c00>\n", " 3\n", " n-hexane\n", " -3.84\n", @@ -172,7 +172,7 @@ " \n", " \n", " 3\n", - " <rdkit.Chem.rdchem.Mol object at 0x1570f9fc0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x288ce2340>\n", " 4\n", " 2-methylpentane\n", " -3.74\n", @@ -182,7 +182,7 @@ " \n", " \n", " 4\n", - " <rdkit.Chem.rdchem.Mol object at 0x1570fa030>\n", + " <rdkit.Chem.rdchem.Mol object at 0x288ce1ee0>\n", " 6\n", " 2,2-dimethylbutane\n", " -3.55\n", @@ -196,11 +196,11 @@ ], "text/plain": [ " mol ID NAME \\\n", - "0 1 n-pentane \n", - "1 2 cyclopentane \n", - "2 3 n-hexane \n", - "3 4 2-methylpentane \n", - "4 6 2,2-dimethylbutane \n", + "0 1 n-pentane \n", + "1 2 cyclopentane \n", + "2 3 n-hexane \n", + "3 4 2-methylpentane \n", + "4 6 2,2-dimethylbutane \n", "\n", " SOL SOL_classification smiles split \n", "0 -3.18 (A) low CCCCC train \n", @@ -210,7 +210,7 @@ "4 -3.55 (A) low CCC(C)(C)C train " ] }, - "execution_count": 4, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -242,10 +242,20 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "id": "f9dbba41-2bd2-4321-b948-13877cee5b13", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-05-16 17:56:13.689\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: MoleculeCuration\u001b[0m\n", + "\u001b[32m2024-05-16 17:56:17.051\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: OutlierDetection\u001b[0m\n", + "\u001b[32m2024-05-16 17:56:17.079\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: Discretization\u001b[0m\n" + ] + } + ], "source": [ "from auroris.curation import Curator\n", "from auroris.curation.actions import MoleculeCuration, OutlierDetection, Discretization\n", @@ -274,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "id": "98aaadd9-8c0f-412e-ab74-79b8f9a3d75a", "metadata": {}, "outputs": [ @@ -283,27 +293,32 @@ "output_type": "stream", "text": [ "\u001b[31;1m===== Curation Report =====\u001b[0m\n", - "\u001b[38;20mTime: 2024-05-02 13:20:55\u001b[0m\n", - "\u001b[38;20mVersion: dev\u001b[0m\n", + "\u001b[34;1mTime: 2024-05-16 17:56:13\u001b[0m\n", + "\u001b[34;1mVersion: dev\u001b[0m\n", "\u001b[34;1m===== MoleculeCuration =====\u001b[0m\n", - "\u001b[38;20m[LOG]: Couldn't preprocess 18 / 1282 molecules.\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_smiles\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_molhash_id\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_molhash_id_no_stereo\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_num_stereoisomers\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_num_undefined_stereoisomers\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_num_defined_stereo_center\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_num_undefined_stereo_center\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_num_stereo_center\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_undefined_E_D\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: MOL_undefined_E/Z\u001b[0m\n", - "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", - "\u001b[38;20m[IMG]: Dimensions None x None\u001b[0m\n", + "\u001b[34;1m[LOG]: Couldn't preprocess 18 / 1282 molecules.\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_smiles\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_molhash_id\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_molhash_id_no_stereo\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_num_stereoisomers\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_num_undefined_stereoisomers\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_num_defined_stereo_center\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_num_undefined_stereo_center\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_num_stereo_center\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_undefined_E_D\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: MOL_undefined_E/Z\u001b[0m\n", + "\u001b[34;1m[LOG]: Default `ecfp` fingerprint is used to compute the distributionin chemical space.\u001b[0m\n", + "\u001b[34;1m[LOG]: Molecules with undefined stereocenter detected: 253.\u001b[0m\n", + "\u001b[34;1m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[34;1m[IMG]: Dimensions 1200 x 2400\u001b[0m\n", "\u001b[34;1m===== OutlierDetection =====\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: OUTLIER_SOL\u001b[0m\n", - "\u001b[38;20m[IMG]: Dimensions 2400 x 600\u001b[0m\n", + "\u001b[34;1m[LOG]: New column added: OUTLIER_SOL\u001b[0m\n", + "\u001b[34;1m[LOG]: Found 7 potential outliers with respect to the SOL column for review.\u001b[0m\n", + "\u001b[34;1m[IMG]: Dimensions 640 x 480\u001b[0m\n", "\u001b[34;1m===== Discretization =====\u001b[0m\n", - "\u001b[38;20m[LOG]: New column added: CLS_SOL\u001b[0m\n" + "\u001b[34;1m[LOG]: New column added: CLS_SOL\u001b[0m\n", + "\u001b[34;1m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[31;1m===== Curation Report END =====\u001b[0m\n" ] } ], @@ -324,14 +339,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "9b896b12-fbae-4b7b-b62a-f2d2d15075c1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/lu.zhu/Documents/Codebase/ValenceLab/auroris/docs/tutorials/test/index.html'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from auroris.report.broadcaster import HTMLBroadcaster\n", "\n", - "broadcaster = HTMLBroadcaster(report, \"/path/to/broadcaster\")\n", + "broadcaster = HTMLBroadcaster(report= report, \n", + " destination=\"/Users/lu.zhu/Documents/Codebase/ValenceLab/auroris/docs/tutorials/test\", \n", + " embed_images=True)\n", "broadcaster.broadcast()" ] }, @@ -345,14 +373,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "id": "97be9d29-03eb-4eb7-b9c0-ac84413f6dca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "mol \n", + "mol \n", "ID 1\n", "NAME n-pentane\n", "SOL -3.18\n", @@ -369,12 +397,12 @@ "MOL_num_stereo_center 0.0\n", "MOL_undefined_E_D False\n", "MOL_undefined_E/Z 0\n", - "OUTLIER_SOL 0.0\n", + "OUTLIER_SOL False\n", "CLS_SOL 0.0\n", "Name: 0, dtype: object" ] }, - "execution_count": 8, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -400,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "id": "f5044a09-c34f-4888-a5ac-65fb62225129", "metadata": { "editable": true, @@ -412,9 +440,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -443,6 +471,12 @@ "id": "e5b79da1", "metadata": {}, "source": [] + }, + { + "cell_type": "markdown", + "id": "b020ee56", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/mkdocs.yml b/mkdocs.yml index ee47e12..247c546 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -27,7 +27,6 @@ nav: - Stereoisomer AC: api/actions/stereo_ac.md - Functional: api/functional.md - Visualization: api/visualization.md - - Types: api/types.md - Community: https://discord.gg/vBFd8p6H7u - Polaris Hub: https://polarishub.io/ @@ -99,6 +98,8 @@ plugins: separate_signature: true show_signature_annotations: true line_length: 80 + extensions: + - griffe_fieldz: {include_inherited: true} # support pydantic data-class - mkdocs-jupyter: execute: False remove_tag_config: From 021c11e7d3a11bd2efcb70585d224f1e7bb049a8 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 22:52:30 -0400 Subject: [PATCH 14/39] update css --- auroris/curation/_curator.py | 5 ++++- .../css/{custom-alchemy.css => custom-auroris.css} | 14 +++++++------- mkdocs.yml | 1 + 3 files changed, 12 insertions(+), 8 deletions(-) rename docs/assets/css/{custom-alchemy.css => custom-auroris.css} (58%) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index de571d2..f4407d2 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -112,7 +112,10 @@ def to_json(self, path: str): path: The destination to save to """ serialization = self.model_dump(exclude="steps") - # # save steps in defined order + # remove data_path + if self.data_path is None: + serialization.pop("data_path") + # save steps in defined order serialization["steps"] = [{step.name: step.model_dump()} for step in self.steps] with fsspec.open(path, "w") as f: json.dump(serialization, f) diff --git a/docs/assets/css/custom-alchemy.css b/docs/assets/css/custom-auroris.css similarity index 58% rename from docs/assets/css/custom-alchemy.css rename to docs/assets/css/custom-auroris.css index bbac249..6fbf63d 100644 --- a/docs/assets/css/custom-alchemy.css +++ b/docs/assets/css/custom-auroris.css @@ -4,25 +4,25 @@ For a list of all available variables, see https://github.com/squidfunk/mkdocs-material/blob/master/src/assets/stylesheets/main/_colors.scss */ - --polaris-primary: hsla(236, 100%, 19%, 1.0); - --polaris-secondary: hsla(290, 61%, 43%, 1.0); - --polaris-ternary: hsla(236, 100%, 9%, 1.0); + --auroris-primary: rgb(36, 82, 97); + --auroris-secondary: rgb(70, 201, 190); + --auroris-ternary: rgb(0, 61, 94); } /* Change the header background to use a gradient */ .md-header { - background-image: linear-gradient(to right, var(--polaris-secondary), var(--polaris-primary)); + background-image: linear-gradient(to right, var(--auroris-secondary), var(--auroris-primary)); } /* Change the footer background to use a gradient */ .md-footer { - background-image: linear-gradient(to right, var(--polaris-primary), var(--polaris-ternary)); + background-image: linear-gradient(to right, var(--auroris-primary), var(--auroris-ternary)); } /* Change the tabs background to use a gradient */ .md-tabs { - background-image: linear-gradient(to right, #F4F6F9, #dfc3e2); - color: var(--polaris-ternary); + background-image: linear-gradient(to right, #F4F6F9, #d7f2c3); + color: var(--auroris-ternary); } /* Remove the `In` and `Out` block in rendered Jupyter notebooks */ diff --git a/mkdocs.yml b/mkdocs.yml index 247c546..52aec8a 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -27,6 +27,7 @@ nav: - Stereoisomer AC: api/actions/stereo_ac.md - Functional: api/functional.md - Visualization: api/visualization.md + - Types: api/types.md - Community: https://discord.gg/vBFd8p6H7u - Polaris Hub: https://polarishub.io/ From d73f6850a25c5c961ba118b5e3e7be308ea2dd63 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 23:09:37 -0400 Subject: [PATCH 15/39] minor change --- auroris/report/broadcaster/_html.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 6e5c7f9..3ead388 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -68,11 +68,11 @@ def broadcast(self): src = f"data:image/png;base64,{image_data}" else: # Save as separate file - filename = ( - f"{re.sub(r'[^\w\-\.]', '_', image.title)}.png" - if image.title is not None - else f"{image_counter}.png" - ) + if image.title: + filename = f"{re.sub(r'[^\w\-\.]', '_', image.title)}.png" + else: + filename = f"{image_counter}.png" + path = dm.fs.join(self._image_dir, filename) save_image(image.image, path, self._destination) src = path2url(path, self._destination) From 085da1cd6a2ddb10eb27c7fe01a33de2cffaf89f Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 23:19:55 -0400 Subject: [PATCH 16/39] minor fix --- auroris/curation/_curator.py | 2 -- auroris/report/broadcaster/_html.py | 8 ++------ 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index f4407d2..dc1449b 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -119,6 +119,4 @@ def to_json(self, path: str): serialization["steps"] = [{step.name: step.model_dump()} for step in self.steps] with fsspec.open(path, "w") as f: json.dump(serialization, f) - # with fsspec.open(path, "w") as f: - # json.dump(self.model_dump(), f) return path diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 3ead388..4897be0 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -68,12 +68,8 @@ def broadcast(self): src = f"data:image/png;base64,{image_data}" else: # Save as separate file - if image.title: - filename = f"{re.sub(r'[^\w\-\.]', '_', image.title)}.png" - else: - filename = f"{image_counter}.png" - - path = dm.fs.join(self._image_dir, filename) + filename = re.sub(r"[^\w\-\.]", "_", image.title) if image.title else image_counter + path = dm.fs.join(self._image_dir, f"{filename}.png") save_image(image.image, path, self._destination) src = path2url(path, self._destination) From 8454d5ef7f9a9d84ae8f61302dc48523c26f4ff7 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 16 May 2024 23:27:07 -0400 Subject: [PATCH 17/39] add dep --- env.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/env.yml b/env.yml index 52c9fd7..e2c8206 100644 --- a/env.yml +++ b/env.yml @@ -45,3 +45,7 @@ dependencies: - mdx_truly_sane_lists - nbconvert - mike >=1.0.0 + + - pip + - pip: + - griffe_fieldz \ No newline at end of file From 9e75e011c49de7e80af5fbd2298cad0387770c8f Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 10:02:58 -0400 Subject: [PATCH 18/39] Update auroris/curation/_curator.py Co-authored-by: Cas Wognum --- auroris/curation/_curator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index dc1449b..dab661e 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -53,8 +53,8 @@ def _validate_data_path(cls, value: Union[str, PathLike]): return value except Exception: raise ValueError( - f"Dataset cann't be loaded by `panda.read_csv('{value}')`." - f"Consider to directly pass the loaded the data to `Curator.curate()`." + f"Dataset can't be loaded by `pandas.read_csv('{value}')`." + f"Consider passing the DataFrame directly to `Curator.curate(dataset=...)`." ) def _load_data(self): From 53ad1da7389fd882bd46f5d5494c0e274618f30f Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 10:09:59 -0400 Subject: [PATCH 19/39] Update auroris/curation/actions/_mol.py Co-authored-by: Cas Wognum --- auroris/curation/actions/_mol.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index bfdc410..750e821 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -14,7 +14,7 @@ try: from molfeat.trans.pretrained.hf_transformers import PretrainedHFTransformer -except Exception: +except ImportError: PretrainedHFTransformer = None From ecdf78596bcf16e526455a5e5a325348a3a0aaa2 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 10:10:44 -0400 Subject: [PATCH 20/39] Update docs/index.md Co-authored-by: Cas Wognum --- docs/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index 290df24..062fa4f 100644 --- a/docs/index.md +++ b/docs/index.md @@ -14,7 +14,7 @@ Auroris is a comprehensive Python library designed to assist researchers, scient **:fontawesome-solid-rocket: Quickstart** -Dive deeper into the Auroris code and learn about how to curate data for your ML-powered drug discovery program. +Dive deeper into the Auroris code and learn how to curate data for your ML-powered drug discovery program. [:material-arrow-right: Let's get started](./tutorials/getting_started.ipynb) From 33569ebb7428166133f0dc24bae25dfba289f819 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 10:18:27 -0400 Subject: [PATCH 21/39] Update auroris/visualization/_distribution.py Co-authored-by: Cas Wognum --- auroris/visualization/_distribution.py | 36 +++++++++++++------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py index 6ae6883..0ca674b 100644 --- a/auroris/visualization/_distribution.py +++ b/auroris/visualization/_distribution.py @@ -106,23 +106,23 @@ def visualize_distribution_with_outliers( values = values[sorted_ind] is_outlier = is_outlier[sorted_ind] - fig = plt.figure() - res = stats.probplot(values, dist="norm", plot=plt, fit=True) - x = res[0][0] - y = res[0][1] - - # Specify the indices of data points to highlight - highlight_indices = np.argwhere(is_outlier.__eq__(True)).flatten() - highlight_color = "red" - - # Overlay specific points with different colors - for idx in highlight_indices: - plt.plot( - x[idx], y[idx], marker="o", markersize=8, color=highlight_color - ) # Red circles for highlighted points - - plt.xlabel("Theoretical quantiles") - plt.ylabel("Ordered Values") - plt.title(title) + with create_figure(n_plots=1) as (fig, axes): + res = stats.probplot(values, dist="norm", plot=plt, fit=True, plot=axes[0]) + x = res[0][0] + y = res[0][1] + + # Specify the indices of data points to highlight + highlight_indices = np.argwhere(is_outlier.__eq__(True)).flatten() + highlight_color = "red" + + # Overlay specific points with different colors + for idx in highlight_indices: + ax.plot( + x[idx], y[idx], marker="o", markersize=8, color=highlight_color + ) # Red circles for highlighted points + + ax.xlabel("Theoretical quantiles") + ax.ylabel("Ordered Values") + ax.title(title) return fig From 83cf9492bdbf6497504f1c7fe1f4b28a500081be Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 10:50:50 -0400 Subject: [PATCH 22/39] Update docs/index.md Co-authored-by: Cas Wognum --- docs/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index 062fa4f..36ae5be 100644 --- a/docs/index.md +++ b/docs/index.md @@ -6,7 +6,7 @@ Welcome to the Auroris - Simplifying Drug Discovery Data Curation ## What is Auroris? -Auroris is a comprehensive Python library designed to assist researchers, scientists in managing, cleaning, and preparing data relevant to drug discovery. The library offers a range of features and techniques to handle diverse data types commonly encountered in drug discovery, including chemical structures, biological assays, and potentially to be extended to cell imaging data, genomic data, and clinical trial information. +Auroris is a comprehensive Python library designed to assist researchers and scientists in managing, cleaning, and preparing data relevant to drug discovery. Our mission is to implement a range of techniques to handle, transform, filter, analyze, or visualize the diverse data types commonly encountered in drug discovery. ## Where to next? From 26f0a6f529c085da4622bdc3fc9ada6e80550d95 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 13:20:22 -0400 Subject: [PATCH 23/39] update test_curator_save_load --- tests/test_curator.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/tests/test_curator.py b/tests/test_curator.py index 221b934..d9152df 100644 --- a/tests/test_curator.py +++ b/tests/test_curator.py @@ -13,17 +13,21 @@ def test_curator_save_load(tmpdir): curator = Curator( steps=[ - OutlierDetection(method="zscore", columns=["outlier_column"]), MoleculeCuration(input_column="smiles"), + OutlierDetection(method="zscore", columns=["outlier_column"]), ], ) path = os.path.join(tmpdir, "curator.json") + curator.to_json(path) - curator.from_json(path) + curator_reload = curator.from_json(path) + + assert len(curator.steps) == len(curator_reload.steps) + for step1, step2 in zip(curator.steps, curator_reload.steps): + assert step1 == step2 - assert len(curator.steps) == 2 - assert curator.steps[0].method == "zscore" - assert curator.steps[0].columns == ["outlier_column"] + assert curator.steps[1].method == "zscore" + assert curator.steps[1].columns == ["outlier_column"] def test_curator_integration(dataset, tmpdir): From 3a3b5e861590ced85bd1f7c39b1643944e510506 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 13:25:54 -0400 Subject: [PATCH 24/39] minor fix --- auroris/visualization/_distribution.py | 35 +++++++++++++------------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py index 0ca674b..39039d3 100644 --- a/auroris/visualization/_distribution.py +++ b/auroris/visualization/_distribution.py @@ -3,7 +3,6 @@ import numpy as np import seaborn as sns from scipy import stats -import matplotlib.pyplot as plt from auroris.visualization.utils import create_figure @@ -107,22 +106,22 @@ def visualize_distribution_with_outliers( is_outlier = is_outlier[sorted_ind] with create_figure(n_plots=1) as (fig, axes): - res = stats.probplot(values, dist="norm", plot=plt, fit=True, plot=axes[0]) - x = res[0][0] - y = res[0][1] - - # Specify the indices of data points to highlight - highlight_indices = np.argwhere(is_outlier.__eq__(True)).flatten() - highlight_color = "red" - - # Overlay specific points with different colors - for idx in highlight_indices: - ax.plot( - x[idx], y[idx], marker="o", markersize=8, color=highlight_color - ) # Red circles for highlighted points - - ax.xlabel("Theoretical quantiles") - ax.ylabel("Ordered Values") - ax.title(title) + res = stats.probplot(values, dist="norm", fit=True, plot=axes[0]) + x = res[0][0] + y = res[0][1] + + # Specify the indices of data points to highlight + highlight_indices = np.argwhere(is_outlier.__eq__(True)).flatten() + highlight_color = "red" + + # Overlay specific points with different colors + for idx in highlight_indices: + axes[0].plot( + x[idx], y[idx], marker="o", markersize=8, color=highlight_color + ) # Red circles for highlighted points + + axes[0].set_xlabel("Theoretical quantiles") + axes[0].set_ylabel("Ordered Values") + axes[0].set_title(title) return fig From 78c731db1c922e380b149f3a124dba9458c7f8a1 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Fri, 17 May 2024 15:46:34 -0400 Subject: [PATCH 25/39] Update auroris/report/broadcaster/_logger.py Co-authored-by: Cas Wognum --- auroris/report/broadcaster/_logger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/auroris/report/broadcaster/_logger.py b/auroris/report/broadcaster/_logger.py index 317f740..26aa89d 100644 --- a/auroris/report/broadcaster/_logger.py +++ b/auroris/report/broadcaster/_logger.py @@ -33,7 +33,7 @@ class LoggerBroadcaster(ReportBroadcaster): def __init__(self, report: CurationReport): super().__init__(report) - self.logger = logging.getLogger() + self.logger = logging.getLogger(self.__class__.__name__) # Lu: debug level might log other irrelevant debugging logs self.logger.setLevel(logging.INFO) From ed0c7f6f7906853f146d24f97b66c38579030984 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 00:38:10 -0400 Subject: [PATCH 26/39] curator save/load --- auroris/curation/_curator.py | 25 +++++++++++-------------- auroris/curation/actions/_base.py | 3 ++- tests/test_curator.py | 4 ++-- 3 files changed, 15 insertions(+), 17 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index dab661e..0d94beb 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -23,7 +23,7 @@ class Curator(BaseModel): # This is the recommended way to add all subclasses in the type. # See e.g. https://github.com/pydantic/pydantic/issues/2200 # and https://github.com/pydantic/pydantic/issues/2036 - data_path: Optional[Union[str, PathLike]] = Field( + src_dataset_path: Optional[Union[str, PathLike]] = Field( default=None, description="Data path. The data must be loadable by `pd.read_csv` with default parameters.", ) @@ -46,8 +46,8 @@ def _validate_verbosity(cls, v): def _serialize_verbosity(self, value: VerbosityLevel): return value.name - @field_validator("data_path", mode="before") - def _validate_data_path(cls, value: Union[str, PathLike]): + @field_validator("src_dataset_path", mode="before") + def _validate_src_dataset_path(cls, value: Union[str, PathLike]): try: pd.read_csv(value, nrows=5) return value @@ -58,14 +58,14 @@ def _validate_data_path(cls, value: Union[str, PathLike]): ) def _load_data(self): - return pd.read_csv(self.data_path) + return pd.read_csv(self.src_dataset_path) def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFrame, CurationReport]: if dataset is None: dataset = self._load_data() report = CurationReport() - dataset = dataset.copy() + dataset = dataset.copy(deep=True) action: BaseAction for action in self.steps: @@ -101,22 +101,19 @@ def from_json(cls, path: str): with fsspec.open(path, "r") as f: data = json.load(f) - steps = [cls._get_action(name)(**args) for step in data["steps"] for name, args in step.items()] - data["steps"] = steps + data["steps"] = [cls._get_action(step["name"]).model_validate(step) for step in data["steps"]] return cls.model_validate(data) def to_json(self, path: str): """Saves the curation workflow to a JSON file. Args: - path: The destination to save to + path: The destination to save to. """ - serialization = self.model_dump(exclude="steps") - # remove data_path - if self.data_path is None: - serialization.pop("data_path") - # save steps in defined order - serialization["steps"] = [{step.name: step.model_dump()} for step in self.steps] + serialization = self.model_dump() + # remove src_dataset_path if unavailable + if self.src_dataset_path is None: + serialization.pop("src_dataset_path") with fsspec.open(path, "w") as f: json.dump(serialization, f) return path diff --git a/auroris/curation/actions/_base.py b/auroris/curation/actions/_base.py index 8df6ca9..9cbc908 100644 --- a/auroris/curation/actions/_base.py +++ b/auroris/curation/actions/_base.py @@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Dict, Optional import pandas as pd -from pydantic import BaseModel, model_validator, Field +from pydantic import BaseModel, model_validator, Field, computed_field from auroris.types import VerbosityLevel @@ -20,6 +20,7 @@ class BaseAction(BaseModel, abc.ABC): prefix: str = Field(default=None, description="If the action adds columns, use this prefix.") + @computed_field @property def name(self) -> str: """The name of the action. Needs to be unique.""" diff --git a/tests/test_curator.py b/tests/test_curator.py index d9152df..5a8b0c1 100644 --- a/tests/test_curator.py +++ b/tests/test_curator.py @@ -17,8 +17,8 @@ def test_curator_save_load(tmpdir): OutlierDetection(method="zscore", columns=["outlier_column"]), ], ) - path = os.path.join(tmpdir, "curator.json") - + path = os.path.join(tmpdir, "curator_lu.json") + print(path) curator.to_json(path) curator_reload = curator.from_json(path) From 499eb2604e432df7460378fceab6a656166fe76a Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 00:39:40 -0400 Subject: [PATCH 27/39] avoid ipython image --- auroris/curation/actions/_mol.py | 24 ++++++++++-------------- auroris/utils.py | 14 ++++++++------ 2 files changed, 18 insertions(+), 20 deletions(-) diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index 750e821..790c7e2 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -297,19 +297,12 @@ def transform( smiles_col = self.get_column_name("smiles") smiles = dataset[smiles_col].dropna().values - if PretrainedHFTransformer and not self.fast: - featurizer = "ChemBERTa-77M-MTR" - transformer = PretrainedHFTransformer(kind=featurizer, notation="smiles", dtype=float) - X = transformer(smiles) - report.log( - "`ChemBERTa-77M-MTR` embedding is used to compute the distributionin chemical space." - ) - else: - featurizer = "ECFP" - with dm.without_rdkit_log(): - # Temporary disable logs because of deprecation warning - X = np.array([dm.to_fp(smi) for smi in smiles]) - report.log("Default `ecfp` fingerprint is used to compute the distributionin chemical space.") + # Lu: User can call visulize_chemspace for the customized molecular features. + featurizer = "ECFP" + with dm.without_rdkit_log(): + # Temporary disable logs because of deprecation warning + X = np.array([dm.to_fp(smi) for smi in smiles]) + report.log("Default `ecfp` fingerprint is used to compute the distributionin chemical space.") # list of data per column y = dataset[self.y_cols].T.values.tolist() if self.y_cols else None @@ -334,7 +327,10 @@ def transform( defined = row[defined_col] legends.append(f"Undefined:{undefined}\n Definded:{defined}") - image = dm.to_image(to_plot[smiles_col].tolist(), legends=legends, use_svg=False) + # returnPNG to avoid ipythonImage + image = dm.to_image( + to_plot[smiles_col].tolist(), legends=legends, use_svg=False, returnPNG=True + ) report.log_image( image, title="Molecules with undefined stereocenters", diff --git a/auroris/utils.py b/auroris/utils.py index 41d28fb..a2e705b 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -1,11 +1,11 @@ import os from io import BytesIO +from typing import ByteString import numpy as np from matplotlib.figure import Figure from PIL import Image from PIL.Image import Image as ImageType -from IPython.core.display import Image as IpythonImage import fsspec from sklearn.utils.multiclass import type_of_target @@ -34,11 +34,6 @@ def fig2img(fig: Figure) -> ImageType: ) -def ipyimg2img(fig: IpythonImage) -> ImageType: - """Convert Ipython image to PIL image""" - return Image.open(BytesIO(fig.data)) - - def img2bytes(image: ImageType): """Convert png image to bytes""" image_bytes = BytesIO() @@ -47,6 +42,13 @@ def img2bytes(image: ImageType): return image_bytes +def bytes2imf(image_bytes: ByteString): + image_stream = BytesIO(image_bytes) + # Open the image using PIL + image = Image.open(image_stream) + return image + + def path2url(path: str, destination: str): """ Convert path to an local or remote url for html report. From d90123831c443c7d571e99fcfcd3e0106dc47609 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 00:40:18 -0400 Subject: [PATCH 28/39] minor viz fix --- auroris/visualization/_chemspace.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/auroris/visualization/_chemspace.py b/auroris/visualization/_chemspace.py index e662a22..35dba00 100644 --- a/auroris/visualization/_chemspace.py +++ b/auroris/visualization/_chemspace.py @@ -12,7 +12,7 @@ def visualize_chemspace( - X: Union[List[np.ndarray], np.ndarray], + X: np.ndarray, y: Optional[Union[List[np.ndarray], np.ndarray]] = None, labels: Optional[List[str]] = None, n_cols: int = 2, @@ -22,10 +22,10 @@ def visualize_chemspace( seaborn_theme: Optional[str] = "whitegrid", **umap_kwargs: Any, ): - """Plot the chemical space. Also, color based on the target values. + """Plot the coverage in chemical space. Also, color based on the target values. Args: - X: A list of arrays with the features. + X: Array the molecular features. y: A list of arrays with the target values. labels: Optional list of labels for each set of features. n_cols: Number of columns in the subplots. @@ -40,7 +40,7 @@ def visualize_chemspace( raise ImportError("Please run `pip install umap-learn` to use UMAP visualizations for the chemspace.") if isinstance(y, np.ndarray): - y = list(y) + y = [y] if y is None: y = [None] @@ -72,5 +72,4 @@ def visualize_chemspace( ax.set_xlabel("Component 0") ax.set_xlabel("Component 1") ax.set_title(label) - return fig From 97c9bd3038fbe727547138ff5d322e92c839635c Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 00:43:44 -0400 Subject: [PATCH 29/39] wip --- auroris/report/_report.py | 11 +++++------ auroris/utils.py | 3 ++- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/auroris/report/_report.py b/auroris/report/_report.py index ef8d685..4024982 100644 --- a/auroris/report/_report.py +++ b/auroris/report/_report.py @@ -5,11 +5,10 @@ from matplotlib import pyplot as plt from matplotlib.figure import Figure from PIL.Image import Image as ImageType -from IPython.core.display import Image as IpythonImage from pydantic import BaseModel, ConfigDict, Field, PrivateAttr from auroris import __version__ -from auroris.utils import fig2img, ipyimg2img +from auroris.utils import fig2img, bytes2img class AnnotatedImage(BaseModel): @@ -72,17 +71,17 @@ def log_new_column(self, name: str): def log_image( self, - image_or_figure: Union[ImageType, Figure, ByteString, IpythonImage], + image_or_figure: Union[ImageType, Figure, ByteString], title: Optional[str] = None, description: Optional[str] = None, ): """Logs an image. Also accepts Matplotlib figures, which will be converted to images.""" self._check_active_section() - if isinstance(image_or_figure, IpythonImage): - image = ipyimg2img(image_or_figure) - elif isinstance(image_or_figure, Figure): + if isinstance(image_or_figure, Figure): image = fig2img(image_or_figure) plt.close(image_or_figure) + elif isinstance(image_or_figure, ByteString): + image = bytes2img(image_or_figure) else: image = image_or_figure diff --git a/auroris/utils.py b/auroris/utils.py index a2e705b..ba4bfdc 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -42,7 +42,8 @@ def img2bytes(image: ImageType): return image_bytes -def bytes2imf(image_bytes: ByteString): +def bytes2img(image_bytes: ByteString): + """Convert bytes to PIL image""" image_stream = BytesIO(image_bytes) # Open the image using PIL image = Image.open(image_stream) From ed7a16e23cb6f255b2864700d5b578be88b317ea Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 00:44:13 -0400 Subject: [PATCH 30/39] refactor image name --- auroris/report/broadcaster/_html.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 4897be0..1a78e45 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -68,7 +68,9 @@ def broadcast(self): src = f"data:image/png;base64,{image_data}" else: # Save as separate file - filename = re.sub(r"[^\w\-\.]", "_", image.title) if image.title else image_counter + # add image title to the file name. (Replace space, slash, dot by hyphen) + filename = re.sub(r"[ ./]", "_", image.title) if image.title else "" + filename = "-".join([str(image_counter), filename]) path = dm.fs.join(self._image_dir, f"{filename}.png") save_image(image.image, path, self._destination) src = path2url(path, self._destination) From e0699c530d0fe1a252301a2b7efd7dc3cca2c735 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 11:23:11 -0400 Subject: [PATCH 31/39] Update docs/index.md Co-authored-by: Cas Wognum --- docs/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index 36ae5be..8b80e7b 100644 --- a/docs/index.md +++ b/docs/index.md @@ -30,7 +30,7 @@ Explore the technical documentation here to delve into the inner workings of the **:fontawesome-solid-comments: Community** -We're excited to have you join us in revolutionizing drug discovery data curation! Explore Polaris, provide feedback, share your use cases, and collaborate with us to enhance and expand the capabilities of Polaris for the benefit of the drug discovery community. +We're excited to have you join us in revolutionizing drug discovery data curation! Explore Auroris and the broader Polaris ecosystem it is part of, provide feedback, share your use cases, and collaborate with us to enhance and expand the capabilities of Auroris for the benefit of the drug discovery community. [:material-arrow-right: Let's get started](https://discord.gg/vBFd8p6H7u) From b41793535441c7b1de8e7af9aedae4f3503615ba Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 13:54:15 -0400 Subject: [PATCH 32/39] Update auroris/utils.py Co-authored-by: Cas Wognum --- auroris/utils.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/auroris/utils.py b/auroris/utils.py index ba4bfdc..04ddd37 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -50,18 +50,18 @@ def bytes2img(image_bytes: ByteString): return image -def path2url(path: str, destination: str): +def _img_to_html_src(self, path: str): """ - Convert path to an local or remote url for html report. - Currently, only GCP is supported. + Convert a path to a corresponding `src` attribute for an `` tag. + Currently only supports GCP and local paths. """ - if not os.path.isfile(path): - if path.startswith("gs://"): - return path.replace("gs://", "https://storage.googleapis.com/") - else: - raise ValueError("Only GCP path is supported.") - else: - return os.path.relpath(path, destination) + protocol = dm.utils.fs.get_protocol(path) + if protocol == "gs": + return path.replace("gs://", "https://storage.googleapis.com/") + elif protocol == "file": + return os.path.relpath(path, self._destination) + else: + raise ValueError("We only support images hosted in GCP or locally") def save_image(image: ImageType, path: str, destination: str): From c50af5b88f5ab282c2a48a63e76e77c6c3ced685 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 13:59:54 -0400 Subject: [PATCH 33/39] fix attribute discriminator --- auroris/curation/_curator.py | 29 +++++++++----------- auroris/curation/actions/_ac_stereoisomer.py | 3 +- auroris/curation/actions/_base.py | 8 +----- auroris/curation/actions/_deduplicate.py | 1 + auroris/curation/actions/_discretize.py | 1 + auroris/curation/actions/_distribution.py | 3 +- auroris/curation/actions/_mol.py | 21 +++++++------- auroris/curation/actions/_outlier.py | 1 + 8 files changed, 32 insertions(+), 35 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 0d94beb..6ce27dc 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -1,5 +1,5 @@ import json -from typing import List, Tuple, Union, Optional +from typing import List, Tuple, Union, Optional, Annotated from os import PathLike import fsspec @@ -7,7 +7,7 @@ from loguru import logger from pydantic import BaseModel, Field, field_serializer, field_validator -from auroris.curation.actions._base import ACTION_REGISTRY, BaseAction +from auroris.curation.actions import BaseAction from auroris.report import CurationReport from auroris.types import VerbosityLevel @@ -28,11 +28,16 @@ class Curator(BaseModel): description="Data path. The data must be loadable by `pd.read_csv` with default parameters.", ) - steps: List[Union[tuple(ACTION_REGISTRY)]] = Field( - ..., - discriminator="name", - description="List of curation actions. Check all the available action .", - ) + steps: List[ + Annotated[ + Union[tuple(BaseAction.__subclasses__())], + Field( + ..., + discriminator="name", + description="List of curation actions. Check all the available action .", + ), + ] + ] verbosity: VerbosityLevel = VerbosityLevel.NORMAL parallelized_kwargs: dict = Field(default_factory=dict) @@ -84,13 +89,6 @@ def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFram def __call__(self, dataset): return self.transform(dataset) - @classmethod - def _get_action(cls, name: str): - for action in ACTION_REGISTRY: - if action.__name__ == name: - return action - return None - @classmethod def from_json(cls, path: str): """Loads a curation workflow from a JSON file. @@ -101,8 +99,7 @@ def from_json(cls, path: str): with fsspec.open(path, "r") as f: data = json.load(f) - data["steps"] = [cls._get_action(step["name"]).model_validate(step) for step in data["steps"]] - return cls.model_validate(data) + return cls(**data) def to_json(self, path: str): """Saves the curation workflow to a JSON file. diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index c1a4bb0..006d4b9 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -1,4 +1,4 @@ -from typing import Dict, List, Optional +from typing import Dict, List, Optional, Literal from pydantic import Field import datamol as dm @@ -76,6 +76,7 @@ class StereoIsomerACDetection(BaseAction): ) prefix: str = Field(default="AC_", description="Prefix for the adding columns.") mol_col: str = Field(default="MOL_smiles", description="Column for molecule strings.") + name: Literal["ac_stereoisomer"] = "ac_stereoisomer" def transform( self, diff --git a/auroris/curation/actions/_base.py b/auroris/curation/actions/_base.py index 9cbc908..f90fb37 100644 --- a/auroris/curation/actions/_base.py +++ b/auroris/curation/actions/_base.py @@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Dict, Optional import pandas as pd -from pydantic import BaseModel, model_validator, Field, computed_field +from pydantic import BaseModel, model_validator, Field from auroris.types import VerbosityLevel @@ -20,12 +20,6 @@ class BaseAction(BaseModel, abc.ABC): prefix: str = Field(default=None, description="If the action adds columns, use this prefix.") - @computed_field - @property - def name(self) -> str: - """The name of the action. Needs to be unique.""" - return self.__class__.__name__ - @model_validator(mode="after") @classmethod def _validate_model(cls, m: "BaseAction"): diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index bd18e50..fe7bcda 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -66,6 +66,7 @@ class Deduplication(BaseAction): method: Literal["mean", "median"] = Field( default="median", description="The method to aggregate the data." ) + name: Literal["deduplicate"] = "deduplicate" def transform( self, diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index 9af9083..548692d 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -111,6 +111,7 @@ class Discretization(BaseAction): description="""Whether visualize distribution in log scale. See more in """, ) + name: Literal["discretize"] = "discretize" def transform( self, diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py index 755ec8d..4422f73 100644 --- a/auroris/curation/actions/_distribution.py +++ b/auroris/curation/actions/_distribution.py @@ -1,4 +1,4 @@ -from typing import Dict, List, Optional, Sequence +from typing import Dict, List, Optional, Sequence, Literal from pydantic import Field import pandas as pd @@ -20,6 +20,7 @@ class ContinuousDistributionVisualization(BaseAction): bins: Optional[Sequence[float]] = Field( default=None, description="The bin boundaries to color the area under the KDE curve." ) + name: Literal["distribution"] = "distribution" def transform( self, diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index 790c7e2..1552f6a 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -1,5 +1,5 @@ from functools import partial -from typing import Dict, List, Optional, Tuple, Union +from typing import Dict, List, Literal, Optional, Tuple, Union from pydantic import Field import datamol as dm @@ -11,11 +11,7 @@ from auroris.report import CurationReport from auroris.types import VerbosityLevel from auroris.visualization import visualize_chemspace - -try: - from molfeat.trans.pretrained.hf_transformers import PretrainedHFTransformer -except ImportError: - PretrainedHFTransformer = None +from auroris.visualization.utils import create_figure def curate_molecules( @@ -261,6 +257,7 @@ class MoleculeCuration(BaseAction): default=True, description="Whether compute molecule features with default ECFP for visualizing distribution in chemical space.", ) + name: Literal["mol_curation"] = "mol_curation" def transform( self, @@ -327,10 +324,14 @@ def transform( defined = row[defined_col] legends.append(f"Undefined:{undefined}\n Definded:{defined}") - # returnPNG to avoid ipythonImage - image = dm.to_image( - to_plot[smiles_col].tolist(), legends=legends, use_svg=False, returnPNG=True - ) + with create_figure( + n_plots=1, + n_cols=1, + ) as (image, _): + dm.to_image( + to_plot[smiles_col].tolist(), legends=legends, use_svg=False, returnPNG=True + ) + report.log_image( image, title="Molecules with undefined stereocenters", diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index 4cbd572..398169d 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -140,6 +140,7 @@ class OutlierDetection(BaseAction): columns: List[str] = Field(..., description="Column names to detect outliers.") prefix: str = Field(default="OUTLIER_", description="Prefix for added column names.") kwargs: Dict = Field(default_factory=dict) + name: Literal["outlier_detection"] = "outlier_detection" def transform( self, From 4ee0270670090105547e1ed510e99deb3e3917a1 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 14:00:15 -0400 Subject: [PATCH 34/39] fix report --- auroris/report/_report.py | 6 ++++- auroris/report/broadcaster/_html.py | 6 ++--- auroris/report/broadcaster/_logger.py | 15 ++++++------ auroris/utils.py | 34 ++++++++++----------------- tests/test_curator.py | 3 +-- 5 files changed, 29 insertions(+), 35 deletions(-) diff --git a/auroris/report/_report.py b/auroris/report/_report.py index 4024982..526147c 100644 --- a/auroris/report/_report.py +++ b/auroris/report/_report.py @@ -71,7 +71,11 @@ def log_new_column(self, name: str): def log_image( self, - image_or_figure: Union[ImageType, Figure, ByteString], + image_or_figure: Union[ + ImageType, + Figure, + ByteString, + ], title: Optional[str] = None, description: Optional[str] = None, ): diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 1a78e45..99ad393 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -8,7 +8,7 @@ import fsspec from auroris.report import CurationReport -from auroris.utils import img2bytes, save_image, path2url +from auroris.utils import img2bytes, save_image, _img_to_html_src from ._base import ReportBroadcaster @@ -72,8 +72,8 @@ def broadcast(self): filename = re.sub(r"[ ./]", "_", image.title) if image.title else "" filename = "-".join([str(image_counter), filename]) path = dm.fs.join(self._image_dir, f"{filename}.png") - save_image(image.image, path, self._destination) - src = path2url(path, self._destination) + save_image(image.image, path) + src = _img_to_html_src(path, self._destination) image.image = src image_counter += 1 diff --git a/auroris/report/broadcaster/_logger.py b/auroris/report/broadcaster/_logger.py index 26aa89d..0cad0ee 100644 --- a/auroris/report/broadcaster/_logger.py +++ b/auroris/report/broadcaster/_logger.py @@ -17,7 +17,7 @@ class ColoredFormatter(logging.Formatter): FORMATS = { logging.DEBUG: grey + format + reset, - logging.INFO: blue + format + reset, + logging.INFO: grey + format + reset, logging.WARNING: yellow + format + reset, logging.ERROR: red + format + reset, logging.CRITICAL: bold_red + format + reset, @@ -34,8 +34,7 @@ class LoggerBroadcaster(ReportBroadcaster): def __init__(self, report: CurationReport): super().__init__(report) self.logger = logging.getLogger(self.__class__.__name__) - # Lu: debug level might log other irrelevant debugging logs - self.logger.setLevel(logging.INFO) + self.logger.setLevel(logging.DEBUG) handler = logging.StreamHandler(sys.stdout) handler.setFormatter(ColoredFormatter()) @@ -55,19 +54,19 @@ def broadcast(self): self.on_report_end(self._report) def render_log(self, message: str): - self.logger.info(f"[LOG]: {message}") + self.logger.debug(f"[LOG]: {message}") def render_image(self, image: AnnotatedImage): width, height = image.image.size - self.logger.info(f"[IMG]: Dimensions {width} x {height}") + self.logger.debug(f"[IMG]: Dimensions {width} x {height}") def on_section_start(self, section: Section): - self.logger.info(f"===== {section.title} =====") + self.logger.debug(f"===== {section.title} =====") def on_report_start(self, report: CurationReport): self.logger.critical("===== Curation Report =====") - self.logger.info(f"Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}") - self.logger.info(f"Version: {report.auroris_version}") + self.logger.debug(f"Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}") + self.logger.debug(f"Version: {report.auroris_version}") def on_report_end(self, report: CurationReport): self.logger.critical("===== Curation Report END =====") diff --git a/auroris/utils.py b/auroris/utils.py index 04ddd37..4402137 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -1,14 +1,15 @@ import os from io import BytesIO from typing import ByteString +import fsspec import numpy as np from matplotlib.figure import Figure from PIL import Image from PIL.Image import Image as ImageType -import fsspec from sklearn.utils.multiclass import type_of_target + import datamol as dm @@ -25,13 +26,12 @@ def is_regression(values: np.ndarray) -> bool: def fig2img(fig: Figure) -> ImageType: """Convert a Matplotlib figure to a PIL Image""" - if isinstance(fig, Figure): - fig.canvas.draw() - return Image.frombytes( - "RGBA", - fig.canvas.get_width_height(), - fig.canvas.buffer_rgba(), - ) + fig.canvas.draw() + return Image.frombytes( + "RGBA", + fig.canvas.get_width_height(), + fig.canvas.buffer_rgba(), + ) def img2bytes(image: ImageType): @@ -60,18 +60,10 @@ def _img_to_html_src(self, path: str): return path.replace("gs://", "https://storage.googleapis.com/") elif protocol == "file": return os.path.relpath(path, self._destination) - else: - raise ValueError("We only support images hosted in GCP or locally") + else: + raise ValueError("We only support images hosted in GCP or locally") -def save_image(image: ImageType, path: str, destination: str): - """Save image to local and remote path""" - if dm.fs.is_local_path(destination): - image.save(path) - else: - # Lu: couldn't find a way to save image directly to remote path - # convert to bytes - image_bytes = img2bytes(image) - # save bytes as image to remote path - with fsspec.open(path, "wb") as f: - f.write(image_bytes) +def save_image(image: ImageType, path: str): + with fsspec.open(path, "wb") as fd: + image.save(fd, format="png") diff --git a/tests/test_curator.py b/tests/test_curator.py index 5a8b0c1..885cb05 100644 --- a/tests/test_curator.py +++ b/tests/test_curator.py @@ -17,8 +17,7 @@ def test_curator_save_load(tmpdir): OutlierDetection(method="zscore", columns=["outlier_column"]), ], ) - path = os.path.join(tmpdir, "curator_lu.json") - print(path) + path = os.path.join(tmpdir, "curator.json") curator.to_json(path) curator_reload = curator.from_json(path) From b6757ca8885c90c461951cdb02b71337d24212ba Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 16:38:05 -0400 Subject: [PATCH 35/39] minor fix --- auroris/curation/_curator.py | 38 ++++++++++++-------- auroris/curation/actions/_ac_stereoisomer.py | 2 +- auroris/curation/actions/_deduplicate.py | 2 +- auroris/report/broadcaster/_html.py | 18 ++++++++-- auroris/utils.py | 29 ++++++--------- tests/test_curator.py | 2 ++ 6 files changed, 55 insertions(+), 36 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 6ce27dc..faef993 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -3,14 +3,14 @@ from os import PathLike import fsspec -import pandas as pd from loguru import logger from pydantic import BaseModel, Field, field_serializer, field_validator +import pandas as pd from auroris.curation.actions import BaseAction from auroris.report import CurationReport from auroris.types import VerbosityLevel - +from auroris.utils import is_parquet_file class Curator(BaseModel): """ @@ -53,21 +53,31 @@ def _serialize_verbosity(self, value: VerbosityLevel): @field_validator("src_dataset_path", mode="before") def _validate_src_dataset_path(cls, value: Union[str, PathLike]): - try: - pd.read_csv(value, nrows=5) - return value - except Exception: - raise ValueError( - f"Dataset can't be loaded by `pandas.read_csv('{value}')`." - f"Consider passing the DataFrame directly to `Curator.curate(dataset=...)`." - ) - - def _load_data(self): - return pd.read_csv(self.src_dataset_path) + # Use pyarrow reader interface for parquet validation which is also used in `pandas.read_parquet` + if not is_parquet_file(value): + try: + pd.read_csv(value, nrows=5) + return value + except Exception: + raise ValueError( + f"Dataset can't be loaded by `pandas.read_csv('{value}')` nor `pandas.read_parquet('{value}')`." + f"Consider passing the DataFrame directly to `Curator.curate(dataset=...)`." + ) + return value def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFrame, CurationReport]: + if self.src_dataset_path is not None: + if dataset is not None: + logger.warning( + "`self.scr_dataset_path` takes precedence over the `dataset` parameter. Overwriting the dataset!" + ) + if is_parquet_file(self.src_dataset_path): + dataset = pd.read_csv(self.src_dataset_path) + else: + dataset = pd.read_parquet(self.src_dataset_path) + if dataset is None: - dataset = self._load_data() + raise ValueError("Running the curator requires a source dataset.") report = CurationReport() dataset = dataset.copy(deep=True) diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 006d4b9..4a88cde 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -98,7 +98,7 @@ def transform( col_with_prefix = self.get_column_name(col) report.log_new_column(col_with_prefix) - has_cliff = dataset[col_with_prefix].__eq__(True) + has_cliff = dataset[col_with_prefix] num_cliff = has_cliff.sum() if num_cliff > 0: diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index fe7bcda..75e4681 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -83,6 +83,6 @@ def transform( method=self.method, ) if report is not None: - num_duplicates = dataset.shape[0] - dataset_dedup.shape[0] + num_duplicates = len(dataset) - len(dataset_dedup) report.log(f"Deduplication merged and removed {num_duplicates} duplicated molecules from dataset") return dataset_dedup diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 99ad393..73962df 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -1,5 +1,6 @@ import base64 import re +import os import pathlib from copy import deepcopy from importlib import resources @@ -8,7 +9,7 @@ import fsspec from auroris.report import CurationReport -from auroris.utils import img2bytes, save_image, _img_to_html_src +from auroris.utils import img2bytes, save_image from ._base import ReportBroadcaster @@ -73,7 +74,7 @@ def broadcast(self): filename = "-".join([str(image_counter), filename]) path = dm.fs.join(self._image_dir, f"{filename}.png") save_image(image.image, path) - src = _img_to_html_src(path, self._destination) + src = self._img_to_html_src(path) image.image = src image_counter += 1 @@ -93,3 +94,16 @@ def broadcast(self): fd.write(html) return path + + def _img_to_html_src(self, path: str): + """ + Convert a path to a corresponding `src` attribute for an `` tag. + Currently only supports GCP and local paths. + """ + protocol = dm.utils.fs.get_protocol(path) + if protocol == "gs": + return path.replace("gs://", "https://storage.googleapis.com/") + elif protocol == "file": + return os.path.relpath(path, self._destination) + else: + raise ValueError("We only support images hosted in GCP or locally") diff --git a/auroris/utils.py b/auroris/utils.py index 4402137..329b857 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -1,8 +1,7 @@ -import os from io import BytesIO from typing import ByteString import fsspec - +import pyarrow.parquet as pq import numpy as np from matplotlib.figure import Figure from PIL import Image @@ -10,8 +9,6 @@ from sklearn.utils.multiclass import type_of_target -import datamol as dm - def is_regression(values: np.ndarray) -> bool: """Whether the input values are for regreesion""" @@ -50,20 +47,16 @@ def bytes2img(image_bytes: ByteString): return image -def _img_to_html_src(self, path: str): - """ - Convert a path to a corresponding `src` attribute for an `` tag. - Currently only supports GCP and local paths. - """ - protocol = dm.utils.fs.get_protocol(path) - if protocol == "gs": - return path.replace("gs://", "https://storage.googleapis.com/") - elif protocol == "file": - return os.path.relpath(path, self._destination) - else: - raise ValueError("We only support images hosted in GCP or locally") - - def save_image(image: ImageType, path: str): with fsspec.open(path, "wb") as fd: image.save(fd, format="png") + + +def is_parquet_file(path): + """Verify parquet file""" + try: + pq.read_schema(path) + return True + except (IOError, ValueError): + return False + diff --git a/tests/test_curator.py b/tests/test_curator.py index 885cb05..183bec5 100644 --- a/tests/test_curator.py +++ b/tests/test_curator.py @@ -1,5 +1,7 @@ import os +from pandas.core.api import DataFrame as DataFrame + from auroris.curation import Curator from auroris.curation.actions import Discretization, MoleculeCuration, OutlierDetection from auroris.report.broadcaster import HTMLBroadcaster, LoggerBroadcaster From 4b2bae893a9214369adade948eb9a53813576ecc Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Wed, 22 May 2024 16:47:23 -0400 Subject: [PATCH 36/39] remove gcp --- auroris/curation/_curator.py | 1 + auroris/report/broadcaster/_html.py | 8 +++----- auroris/utils.py | 1 - 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index faef993..7e07413 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -12,6 +12,7 @@ from auroris.types import VerbosityLevel from auroris.utils import is_parquet_file + class Curator(BaseModel): """ A curator is a collection of actions that are applied to a dataset. diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 73962df..3ca4e1a 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -98,12 +98,10 @@ def broadcast(self): def _img_to_html_src(self, path: str): """ Convert a path to a corresponding `src` attribute for an `` tag. - Currently only supports GCP and local paths. + Currently only supports local paths. """ protocol = dm.utils.fs.get_protocol(path) - if protocol == "gs": - return path.replace("gs://", "https://storage.googleapis.com/") - elif protocol == "file": + if protocol == "file": return os.path.relpath(path, self._destination) else: - raise ValueError("We only support images hosted in GCP or locally") + raise ValueError("We only support images hosted locally") diff --git a/auroris/utils.py b/auroris/utils.py index 329b857..095f3c3 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -59,4 +59,3 @@ def is_parquet_file(path): return True except (IOError, ValueError): return False - From 5ec838a045764521b7d43e12a17e9a0f2ce34e8b Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 23 May 2024 01:06:41 -0400 Subject: [PATCH 37/39] update tutorial --- README.md | 4 + auroris/curation/actions/_discretize.py | 2 +- auroris/report/broadcaster/_html.py | 2 +- docs/tutorials/getting_started.ipynb | 129 +++++++++++------------- 4 files changed, 66 insertions(+), 71 deletions(-) diff --git a/README.md b/README.md index 2d9308e..829d913 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,10 @@ curator = Curator( # Run the curation dataset, report = curator(dataset) ``` +### Run curation with command line +``` +auroris [config_file] [destination] --dataset-path [data_path] +``` ## Documentation diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index 548692d..8a619e7 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -83,7 +83,7 @@ class Discretization(BaseAction): """ input_column: str = Field(..., description="Column to be discretized.") - prefix: str = "CLS_" + prefix: str = Field(default="CLS_", description="Prefix for added column names.") thresholds: List[float] = Field(..., description="Interval boundaries that include the right bin edge.") inplace: bool = Field( default=False, diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index 3ca4e1a..d8f97ed 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -104,4 +104,4 @@ def _img_to_html_src(self, path: str): if protocol == "file": return os.path.relpath(path, self._destination) else: - raise ValueError("We only support images hosted locally") + raise ValueError("We only support images hosted locally.") diff --git a/docs/tutorials/getting_started.ipynb b/docs/tutorials/getting_started.ipynb index d3f1e09..28fcbc0 100644 --- a/docs/tutorials/getting_started.ipynb +++ b/docs/tutorials/getting_started.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "id": "976c5af4-2819-4cd6-8a57-072441eb9305", "metadata": { "editable": true, @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "id": "a8f88963-f561-4cdc-8bfb-0a3045743e98", "metadata": { "editable": true, @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "id": "5483a1fd-b22e-43e5-92f4-e6e8f4f3e629", "metadata": { "editable": true, @@ -142,7 +142,7 @@ " \n", " \n", " 0\n", - " <rdkit.Chem.rdchem.Mol object at 0x288ce21f0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x169be1fc0>\n", " 1\n", " n-pentane\n", " -3.18\n", @@ -152,7 +152,7 @@ " \n", " \n", " 1\n", - " <rdkit.Chem.rdchem.Mol object at 0x288ce11c0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x169be2110>\n", " 2\n", " cyclopentane\n", " -2.64\n", @@ -162,7 +162,7 @@ " \n", " \n", " 2\n", - " <rdkit.Chem.rdchem.Mol object at 0x288ce2c00>\n", + " <rdkit.Chem.rdchem.Mol object at 0x169be2180>\n", " 3\n", " n-hexane\n", " -3.84\n", @@ -172,7 +172,7 @@ " \n", " \n", " 3\n", - " <rdkit.Chem.rdchem.Mol object at 0x288ce2340>\n", + " <rdkit.Chem.rdchem.Mol object at 0x169be21f0>\n", " 4\n", " 2-methylpentane\n", " -3.74\n", @@ -182,7 +182,7 @@ " \n", " \n", " 4\n", - " <rdkit.Chem.rdchem.Mol object at 0x288ce1ee0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x169be2260>\n", " 6\n", " 2,2-dimethylbutane\n", " -3.55\n", @@ -196,11 +196,11 @@ ], "text/plain": [ " mol ID NAME \\\n", - "0 1 n-pentane \n", - "1 2 cyclopentane \n", - "2 3 n-hexane \n", - "3 4 2-methylpentane \n", - "4 6 2,2-dimethylbutane \n", + "0 1 n-pentane \n", + "1 2 cyclopentane \n", + "2 3 n-hexane \n", + "3 4 2-methylpentane \n", + "4 6 2,2-dimethylbutane \n", "\n", " SOL SOL_classification smiles split \n", "0 -3.18 (A) low CCCCC train \n", @@ -210,7 +210,7 @@ "4 -3.55 (A) low CCC(C)(C)C train " ] }, - "execution_count": 13, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -218,8 +218,8 @@ "source": [ "# Load your data set\n", "# See more details of the dataset at https://docs.datamol.io/stable/api/datamol.data.html\n", - "dataset = dm.data.solubility()\n", - "dataset.head(5)" + "data = dm.data.solubility()\n", + "data.head(5)" ] }, { @@ -242,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "id": "f9dbba41-2bd2-4321-b948-13877cee5b13", "metadata": {}, "outputs": [ @@ -250,9 +250,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2024-05-16 17:56:13.689\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: MoleculeCuration\u001b[0m\n", - "\u001b[32m2024-05-16 17:56:17.051\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: OutlierDetection\u001b[0m\n", - "\u001b[32m2024-05-16 17:56:17.079\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m76\u001b[0m - \u001b[1mPerforming step: Discretization\u001b[0m\n" + "\u001b[32m2024-05-23 00:53:40.139\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m88\u001b[0m - \u001b[1mPerforming step: mol_curation\u001b[0m\n", + "\u001b[32m2024-05-23 00:53:55.266\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m88\u001b[0m - \u001b[1mPerforming step: outlier_detection\u001b[0m\n", + "\u001b[32m2024-05-23 00:53:55.338\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mauroris.curation._curator\u001b[0m:\u001b[36mtransform\u001b[0m:\u001b[36m88\u001b[0m - \u001b[1mPerforming step: discretize\u001b[0m\n" ] } ], @@ -271,7 +271,7 @@ ")\n", "\n", "# Run the curation\n", - "dataset, report = curator(dataset)" + "dataset, report = curator(data)" ] }, { @@ -284,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "id": "98aaadd9-8c0f-412e-ab74-79b8f9a3d75a", "metadata": {}, "outputs": [ @@ -293,31 +293,31 @@ "output_type": "stream", "text": [ "\u001b[31;1m===== Curation Report =====\u001b[0m\n", - "\u001b[34;1mTime: 2024-05-16 17:56:13\u001b[0m\n", - "\u001b[34;1mVersion: dev\u001b[0m\n", - "\u001b[34;1m===== MoleculeCuration =====\u001b[0m\n", - "\u001b[34;1m[LOG]: Couldn't preprocess 18 / 1282 molecules.\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_smiles\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_molhash_id\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_molhash_id_no_stereo\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_num_stereoisomers\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_num_undefined_stereoisomers\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_num_defined_stereo_center\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_num_undefined_stereo_center\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_num_stereo_center\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_undefined_E_D\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: MOL_undefined_E/Z\u001b[0m\n", - "\u001b[34;1m[LOG]: Default `ecfp` fingerprint is used to compute the distributionin chemical space.\u001b[0m\n", - "\u001b[34;1m[LOG]: Molecules with undefined stereocenter detected: 253.\u001b[0m\n", - "\u001b[34;1m[IMG]: Dimensions 1200 x 600\u001b[0m\n", - "\u001b[34;1m[IMG]: Dimensions 1200 x 2400\u001b[0m\n", - "\u001b[34;1m===== OutlierDetection =====\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: OUTLIER_SOL\u001b[0m\n", - "\u001b[34;1m[LOG]: Found 7 potential outliers with respect to the SOL column for review.\u001b[0m\n", - "\u001b[34;1m[IMG]: Dimensions 640 x 480\u001b[0m\n", - "\u001b[34;1m===== Discretization =====\u001b[0m\n", - "\u001b[34;1m[LOG]: New column added: CLS_SOL\u001b[0m\n", - "\u001b[34;1m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[38;20mTime: 2024-05-23 00:53:40\u001b[0m\n", + "\u001b[38;20mVersion: dev\u001b[0m\n", + "\u001b[38;20m===== mol_curation =====\u001b[0m\n", + "\u001b[38;20m[LOG]: Couldn't preprocess 18 / 1282 molecules.\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_smiles\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_molhash_id\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_molhash_id_no_stereo\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_num_stereoisomers\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_num_undefined_stereoisomers\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_num_defined_stereo_center\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_num_undefined_stereo_center\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_num_stereo_center\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_undefined_E_D\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: MOL_undefined_E/Z\u001b[0m\n", + "\u001b[38;20m[LOG]: Default `ecfp` fingerprint is used to compute the distributionin chemical space.\u001b[0m\n", + "\u001b[38;20m[LOG]: Molecules with undefined stereocenter detected: 253.\u001b[0m\n", + "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[38;20m===== outlier_detection =====\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: OUTLIER_SOL\u001b[0m\n", + "\u001b[38;20m[LOG]: Found 7 potential outliers with respect to the SOL column for review.\u001b[0m\n", + "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[38;20m===== discretize =====\u001b[0m\n", + "\u001b[38;20m[LOG]: New column added: CLS_SOL\u001b[0m\n", + "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", "\u001b[31;1m===== Curation Report END =====\u001b[0m\n" ] } @@ -339,26 +339,29 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "id": "9b896b12-fbae-4b7b-b62a-f2d2d15075c1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'/Users/lu.zhu/Documents/Codebase/ValenceLab/auroris/docs/tutorials/test/index.html'" + "'/var/folders/_7/ffxc1f251dbb5msn977xl4sm0000gr/T/tmpp9qm656e/index.html'" ] }, - "execution_count": 16, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from auroris.report.broadcaster import HTMLBroadcaster\n", + "import tempfile\n", + "\n", + "temp_dir = tempfile.TemporaryDirectory().name\n", "\n", "broadcaster = HTMLBroadcaster(report= report, \n", - " destination=\"/Users/lu.zhu/Documents/Codebase/ValenceLab/auroris/docs/tutorials/test\", \n", + " destination=temp_dir, \n", " embed_images=True)\n", "broadcaster.broadcast()" ] @@ -373,14 +376,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "id": "97be9d29-03eb-4eb7-b9c0-ac84413f6dca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "mol \n", + "mol \n", "ID 1\n", "NAME n-pentane\n", "SOL -3.18\n", @@ -402,7 +405,7 @@ "Name: 0, dtype: object" ] }, - "execution_count": 17, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -428,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "id": "f5044a09-c34f-4888-a5ac-65fb62225129", "metadata": { "editable": true, @@ -440,9 +443,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABMEAAAJpCAYAAACkSyW0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABcSAAAXEgFnn9JSAADDqUlEQVR4nOzdeXyU1dn/8e9kJplsE7KQsCVsCTsBARFFWRJw/am1FrVqW9u6W3f72KrVWqt2UetKXVor1apVWkWlWpUkbCL7FnaYEEIgJCEJyWSbTGbu3x+RFMwEQjJLls/79erzgvu+7vtcmRx45Mq5zjEZhmEIAAAAAAAA6MZCgp0AAAAAAAAA4G8UwQAAAAAAANDtUQQDAAAAAABAt0cRDAAAAAAAAN0eRTAAAAAAAAB0exTBAAAAAAAA0O1RBAMAAAAAAEC3RxEMAAAAAAAA3R5FMAAAAAAAAHR7FMEAAAAAAADQ7VEEAwAAAAAAQLdHEQwAAAAAAADdHkUwAAAAAAAAdHsUwQAAAAAAANDtUQQDAADdWmFhoUaMGNHq/8aOHaszzzxT3//+9/XKK6+ouro6YLm9+OKLGjFihK6++uqAjPfDH/5QI0aM0LPPPntKz2VmZmrEiBGaP39+87VVq1Y1f4aNjY3N13/5y19qxIgR+vnPf+71Xbt3725f8m10bF7f/t/IkSOVnp6uc845R9ddd53eeustOZ3OFu/w9vV2VF1dnQoLC332PgAAcOoswU4AAAAgUIYPH67o6OjjrrlcLpWXl2vDhg3asGGD3nvvPc2bN0+DBg0KUpbd0969e/X444+rtrZW7777bkDGHDt2rMLCwo675nQ6VVJSopUrV2rlypWaP3++5s2bp/j4eL/l8cknn+ipp57SHXfcoSuuuMJv4wAAgBOjCAYAAHqMX/3qV5oyZYrXe6tWrdJtt92mgwcP6he/+IX++c9/Bji7zmvevHlyuVxKSko6aey9996rG2+8UTab7bjrCxcu1PLlyzVx4kR/pdnC888/r+TkZK/3Pv30U91///3auXOnnnjiCT3zzDN+y+PZZ59VcXGx394PAADahnZIAAAASVOmTNG9994rSdqwYYO2bNkS5Iw6j4EDByo1NbVFYcubpKQkpaamtqlgFkwXXXSRfvSjH0mSPvvsMx0+fDjIGQEAAH+jCAYAAPCNc889t/nXmzZtCmImCISj32+3203REwCAHoAiGAAAwDeOXelUU1PT/OujG8ovWbJEc+fO1dSpUzV+/HhdfPHFstvtzXHFxcX6wx/+oIsuukjjx4/XhAkT9J3vfEcvvfSSqqqqTjh2SUmJHnzwQZ199tlKT0/XhRdeqGeffbbV5xobG7VgwQLdcsstmjZtmtLT0zVhwgSdf/75euSRR7R3794Tjrd582bdcMMNmjRpkiZMmKArr7xS//znP+V2u1vEnspG8d/eGP/owQQvvfSSJGn9+vUaMWKEMjMzVVVVpXHjxmnEiBH64osvWn3nj3/8Y40YMUKvvfbaScc/Fa19v0+ksrJSL730ki677DJNmDBB48eP14UXXqg//OEPKikpOS726MEHBw4ckNTUjjtixAi9+OKLvvsiAABAm7EnGAAAwDf27dvX/Ou+ffu2uP/KK69o/fr1GjhwoGw2m6qrqzV48GBJ0tdff6077rhDDodDoaGhSktLU2Njo3bt2qUdO3boX//6l1599VWNGDGixXsPHz6sOXPmqLi4WIMHD1ZCQoJ2796tV155RZ988oneeustDRgwoDm+vr5eN910k1atWiVJGjBggIYPH66ysjLl5+crPz9fn3zyid5++22NHj26xXgrV67U66+/LsMwNHz4cDkcDm3atEmbNm3Sl19+qZdffrnFhvLtZbVaNXHiRBUVFamoqEjR0dEaPny4EhMTFRMTo3PPPVcLFy7URx99pPPOO6/F84cOHdKqVatkNpv1ne98xyc5HZWfn9/8a2/f72/buXOnbrjhBpWUlCgkJESpqamyWCzavXu3/va3v+nf//63XnzxxeZ95/r166eJEydqy5Ytamho0KBBg5SQkKB+/fr59OsAAABtw0owAACAb7zxxhuSpNDQUE2dOrXF/fXr1+vnP/+5vvzyS33++ef64IMPZDabdeDAAd12221yOBzKzMzU4sWLtWDBAi1cuFBffPGFJkyYoKKiIt1yyy1yOBwt3ltQUCCXy6W3335bn3/+uT7++GN9+umnSk1N1YEDB3T//fcfF/+Xv/xFq1atUlxcnObPn6/s7Gz9+9//1uLFizV//nwlJiaqtrZWr7zyitevc+PGjRo1apS++OILffjhh1q0aJFeffVVRUVFafny5Xr55Zd98Gk2SUxM1Lvvvqvvfe97kppO6Hz33Xf1wgsvSJLmzJkjSVqyZImOHDnS4vmPPvpIHo9H55xzjvr06eOzvCTp73//uyQpPj5e6enpJ4ytrq5uLoBNmDBBX3zxhRYuXKgFCxZoyZIlysjIUGVlpX72s59p//79zV/bu+++q8TEREnSjTfeqHfffbf5awYAAIFFEQwAAPRo9fX12rZtm379619rwYIFkpra73r37t0idsCAAbrhhhuafx8fHy9JevXVV1VbW6vhw4fr+eefP+7ZlJQUvfrqq0pMTNTBgwf11ltvec3j6aef1umnn978+yFDhuill16S2WzW2rVrtXbt2uZ7K1asUEhIiG6//XaNGzfuuPeMGzdOV199tSRp165dXseKiYnRq6++etzqspkzZ+qBBx6QJL355puqra31+qyvnXnmmRowYIBcLpc+/fTTFvePfk8uv/xyn4xXU1OjDRs26M4779Tq1aslSXfeeedJV7698847KikpUe/evfXqq68qJSWl+V7v3r31wgsvNK+qa634CAAAgot2SAAA0GMcPQ3wRK644grdddddXu9NmDBBJpOpxfXFixdLkq6++mqvxZRevXrpe9/7nl555RUtWrRIt91223H3Bw8erLPPPrvFc0OHDtXpp5+uVatWacmSJc1FsnfffVcul8trLpIUEREhqanA582FF17YXMA71ne+8x09/vjjqq6u1rp16zRt2jSvz/uSyWTS5ZdfrhdffFEfffSRrrnmmuZ7mzZtUl5enmJjY5WZmXnK7541a9YJ75vNZt18883NRcMTyc7OliRddtll6tWrV4v7YWFh+uEPf6iHH35Y2dnZMgyj1e8PAAAIDopgAACgxxg+fLiio6Obf28ymWS1WhUbG6sRI0Zo9uzZSktLa/X5o21tx6qurlZxcbEkaezYsa0+O2bMGEnyumH90XvejBgxQqtWrTpuA36pqWXT4XBo/fr1ys/P1/79+5Wfn6/t27fr8OHDkiSPx+P1nd72CZOaCjmDBw/Wjh07ZLfbA1IEk5pWec2dO1cbN25Ufn5+8z5rR1eBXXLJJe3ao2zs2LHHPWcymRQREaG4uDiNHj1a559//nGr4U7k6PftRN+ro/fKy8t15MgRxcXFnXLOAADAfyiCAQCAHuNXv/pV86bl7WG1WltcO/ZUwWMLbN929F5tbW2LVUJRUVGtPnf03rGruqqrq/WnP/1JH3744XFti6GhoRozZoxGjRqlZcuWnfSdbR3P3/r3768zzzxTK1as0Mcff6w777xTDQ0Nze2R7W2FfP7555WcnOyTHKurqyUdf6Lktx37/a+pqaEIBgBAJ8OeYAAAAB1wbEHpaKHEm8rKSklSZGRkiza5E+2/dfSdMTExzdduu+02vf322/J4PPrJT36i5557Tv/5z3+0YcMGvffee15PWWzreEc37j92vEA4unH+J598Iul/G+WPHDmy1ZVrgXT0++ztYIOjjn6Pj40HAACdB0UwAACADoiOjlZSUpIkacuWLa3GHb13tNXvWHl5ea0+t3XrVklNrZxS08mOq1atktS0If8vf/lLXXjhhUpLS1NoaKgk6dChQyfMubXxamtrm9v+jo4XKOeee6569eqlgoIC7dixQ19++aUk322I31FDhw6V9L/vhzdHv8e9evViFRgAAJ0QRTAAAIAOysjIkNS0YX1DQ0OL+5WVlc37W02fPr3F/e3bt2vbtm0trm/dulUbNmyQpOaN4QsLC5vve9uDrK6uTv/5z38kSW6322u+n3322XFtnEe9//77crlcSkxMbHHqZEcdXf1mGIbX+1arVRdffLEk6b///a+WLFmi0NBQXXLJJT7No72Ofo8XLFhw3IqvoxoaGvTuu+9KUou91E72tQMAgMCgCAYAANBBN954o6KiorRr1y7dddddKisra763f/9+3XzzzTp8+LD69Omj6667rsXzhmHojjvu0I4dO5qvbdu2TbfffrsMw9CFF16okSNHSvrfiiRJmjt3rhobG5t/v2fPHt14443Kz8+X1FQQ86a4uFh33nmnysvLm68tXLhQzzzzjKSmdsv2bER/IkfbA0tKSo7L+VhHWyL//ve/68iRI8rIyPB6imUwXH311erTp48OHz6sm2++Wfv372++V1ZWprvuuku7du1SVFSU7rjjjuOejYyMlCQdOHAgoDkDAIDjsTE+AABAB6WkpOiFF17QXXfdpezsbM2YMUNpaWlyu93as2ePPB6P+vfvr5deeslrUefMM8/Ujh07dNlllzWfTrl7925J0sSJE/Xb3/62OXb06NG68MIL9dlnn+lvf/ubPvzwQw0YMEBHjhxpXiV29tln66uvvlJNTY2qq6tbbNh//vnn64svvtDMmTOVlpam8vJyFRUVSZJ+8IMf6JprrvH5ZzRq1ChJTYWg8847T0lJSXr33XeP2x9tzJgxGjlyZHMxsLO0QkpNe6S98soruummm7Rhwwadd955SktLk8Vi0e7du+VyuRQbG6unn366Rcvr6NGjtWvXLv31r3/V0qVLde655+q2224LzhcCAEAPxkowAAAAHzjnnHP0n//8Rz/+8Y+VnJysvXv3qqioSKNGjdJ9992njz76SGPGjPH67KBBgzR//nxdcMEFKi0tVUFBgUaOHKkHHnhAf//731ucSPjMM8/ot7/9rdLT0+XxeLRz5041NDQoIyNDr776qv72t79pwIABkqTs7OwW451//vl64403NG7cOO3du1dVVVWaMmWK5s6dq4cfftj3H46aCn3333+/BgwYoJKSEhUWFurw4cMt4r773e9KkhITE1u0FQbb6NGjtXDhQt12220aNmyY9u/fr/z8fA0ZMkS33HKLPv74Y685/+IXv9D555+viIgI5eXlyW63ByF7AABgMticAAAAAJ3E73//e73xxhu6/vrrdf/99wc7HQAA0I2wEgwAAACdgtPp1McffyyTyaQrrrgi2OkAAIBuhj3BAAAAEDQVFRXNG/Q/88wzKisrU0ZGhoYMGRLkzAAAQHdDEQwAAABBk5+fr+9///vNv4+IiNAvf/nLIGYEAAC6K9ohAQAAEDQpKSkaPHiwwsPDNX78eL3xxhstTlcEAADwBTbGBwAAAAAAQLfHSjAAAAAAAAB0exTBAAAAAAAA0O1RBAMAAAAAAEC3RxEMAAAAAAAA3R5FMAAAAAAAAHR7lmAngBPLzc2Vy+VSSEiIrFZrsNMBAAAAAAAICqfTKY/Ho9DQUKWnp5/y8xTBOjmXyyXDMOR2u1VbWxvsdAAAAAAAAILK5XK16zmKYJ1cSEiI3G63TCaTIiIigp1Ot2UYhurq6iRJERERMplMQc4I3QnzC/7GHIO/McfgT8wv+BtzDP7GHAucuro6GYahkJD27e5FEayTs1qtqq2tVUREhEaNGhXsdLott9utjRs3SpJGjBghs9kc3ITQrTC/4G/MMfgbcwz+xPyCvzHH4G/MscDZvn27amtr271dFBvjAwAAAAAAoNujCAYAAAAAAIBujyIYAAAAAAAAuj2KYAAAAAAAAOj2KIIBAAAAAACg26MIBgAAAAAAgG6PIhgAAAAAAAC6PYpgHXTnnXdqxIgR+uCDD4KdCgAAAAAAAFpBEawD5s+fr88//zzYaQAAAAAAAOAkKIK10969e/Xkk08GOw0AAAAAAAC0AUWwdmhoaNB9992nkJAQjR49OtjpAAAAAAAA4CQogrXDs88+q61bt+qRRx5Rv379gp0OAAAAAAAATsIS7AS6mhUrVuiNN97Q//t//0/f+c53ArYnmGEYcrvdARmrJzr2s+Vzhq8xv+BvzDH4G3MM/sT8gr8xx+BvzLHAMQyjQ89TBDsF5eXluv/++9W3b189+uijAR27rq5OGzduDOiYPVVubm6wU0A3xvyCvzHH4G/MMfgT8wv+xhyDvzHHOjeKYKfgoYceUllZmebNm6eYmJhgpwMAAAAAAIA2ogjWRm+//bays7N14403asqUKQEfPyIiQiNGjAj4uD2F2+1urtinp6fLbDYHOSN0J8wv+BtzDP7GHIM/Mb/gb8wx+BtzLHB27typurq6dj9PEawNdu/erT/+8Y8aM2aM7rrrrqDkYDKZ+IMUIGazmc8afsP8gr8xx+BvzDH4E/ML/sYcg78xx/zLZDJ16HmKYG3w9NNPq76+XuHh4XrggQeOu7d161ZJ0vvvv68VK1Zo8uTJuuqqq4KRJgAAAAAAQAu1BQWq2r5DvcaOVcSA/sFOJ2gogrVBbW2tJGndunVat26d15gNGzZow4YNslgsFMEAAAAAAEBQuRwOHV72lUqyc1S9e48kyRwVqclv/FVmqzXI2QUHRbA2eOutt1q9d9tttykrK0u/+93vdPnllwcwKwAAAAAAgP8x3G4d2bhJxVk5Kl+1WkZj43H33XX1TdcoggEAAAAAAKCrqS0sVElWjkoXL1VDebnXmOi0VA285vuyREUFOLvOgyIYAAAAAABAF9NYXaPDy5vaHR07d3mNCe3VS4kZM5SUMVNRgwcFNsFOiCIYAAAAAABAF2C43TqyOVcl2TkqX7lanoaGFjEmi0XxkycpKTNDsRMnKMRC6ecoPokO+vOf/xzsFAAAAAAAQDdWd+CgSrJzVJKzWA1l3tsdo4YOUVJmhhJnTFNoTEyAM+waKIIBAAAAAAB0Mo21tTq8fIVKsrLl2LHTa4wlJkaJM6arz6wMRQ0ZHNgEuyCKYAAAAAAAAJ2A4fGoMneLSrJyVPb1Su/tjmaz4k6fqKTMDMVNmqiQ0NAgZNo1UQQDAAAAAAAIorqiQyrJzlFpzmI5Sw97jYkcNFBJszKVOGO6wmJ7BTjD7oEiGAAAAAAAQIA11tapbMUKlWTlqGrbdq8xFlu0EqdPV9LsDEUNGSKTyRTgLLsXimAAAAAAAAABYHg8qtyyVSXZi1W24mt5nM6WQSEhips0QUmZGYqffDrtjj5EEQwAAAAAAMCP6ouLVZK9WCXZi+UsKfEaE5GSrD6zMpU4c7rC4uICnGHPQBEMAAAAAADAx9z19Spb8bWKs3JUtWWr1xhLdLR6Tz9HSZkZik5Lpd3RzyiCAQAAAAAA+IBhGKrculUlWYt1+KsV8tTXtwwKCVHchPFKmpXZ1O4YFhb4RHsoimAAAAAAAAAdYByplHtzrja++rqcxcVeYyKSBzSf7mhNiA9whpAoggEAAAAAAJwyt9Opsq9XqnhRtpy5WyRJjd+KMUdFKnHaN+2Ow4fR7hhkFMEAAAAAAADawDAMOXbsVElWjg4v/0ruurqWQSaTYsePa2p3nDJZZqs18InCK4pgAAAAAAAAJ+AsPaySxUtUkp2j+oNFXmNMCfFKvuB89cnMkLV3QoAzRFtQBAMAAAAAAPgWt9Op8lWrVZKVoyObNkuG0SLGHBGhhHOm6kjyAJmSB2jAhAkym81ByBZtQREMAAAAAABATe2O1bt2qzgrR4eXL5e7prZlkMmkXuPSlZSZoYSzpkgWizZu3BjwXHHqKIIBAAAAAIAezVlWptKcpnbHugMHvcaE9+2rpFkZSsqYIWtiYvN1t9sdqDTRQRTBAAAAAABAj+NpaFDZqjUqyc7RkY2bJI+nRUxIeLh6nzNVSZkZihk9itMduziKYAAAAAAAoEcwDEPVe+wqycpW6dLlctfUeI3rlT62qd1x6pkyh4cHOEv4C0UwAAAAAADQrTVUVKjkaLvj/kKvMdY+SUrKzFBSxkyF90kKbIIICIpgAAAAAACg2/G4XCpfvVYl2TmqWL/Be7uj1areZ5+lpFmZTe2OISFByBSBQhEMAAAAAAB0C4ZhqMaep5LsHJUuXaZGR7XXuJgxo5U0K0MJZ50lS2REgLNEsFAEAwAAAAAAXVrDkSMqXbJUJVk5qt1X4DXGmthbiRkzlZSZoYh+fQObIDoFimAAAAAAAKDL8bhcqli7vqndcd16GW53i5iQsDAlTD1LSbMy1GvsGNodeziKYAAAAAAAoMuoztvb1O64ZJkaq6q8xsSMHqWkzJlKOHuqLJGRAc4QnRVFMAAAAAAA0Km5KitVunSZSrIWq2bvXq8xYQkJSsqcqaTMmYro3z/AGaIroAgGAAAAAAA6HU9joyrWbVBJVrYq1q5rtd0x/swp6jMrQ73Sx8pkNgchU3QVFMEAAAAAAECnUZO/r6ndcfFSuSorvcbYRoxQ0qyZ6n322bJERwU4Q3RVFMEAAAAAAEBQuaocOrxsmYqzclRjz/MaExYfr8SMGUrKnKnI5OQAZ4jugCIYAAAAAAAIOMPtVsWGjSpZlK3yNWtlNDa2iDGFhiphyhlKmpWh2PHjaHdEh1AEAwAAAAAAAVNbUKDirByVLlkqV8URrzHRw4YpadZMJU47R5bo6MAmiG6LIhgAAAAAAPCrxupqlS5drpLsHFXv3uM1JjQuVkkzZygpM0ORA1MCnCF6AopgAAAAAADA5wy3W0c2blJxVo7KV6323u5osSj+jMlKmpWhuAmn0e4Iv6IIBgAAAAAAfKa2sFAlWU2nOzaUl3uNiUpNVZ9ZM9V72jSFxtgCnCF6KopgAAAAAACgQxqra3R4+Vcqyc6RY+curzGhvXopceZ0JWVmKGrwoABnCFAEAwAAAAAA7WC43TqyOVcl2TkqX7lanoaGFjEms1lxk09Xn1kZip04QSEWyhAIHmYfAAAAAABos7oDB1WSnaOSnCVqKCvzGhM1ZIiSZmUocfo5Cu3VK8AZAt5RBAMAAAAAACfUWFurw8tXNLU7bt/hNcYSE6PEGdOUlJmh6KFDApwhcHIUwQAAAAAAQAuGx6PK3C0qyc5R2YqVXtsdFRKi+NMnNZ3uOGmiQkJDA58o0EYUwQAAAAAAQLO6okMqyc5Rac5iOUsPe42JHDRQSbMylThjmsJiYwObINBOFMEAAAAAAOjhGmvrVLbia5Vk56hq6zavMRZbtBKnT1fSrAxFDR0ik8kU4CyBjqEIBgAAAABAD2R4PKrauk3FWTkqW/G1PE5ny6CQEMVNmqCkzAzFTz6ddkd0aRTBTtFHH32kf/3rX9qxY4fq6uqUkJCgM888UzfddJNSU1ODnR4AAAAAACdUX1yskuzFKsleLGdJideYiJRk9ZmVqcQZ0xUWHxfgDAH/oAjWRoZh6Oc//7kWLlwoi8Wi9PR0xcfHa8eOHVqwYIH++9//au7cuTrnnHOCnSoAAAAAAMdx19erbMVKFWdlq2rLVq8x5qgoJU6fpqRZGYpOS6XdEd0ORbA2+vjjj7Vw4UIlJibqr3/9q0aOHClJcrvdeuGFF/TKK6/o/vvv15dffqmoqKggZwsAAAAA6OkMw1DVtu0qycrR4a9WyFNf3zIoJERxE8Y3tTueMVkhYWGBTxQIEIpgbfSvf/1LknTfffc1F8AkyWw26+6771ZWVpZ2796tr776Suedd16w0gQAAAAA9HDO0tLmdsf6Q4e8xkQkD1BSZoYSZ86QNSE+wBkCwUERrI1iYmKUmpqq008/vcU9k8mkIUOGaPfu3SouLg5CdgAAAACAnsztdKrs65UqycpRZe4WyTBaxJijItX7nHPUZ1aGoocPo90RPQ5FsDaaO3duq/fcbre2bm3qqe7Xr1+gUgIAAAAA9GCGYcixY2dTu+Pyr+Suq2sZZDIpdvw4Jc3KUPyUM2S2WgOfKNBJUATzgXfeeUcHDhxQbGyszjrrLL+MYRiG3G63X94NHffZ8jnD15hf8DfmGPyNOQZ/Yn7B37rjHHMePqzDi5eqNGeJ6ouKvMaE9+unxIwZ6j1zhqy9E5qvd5fPoDPpjnOsszK8rHA8FSajo2/o4b7++mvddNNNamho0OOPP64rrrjCp+/fvn27amtrffpOAAAAAEDXYrhc8uzcJffGzfLk7fUeFBYm89jRMo8fJ1PyANod0W1FRkZq1KhRp/wcK8E6ICcnR3fffbcaGhp09dVX+7wABgAAAADouQzDkHHgoNybNsu9ZZvkdHqNCxkyWObTxilk5AiZQkMDnCXQdVAEa6e33npLv/vd7+R2u3Xttdfq4Ycf9ut4ERERGjFihF/H6Mncbrdyc3MlSenp6TKbzUHOCN0J8wv+xhyDvzHH4E/ML/hbV5xjDeXlKv2m3dF54IDXGGvfPkrMmKnEGdNlTUoMbII4TlecY13Vzp07Vedt77s2ogh2ihobG/XYY4/pvffek8lk0j333KNbbrnF7+OaTCb+IAWI2Wzms4bfML/gb8wx+BtzDP7E/IK/deY55mloUPnqNSrOytGRjZskj6dFTEh4uHqfM1VJmRmKGT2KdsdOqDPPse6go3OeItgpqK+v189+9jMtX75cERER+v3vf68LLrgg2GkBAAAAALogwzBUvcfedLrjsuVqrK72Ghczdoz6zMpUwllTZI6ICHCWQPdBEayN3G53cwEsISFBr7zyisaNGxfstAAAAAAAXUxDRYVKFy9VSXaOagv2e42xJiUpaVaGkjJmKLxPnwBnCHRPFMHa6OWXX9by5csVGRmpv//97xo2bFiwUwIAAAAAdBEel0vla9aqJCtHFes3eG93tFrV++yzmtodx4yWKSQkCJmiu6lw1OuLVfu0xV6mOmejIqwWpaf21rlTBirOFh7s9AKKIlgbVFZW6vXXX5ckJSUl6dVXX2019pJLLtGMGTMClRoAAAAAoJMyDEM1eXtVkpWt0qXL1Ohopd1xzGglZWYoYepZskTS7gjfcLrc+suCXGWtKVCj2zju3sZdpXr3ix2aNXmgbrosXWGhPWMfM4pgbbB69WrV1tZKkvLz85Wfn99q7KhRoyiCAQAAAEAP1nCkUqVLlqgkK0e1+wq8xlgTeysxY6aSMjMU0a9vYBNEt+d0ufXoX77WFntZqzGNbkOfr9ynA6XVevTGs2TtAYUwimBtcO6552rnzp3BTgMAAAAA0El5XC5VrFvf1O64br0Mt7tFTEhYmBKmnqmkzAz1Sh9LuyP85i8Lck9YADvWFnuZ/rIgV7dfcZp/k+oEKIIBAAAAANBONXvzVZyVrdIly9RYVeU1xjZqpJIyM9T7nKmyREYGOEP0NBVV9cpa430FYmuy1hTo2gtGdvs9wiiCAQAAAABwClyVlSpdukwlWYtVs3ev15iwhAQlZcxQ0qwMRfTvH+AM0ZN9sXpfiz3ATqbRbejLVQW6cvZwP2XVOVAEAwAAAADgJDyNjapYt0El2TmqWLtORmNji5iQsDDFn3mG+szKbGp3NHf/PZYgHXE4tXRLlfJLnHp3+XJFhIcG9fTFtrZBfluu/TBFMAAAAAAAeqqa/H0qyc5R6eKlclVWeo2xjRiupFkZ6n322bJERwU4QwTL0dMXF60pkLt55ZVTUnBPX6xztizQ+vO5roQiGAAAAAAAx3BVOXR42TIVZy1Wjd3uNSY0Lq653TEyOTnAGSLYOvPpixHW9pV62vtcV9L9v0IAAAAAAE7CcLtVsWGjSrJyVL56jdd2R5PFovgpZ6jP7EzFjh9Hu2MP1plPXxybmqCNu0pP+bn01N5+yKZzoQgGAAAAAOixagv2qyQ7RyWLl8hVccRrTPSwYUqaNVO9zzlboTZbYBOEz1Q46vXFqn3aYi9TnbNREVZLu/bu6uynL553xiD984udp7Q5vsVs0rlTBvoxq86BIhgAAAAAoEdprK5W6bLlKsnKUfXuPV5jQuNilTRzhpIyZypyYPcvDnRnR/fuylpT0KIw1J69uzr76YtxMeGaNXmgPl+5r83PzJocnE38A40iGAAAAACg2zM8Hh1Zv1GlOYub2h1drhYxJotF8WdMVtKsDMVNOI12Rz871ZVZ7VnJ5Y+9u7rC6Ys3XpauA6XVbcp1bGqCbrosPQBZBR9FMAAAAABAt1VXeECurBy5N+dqh6Paa0xUaqr6zJqp3tOmKTSm+7U7tlY8OmNMH63aeqjN148Wm05WjDrZ/VNdmdWRlVz+2LurK5y+aA0169Ebz2r1c5OaWiCDcXplMFEEAwAAAAB0K401NTq8/CuVZOXIsXOX15jQXr2UOHO6kjJnKmrwYL/m8+2ikMUcolBziBrdHrncnlP+fYTVorTkWEmG9hRWNheavn3NGmpWrbNRew9Uyu1pWTx667PtLXI90fV3Pt+ufr2jVVRWI7eXYtTJ7r/7xQ7NnJSsotIabd1b3urndezKrAd+fIZ+N291u1Zy+Wvvrq5y+qI11KzbrzhN114wUl+uKlCu/XCH9kLrDiiCAQAAAAC6PMPtVmXuFhVnZat85Wp5GhpaxJjMZsVNPl1JmRmKmzRBIRb//ZO4wlGvT1fs1ZerClRWWe/z93s7/a89JwKeCrdHKizxvpquLfcb3YYWrd7f5vG22Mv0ixeXnfCd344/diWXv/bu6mqnL8bZwnXl7OEBa8XszCiCAQAAAAC6rLqDB1WSlaOSnCVqKPO+WsjUt4/M49M1/vvfV3h8XJvffewKLkdtg2rqXDLJpLCwEDkb3F5/Xe9sVFWNK6Ctb91ZWwtgRx27kstfe3dx+mLXRREMAAAAANClNNbW6vDyFSrJzpFj+w6vMZaYGCXOmKbeM2dod+URVde5tWBtsbbu3d5c0PJ4pEa3W65Gj0ItZlnMJkkmuRobVV3rkusUVxEh+I5dyeWvvbs4fbHroggGAAAAAOj0DI9HlblbVJKdo7IVK722OyokRPGnT1JSZoZMI8foy3UHtPbTA7IXHvmmoFV0ghFanhaJrunoSi5/7t3F6YtdE0UwAAAAAECnVVd0SCXZOSrNWSxn6WGvMZGDBippVoYSZ0yXEWXTXxbkatEHWXJ7ApwsOoWjK7n8uXfXsacvLlpT0OIgAKlnnr7Y2VEEAwAAAAB0Ko21dSpb8bVKsnNUtXWb1xiLLVqJ06cpaVamooYOkclkktPl1q9e/ko79lUEOGN0JkdXcvl7766jpy9efe5wvfnxKuUXOxUaFqGI8NAee/piZ0cRDAAAAAAQdIbHo6qt21SSnaPDK1bKU+/lRMWQEMVNnKCkWRmKn3y6QkJDm28Vl9fo3ueWqKqGtsae7uhKrkDt3RVrs2r6mBhNHyOddtppMptZ9dVZUQQDAAAAAARNfXGxSnKWqCQ7R87iEq8xESnJ6jMrU4kzpqsmNEJfrNqnDa+tUnF5jWrrXapvcMtD6yPUciUXe3fhWBTBAAAAAAAB5a6vV9mKlSrJzlFl7havMeaoKCVOP0dJszIVnZaqhkaPXluQq0Wr97HXVw+SnBStwpLqNsd/eyXXsXt3Za0p8Noayd5dPQdFMAAAAACA3xmGoapt25vaHZevaLXdMfa08eozK0PxZ0xWSFiYKhz1eueLHfp4aZ5q6xsDnziCZmxqgh788Rl6ct7qDq3kOrp317UXjNSXqwqUaz+sOmejIqwW9u7qYSiCAQAAAAD8xlla2tTumJWj+kOHvMZEDOivpFmZSpw5XdaEBElNe3z9/s0V2rO/MpDpIgBGD4nXgMRo5azb36aVWb5ayRVnC9eVs4frytnDffr1oOugCAYAAAAA8Cm306myr1epJCu7qd3RaFm4MEdFqvc556jPrAxFDx8mk8kkqan49eS81co7UBXotHES5hCpX+9oFZXVyO2lGHWy+98uVv3wolFtWpnFSi74CkUwAAAAAECHGYYhx46dKsnK0eHlX8ldV9cyyGRS7PhxTac7TjlDZqtVklThqNenK/bqvyvydaS6IcCZd3/mEGnogFhFhltU3+BuLh6dMaaPVm8tblFUau360WJThaP+hMWok90/6lRXZrGSCx1FEQwAAAAA0G7Ow2UqyVmskuwc1R8s8hoT3r+fkjIzZJ18pj7dekRfLT+oyv9+qQZX06mOLdcMdW9xNqsG9rXJ7TbkcntkMYco1BKixkZPm34fYbUoLTlWkrSn8EhzocnbtZOtlBrcr5fXolJr15vyP3EximIVOiuKYAAAAACAU+J2OlW+ao1KsrJ1ZNNm7+2OERHqfc7ZSpqVodqkZP3u72uUt3JtELLtHBJ6hev8MwfpgrMG07oHBAlFMAAAAADASRmGoepdu1WclaPDy5fLXVPbMshkUq/0sYqaeo6WNiTor1tKVfr6TnmMnYFP2A8irBb1ig6TNcyshga3JJPCwkK8/joywiJbZBh7VgGdCEUwAAAAAECrnGXlKl28RCXZOaorPOA1JrxvH9nOnqavzclauOWI6hfVSKoJbKLtEBFmVni4RY2NHoVazLKYTZJManS75Wr0yBpmUd/4SE0YkUQhC+gGKIIBAAAAAI7jaWhQ+eo1KsnOUcWGTZLH0yLGZLXqyKDRWmpK1tbGWGmTSVJ5wHM9VZHhFl02I5W2RKAHoggGAAAAAGhqd9xjbzrdcdlyNVZXe42LGDlKi43+Wu5KkssT2nTRFMBEO2D25BTd+r3xCgs1BzsVAEFAEQwAAAAAerCGigqVLl6qkuwc1Rbs9xpzxBKtLbahyo1JVWWjreliSACT7KB+caG6cnqCMs4eL7OZAhjQU1EEAwAAAIAexuNyqXzN2qZ2x3UbvLY7Npgs2hk9ULm2NBVE9JFMXWS51zGGpcTq/34wUQf37Qp2KgA6AYpgAAAAANADGIahmry9KsnKUcmSpXK30u64PzxJm2PStDN6kBpCQgOcZfuFhJgUZ7OqX0LUcRvZu91uHdwX7OwAdAYUwQAAAACgG2s4UqnSJUtVkpWt2n0FXmMqLVHaYktVrm2ojoTFBDjDjjGbTZo9eaBuuiydvb4AnBBFMAAAAADoZjwulyrWrW9qd1y7Xobb3SLGZTJrZ/Qg5dpStS+ib5dqd7SGmZU6oJcmjezTvOILAE6GIhgAAAAAdBM1e/NVnJWj0iVL1VhV5TWmMDxRm21N7Y5Oc1iAM+yYcKtZz949Q8lJtmCnAqALoggGAAAAAF2Yq6pKpUuWqSQrRzV793qNqTJHaktMqnJtqaroYu2OUtMitRkTknXHlafR8gig3SiCAQAAAEAX42ls1JH1G1SclaOKtetkNDa2jDFbtD0iWbkxadoX0VeGKSQImbYfLY8AfI0iGAAAAAB0ETX7ClSSla3SxUvlqqz0GmNNTdUiVz+tNSd3mXZHi9mkUItZsdFWnT2+vy6dPpSiFwCfowgGAAAAAJ2Yy+HQ4aXLVJy1WDV2u9eY0Lg4RZ01Vf8ojtGWylCpC9S+aHEEEGgUwU7B3r17NXfuXK1bt05lZWXq27evLrzwQt18882KjIwMdnoAAAAAugnD7VbFho0qycpR+eo13tsdQ8zK7zVI6yOHyB7eT8auzt3uGGIyKdYWpv69ozVhRBItjgACjiJYG23evFnXXXedamtrNW7cOKWnp2v9+vV65ZVXlJOTo3feeUfR0dHBThMAAABAF1ZbsF8l2TkqWbxEroojXmMOWhOUG5Oq7dFDVG+2BjbBUxRhtejCswbrspmpFLwABB1FsDZobGzUvffeq9raWj3xxBOaM2eOJKm+vl733HOPsrOz9ac//UmPPPJIkDMFAAAA0NU0VlerdNlylWQtVvXu3V5jqs3h2mobqlxbmg5bYwOb4ClKjI3QjInJ7OsFoNOhCNYG//nPf7R//36dddZZzQUwSQoPD9eTTz6pzMxMvf/++7rrrrvUq1evIGYKAAAAoCsw3G4d2bRZJVk5Klu1WobL1SLGrRDtjmo63TEvsn+nP91x+oQBuuuqCezvBaDTogjWBtnZ2ZKkc889t8W9uLg4TZkyRTk5OVq2bJkuvvjiQKcHAAAAoIuoLTygkuwcleYsUUN5udeYQ9Z4bbalaZttsOrNnWcllemb/2Nq+pXMZpPibOGaPmEAq74AdAkUwdpg165dkqQRI0Z4vZ+WlqacnBzt2LGDIhgAAACA4zTW1Ojw8q9UkrVYjp07vcbUmMO1NXqIcmPSVGqNC3CGJ8YKLwDdBUWwNigpKZEk9enTx+v9pKSk4+L8wTAMud1uv72/pzv2s+Vzhq8xv+BvzDH4G3MM/tRd55fh9ujg6vXa/K9PZcvfLovR8mtzyyR7VLI2x6QpL3KAPJ2k3dFiNik+JlzTThugS84Zolhb0+b7XfX7013nGDoP5ljgGIbRoecpgrVBbW2tpKY9wLw5ev1onD/U1dVp48aNfns//ic3NzfYKaAbY37B35hj8DfmGPypO8wvT1m5atZuknP9JkW7auVtTVdxWJxyY9K01TZEdZ2o3XHswAh956x4hZpN31ypV759e1Bz8rXuMMfQuTHHOjeKYG1gNpvl8XhkMplOGNfRiiQAAACArsdwOuXetl3OdZtkPnhAoZJCvxVTG2JtOt0xJlUl1vhgpNmq6PAQXX9+kuKi+OchgO6Nv+XaICoqSkeOHFFdXZ3X+/X19ZKkiIgIv+UQERHR6p5k6Di3291csU9PT5fZzH4H8B3mF/yNOQZ/Y47Bn7rq/DI8HlVt3ab8hV+oet1aWTyN+nbmHplkjxqgXFua9kQNkMfU+b62/olReu7u6d16v6+uOsfQdTDHAmfnzp2t1mbagiJYGyQlJenIkSMqLS1VSkpKi/tH9wI7ujeYP5hMJv4gBYjZbOazht8wv+BvzDH4G3MM/tQV5lf9oUMqyV6sQ1k5ch0+LKnlP6pKwmKVa2tqd6y1+O8H5R01YmCsnrztnG5dAPu2rjDH0LUxx/zrZB16J0MRrA1GjBihXbt2ac+ePZo4cWKL+3v27GmOAwAAANC9uOvqdHjF1yrJylHV1m1eY+pCwrTNNkSbbWkqtsZLHfyHmj+ZTNLsyQN1y+XjelQBDAAogrXBjBkz9Mknn+jzzz/XlVdeedy9iooKrVq1SqGhoTr77LODlCEAAAAAXyqvrNV/3v5S9atWKK0yX2FGY4sYj0zKi+yv3Jg07YlKlrsTtjseKzzMrIumDtFlM1MVZ+s8G/IDQKBQBGuDc889V/3799fy5cv19ttv69prr5XUtBfYQw89pNraWl199dXq3bt3kDMFAAAA0B75RZV68f2NKrYXaqzDrvQqu4Y2VnuNPRzaS5tjUrXVNlQ1lsgAZ3rqBveL0cM/naKk+M6fKwD4E0WwNggPD9fvf/973XTTTXrsscf073//W8nJydqwYYNKSko0evRo/fznPw92mgAAAABOosJRr/cW7VT2mv2qc7olSaEel0ZUF2iSw65BdYe8PlcfEqZt0YOVG5OmImtCp293TIyN0PQJybp0+lBWfQHANyiCtdGUKVM0f/58vfTSS1q9erX27Nmj5ORkzZkzR9dff72io6ODnSIAAACAVuwqKNejr30tR903bY2GoeT6EqVX2TWyOl/WVtod90b2U64tVbujBsod0jnbHS1mk+JjIjR9wgCKXgBwAhTBTsHw4cP1wgsvBDsNAAAAACdxdMXXolX75HQZzddjXNUa68hTusOuOJfD67NloTHKjUnVFluqqjthu2NibIRmTGSVFwCcKopgAAAAALoNp8utuf/aoJy1B5qvWTyNGl5ToPQquwbXFclbI2N9SKi2f9PueNDau9O1O8barHrkp1M0bGBcsFMBgC6LIhgAAACALu3oqq+s1QWqb/A0XTQMDagvVbqjqd0x3ONq8ZwhKT+inzbHpGl3VIoaQzrXP484zREAfKtz/S0PAAAAAG3kdLn1hzfXaM224uZrtsYajalqandMcFV5fa481KZcW5q22IbKERoVqHTbjNMcAcA/KIIBAAAA6FIqHPWat3CLsr9pebR4GjWsZr/SHXYNri1SiIwWzzhNodphG6TNtjQdCE/sVO2OISaT4ntZNXNiCvt8AYAfUQQDAAAA0GnlF1Xqxfc3anfBkeNLW4ahfs7DSq+ya3T1Xq/tjpKUH9FXuTFp2hWVIldIaEByPpHpEwborqsmKCy0c540CQDdGUUwAAAAAJ1KflGlnn13vfIOtGxnjG6s1RhHntKr7OrtqvT6fIUlWrkxTe2OVaHR/k73pMwhJv2/c4ZoTuYwVnkBQBBRBAMAAADQKRQWO/R/Ly1TndNz3HWzx6202v0aV2XXkNqDXtsdG0wW7YgepNyYNO0PT+oU7Y4jB8fpZ3PGa3C/XsFOBQAgimAAAAAAAqjV9kZJUuH/fmkY6ussU7rDrtGOvYrwNHh9376IPsq1pWln9MBO0e4oSTGRoXr1gdmKjgwLdioAgGNQBAMAAADgF0cLXrsKjrT5majGuqZ2R4ddiQ3en6u0RCnXlqrcmFRVhtp8k6yPsOcXAHReFMEAAAAA+ESFo17vLdqpRav2yelquc6rNSGGW8NqCpVeZdfQ2gOttjvujB6oXFuaCiL6dIp2R4mTHQGgK6EIBgAAAKBDistr9MhrK3SwtLbtDxmG+jjLm9sdIz1Or2H7w5OUG5OqHdGD1RCkdsdQS4iGD4zTLZens78XAHRhFMEAAAAAnJIKR73e/HSbctbsl7vtC74kSZGNdRpTvVfpVXYlNVR4jam0RGqLLVW5tlQdCYvxQcZtZ5IUGRGqjEnJunL2cFZ2AUA3QhEMAAAAQJus23FIj7++So2ek8ceK8TwKLWmUOkOu1JrCmX20u7oMpm1M2qgcmPStC+ib8DaHWMiw/TojWdq2MC4gIwHAAgeimAAAAAAWlXhqNe8hVuUvfbAKT+b5CxXepVdo6v3Kspd7zWmMDxRubamdkenOXCnKcbHWPXUHdOVFB8ZsDEBAMFFEQwAAABAC+3a50tShLteox17le6wq6+z3GtMlTlSW2KGKteWpopAtzuapNmTB+qWy8dxgiMA9DAUwQAAAAA0n+yYtbpA9Q2n1u8YYng0tPaA0qvsSqsplFktn280hWhX1EBt/qbd0TCF+Cr1k+dnkuJ7hXOCIwD0cBTBAAAAgB6svSu+JKm3s0LpDrvGOPIU3Uq74wFrb+XGpGl7gNsde8dG6MX7Zio6MnBjAgA6t4AVwYqLi/XFF1/I7XZr2rRpSk1NDdTQAAAAAL6lvZvch7udze2O/ZxlXmMc5ghtsQ3VlphUlYXFdjzZU8BG9wCA1vi8CLZjxw4988wzSktL0y9+8QtJ0rp163TDDTeovr7pp0N//OMfdd999+n666/39fAAAAAAWpFfVKk//GONCg/VnNJzJsOjIbUHle6wa1j1flm8tTsqRLujU5RrS9PeyH4Ba3c0SYqMCFXGpGRdOXs4rY4AgFb5tAh24MAB/eAHP1BNTY1Mxxxp/Jvf/EZ1dXWKjo5Wv379tHv3bj399NOaNGmSTjvtNF+mAAAAAOAbFY56vfnpNmWv3u+lbHVyCQ1HlF7V1O5oc9d5jSmyJmhzTKq2Rw9RvdnasYTbIHVAL9199QQN7tfL72MBALoXnxbB5s2bp+rqak2YMEF33nmnpKaVYbt27VJoaKj+/e9/a9CgQXr77bf129/+Vv/4xz8oggEAAAA+VOGo1xsLtyhn7YF2PW91OzW6Ol/pVXb1dx72GlNtDtdW21Dl2lJ12BqYtsMzRvfRL340mRMdAQDt5tMi2IoVK2S1WjV37lzFx8dLkpYuXSpJOvPMMzVo0CBJ0jXXXKOXXnpJ69at8+XwAAAAQI+0eU+pnnl7ncqrnO163mR4NLi2SOkOu4bXFMhitFw35laIdkclKzcmTXsj+8sTgHbHyHCLMk9Poc0RAOATPi2CFRUVafDgwc0FMEn66quvZDKZdNZZZzVfM5lM6t+/v3bt2uXL4QEAAIAexV5YoXueWyrDaN/z8Q2VSq+ya6zD3mq74yFrvHJtqdpqG6J6s28LUSEmk4al9FLmmDD1iQvTaaedJrOZlV4AAP/waRHs2H3AJMnpdGrDhg2SpDPOOOO4ew6HQxZLwA6nBAAAALq8Cke93lu0U4tW7ZPT1b7Kl9XdoJHV+Up32JVcX+o1psYcrq3RQ5Qbk6ZSH7Y7DkuJ1Z1XnXbcfl5ut1sbN2702RgAALTGp1Wo5ORk7d+/X3V1dYqIiNDy5cvV0NCguLg4jR07tjkuLy9PhYWFSktL8+XwAAAAQLeyeU+pnv7HOlU42tfmeJTJ8GhQ3SGlVzW1O4Ya7hYxbplkj0pWri1V9qhkn7U7xkSG6dEbz9SwgYHZOwwAgNb4tAg2efJk7dy5Uw8++KAuvvhiPf300zKZTDr33HObY7Zu3aoHHnhAhmFo+vTpvhweAAAA6PIqHPWat3CLstu5sf2x4hqqNNbR1O7Yq7HWa0xJWJw2x6RqW/QQ1VoiOjymJEVaLcqczF5eAIDOxadFsBtvvFGffvqp/vvf/+q///2vDMNQVFSUbrrpJklNG+dff/31MgxD/fv3109/+lNfDg8AAAB0Wet2HNLjf1ulxpaLtE5JmKdBI6v3Kb3KrpT6Eq8xtSFWbbMN0eaYNJVY473GnAqTpPPOHKRrLxhJ0QsA0Gn5tAjWp08fvffee/rTn/6knTt3atCgQbrrrruUnJwsSRo0aJBCQkI0Y8YM/eY3vzluA30AAACgp6hw1OvNT7cpZ81+udu5qf1xDKOp3dFh1/DqAoUZjS1CPDLJHjlAuTFp2hM1QB5TxzegD7WE6PFbpmr0kIQOvwsAAH/z+c70KSkpevbZZ73eGzBggL766ivFxsb6elgAAACg08ovqtSz765X3oEqn763l8uh9Cq70h129Wqs8RpTGharXFuqttiG+qzdMSYyVI/eeBb7fAEAupSAH89IAQwAAADdlc9XeHkR6nE1tzsOrC/2GlMXEtbU7mhLU7E1XvrWKe7tGtcSopkTk/XDi0bR8ggA6JL8UgRraGjQBx98oJycHOXl5cnhcGjlypUqLy/XU089peuvv56TIQEAANAtVDjq9cbCLcrxwUb2rTIMpdQXa1yVXSOq97Xa7pgX2f+bdsdkuWl3BADgOD4vgu3du1e33nqr9u3bJ8No+vGX6ZufPB08eFAffvihPv30Uz3zzDOaPXu2r4cHAAAA/G7znlI99dZaHalu8Os4vVzVGuuwK73KrtjGaq8xh0N7aXNMqrbahqrGEumTcYelxOrOq07T4H69fPI+AAA6A58WwRwOh66//nodPHhQ/fv31/nnn6+srCzt379fkmSz2TR06FDl5eXp7rvv1gcffKDhw4f7MgUAAADAb5ZtLNQf31rn1zFCPS4Nry7QOIddg+oOeY2pDwnTtujByo1JU5E1wSftjoP72XTftZMofAEAui2fFsHmzZungwcPaubMmXr++edltVq1adOm5iLYoEGD9Mknn+iuu+7SokWL9MYbb+h3v/udL1MAAAAAfOboHl+LVu/370CGoeT6EqVX2TWyOl/WVtod90b2U64tVbujBsod0vF2x4Re4br3mokal5bY4XcBANDZ+bQI9sUXX8hiseiJJ56Q1Wr1GmM2m/XYY49p6dKlWrVqlS+HBwAAAHxiV0G5Hn7lK9U6PX4dJ8ZVrbGOPI112BXvcniNKQuNUW5MqrbYUlXdwXZHk0nKnJSi6y4ezeb2AIAex6dFsMLCQg0bNkwJCSfeODM+Pl5DhgxRXl6eL4cHAAAAOmRrXqkemLtCfjrYUZJk8TRqeE2B0qvsGlxXJG+NjPUhodoePVi5tjQdDO/doXZHi9mkjEkpnOoIAOjxfFoEM5lMqqura1Osx+NRWFiYL4cHAAAA2mVrXql+OXeF/wYwDA2oL1W6o6ndMdzjahkiKT+in3JjUrUraqAaQzr2n+rj03rrkRvOVFhox9smAQDoDnxaBBs0aJB2796t0tJSJSa2vq9AUVGR7Ha7Ro4c6cvhAQAAgDbbvKdUf3xzjSprWhakfCW6sVZjq+xKd9iV4KryGlMealOurand0REa1aHxWPUFAEDrfFoEmz17trZv367HHntML7zwgkxelm03NDTooYcekmEYyszM9OXwAAAAQKvyiyr17LvrlXfAezHKV8wed1O7o8OuwbVFCvHSXOk0WbTDNli5tlQVhie1u93RZJJSB/TSXd+fwKmOAACchE+LYNddd53+/e9/a9GiRbriiit00UUXqaysTJK0ZMkS7d69W/Pnz9e+ffuUmJioH/7wh74cHgAAAJD0v1Mds1fvl3+3tv+GYaif87DSq+waXZ2vcE+D17D8iL7KtaVqV/RAuUJCT3mYkBCTHvzxZE0Z06+jGQMA0OP4tAgWHR2tv/zlL7r11lu1ZcsWbd26tfneLbfcIkkyDEOJiYl6+eWX1atX1/lp1a5du/TXv/5Vq1ev1uHDhxUeHq5Ro0bpqquu0sUXXxzs9AAAAHq8/KJKPfPOOuUf9H7Koj9EN9ZqjCNP6VV29XZVeo05YoluPt2xMjS6XeMM7mfTfddOYrUXAAAd4NMimCSlpqbqo48+0vvvv69FixZp9+7dqq6uVkREhIYMGaKMjAxde+21iomJ8fXQfpOdna0777xTLpdLgwYN0vTp01VWVqa1a9dq9erVWrlypR5//PFgpwkAANDjVDjq9dePc7V0/cGAjWk23Eqr2a/0KruG1h702u7YYLJoR/Qg5cakan94n3a1O/aODdc9V0/UuLTW99oFAABt5/MimCRFRETouuuu03XXXeeP1weUw+HQAw88IJfLpfvvv18//elPm/c627Rpk66//nrNnz9fU6dO1UUXXRTkbAEAAHoGp8utx/6yUpvthwMzoGGor7NM6Q67Rjv2KqKVdseC8D7aHJOmnafY7miSlJrM3l4AAPiTX4pg3cmXX36pI0eO6IwzztD1119/3L3x48frlltu0VNPPaWPP/6YIhgAAIAfBGpDe2+iGus0xpGnsQ67khqOeI2ptEQp15aq3JhUVYba2vTeCKtFsyan6MrZwznFEQCAAPFpEWzBggWn/Mxll13myxR8zuVyacyYMZo5c6bX+0OHDpUklZSUBDArAACA7q3CUa+5/96kVbmHAj52iOFWWk2h0qvsSq094LXd0WUya2f0IG22pakg4sTtjkP6x+jeayaywgsAgCDzaRHsl7/8ZXOr4MkYhiGTydTpi2BXXXWVrrrqqlbvb9q0SZLUt2/fQKUEAADQLQVjY/tmhqE+DeVNpzs69irS4/Qatj88SbkxqdoRPUgNIWFeY2htBACgc/JpEax///6t3qurq5PD4VBjY6NMJpNmzZqlyMhIXw4fcMXFxXrrrbckye+tkIZhyO12+3WMnuzYz5bPGb7G/IK/Mcfgb/6cY0ccTr3+yVYt2xi4je2PFdlYp9HVezWuyq6khgqvMZWWSG2xpSrXlqojYa0f7nT/NRM09bQBx13jz+TJ8XcY/I05Bn9jjgWOYbRcnX0qTEZH33AKnE6nsrKy9Nvf/lYpKSl6++23FRra9g1DfeHmm2/W4sWL2xSblZWl5ORkr/ccDod+/OMfa8uWLZo8ebLeeuutNq+COxXbt29XbW2tz98LAAAQLHsP1Wv+V4dV632xld+FGB6l1hQq3WFXak2hzK21O0YNVG5Mqgoi+sowhXh9V3R4iL43NV5D+rKvFwAAgRIZGalRo0ad8nMB3RjfarXqoosuUkxMjG644Qa9/vrruuWWWwKZghISEjRgwICTB0qyWLx/PGVlZbrxxhu1detWJScn67nnnvNLAQwAAKA7qaxx6/mPiuQJ0viJzgqNq9qj0dV7FeWu9xpTGJ6oXFuqdkQPltPsvd0xJET68azeGphI4QsAgK4koCvBjpWZmamIiAj95z//Ccbw7bZr1y7deuutKiws1JAhQ/TGG2+oX79+fhvv6EqwiIgIjRgxwm/j9HRut1u5ubmSpPT0dJnN5iBnhO6E+QV/Y47B3zoyx3L3HNaf3tmgiurgLPuKcNdrtGOv0h129XWWe42pMkdqS8xQbbGlqjys9T28osMtevSmM5WWHOunbHsm/g6DvzHH4G/MscDZuXOn6urqusZKsGPFxsbKbrcHa/h2WbJkie655x7V1NRo4sSJ+vOf/6y4uLiAjG0ymfiDFCBms5nPGn7D/IK/Mcfgb22ZY5v3lOoPf1+tqtrGAGV1vBDDo6G1B5ReZVdaTaHMXtaeNZpCtCtqoHJtqcqP7Ndqu6Mk9Y2P1BO3nq2k+K69n21XwN9h8DfmGPyNOeZfHe3CC0oRrKSkRHv27FFUVFQwhm+X9957T7/5zW/kdrt16aWX6oknnlBYmPcl8gAAAD3F5j2l+uOba1VZ0xDsVNTbWaF0h11jHHmKbqXd8YC1t3JjUrU9erCcZmur77KYTcqYlKIfXjRKcTbaHgEA6A58WgTbv39/q/cMw1BDQ4Py8vL04osvyuVy6fTTT/fl8H6zYMEC/frXv5ZhGLrjjjt0++23BzslAACAoNhXVKXn39+ovANVwU5FkhTudja3O/ZzlnmNcZgjtNU2VLkxqSoLi231XbHRYfq/H56ucWmJfsoWAAAEk0+LYOedd16b4gzDkMVi0Y033ujL4f0iLy+PAhgAAOixKhz1+vvCrcpaW/jNlcITxgeCyfBoSO1BpTvsGla9XxZv7Y4K0e7oFOXa0rS3lXZHVnsBANCz+LQI1pY99k0mk8aMGaO7775b48aN8+XwfjF37lzV19crNDRUe/fu1c9//nOvcf369dN9990X4OwAAAD8w+ly66l/rNOqLUXBTqVZQsMRpVc1tTva3HVeY4qsCcq1pWqbbYjqv9XuOKR/jO69ZqIG92t983sAANB9+bQIlpWVdeLBLBbFxsbKam19/4XOZvHixZIkl8ulhQsXtho3bNgwimAAAKBb2F9cpdv/mONlfVXgWd1OjarO17gqu/o7D3uNqTGHa4ttqHJtqTpsPf7QIgpfAADgKJ8WwQYMGODL13UK69atC3YKAAAAflfhqNcrH27Wik3BX/llMjwaXFukdIddw2sKZDFaluPcCtGeqGRtjknT3sj+8nyr3fHRG87QpFH9ApUyAADoAoJyOiQAAACCrzMVviQpvqFSYx12ja3KU4y71mvMIWt8c7tjnfn4fbwirGbd/f0Jmjqu+/1gFgAAdFy7i2DPP/+8TxK46667fPIeAAAAnNzmPaX6w9/XqKrWFexUJElWd4NGVucr3WFXcn2p15gac7i2Rg/RlphUlVjjJUkzJyXrp5eMYUN7AADQZu0ugr388ssymUztHtgwDJlMJopgAAAAflLhqNebn25Tzpr9cp/8/KKAMRkeDaw7pHFVTe2OoYa7RYxbJtmjkpVrS5U9aoA8JrOG9I/Ri+zvBQAA2qndRbDJkyf7Mg8AAAD4SHF5jX718nIdKq8PdirHiW2oUrrDrrEOu3o1em93LAmL0+aYVG2LHqJaS4QG97Pp+WsnUfgCAAAd1u4i2FtvveXLPAAAANABFY56vbFwi3LWHgh2KscJ87ia2h2r7EqpL/EaUxti1TbbEOXGpKo4LF7xvcL10LWTNC4tMcDZAgCA7oyN8QEAALqw4vIaPTB3mUqPOIOdyv8YhgbWFWucY4+GVxcozGhsEeKRSfbIAcqNSZU9Klkym/Xs3TM0ZEBs4PMFAAA9QtCKYDU1NcrJydHFF18crBQAAAC6LKfLrUdeXqFt+8qDnUqzXi6H0qvsSnfY1auxxmtMaViscm2p2mobqhpLhGJtVj32A1Z9AQAA//N5EWzHjh165ZVXtGvXLtXX18vj8Rx3v7GxUfX19aqpqZHJZKIIBgAA0EZHN7pftHp/sFNpFupxaWT1PqVX2TWwvthrTF1IWFO7oy1VR2xJuueaiXp43IAAZwoAAHo6nxbB8vPzdfXVV6u+vl6GcfIjiPr16+fL4QEAALqlplVfX2nbvopgp9LEMJRSX6z0KrtGVu9rtd0xL7K/cmNSdSBusO645nTdSeELAAAEkU+LYG+88Ybq6uqUmJioq6++WuHh4frjH/+o6dOn69xzz9WhQ4e0cOFC7du3T2effbZef/11Xw4PAADQ7XyxMl8vzt8U7DQkSb1c1RrrsGtslV1xjdVeYyqsvdRndqbGfe8iTUuID3CGAAAArfNpEWzlypUymUx6+eWXNXbsWEnS3/72N1VVVemKK66QJN1444264YYbtGLFCi1dulTTp0/3ZQoAAABdXoWjXq8u2KyvNhYFOxWFelwaXl2gdIddg+sOeY1pDLUqcfo5Sjl/tqKHD5PJZApwlgAAACfn0yJYSUmJ+vXr11wAk6RRo0Zp1apVcrvdMpvNCg8P16OPPqqLL75Y7733HkUwAACAbzhdbj31j3VatSXIxS/DUHJ9idIddo107JPVcLUMkRQzbpz6nTdbCVMmKyQsLPB5AgAAnAKfFsHcbrcSEhKOuzZ48GAtX75c+fn5Sk1NlSSlpaUpOTlZW7Zs8eXwAAAAXdb+4ird/lSOPCffVtVvYlzVGuPIU7rDrniXw2tMeWiM+p83S2Mvv1DW3gleYwAAADojnxbBYmNjVVFx/IatKSkpkqQ9e/Y0F8GOxu7cudOXwwMAAHQ5uwrK9dCfl6m+5WKrgLB4GjW8pkDpVXYNriuSt0bG+pBQ7YsfogEzT9eFV39HFovPDxgHAADwO5/+F8zo0aO1ZMkSbd26VWPGjJHUtBLMMAxt2rRJ559/vqSmFWMHDhxQZGSkL4cHAADoEvKLKvXU22tVUOR9c3m/Mwz1rz+scY49Glmdr3CP93bH4tgUjbr8QqWdO02x27dLEvt9AQCALsunRbALLrhAixcv1o033qjbb79d3//+9zVx4kRFRETo3XffVUZGhkaPHq25c+eqoqJC48aN8+XwAAAAndrWvFI9OHeFPEEaP7qxVmMddqVX2ZXgqvIaUx3eS/3Oy9SIS8+XNTFRUtMPMAEAALo6nxbBLrnkEn3wwQdavXq1nnjiCV111VWKjo7Wd7/7Xb3zzjv60Y9+1BxrMpmaT4wEAADobioc9Xrz023KWbNf7iDu82X2uDWspkDjHHYNri1SiLwkY7Uqado56jMrQ7ZRI1ntBQAAuqV2F8GWLVumadOmHXfNbDbrL3/5i1577TV9/fXXMpvNkqT77rtPe/bs0erVq5tjL7roIs2ZM6e9wwMAAHRKTpdbj/1lpTbbDwcvCcNQP+dhpVfZNbo6X+GeBq9hvcalKylzphLOOlPm8PAAJwkAABBY7S6C3Xjjjerfv78uv/xyXX755erfv78kyWq16o477tAdd9zRHBsVFaU333xTmzZtUmFhoYYOHapRo0Z1PHsAAIBOYvOeUv1+3io56oLXOhjVWKuxjjylV9nV21XpNcbaJ0lJmRlKypip8D5JgU0QAAAgiDrUDnnw4EHNnTtXf/7znzV16lTNmTNHs2fPbvXEoPHjx2v8+PEdGRIAAKDTqHDU69UFm/XVxqKg5WA23Eqr2a/0KruG1h702u4YEh6u3lPPUtKsDMWMHiVTSEgQMgUAAAiudhfBsrKy9OGHH+qTTz7Rvn37tHz5cn311VeKjY3VZZddpjlz5ig1NdWXuQIAAATV0X2+slfvD9rm9pIkw1BfZ5nSHXaNduxVRCvtjjFjxygpc6Z6Tz1L5oiIACcJAADQubS7CDZgwADdfvvtuv3227V+/Xp9+OGH+vzzz1VRUaF58+Zp3rx5Ou200zRnzhxddNFFiuA/vAAAQBe1bsch/fb1VXIHtfIlRTXWaYwjT2MddiU1HPEeFBuvlPNnKTFjpiL69Q1kegAAAJ2aT06HnDhxoiZOnKiHH35YixYt0oIFC7RixQpt2LBBGzdu1JNPPqn/9//+n+bMmaNx48b5YkgAAAC/sxdW6O5nlwY1hxDDrbSaQqVX2ZVae8D76Y6hoUo8e6qSZmWo19gxtDsCAAB44ZMi2FFhYWG66KKLdNFFF6msrEwff/yxPvzwQ+3atUvvv/++5s+fr2HDhmnOnDm69NJLFRsb68vhAQAAOqzCUa83Fm5RztoDQc2jj7Os6XRHx15FepxeY4yUIRr2nQuUcPZUWSIjA5whAABA1+LTItixEhIS9JOf/EQ/+clPtGPHDn344Yf69NNPtWvXLv3ud7/T008/rXPPPVfPPPOMv1IAAABok85S+Ipw12vMN6c79mmo8BpTZYlU2Olnaup131XEN6dzAwAA4OT8VgQ71siRI/XAAw/ogQce0Lp16/Tmm2/q888/16effkoRDAAABI3T5dZT/1inVVuCd7pjiOFRak2h0h12pdYUyuyl3dFlMmtX1EDl9x2pB37zA9miw4OQKQAAQNcWkCKYJBUVFenTTz/Vl19+qc2bNwdqWAAAAK/2F1fpjqdy5PayxVYgJDorlF61R2Oq9yrKXe81pjA8Ubm2VO2KGaJH78jQTUMSApwlAABA9+HXIlhlZaX++9//6pNPPtH69etlGIYMw1BiYqIuu+wyfe973/Pn8AAAAC3sKijXr15errqGwFe/Itz1Gu3Yq3SHXX2d5V5jqsyR2hIzVFtsqWrolaDHbpqqYQPjApwpAABA9+PzIlhDQ4OysrL0ySefaNmyZWpsbJRhGLJYLJoxY4a+973vacaMGTKbzb4eGgAAoFX7i6t0959y1NAY2HFNhkdDaw9qXNUepdUUyixPi5hGU4h2RQ1Uri1V+ZH9dM5pyXruu+mKs9H2CAAA4Cs+KYIZhqGVK1fq448/1pdffqmamhoZRtNPV4cOHarLL79c3/3ud5WQwBJ+AAAQWMXlNXpw7lKVHGkI6Li9nUeU7tijMY48RbfS7njQ2lubY1K1PXqwYhNj9eSt5ygpnlMeAQAA/KFDRbCtW7fqk08+0X/+8x8dPnxYUlNBLDIyUhdccIHmzJmjiRMn+iRRAACAUxGMtsdwt1OjqvdqXJVd/ZxlXmOqzRHaYhuq3JhUVVhjNe20AfrLd8ay6gsAAMDP2l0Eu+iii7R3715Jal71ddppp2nOnDm66KKLFBnJTzEBAEBgVTjq9dePc7V0/cGAjWkyPBpSe1DpDruGVe+XxVu7o0K0OzpFubZUJUw4Tb/86ZkKC2VrCAAAgEBqdxEsLy9PktS7d29deumlmjNnjoYOHeqzxAAAAE6kwlGvNz/dppw1+4NywmNCwxGlV9k1xpEnm7vOa0yRNaHpdMfYITrrjGF69KJRrPgCAAAIknYXwWbOnKk5c+YoIyODTe4BAEDAOF1uvfD++oCu9jrK6m7QqOq9Sq+ya4DzsNeYGnO4ttiGamtMqm665XzNGdMvwFkCAADAm3YXwV555RVf5gEAAHBC+UWVeuaddco/6AjouCbDo8G1RUp32DW8pkAWo2W7o1sh2hOVrNyYVLmHjtS9P5yse/v1CmieAAAAODGfnA4JAADgD/lFlXr23fXKO1AV8LHjGqqU7tijsVV5inHXeo05ZI1XYf/RuvhnV2j6sOQAZwgAAIBTQREMAAB0Oiu3HNQTb6wJ+LhWd4NGVucr3WFXcn2p15jaEKu22oZqX7/R+u2v5yg6MizAWQIAAKA9KIIBAIBO43BlnW58/As1tuw49B/D0KC6IqVX2TWipkChhrtFiFsm2aOSlWtLlSdtlO7+wWQNpt0RAACgS6EIBgAAOoUVmwv1u7+vC9h4sQ1VSnfYNdZhV69G7+2OJWGxyo1JU+XQdN3x02n6CYUvAACALosiGAAACKqq2gbd9VSWDlc1+H2sMI+rqd2xyq6U+hKvMXUhYdpqG6rcmFQ19u6vl+7PpOURAACgG6AIBgAAgqLCUa9XF2zWVxuL/DuQYWhgXbHSHXs0orpAYUZjixCPTMqLHKDcmFTtiUqWyWLRE7eerdFDEvybGwAAAAKGIlg75eTk6JZbbtEZZ5yht956K9jpAADQJVQ46vXGwi3KWXvA72P1cjmUXmXXWEeeYhurvcaUhsUq15aqrbahqrFEKCrcoqdunqphA+P8nh8AAAACq91FsP379/skgZSUFJ+8J5BKS0v14IMPBjsNAAC6DKfLrd/NW611O7y3IPpKqMelkdX7lF5l18D6Yq8xdSFh2mYbolxbqg5ZEySTSeFhZr18zwwlJ9n8mh8AAACCp91FsPPOO6/Dg5tMJm3btq3D7wkkwzD0i1/8QuXl5cFOBQCALmHjrkN6+NVV/hvAMJRSX6L0qj0aWb2v1XbHvZH9tTkmVXsiU+QOMUuSLGYTbY8AAAA9RLuLYIZhtCnOZDIpPDxcLpdLjY3/+49Ss9nc3qGD6m9/+5u++uornXHGGVq9enWw0wEAoFPavKdUf3xzjSprXH4bI8ZV3XS6Y5Vdca20Ox4O7aXcmKZ2x2pLZPP16IhQPXbTWbQ9AgAA9CDtLoJlZWW1uObxePTQQw9p9erVuvzyy3X11Vdr5MiRCg0NlSTl5eXp/fff11tvvaWZM2fqhRdeaH/mQbBt2zY9++yzmjp1qq655hqKYAAAHCMQG91bPI0aUb1P6Q67Btcd8hpTHxKqbdFDlBuTqiJrb8lkar43c1KyfnrJGMXZwv2WIwAAADqndhfBBgwY0OLa22+/rTVr1ui+++7TjTfe2OL+0KFD9ctf/lIDBw7Ub3/7W7322mu69dZb25tCQNXV1enee+9VVFSUfv/73ys3Nzeg4xuGIbfbHdAxe5JjP1s+Z/ga8wv+Fow5dsTh1FufbdeS9YVq9Ph5MMNQcn2J0h12jXTsk9VoubrMkLQ3op9yY9K0OypFjSFN/4kTYjJpWEov3fa9cRrUL6Y5nj+Lp4a/x+BPzC/4G3MM/sYcC5y2diW2xmR09A3HuOSSS1RWVqavvvpKpmN+6urNtGnTFBkZqc8//9xXw/vVr371K82fP18vvviizjvvPC1atEg/+9nP/H465Pbt21VbW+u39wMAcCpcjYb+saRY+4pb7rvlazZXjcY67Ep32BXvcniNKQuNaTrdMWaoHJYoSVKoWbrz0n6yRXTNrRcAAABwYpGRkRo1atQpP9fulWDeFBQUaPjw4SctgElS3759tWvXLl8O3yY333yzFi9e3KbYrKwsJScn64svvtD8+fP1ve99zycHAgAA0JVU17mVtfGINuyt8/tYFk+jhtcUKL3KrsF1RfL2XxROU6i22wYr15aqA+GJze2OMREh+u5Z8RrSl1ZHAAAAtOTTIlhcXJwKCgrU2Ngoi6X1V9fU1GjPnj3q3bu3L4dvk4SEBK+tnN5YLBYdOnRIDz/8sAYOHKiHHnrIz9m1LiIiQiNGjAja+N2d2+1ubnFNT0/vsgc3oHNifsHf/DXHSspr9fCrK1RcUe+T97XKMNS//rDSHXs0qjpf4R7v7Y75Ef2UG5OqXVED1RhikckkZU5K1o8uHKVYm9W/OfZw/D0Gf2J+wd+YY/A35ljg7Ny5U3V17f/BrE+LYJMmTdKnn36qP/3pT7r//vu9xhiGoccee0z19fU655xzfDl8mzz55JNtjvV4PLruuutUXV2t1157TVFRUX7M7MRMJhN/kALEbDbzWcNvmF/wt47MsQpHvd5btFOLVu2T0+Wz3RJaFd1Y29TuWGVXgqvKe06hNuXaUrXFNlRVodGSpLPS++rW741nc/sg4e8x+BPzC/7GHIO/Mcf8qy2dhyfi0yLYDTfcoM8//1xvvPGGtm3bpssuu0zDhw9XZGSkqqurtX37dr333nvaunWroqOjdcMNN/hyeJ/74osvtHr1aiUmJuqtt946bu+v4uJiSZLdbtfPf/5zSdLTTz8dlDwBAOiI4vIaPfLaCh0s9f8elGaPW8NqCpTusGtIbZFC1LLY5jRZtCN6sHJjUlUYnnTc6Y5/eXCW+iZE+z1PAAAAdD8+LYKNGjVKTz75pB5++GGtXLlSq1atahFjGIZ69eql5557TikpKb4c3ueObkhfWlqqTz75xGtMWVlZ8z2KYACAriK/qFLP/3OD9hRW+n8ww1A/Z5nSq/ZodHW+wj0NXsP2RfRVri1VO6MHyhUSety9yHCzXn/oPEVHhvk/XwAAAHRLPi2CSdKll16qCRMm6K9//auWLl2qoqKi5nv9+/fX+eefr+uvvz4o+4Gdqssvv1yXX36513uBOh0SAABfqXDU661Pt+rL1YUBGS+qsVZjHHlKd9iV2OC92HbEEq3cmFRtsaWqMtT7Cq+p6f1037WTFBZKawEAAADaz+dFMElKSUnRb37zG0mS0+lUZWWlYmNjFRbGT28BAAiUo3t8Za0uUH2DJyBjmg230moKlV61R0NrD3ptd2wwWbQzepA2x6Rqf3if49odj2ra9D5F1108mr2/AAAA4BN+KYIdy2q1Kikpyd/DAACAbzhdbj3++ipt3F0amAENQ32c5Rrn2KPRjr2KaKXdsSC8j3JjUrUzepAavtXueNTMScn66SVjKHwBAADA5/xSBGtoaNAHH3ygnJwc5eXlyeFwaOXKlSovL9dTTz2l66+/Xmlpaf4YGgCAHm3t9kN6/I21ARkrsrFOYx15GuuwK6nhiNeYSkuUtthSlRuTqiOhtlbfRcsjAAAA/M3nRbC9e/fq1ltv1b59+2QYTS0QR4+wPHjwoD788EN9+umneuaZZzR79mxfDx8ws2fP1s6dO4OdBgAAkqR9xfV6I+uwJP/u9xXS3O5oV2rtAa/tji6TWTujBynXlqp9EX29tjselZwYrd/cdJaS4iP9mTYAAADg2yKYw+HQ9ddfr4MHDzZvgp+VlaX9+/dLkmw2m4YOHaq8vDzdfffd+uCDDzR8+HBfpgAAQI9wdL+vRav2yelqWYjytSRnucZVNbU7RnqcXmP2hycpNyZVO6IHqSGk9X1Aw61mzZ48UFfOHk7bIwAAAALGp0WwefPm6eDBg5o5c6aef/55Wa1Wbdq0qbkINmjQIH3yySe66667tGjRIr3xxhv63e9+58sUAADoloKxyX2Eu77pdMcqu/o0VHiNqbJEKtfWdLpjRVhMq++KjgjVYzedpWED4/yVLgAAAHBCPi2CffHFF7JYLHriiSdktVq9xpjNZj322GNaunSpVq1a5cvhAQDodpwut/7w5hqt2VYckPFCDI9SawqV7rArtaZQ5lbaHXdFDVRuTFO7o2EK8fquUEuIZk5M1g8vGsWKLwAAAASdT4tghYWFGjZsmBISEk4YFx8fryFDhigvL8+XwwMA0G1UOOo1b+EWZa89EJDxEp0VSq/aozHVexXlrvcaUxieqFxbqnZED5bT3LLdMcJq0Z/unq7kpNY3wAcAAACCxadFMJPJpLq6ujbFejwehYW1vl8IAAA9TYWjXu98vl2fryyQ4f9tvhThrtdox16lO+zq6yz3GuMwRzSf7lge1strzPCUWN1x1Wka3M/7fQAAAKAz8GkRbNCgQdq9e7dKS0uVmJjYalxRUZHsdrtGjhzpy+EBAOiSnC635v5rg3ICsOrLZHg0tPag0qv2aFhNocxqub9Yoymkqd3Rlqr8yH5e2x37JUTq8VvO5lRHAAAAdBk+LYLNnj1b27dv12OPPaYXXnhBJi9Hojc0NOihhx6SYRjKzMz05fAAAHQ5Tpdb97+4VHkHqvw6Tm/nEaU79miMI0/RrbQ7HrT2Vm5MqrZFD5bT3HJvzwirRbMmp3CqIwAAALoknxbBrrvuOv373//WokWLdMUVV+iiiy5SWVmZJGnJkiXavXu35s+fr3379ikxMVE//OEPfTk8AABditPl1q1/yFJpRdu2EjhV4W6nRlXvVXqVXf2dZV5jqs0R2mIbqtyYVJWFxba4Hxlu0TN3sc8XAAAAuj6fFsGio6P1l7/8Rbfeequ2bNmirVu3Nt+75ZZbJEmGYSgxMVEvv/yyevVi7xAAQM9T4ajXW59u1ZerC33+bpPh0ZDaIqU79mhY9X5ZvLU7KkR7olKUG5OqvMj+LdodQ0wmDRsYq9uvGM8+XwAAAOg2fFoEk6TU1FR99NFHev/997Vo0SLt3r1b1dXVioiI0JAhQ5SRkaFrr71WMTExvh4aAIBObVdBuR597Ws56hp9/u6EhiNKr7JrjCNPNrf3lWVF1gTl2lK1zTZY9ebj2xmtoWY9eN1kTRzVx+e5AQAAAJ2BT4tga9as0ahRoxQdHa3rrrtO1113nS9fDwBAl7Q1r1QPvbxC7paLsjrE6m7QqOp8pVft0QDnYa8xNeZwbbEN1RZbqkqtccfdi7RalMkeXwAAAOghfFoE+9WvfqXDhw9r0aJFiouLO/kDAAB0Y1W1Dbrr6Swdrmzw2TtNhkeD6g5pXNUeDa8pkMVoWVlzy3RMu+MAeY5pdwwPM+vZe2awxxcAAAB6HJ8WwYqKijR48GAKYACAHm97/mHd/+JXPntfXEOV0h17NLYqTzHuWq8xxWFx2hyTpm22Iar7VrujxRyiJ26dqtFDEnyWEwAAANCV+LQIFh8fL4fDIcMwZDKZfPlqAAC6hOLyGj386lcqOtzxEx+t7gaNrM5XusOu5PpSrzG1IVZt/eZ0xxJrfIv7oZYQPX4LxS8AAADAp0WwW2+9Vb/+9a/15JNP6r777lN4OPuLAAB6BqfLraf+sU6rthR17EWGoUF1RUqvsmtETYFCDXeLELdMskclK9eWKnvUAHlM5hYxw1NidcdVp3G6IwAAAPANn58OOXHiRP3jH//Q/PnzNWrUKCUmJrZaDDOZTPrDH/7g6xQAAAioqtoG3fb7RaqscbX7HbENVUp32DXWYVevRu/tjiVhscqNSdPW6CGqtUQcd88aatL4IZG67aqpSoiNbHceAAAAQHfl0yLYr3/9a5lMJhmGofr6em3YsMFr3NEYimAAgK7O6XLrtj9ktasAFuZxNbU7VtmVUl/iNaYuJKyp3dGWqmJrvHTMdgOR4RY9c9d09UuI1MaNGyVJsTZru74OAAAAoLvzaRHssssuYy8wAECPsaugXL94cZkaWx7Q2DrD0MC6YqU79mhEdYHCjMYWIR6ZlBc5QLkxqdoTlSz3t9ode0WF6dc3nKlhA5sOonG7W7ZMAgAAADieT4tgv//97335OgAAOo0KR73eW7RTOWsLVVvfsnB1Mr1cDqVX2TXWkafYxmqvMaVhvZRrS9NW2xDVWFq2NF589mBdee4IxdnYcxMAAAA4VT7fEwwAgO6iwlGvD3J26z/L98rlNk75+VCPSyOqCzSuao8G1hd7jakPCdNW2xDl2lJ1yJpwXLvjUSZJ8x45T/G9Ilq+AAAAAECb+K0IZrfbtXjxYuXl5cnhcOiFF15QbW2tPv/8c1188cUKDQ3119AAAHTIroJyPfb6KlVWN5z6w4ahlPoSpVft0cjqfa22O+6N7K9cW6p2R6XIHdLydMejoiMs+suD5yo6MuzUcwEAAADQzOdFsLq6Oj366KP65JNPZBhG8wb4klRYWKgHHnhAc+fO1d/+9jcNHDjQ18MDANBuVbUNuvdPi1VcUXfKz8a4qjXWkaf0qj2Ka6Xd8XBoL+XGpGqrbaiqvbQ7ftv0CQN011UTFBbaepEMAAAAQNv4tAjm8Xh02223aeXKlQoJCdGoUaN08OBBHTlyRJLkdDplsVhUWFioa6+9Vh999JHi4+N9mQIAAO1iL6zQ3c8uPaVnLJ5GjagpUHrVHg2uO+Q1pj4kVNujh2hzTKqKrL29tjseyxpq1v87e4gum5nK3l8AAACAD/m0CPbvf/9bX3/9tQYPHqwXX3xRw4YN0zXXXKMNGzZIktLT0/XZZ5/ppptuUn5+vubNm6d7773XlykAANBmR/f8Wrgsr+0nPBqGBtSXKt2xR6Mc+2Q1XC1DJO2N6KfcmDTtjkpRY8iJ/9+tOcSk86cM0vfPZ9N7AAAAwF98WgRbsGCBTCaTnnvuOQ0bNsxrTEpKip5//nl95zvfUU5ODkUwAEDAOV1uPf/PDVq28UCbn7G5ajTWYVe6w654l8NrTHmoTbm2NG2JGSqHJapN733h3hkaMiC2zXkAAAAAaB+fFsF27dqlgQMHauTIkSeMGz58uAYNGqT9+/f7cngAAE5qa16pHnx5hTxtWPll8TRqeE2B0qvsGlxXJG+NjE5TqLbbBivXlqoD4YknbXc8KirCor+y4T0AAAAQMD4tgjmdTkVGnnyjX0mKioqSYZz6cfMAALRHmze9Nwz1dx5WetUejarOV7jHe7vjvoi+2hyTpl1RA0/a7vhtZ4zuo1/8aDIb3gMAAAAB5NMiWN++fZWfn6+GhgaFhbX+k+3a2lrZ7Xb16dPHl8MDAODVxl2H9PCrq04YE91Y29TuWGVXgqvKa0xFqE25tlRtsQ1VVWh0u3KZOTFZ9107qV3PAgAAAGg/nxbBpk6dqvfee0+vvvqq7rjjjlbjXnjhBTmdTp111lm+HB4AgOOcbPWX2ePWsJoCpTvsGlJbpBC1XKHsNFm0I3qwcmNSVRie1OZ2R29GDY7XHVee1u7nAQAAALSfT4tg119/vRYsWKCXX35Z1dXVuuSSS9TQ0CBJqq+v165du/TWW29p4cKFslgsuu6663w5PAAAzQ5X1umGx7+Q+9t7fxmG+jnLlF61R6Or8xXuafD6/L6IPsq1pWln9EC5QkI7nM+s01N025zxtEACAAAAQeLTIlhKSoqeeuop3XfffXrzzTf15ptvNt+bMGGCJMkwDJnNZj322GMaOnSoL4cHAECSVFxeo5ueXCTPMQu7ohprNcaRp3SHXYkNlV6fO2KJVm5MU7tjZaitw3mYTNJ5Uwbp2gtGKs4W3uH3AQAAAGg/nxbBJOncc8/V+++/rxdffFHLli1rXgkmSWazWWeccYbuuOMOTZw40ddDAwB6sPyiSs2dv0k79lU0XzMbbqXVFCq9ao+G1h702u7YYLJoZ/Qg5dpSVRDRp0PtjkfFRIbp0RvP1LCBcR1+FwAAAADf8HkRTJJGjhypuXPnqqGhQfv27ZPD4VBkZKRSUlIUFRXljyEBAD1UVW2D7nt2iQ6V1zZdMAz1cZZrnGOPRjv2KqKVdseC8D7KjUnVzuhBauhgu6NJUmREqDImJevK2cNZ9QUAAAB0Qn4pgh0VFhamYcOG+XMIAEAPdriyTtf/9gt5DCmysU5jHHuV7tijpIYjXuMrLVHaYktVbkyqjnSw3THWZtUjP53Cai8AAACgi2h3Eczj+fZOw+0TEhLik/cAAHqWqtoG3fjYZ0qrPqD0qj1KrT3gtd3RZTI3tzvui+jb4XbHi88erCvPHcFqLwAAAKCLaXcRbMyYMR0e3GQyadu2bR1+DwCgZ6nYZdc7v5+n2yrsivQ4vcbsD09Uri1NO2yD1BAS1uExk+Ij9fw9MxQd2fF3AQAAAAi8dhfBDKPlT9uD8Q4AQM/gqqxU6dJlOrQoW3X5+3Sal5gqS2RTu6MtVRVhMT4ZN8wSot/eMlWjhyT45H0AAAAAgqPdRbA333zT6/WXXnpJq1ev1plnnqnvf//7GjVqlGJiYuR0OrV79269//77+vLLL3XeeefpwQcfbHfiAIDuz9PYqIp1G1SSla2KtetkuN0tYlwms3ZFpSg3Jk37IvrKMPmmzT7CatYTt5zNnl8AAABAN9HuItgZZ5zR4tp//vMfrVmzRj/84Q/10EMPtbjft29fTZs2Tc8//7xeeeUVnXnmmbrmmmvamwIAoJuqyd+nkqxslS5ZKldlldeYA9be2hyTph3Rg+U0+7ZF8dwzBuqWy8cpLNTs0/cCAAAACB6fng45b9482Ww2/d///d8J4372s5/p3Xff1bvvvksRDAAgSXJVOVS6dJlKsnNUY8/zGuMwR2iLbahyY9JUHtbLp+ObTNIl04ZqTuYwNr0HAAAAuiGfFsF2796tYcOGKSzsxD+Rt1gsSklJ0a5du3w5vF8ZhqEFCxZo/vz52rlzpxoaGjRo0CBdeuml+vGPf3zSrxkA0JLhdqti/QaVZOWofM1aGY2NLWJMoaFKmHKGPqxK0IqaGJ+1Ox7r9FGJeuC6Kaz8AgAAALoxnxbBoqOjVVRUdNI4l8ulgoICxcV1jX1W3G637rvvPn322WeyWq2aMmWK3G631q9fr2eeeUYbN27U3LlzZTKZgp0qAHQJtQUFKs7KUenipXIdOeI1JnrYMCXNmqnEaedof5VbXz2zWPLDX7PTJgzQ/T843fcvBgAAANCp+LQINnbsWC1ZskTz5s3Tj3/841bjnn/+eVVWVmratGm+HN5v5s2bp88++0ypqal6/fXX1a9fP0lSYWGhrrvuOmVlZemTTz7RpZdeGuRMAaDzaqyuVunS5SrJzlH17j1eY0LjYpU0c4aSMmcqcuBAOV1u/emfG7Rs4wG/5DRqcLzuvmqCX94NAAAAoHPxaRHsJz/5iZYsWaI//vGP2r17t7773e9q2LBhioyMVHV1tbZv3653331XixYtUlhYmG644QZfDu8XDQ0Neu211xQaGqoXXnihuQAmScnJybr99tv13HPPdanWTgAIFMPt1pGNm1SclaPyVau9tztaLIo/Y7KSZmUobsJpMpmbWhKraht06+8XqarG5ZfcZp2eotvmjKcFEgAAAOghfFoEmzJliu655x796U9/0gcffKAPPvigRYxhGAoNDdUTTzyhkSNH+nJ4v1ixYoWOHDmic889V2lpaS3uf/e739V3v/vdIGQGAJ1XbWGhSr5pd2woL/caE5Waqj6zZqr3tGkKjbEdd6+qtkE/eexzNbg8Ps3LYjbpvDMG6fvnj2DzewAAAKCH8WkRTJJuuukmTZo0SS+//LJWr16thoaG5nvh4eGaPn267rjjDg0bNszXQ/tFbm6uJOm0006TYRhaunSpvv76a1VXV2vw4MG65JJL1KdPH7/nYRiG3G6338fpqY79bPmc4Ws9ZX411tSobPkKleYsVvWu3V5jQnv1Uu/p09Q7Y4aiBg9qvn7s5+J0uXXr77N8WgA7b0qKrjlvpGJtVq9jdnU9ZY4heJhj8CfmF/yNOQZ/Y44FjmEYHXreZHT0DceoqqpSTExM8+/r6+t14MABVVVVKTY2Vv3795fVaj3BGzqf++67TwsXLtQjjzyi//73v1q9evVx9yMjI/W73/1OF1xwgV/G3759u2pra/3ybgDoKMPjkWdvvtybNsuzY5fkpd1RISEKGZ4m8/hxCklLbW539Ka6zq03vixWWbXvCmAThkbqO2fG++x9AAAAAIIrMjJSo0aNOuXnfLoS7Mc//rHCw8P15z//WbGxsQoPD1dqaqovh+iwm2++WYsXL25TbFZWlqqrqyVJzz33nMxms55++mlNmzZNDodD77zzjt544w39/Oc/V//+/TVu3Dg/Zg4AnYenrEzuTblyb86VqhxeY0x9+8g8Pl3msWNkioo64ftcjYY+WlmmLQX1Ps3TajHposld4yRiAAAAAP7l0yLY3r17FR8fr9jYWF++1qcSEhI0YMCANsVaLBY5nU5JksPh0Ntvv61JkyZJkmJjY/WLX/xCtbW1+uc//6mXXnpJr732mt/yjoiI0IgRI/z2/p7O7XY3t76mp6fLfIKVKsCp6i7zq7G2VuVffa3SnMVy7NjpNcYSY1PvadOUmDlTUUMGt+m9hcUO3fvCMp/v/yVJ381I0+RJ3f/vzu4yx9B5McfgT8wv+BtzDP7GHAucnTt3qq6urt3P+7QIFhoaqsjISF++0ueefPLJU4oPD2/aODk9Pb25AHasH/zgB/rnP/+plStXyjAMmUwmn+T5bSaTiT9IAWI2m/ms4TddbX4ZHo8qc7eoJCtHZV+vlOeYfR6bhYQo/vRJSsrMUNzpExUSGur1XRWOen201K6lGw6ooqpejW6fdeN7ZZJ00dlDu9Tn7QtdbY6h62GOwZ+YX/A35hj8jTnmXx2tufi0CHbppZfq7bff1n//+1+/7ZEVaL1795YkJScne71/9LrT6VRNTY2io6MDlhsA+Etd0SGVZOeoNGexnKWHvcZEDhqopFkZSpwxXWEnWAFcXF6jx/62SgVF3tsm/WXmpGROgAQAAADQzKdFsCuuuELbtm3TPffco7ffflsTJ05UUlLSCTfDnzNnji9T8LmjLYjFxcVe7x8+3PSPw/DwcApgALq0xto6la34WiVZ2aratt1rjMUWrcTp05Q0K1NRQ4ec8CcxxeU1evT1lSo8VO2vlFsVGx2m2684LeDjAgAAAOi8fFoEu+yyyyQ1HVm5du1arV279qTPdPYi2MyZM/XEE09o48aN2r9/v1JSUo67v2TJEknS5MmTg5EeAHSI4fGoaus2FWflqGzF1/J8sw/icUJCFDdxgpJmZSh+8umttjse5XS5NfdfG5Sz9oCfsj6xsNAQvfyLWQoLZRk6AAAAgP/xaRGsX79+vnxdp5CSkqILLrhAn332me655x69+uqrSkhIkCRt3rxZL774oiTpJz/5STDTBIBTUl9crJLsxSrJXixnSYnXmIiUZPWZldnU7hjfthMWnS63Hnl1hbbtLfdlum3WKypMr/xylqIjw4IyPgAAAIDOy6dFsOzsbF++rtN49NFHtX//fuXm5mr27Nk644wz5HA4tHnzZrlcLt1yyy06++yzg50mAJyQu75eZSu+VnFWjqq2bPUaY46KUuL0c5Q0K1PRaamnvPHkXxbkBq0ANn3CAN111QRWgAEAAADwyqdFsO4qNjZW77zzjt566y198sknWrlypcLCwjRx4kT96Ec/0uzZs4OdIgB4ZRiGqrZtU0nWYh3+aoU89fUtg0JCFHvaePWZlaH4MyYrJKx9q6gqqur15ap9Hcz41CUnRuvJn53NJvgAAAAATsjnRbDy8nLt2rVL5eVNKwHi4uI0YsQIxcfH+3qogLJarbrhhht0ww03BDsVADip+pISleYsUUl2juoPeT/YI2JAfyXNylTizOmyftPm3V5Ol1u/emWFPEaHXnPKekWF6vn7ZrL6CwAAAMBJ+awI9vHHH+sf//iHtmzZIsNo+a+gMWPG6Ac/+EHz5vkAAN9yO50q+3qlSrJyVJm7RfLyd7E5KlK9zzlHfWZlKHr4sFNud/y2Cke9Pl5m14c5e+T2dOhVpywsNESv/HI2BTAAAAAAbdLhIlhZWZkefPBBLV261Gvx66gtW7bogQce0MKFC/WHP/yheXN5AED7GYYhx46dKsnK0eHlX8ldV9cyyGRS7PhxTac7TjlDZqu1w+MWl9fo8TdWK/9gVYff1R5sgA8AAADgVHWoCFZTU6Mf/ehHysvLk2EYOu2003Teeedp1KhR6t27t8xmsyoqKrR9+3YtWrRIK1eu1FdffaVrrrlGH3zwgaKionz1dQBAj+IsPaySxd+0Ox4s8hoT3r+fkjIzlDRzhqyJvX0zrsutuf/aoJy1B3zyvvZgA3wAAAAA7dGhItiDDz4ou92upKQkPfbYY5o5c6bXuEmTJukHP/iB1qxZo//7v/9TQUGBHnnkET3zzDMdGR4AehS306nyVatVkpWjI5s2e293jIhQ73POVtKsDNlGjuhwu+Oxistr9IuXlqms0umzd7aVySRdMm2o5mQOYwN8AAAAAO3S7iLYhg0b9PnnnysmJkZvvPGGUlNTT/rM5MmT9eabb+qqq67Sp59+quuuu07jxo1rbwoA0O0ZhqHqXbtVnJWjw8uXy11T2zLIZFKv9LFKmpWhhLPO9Em747GKy2v05LzVyjsQnNbHc8b31z1XT2TlFwAAAIAOaXcR7MMPP5TJZNJtt93WpgLYUQMHDtTdd9+tX//611qwYAFFMADwwllWrtJv2h3rCr23Hob37aOkzAwlZsxQeFKS73NwufXKB5u0aPV+n7+7LQb3i9HDP52ipPjIoIwPAAAAoHtpdxFs3bp1slgsuvLKK0/52UsvvVRPPPGE1qxZ097hAaDb8TQ0qHz1GhVn5ejIxk2Sp+VxiyHh4ep99lQlzcpQzOhRPm13PJbT5davXv5KO/ZV+OX932aSZDaHKD4mXNMnDNCl04fS9ggAAADAp9pdBDt48KD69++vyMhT/wl9RESEBg0apMLCwvYODwDdgmEYqt5jV0lWtkqXLpe7psZrXMzYMepztN0xIsKvOTldbt31TI4OlHrPxZeeuWuahg+M9/s4AAAAANDuIpjH45HNZmv3wFarVY2Nje1+HgC6soaKCpXkfNPuuN/7DwSsSUlKypyppMyZCu/TJyB5OV1uPTh3eUAKYBmTkimAAQAAAAiYdhfB4uPjdfDgwXYPXFRUpLi4uHY/DwBdjdHYqLIVK3V48RJVrN/gvd3RalXC1LPUZ1aGYsaMlikkJGD5VTjq9chrXyv/oP83wI+zWXX7Faf5fRwAAAAAOKrdRbCRI0dq8eLFWr9+vSZOnHhKz27cuFFlZWWaOXNme4cHgC7BMAzV2PPk+uxzubds0+66Oq9xMaNHKWlWphKmniVLpH/bHb8t0Bvgx9ms+vP9mZz2CAAAACCg2l0Ey8jIUE5Ojp599lm99dZbbX7O4/HomWeekclk0rnnntve4QGgU2s4ckSlS5aqJCtHtfsKvMZYE3srMaOp3TGiX7/AJviN4vIaPfDn5SqtqA/IeOeM7697rp5IAQwAAABAwLW7CHbZZZfpz3/+s9auXavHHntMDz/88ElPKWtsbNQjjzyiNWvWqH///rr00kvbOzwAdDoel0sVa9erJDtHFevWy3C7W8SEhIUpYeqZSsrMUK/0sQFtdzxWcXmNHn9jdUBaHyXJGmbWc/fMUHJS+/eSBAAAAICOaHcRLCwsTI8//rhuvvlmvfvuu9q6dauuv/56nX322YqKijou1ul0avHixXrllVe0Y8cOWa1WPffccwoNDe3wFwAAwVadt1cl2TkqXbJMjVXei0qm5GSZTxun0666UtaY4BWCmopfq5R/0BGQ8UwmacaEZN1x5Wms/gIAAAAQVO0ugknSOeecoyeeeEKPPPKINm3apLvuuksmk0nJycmKjY1VaGioKisrtW/fPjU2NsowDEVEROjJJ5/UuHHjfPU1AEDAuSorVbp0mUqyFqtm716vMWEJCUrKmKGEmdO1s6REkmSJigxkms0Cve9XWGiI5mQO0wVnDVacLTwgYwIAAADAiXSoCCY1tUUOGzZMf/zjH7Vq1SoZhqGCggIVFLTcA2fKlCn67W9/q4EDB3Z0WAAIOE9joyrWbWhqd1y7TkZjY4uYkLAwxZ95hpIyMxQ7Ll0ms1lut1v6pggWDP+/vTuPq6rO/zj+vlx2FEEUUklFEDVzzdzKBdBSp8Uxy9TKybWacmyaKevXVDNTOo6VM5qWYzmVWZPlUmZlCbibSyIuuaKouHARN5T9cn5/MNwRuSoK9164vJ6Ph49HnfM953y4fOUR776f78krsOq1ORu0MyXTKc9r0ThIk566k5VfAAAAAKqUCodgktS6dWt99NFHOnDggNavX6/du3frzJkzys/PV1BQkFq2bKnevXsrOjq6Mh4HAE51MfVwcbvjytUqOHfO7pjaLaIVGhujenfeIc9aAXbHuMr0/yQ5JQAzmaQ+tzfWE4PaEoABAAAAqHIqJQQrERUVpaioqMq8JQC4RMH5LJ1as0bp8Ym6mHLQ7hiv4GCFxvRSaGyM/G8Od3KF15ZXYNU//7NVa7Ydd+hzfL3NuufOZrqvZzNaHwEAAABUWZUaggFAdWZYrTqTtE2WFQk6vXmL3XZHk6en6nbprLC4GAW1byeTuWqueEo/fVEvvbtOltM5Dn1OaLCf3n0hjpVfAAAAAKo8QjAANV72kaOyJCTKsnKVCs6ctTumVvOo4nbHHnfIq7br3u54NWeycvXt+kNavuGwzmTlOfx5JkmTnrqDAAwAAABAtUAIBqBGKrxwQRlr1soSn6gL+w/YHeMVFKT6vXsqLC5G/lX4hR55BVa9s2CbVm5Nc+pz7+raRGF1q9b+ZwAAAABwJYRgAGoMw2rV2eTtSl+RoNObNssoKCgzxuTpqbq3d1Jon1gFd2hfJdsdz2Tl6qvVKVqXfFxnzucor8Bweg23RoZo7MA2Tn8uAAAAANwoQjAAbi87LU2W+OK3O+afPm13TEBkM4XFxahejx7yCqya7Y55BVa9tyhZ8ZuPynB+7iVJMptN6nN7Y40d2IY2SAAAAADVCiEYALdUeOGiTq1dJ0tCorL27rM7xqtOoOr36qnQuBgFNG3q3AKvQ8leX1+tSlFOntUlNfj7empgr0j169aUN0ACAAAAqJYIwQC4DcNq1dntO2RJSNTpnzapKD+/zBiT2azgTrcpNC5Wwbd1kIdn1foxeCYrVz9sPKykvRk6mXlB5y7kq9DqomVfksweJvXpzMovAAAAANVf1frtDwBuQM7x47LEJ8qSuEr5mZl2xwRENFVoXIzq9+whrzp1nFzhteUVWDVnyQ6t2HRY1iJXVyMF1fbRgO5NWfkFAAAAwG0QggGolgqzs3Vq7fridsfde+yO8QwMVP1ePRQaG6NazSKcXGH55RVY9dqcDdqZYj/Ac6YmDQL113HdCL4AAAAAuB1CMADVhlFUpHM7dsqSkKjM9T/ZbXeUh4fqdrpNobExCu7UUR5eXs4v9DrNWbKjSgRgt0aG6M9jutH2CAAAAMAtEYIBqPJyTpyUJSFRGYkrlZdxyu4Y/yaNi9sde/WUd1CQcwusgDPncxW/+Yiry1DPDo30uyEdCMAAAAAAuC1CMABVUmF2jjLXb5AlIVHnd/1id4xn7Vqq37O43TEgsplMJpOTq6y4HzYddunG95LUo0Mj/fGRTi6tAQAAAAAcjRAMQJVhFBXp/K5fZElI1Kn1P6koN7fsIA8PBXfsoNDYGNXt3KlatDtejavbIG+NDNGEIR1cWgMAAAAAOAMhGACXy01PlyVxlSwJicpLt9gd4xcertC4GIX27iXvusFOrtBxsrLt7GvmBGYPk/p0bqyxA9vQAgkAAACgRiAEA+AS1txcZa7/SenxCTq/c5fdMeaAANXveWfx2x2bR1XLdscrySuwas6SHUpJO+fU5wbX9lH/7k3Vr1tT3gAJAAAAoEYhBAPgNIZh6Pwvu2WJT9Spdeuv2O4Y1L6dQmNjFNLldnl4ezu/UAfLK7DqtTkbnNYKGVTbRwMIvgAAAADUcIRgABwuLyNDloSVsiSsVO7Jk3bH+DVqqNDYGNWP6SWfkBAnV+hcc5bscEoA1vzmIE187HaF1vV3+LMAAAAAoKojBAPgENa8PGVu2ChLfILO7dgpGWXfgGj291e9HncoLC5WtaKbu1W74+Uu5Fi1NeWiPl2zVvuOnnXIMzzNJkU3DtZtLcPUt0tjVn0BAAAAwCUIwQBUGsMwlLVnb3G749p1subklB1kMimoXVuFxsWobpfOMvv4OL9QJ8orsGr2ou1asfmEvRywUrDJPQAAAABcGyEYgArLyzgly8ritzvmHj9hd4xvg5sUGher0N695FO/npMrdA1H7/3FJvcAAAAAUH6EYABuiDUvT6c3bpIlPlFnk7fbb3f081PIHd0V1idWtVu2cMt2xzNZufph42HtTMlUVna+LuYUqKhIKrRadf5ivgqtlbv8y8/HU4Njm9PuCAAAAADXiRAMQLkZhqEL+/YrPT5Rp9aulfVitt1xddq2UWhcjEK6dpHZ1z2DmrwCq+Ys2aH4zUcqPei6mhZNgvVQn2inPQ8AAAAA3AUhWDmdPHlSs2bN0urVq3Xq1CkFBASoXbt2GjlypLp27erq8gCHyss8rYz/tjvmpB2zO8b3pjDb2x19Q0OdXKFz5RVY9fK767Tn8BmnP7tNZM1oJQUAAACAykYIVg6HDh3SsGHDdPr0aTVq1Ei9e/fWyZMntWrVKq1evVp/+tOfNHz4cFeXCVSqovx8nd60WZaERJ1JSpaKisqM8fD1Vb07uis0rrcCb7nFLdsdL3UmK1ffrj+kxYkpyiuwOv35nmaT+nZp7PTnAgAAAIA7IAQrh7/+9a86ffq0hg8frv/7v/+T2Vz89rXly5drwoQJmjx5svr06aOwsDAXVwpUjGEYunAgpfjtjmvWqvDCBbvjAm9trbC4GIV06yqzn5+Tq3SOS/f6OncxTydPXVROnvODr0vF3c4+YAAAAABwowjBrqGwsFA//fSTJGn8+PG2AEyS7r77brVr105JSUnaunWr+vfv76oygQrJP3NGGStXy5KQqOwjR+2O8Qmtr9DYGIXG9JLvTTc5uULncdVeX9dya2SIxg5s4+oyAAAAAKDaIgQrh5IWr5MnTyooKMh2vKioSGfOFO8JFBwc7IrSgBtWVFCg05u3yBKfqDNbk+y3O/r4KKR7N4XG9ladW1vL5OHhgkqdJ6/AqtfmbNDOlExXl2LjYZL6dmmisQPbyNvLfO0LAAAAAAB2EYJdg6enp+644w6tWrVKf/zjH/Xqq6+qdevWysjI0PTp05WamqoOHTqoc+fODq3DMAxZra5txXJnl3627vw5G4ah7IOHlJG4UqdWX7ndsfYtrVQ/ppdCuneztTsWGYbkxp+NJM1etL1KBWAmkzRtQk81aRAoyb3nJiqmpvwMg+swx+BIzC84GnMMjsYccx7DqFi3jsmo6B1qgIyMDD399NPatm1bmXOPPvqonn32WQUEBDjk2bt371Z2drZD7o2aw7h4UdYdu2TdlizDkmF/UGCgzO3ayNyujTzq1nVugVVAVo5V05acUFEV+ol4W1SA7u3MKlMAAAAAuJS/v79atWp13dfVuJVg48aN08qVK8s1Nj4+XuHh4QoODtavf/1rHTp0SHXq1FHz5s114sQJ7d69W0uXLlXr1q3161//2rGFA9fJsFpVtP+ArNu2q+hAit12R3l6yqNVC5nbtZVHRFO3f7ujPRdyrNq8/4I27LlQpQKwJqHe6ndbkKvLAAAAAAC3UeNCsJCQEDVq1KhcYz09PWW1WjVu3DitXbtWzz//vEaOHGkLCjZs2KDx48frxRdfVO3atdWnTx+H1e3n56cWLVo47P41ndVq1Y4dOyRJbdq0KfUChOrm4qFUZSSs1Kk1a1R4PsvumFotWqh+bC+FdO8uzwB/J1dYNeQVWPX+V7sUvyXNbj7oKmazSXGdbtbo+1qzBxjKzZ1+hqFqYo7BkZhfcDTmGByNOeY8e/fuVU5Ozg1fX+NCsEmTJl3X+C+//FJr165VXFycRo0aVepct27d9Pzzz+vll1/WzJkzHRqCmUwm/iI5idlsrnafdcH588pYtVqW+JW6eOiQ3THeIXUVGtNbobEx8mvU0LkFVjHppy/qpXfXyXL6xn94VhZPs0lBtX11U11/dWgRqr5dGiu4tq+ry0I1Vh1/hqF6YY7BkZhfcDTmGByNOeZYFe1eqnEh2PXasGGDJKlHjx52z/fq1UtScRpZUFAgLy8vp9WGmq2osFBntyYpPT5RZ7b8LKOwsMwYk5eXQrp2VmhcrILatpGphv4wPpOVqx82Htb2/ad0+OR5nbuQ7+qSJEm3Roboz2O6seILAAAAAJyAEOwazp49K6m4NdKekuNWq1VFVamnCm7rYuphWRISlbFytQrOnbM7plZ0c4XFxarenXfIs5ZjXtpQHeQVWDVnyQ7Fbz6iQmvV2fDLbDapz+2NNXZgGwIwAAAAAHASQrBriIyM1Nq1axUfH68HH3ywzPk1a9bYxvn4+Di7PNQQBeezdGrNGqXHr9TFlBS7Y7yCgxUa00uhsTHyvzncyRW6Xslqr50pmcrJK5SHyaQj6Vm6mFPgkno8zSZ5e5slQzKZJLPJUHAts+7sGKG7uzal5REAAAAAnIwQ7BqGDBmi+fPnKzExUR999JFGjBhhO5ecnKwpU6ZIkh5//HFXlQg3ZVitOpO0TZb4RJ3etNl+u6Onp+p26aywuBgFtW9XI9sdq9pqL3urvKxWq7Zt2yZJat++OXsEAAAAAIALEIJdQ2RkpN544w29/PLLmjRpkj755BO1bNlSJ0+e1M6dO1VUVKShQ4faXSUG3IjsI0dlSUiUZeUqFZw5a3dMrahIhcbFql6PO+RVu7ZzC6xCqtIG93UDfdWvWxP168YqLwAAAACoigjBymHgwIFq0aKFPvjgA23atEkJCQkKCAhQ165dNWzYMPXt29fVJaKaK7xwQRlr1soSv1IX9u+3O8YrKEj1e/dUaGyMApo0dnKFVUvJ6q8fNh6W4cLFXyZJUTcHaeJjtyu0rr/rCgEAAAAAXBMhWDm1atVKb775pqvLgBsxrFadTd4uS3yiMjduklFQdu8qk6en6t7eSaFxMQrq0F4eV3hBQ01w6Rse9x89q5y8su2hznJrsxB1aBGqvl0as+oLAAAAAKqJmvsbNeAi2WlpsiSsVEbiKuWfPm13TEBkM4XGxqh+zx7yCqy57Y5S1dvz6+6uTfT0g+1dXQYAAAAA4DoRggFOUHjxok6tXSdLfKKy9u6zO8arTqDq9+qp0LgYBTRt6twCXezyNzv6+XgqKjxIVqtVP2w66rI3PF7u1sgQjR3YxtVlAAAAAABuACEY4CCG1apzO3YqPT5Bp3/apKL8/DJjTGazgjvdptC4GAXf1tHt2h2vFG5Jhg6kndPFnAKdPp+rM+dzVXTZIq9t+zJcUbJd9t74CAAAAACoXtzrN26gCsg5flyWhJWyJKxUfmam3TH+TZsoLC5W9Xr2kHdQHSdX6HhXa2GsSuHWtYTU8dXdXXnjIwAAAAC4A0IwoBIUZmcrc916pccnKmv3HrtjPGvXVv1ePRQaF6tazSKcXKFjXbri62JOgY6fulhlWhhvRGhdP01+8k7e+AgAAAAAboQQDLhBRlGRzu3YKUtCojLX/2S33VEeHgq+raPC4mIV3KmjPLy8nF+oA1W1TesrytNsUhxtjwAAAADglgjBgOuUc+KkLAmJykhcqbyMU3bH+De+WaFxsarfu6e8g4KcW6CDXL6/l4+XWemns5V+OtvVpVVInVreatogUG2j6qtvl8a0PQIAAACAmyIEA8rBmpOjU+s2yJKQqPO7frE7xrNWLdXreafC4mIVENlMJpPJyVU6hrut9ipByyMAAAAA1CyEYMAVGEVFOr/rF1kSEnVq/U8qys0tO8jDQ8Ed2is0LlZ1O3eq3u2OVqv0/ffS3LlSSop04YKKAmppv0eQMpv2UFHTDpJH9W8RpOURAAAAAGomQjDgMrnpFmWuXiNLQqLy0i12x/iFhys0LkahvXvJu26wkyusZFarNH168Z/U1FKnPCTdKunWbauUHhiqpR3u0dcd75Fh8nBFpdctwM9TTW4KlLXIkJ+Pp9pE1qPlEQAAAABqKEIwQJI1N1fW5B2yJm/XttTDdseYAwJUv+edCo2NUa3mUe7R7piTIz3yiLRo0TWHhp23aPSqubrl2C96q/+zyvfycUKBN4bVXgAAAACAyxGCocYyDEPnf9ld3O64dv0V2x2D2rdTaGyMQrrcLg9vb+cXWhnstDoqIEA6dUo6flyGpPJEeoak7gd+kr6bpin3/FFFVag90s/HU9GNg9jgHgAAAABgFyEYapy8jAxZElfJEp+o3JMn7Y7xbdhQYXExqh/TSz4hIU6usBJdpdXxUuVd02bS/4Kwe7Yt09cd76uEIiuGVV8AAAAAgPIgBEONYM3LU+aGjbIkJOrc9h2SYecthz4+MrdupZYPDladVi2rf7vjdbQ6Xo+ST+XepGX6pv2vXLYaLMDPS/f3bKZ+3Zqy6gsAAAAAcE2EYHBbhmEoa89eW7ujNTu77CCTSUHt2qpe71466ucjk5eXareIrj4BmL02x1q1pGbNpJMnpQ0byt3qeL1uOpeuDqlJ+rlZJwfc/cpY+QUAAAAAuBGEYHA7eacyZUlcKUtConKPn7A7xrfBTQqNjVFoTG/51K8nq9WqtG3bnFqnXVcKtSIjpZEjpX79JLP52m2OycmS5LAArMRdO1dUWgjmYZKCA30VUsdX/r5eigoPkiQdSDurnLxC3u4IAAAAAKgQQjC4BWtenk5v3CxLfILOJm+32+7o4eurenfeobC4GNWuau2O5Qm1Fi2SmjaVnnhC2rhRWrz4mrd19FcYdi69XOMC/LzUqH4A4RYAAAAAwGUIwVBtGYahC/v2Kz0+UafWrpX1op12R0l12rZRaGxvhXTrKrNvFQxZrmfvrtRUaeJESY5f5VUefvk5Vz1P6yIAAAAAoKogBEO1k5d5WhkrV8mSkKictGN2x/iEhdraHX3DQp1b4PWwWqXhw6XFi6871HJ1ACZJOd5+tn8OreunBiEBys23sroLAAAAAFDlEIKhWijKz9fpTZtlSUjUmaRkqaiozBgPX1/V695NoX1iFNiqlUweHi6o9DpNn35DAVhVkV4njNVeAAAAAIBqgRAMVZZhGLpwIEWW+ESdWrNWhRcu2B0XeGtrhcXFFLc7+vnZHVMllewDpuoZgElS4W9Gau74u1jtBQAAAACo8gjBUOXknzmjjJWrZUlIVPaRo3bH+ITW/2+7Yy/53nSTkyusJN9/b38T/OoiIkI9J44sflslAAAAAABVHCEYqoSiggKd3ryluN3x5yT77Y7e3grp3k2hcTGqc2vr6tHueDVz57q6ghtia90cP54ADAAAAABQbRCCwWUMw9DFg4dkiU9Uxuo1KszKsjsu8JZWCo2LUUj3bvL093dylQ6UkuLqCq6bLQB74IHiEAwAAAAAgGqCEAxOl3/2nDJW/bfdMfWw3THe9eopNLa3QmN7y69BAydX6CRX2OOsKrMFYPPmSdV9JR4AAAAAoEYhBINTFBUU6MzPW4vbHbdslWG1lhnj4e2tkG5dFRrbW3Xatqn+7Y7XUquWqyu4PhERxau/xo8nAAMAAAAAVDuEYHC4CwcPavfrk5Wfedru+dotWyg0Lkb17uguz4AAJ1fnQpGRUnKyq6uwsbU6NmwohYZKWVlS7dpSs2bSqFHS3XezBxgAAAAAoNoiBIPDnfz+hzIBmHdIXYXG9Fb9mN7yD2/kkrpcbuRIadEiV1dhU6rV0c/P1eUAAAAAAFCpCMHgcHU73y5LwkpJUkjXzgqNjVFQu7Yy1fRVRf36SU2bSqmpDn+UbZXXldDqCAAAAABwc4RgcLi6nW5T54/nymQ2y+zj4+pyqg6zuTh0+v3vrx1SVYDt3t27S2Fh0qFDtDoCAAAAAGocQjA4hae/v6tLqJrGj5fWrpVp0aJyB2HXG5jR5ggAAAAAgETfE+BKZrP0ySfSoEHlDrZMkjRokPT3vxe3U15NRIQ0bZq0YAEBGAAAAACgRmMlGOBqfn7FIdWMGdI//3n1PcIu37vr97+Xli+XPvhAOniQNkcAAAAAAK6AEAyoCsxmacIE6Zlnri/UMpulAQOK/wAAAAAAgCsiBAOqEkItAAAAAAAcgj3BAAAAAAAA4PYIwQAAAAAAAOD2CMEAAAAAAADg9gjBAAAAAAAA4PYIwQAAAAAAAOD2eDvkf40cOVJJSUlKSkq64pj09HTNmjVL69ev18mTJ1WvXj3Fxsbqt7/9rerWrevEagEAAAAAAHA9WAkmacqUKVq3bt1Vxxw9elQPPPCA/vOf/8jX11cxMTEym8365JNP9Otf/1onT550UrUAAAAAAAC4XjU6BMvOztYLL7yguXPnXnPsxIkTlZGRod/+9rdaunSppk+fruXLl+vhhx/WyZMn9eqrrzqhYgAAAAAAANyIGhmCGYah7777Tvfff7+WLFmim2+++arjt2zZoi1btqhp06Z6+umnbcfNZrNefvllNWzYUCtXrtSBAwccXToAAAAAAABuQI0MwY4dO6YJEybo+PHjGjlypGbPnn3V8QkJCZKkuLg4eXiU/si8vLwUGxsrSYqPj3dMwQAAAAAAAKiQGrkxvpeXlwYNGqSxY8cqIiJCaWlpVx2/b98+SVJ0dLTd81FRUZKkPXv2VG6hAAAAAAAAqBQ1MgQLCwvT5MmTyz3eYrHYrrMnNDS01DhHMAxDVqvVYfev6S79bCv8OVut0vffy+PDD6WDB6ULF6RataRmzVT0m99I/fpJZnPFnoFqpVLnF2AHcwyOxhyDIzG/4GjMMTgac8x5DMOo0PXVPgQbN26cVq5cWa6x8fHxCg8Pv+5nZGdnS5L8/Pzsnvf19S01zhFycnK0bds2h90f/7Njx44bu9BqVeh//qPQzz+Xz/HjZc8nJ8u8eLHyGjaUZcgQWYYOlTxqZEdyjXbD8wsoJ+YYHI05BkdifsHRmGNwNOZY1VbtQ7CQkBA1atSoXGM9PW/syzX/d9WOyWS66riKJpKovky5uYr4058UnJh4zbE+x4/r5mnTVGvbNh36619l/DdEBQAAAAAAjlPtQ7BJkyY5/BkBAQGSildj2ZObmyvpyivFKoOfn59atGjhsPvXdFar1ZbYt2nTxhZ8lvNieQwZIlNiogxJV49KixmSghMTFfTWWyr6z39oj3RzFZpfQDkwx+BozDE4EvMLjsYcg6Mxx5xn7969V8xmyqPah2DOEBoaql27dikjI8Pu+ZK9wEr2BnMEk8nEX6TK9t+9uzR3rjxSUtQ6M1NF/v7yat1aplGjyr931/Tp0pIl5Q7A9N9xhiTT4sUyz5olTZhww18Gqhez2czfZTgUcwyOxhyDIzG/4GjMMTgac8yxrtWhdy1sSFQOJSuwDhw4YPd8yXFWalUTVqs0bZoUFSXdc4+0aJFMycnyTUuT/759Mi1eXHw8Kqp4XFHR1e81fbqk8gdgJWzjp08vvg8AAAAAAHAYQrBy6NWrlyTpxx9/VNFlgUhBQYHi4+MlSTExMU6vDdcpJ0d66CHp97+XUlOvPjY1tXjcgw8WX2fP999f+z7XcuiQtHx5xe4BAAAAAACuihCsHDp27Kg2bdooJSVFb7/9tm0DfKvVqjfeeEMnTpxQz5491apVKxdXiquyWqXhw6VFi1TeVxgYkrRokfTII/ZXa82dWzm1ffBB5dwHAAAAAADYxZ5g5TR58mQ98sgjmjNnjuLj49W8eXPt3r1bR44cUaNGjfT666+7ukRcy/Tp0uLFN7Z316JF0owZZffuSkmpnNoOHqyc+wAAAAAAALtYCVZOzZs316JFizRo0CBlZWUpMTFRkvToo49qwYIFCgsLc3GFuCpH7d114UJFKyuWlVU59wEAAAAAAHaxEkxSeHi49u7de81xjRo10uTJk51QESpdZe7dNWDA/47VqlWxe5aoXbty7gMAAAAAAOxiJRhqBkft3RUZWTn3bdascu4DAAAAAADsIgRDzeCovbtGjqyc+44aVTn3AQAAAAAAdhGCoWZw1N5d/fpJTZtW7J4REdLdd1fsHgAAAAAA4KoIwVAzOGrvLrNZGj9eUvFbJK+Hbfz48cX3AQAAAAAADkMIhprBkXt3jR8vDRokk8ofhBn671snH3jAFqIBAAAAAADHIQRDzeDIvbvMZumTT2xBWHnYArB58yQP/hoCAAAAAOBo/PaNmsHRe3f5+UkLFkjTpl37ORERxeMWLCi+DgAAAAAAOBwhGGoGZ+zdZTZLEyZIBw5Iy5ZJgwZJ7dsXt2K2b1/878uWSfv3F49jBRgAAAAAAE7j6eoCAKcZP15au1amRYv+tyfXNdzQ3l1mszRgQPEfAAAAAABQJbAUBTUHe3cBAAAAAFBj8Vs9ahb27gIAAAAAoEaiHRI1T8neXc88Iy1fLn3wgYyDB5V36pSK/P3l17q1TKNHF2+Cf7U9wAAAAAAAQLVBCIaa65K9u4qsVu3atk2S1L59e5kJvwAAAAAAcCu0QwIAAAAAAMDtEYIBAAAAAADA7RGCAQAAAAAAwO0RggEAAAAAAMDtEYIBAAAAAADA7RGCAQAAAAAAwO0RggEAAAAAAMDtEYIBAAAAAADA7RGCAQAAAAAAwO0RggEAAAAAAMDtEYIBAAAAAADA7RGCAQAAAAAAwO0RggEAAAAAAMDtEYIBAAAAAADA7RGCAQAAAAAAwO15uroAuDGrVfr+e2nuXCklRbpwQapVS4qMlEaOlPr1k8xmV1cJAAAAAABqAEIwVD6rVZo+vfhPamrZ88nJ0qJFUtOm0vjx0u9+J3mwKBEAAAAAADgOyQMqV06O9NBD0u9/bz8Au1RqavG4Bx8svg4AAAAAAMBBCMFQeaxWafhwadEiGeW8xJCKV4U98kjx9QAAAAAAAA5ACIbKM326tHixDEmmcl5i0iVB2IwZDisNAAAAAADUbIRgqBwl+4Cp/AFYCdv46dNZDQYAAAAAAByCEAyV4/vvr70H2LUcOiQtX14p5QAAAAAAAFyKEAyVY+7cyrnPBx9Uzn0AAAAAAAAuQQiGypGSUjn3OXiwcu4DAAAAAABwCUIwVI4LFyrnPllZlXMfAAAAAACASxCCoXLUqlU596ldu3LuAwAAAAAAcAlCMFSOyMjKuU+zZpVzHwAAAAAAgEsQgv3XyJEj1aFDh6uOWblypUaPHq2uXbuqdevWuuOOO/TMM88oOTnZSVVWYSNHVs59Ro2qnPsAAAAAAABcghBM0pQpU7Ru3bqrjnn77bc1btw4rV27Vo0aNVLv3r0VGBioH374QUOHDtXixYudVG0V1a+f1LRpxe4RESHdfXellAMAAAAAAHCpGh2CZWdn64UXXtDcuXOvOm7Lli2aPXu2/Pz89NFHH2nhwoWaOXOmvvvuO/35z3+W1WrVK6+8ouPHjzup8irIbJbGj5ckGdd5qW38+PHF9wEAAAAAAKhkNTIEMwxD3333ne6//34tWbJEN99881XHf/nll5Kk0aNHq0uXLqXOPfzww+rVq5fy8/O1fPlyh9VcLYwfLw0aJJPKH4QZkkyS9MADthANAAAAAACgstXIEOzYsWOaMGGCjh8/rpEjR2r27NlXHe/r66vo6Gh17drV7vlm/93MPT09vdJrrVbMZumTT2xBWHnYArB58ySPGjkdAQAAAACAE3i6ugBX8PLy0qBBgzR27FhFREQoLS3tquNfe+21q54v2Rj/pptuqqwSqy8/P2nBAmnGDOmf/5RSU688NiKiePXX+PEEYAAAAAAAwKFqZAgWFhamyZMnV8q9EhIStHXrVnl5ealv376Vck97DMOQ1Wp12P0r3TPPSE89JS1fLo9//1s6dEjKypJq15YiIlT0+OPFm+CbzZJhSC7+2i79bKvV54xqgfkFR2OOwdGYY3Ak5hccjTkGR2OOOY9hXO8u5KWZjIrewcXGjRunlStXlmtsfHy8wsPDyxxPS0tTXFyc/P39lZSUVO5n7927V4899pjOnj2rJ598UhMmTCj3teW1e/duZWdnV/p9AQAAAAAAqiN/f3+1atXquq+r9ivBQkJC1KhRo3KN9fSsvC93+/btGjt2rM6ePauYmBiNZ1N3AAAAAACAKqvah2CTJk1y+jO///57TZw4UTk5OerTp4+mTZsmDwfvaeXn56cWLVo49Bk1mdVq1Y4dOyRJbdq0kdlsdnFFcCfMLzgacwyOxhyDIzG/4GjMMTgac8x59u7dq5ycnBu+vtqHYM42c+ZMzZgxQ4ZhaNiwYXr55ZedMsFNJhN/kZzEbDbzWcNhmF9wNOYYHI05BkdifsHRmGNwNOaYY5lMpgpdTwhWTkVFRXrppZe0ePFimc1mTZw4UY899pirywIAAAAAAEA5EIKV08svv6zFixfL399f//jHP9SrVy9XlwQAAAAAAIByIgQrhyVLlmjhwoXy9PTUrFmz1K1bN1eXBAAAAAAAgOtACHYNVqtV//jHPyQVv4ly4cKFWrhwod2xd955pwYOHOi84gAAAAAAAFAuhGDXsHfvXp04cUKSlJ6erqVLl15xbGBgICEYAAAAAABAFUQIJik8PFx79+61e+6WW2654jkAAAAAAABUDx6uLgAAAAAAAABwNJNhGIari8CVbdu2TVarVSaTSX5+fq4ux20ZhqGcnBxJkp+fn0wmk4srgjthfsHRmGNwNOYYHIn5BUdjjsHRmGPOk5OTI8MwZDab1b59++u+nnbIKq6oqEhS8V+q7OxsF1dTM5T88AIcgfkFR2OOwdGYY3Ak5hccjTkGR2OOOUdJVnK9CMGqOC8vLxUUFMjDw0M+Pj6uLgcAAAAAAMAl8vLyVFRUJC8vrxu6nnZIAAAAAAAAuD02xgcAAAAAAIDbIwQDAAAAAACA2yMEAwAAAAAAgNsjBAMAAAAAAIDbIwQDAAAAAACA2yMEAwAAAAAAgNsjBAMAAAAAAIDbIwQDAAAAAACA2yMEAwAAAAAAgNsjBAMAAAAAAIDbIwQDAAAAAACA2yMEAwAAAAAAgNsjBAMAAAAAAIDbIwQDAAAAAACA2yMEAwAAAAAAgNsjBAMAAAAAAIDbIwQDAAAAAACA2/N0dQFAVXT48GHNmjVL69at09mzZ1W3bl1169ZNY8aMUVRUlKvLgxvYt2+f3n//fW3atEmnTp2Sr6+vWrVqpSFDhuiee+5xdXlwMyNHjlRSUpKSkpJcXQqqmUOHDmnmzJn6+eeflZmZqZtuukn9+/fXuHHj5O/v7+ry4IZSU1M1cOBADRo0SK+88oqry4Eb+Oqrr/Tll19qz549ysnJUUhIiLp27aqxY8cqMjLS1eWhmvvuu+80f/587dq1S4Zh6Oabb9aAAQP0+OOPy9fX19XlwQ6TYRiGq4sAqpI9e/Zo+PDhunDhgiIiIhQVFaW0tDTt3r1bXl5eeuedd9S7d29Xl4lqLCEhQePHj1dBQYGaNGmiqKgoZWZmavv27SoqKtKDDz6o119/3dVlwk1MmTJFc+fOlb+/PyEYrsv27ds1YsQIZWdnq23btmrQoIG2bt2qjIwMtWjRQp9++qlq1arl6jLhRk6dOqXHHntMKSkpGj58OCEYKsQwDP3hD3/QN998I09PT7Vp00Z169bVnj17dOzYMfn6+mrmzJm68847XV0qqqkZM2bonXfekdls1m233aZatWpp+/btOnXqlJo3b6758+erTp06ri4TlyEEAy5hGIbuvvtuHT58WOPHj9dTTz0lk8kkSfriiy/08ssvq27dukpISJCfn5+Lq0V1lJWVpT59+ujs2bN6/vnnNXLkSNscS05O1qhRo5SVlaVp06ZpwIABLq4W1Vl2drb+/Oc/a8mSJZJECIbrUlhYqH79+uno0aN64403NHjwYElSbm6unn32WSUkJBBSoFLt3r1bv/vd73T48GFJYn6hwr766is9//zzql+/vt5//321bNlSkmS1WjV9+nS99957CgkJ0Y8//qiAgAAXV4vqZsuWLRo+fLgCAwM1b9482/zKzs7W+PHjtWbNGg0bNkyvvvqqiyvF5dgTDLjEzz//rMOHD6tZs2b67W9/awsnJOnBBx9UZGSkTp8+reTkZBdWiersxx9/1NmzZ9W5c2eNGjWq1Bxr166dnnjiCUnS119/7aoSUc0ZhqHvvvtO999/v5YsWaKbb77Z1SWhGlq2bJmOHj2qbt262QIwSfL19dWkSZPk7++vBQsW6Ny5cy6sEu7g3Llzmjp1qh566CEdPnxY4eHhri4JbuLLL7+UJD333HO2gEKSzGazJkyYoObNmyszM1Pr1q1zVYmoxhYvXixJGjNmTKn55e/vr/Hjx0uSVq5c6YrScA2EYMAlOnXqpDVr1ui9996ze95qtUqSPD3ZTg83pqCgQK1bt75iS22zZs0kSRaLxYlVwZ0cO3ZMEyZM0PHjxzVy5EjNnj3b1SWhGkpISJAk9e3bt8y54OBgdenSRQUFBVqzZo2zS4Ob+fjjj/X++++rbt26evfddzVw4EBXlwQ3ERgYqMjISHXq1KnMOZPJpIiICElSenq6s0uDG/jzn/+sb7/9Vg8//HCZcyW/M5rNZmeXhXLgN3ngMqGhoWWO5efna86cOUpNTVVERITat2/v/MLgFoYMGaIhQ4Zc8XzJKsObbrrJWSXBzXh5eWnQoEEaO3asIiIilJaW5uqSUA3t27dPktSiRQu756OiopSYmKg9e/bwMg9UyE033aQXXnhBw4YNk6+vr3bt2uXqkuAmZs6cecVzVqvVNtcaNGjgrJLgRjw9Pe2+WOHEiROaMmWKJGnQoEHOLgvlQAgGXEViYqI+/fRT7dixQ2fOnFGHDh00depUVoLBIdLT0zVv3jxJYj8w3LCwsDBNnjzZ1WWgmitZjRoWFmb3fMn/MGLVKirqwQcfdHUJqIE+/fRTHTt2TEFBQerWrZury4Eb+Nvf/qbk5GQlJyfLZDJp5MiRtm1OULXwmzzc2rhx48rdix0fH19mH4oNGzZo9erVtn8vKChQSkoKe+zApqJzrERWVpaeeuopXbx4Ubfffrt+9atfVWKVqK4qa34B1ys7O1uSrvh695LjJeMAoLrYsGGD/v73v0uS/vCHP7ApPirFwoULdf78eUmSt7e3MjIydOrUKbtdRnAtQjC4tZCQEDVq1KhcY+2t7hozZoyee+45ZWRkaMmSJXrvvff05JNPaubMmYqNja3sclENVXSOSVJmZqbGjBmjXbt2KTw8XP/4xz9KbZiPmqsy5hdwI8xms4qKiq75s4iXjAOoThITEzVhwgTl5+dr6NChrEREpfn6668VHBysffv26a233tLSpUuVlJSkpUuXyt/f39Xl4RL8FzPc2qRJkyp0ff369SVJ4eHhevrpp+Xp6alp06bpn//8JyEYJFV8ju3bt09PPvmk0tLSFBERoX//+9+qV69eJVWH6q6i8wu4UQEBATp79qxycnLsns/NzZUk+fn5ObMsALhh8+bN0+TJk2W1WjV8+HD96U9/cnVJcCMle8u1bdtWc+bM0QMPPKB9+/ZpwYIF+s1vfuPa4lAKb4cErkPJG4v279+vgoIC1xaDam/VqlV6+OGHlZaWpo4dO+qzzz5jc1YAVUJJ+0ZGRobd8yV7gdHmAaCqKyws1CuvvKLXX39dRUVFevbZZ/XKK6+w6h4O4+3trf79+0uSfvnlFxdXg8sRggGXWLVqlV566SUtXrzY7nlvb29JxW+UoQUEFfH555/rySef1MWLF3Xffffpo48+UnBwsKvLAgBJ/3sr5IEDB+yeLzl+pbdHAkBVkJubq3Hjxunzzz+Xn5+f/vGPf7BZOSrF9OnTNWHCBJ08edLu+ZLfGwsLC51ZFsqBEAy4xIkTJ7Rw4ULNnTvXbshVskF1dHS07QcbcL2WLFmiV199VVarVc8884ymTp3KfAJQpfTq1UuStHz58jLnzpw5o40bN8rLy0t33HGHs0sDgHKxWq367W9/q7Vr1yokJEQff/yx+vXr5+qy4CbWrVun7777TsuWLbN7ftWqVZKkNm3aOLMslAMhGHCJAQMG2DY0nDZtmoqKimznNm3apL/97W+Sit/YBtyIgwcP6tVXX5VhGHrmmWf09NNPu7okACijb9++atiwodauXav58+fbjufm5ur//u//lJ2drcGDB7OHIYAq691339XatWvl7++vjz76SG3btnV1SXAjw4cPlyS988472r59u+14QUGB3nzzTW3atEkhISF64IEHXFUiroCN8YFLBAYG6u2339ZTTz2l2bNn69tvv1XLli11/Phx/fLLLzIMQ0888YTuueceV5eKamrmzJnKzc2Vl5eXDh06pD/84Q92xzVo0EDPPfeck6sDgGK+vr7629/+prFjx+ovf/mLFi5cqPDwcCUlJcliseiWW2654s8vAHC1c+fO6YMPPpBUvHfh7Nmzrzj23nvvta1+Bcrrvvvu05YtW/T5559ryJAh6tChgwIDA7V7926dPHlSQUFBevfddxUYGOjqUnEZQjDgMt27d9fixYv1r3/9S2vXrlViYqJq166t3r17a8SIEerWrZurS0Q1VtJSW1BQoG+++eaK45o3b04IBsClunTpoi+++ELvvPOONm3apAMHDig8PFyDBw/WqFGjVKtWLVeXCAB2bdq0SdnZ2ZKk1NRUpaamXnFsq1atCMFwQ/7yl7+oa9eu+uyzz7Rr1y7l5+erYcOGGjFihEaNGqWwsDBXlwg7TAa7ewMAAAAAAMDNsScYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAHCYRYsWqUWLFtf959FHH5UkpaWl2Y4dPnzYxV+N6xiGoZSUlFLHXP3ZuPr5Vdn+/fvLHCv5rNavX287VvL3o2fPns4sDwCAGsvT1QUAAAD3FRISoo4dO5Y5fuLECZ04cULe3t669dZby5yPjo52RnnVwvbt2/XXv/5VTZo00ZtvvunqcnAVhw4d0uuvv67s7Gx99tlnri4HAABchhAMAAA4TK9evdSrV68yx2fMmKF33nlH9evXJyy4hk8//VTbt29XkyZNSh0PCwvTt99+K0lq2LChK0rDZb755hutXbvWbvDL9woAANcjBAMAAKiGvLy8FBkZ6eoyUE58rwAAcD32BAMAAAAAAIDbYyUYAACoFgzD0OLFi/X5559r7969MplMioiI0ODBg/Xwww/LZDKVuSY/P1+fffaZvv32Wx04cEAFBQVq0KCBevfurVGjRik0NNTus86dO6d58+ZpxYoVOnz4sIqKitSwYUP17t1bjz/+eJnrFi1apBdffFEDBgzQI488or/85S9KSUlRUFCQRo8erd/85jeSJKvVqq+//lqLFy/Wnj17lJ2drdDQUN1xxx0aNWqUmjZtarvnxo0b9dhjj9n+fenSpVq6dKk6d+6sefPmKS0tTXFxcZKkH374oUy75JEjRzR//nytWrVKJ06ckNlsVnR0tAYNGqTBgwfLw6P0/wu1WCyaP3++1q1bpyNHjujixYsKCAhQs2bNdNddd2nYsGHy9fUt9/fran766Sd9+OGH2rFjhy5evKioqCiNGDFC/fv3V+vWrSVJu3btkqdn8X+qTpw4UYsXL9a9995rd1+0ks+/UaNGSkhIKHUuNzdXCxcu1IoVK7R3716dP39e3t7eatiwoe688049/vjjCgsLK3VNbGysjh07pm+//VaZmZl6//33lZycrOzsbIWHh6t///4aNWqUAgICJKnU90KStm7dqhYtWpSqp0WLFpKkf//73+revXu5PqfNmzdr3rx52rp1q86ePavAwEC1b99ejz76qLp162b3mmXLlmnRokU6ePCgMjIyVLt2bd1yyy26//77dc8995T5vgMAUJMQggEAgGrh5Zdf1ubNm1WnTh1FRETo2LFj2rlzp3bu3Knt27dr8uTJpcZbLBaNHTtWu3fvlslkUsOGDRUUFKQDBw7oww8/1JIlSzRr1izddtttpa7bu3evRo8eLYvFIg8PD0VGRsrT01P79+/X3LlztXDhQs2YMUNdunQpU+PBgwc1evRomc1mNW/eXCkpKYqKipIkXbx4UU8//bTt7YBhYWEKDw9XamqqFixYoK+//lpTp07VXXfdJUmqXbu2OnbsqMOHDyszM1N169ZV06ZNy/XSgB9//FHPP/+8srOz5ePjo6ioKJ0/f15JSUlKSkrSpk2bNHXqVFtwuG3bNo0ZM0bnz5+Xj4+PGjduLE9PT6WlpdmuiY+P18cffyyz2Xz937xL/Otf/9Lbb78twzAUEhKiyMhIpaSk6A9/+IP27dtXoXtf7vTp0xoxYoT27dsnk8mkxo0bq0GDBkpPT9f+/fu1f/9+ff3111q0aJFuuummMtd/8cUX+vDDD+Xt7a2mTZvq3LlzOnjwoGbOnKn169dr/vz5MpvN8vHxUceOHW0vfKhVq5aio6NVv379G679zTff1Jw5cyRJderUUXR0tCwWi+Lj4xUfH6/Ro0frj3/8Y6lrJk+erA8//FCS1KhRI7Vo0UIWi0Vr1661/fn73/9+wzUBAFDtGQAAAE42ffp0Izo62oiJibnquKNHjxrR0dFGdHS00bJlS2Pu3LlGfn6+YRiGkZ+fb7z22mu28wcOHLBdV1RUZAwZMsSIjo42hg4daqSkpNjOnT9/3njxxReN6Ohoo0uXLobFYrGdy8rKMu68804jOjraGDJkiHHkyBHbuYyMDGPcuHFGdHS0cdttt5U6t3DhQlsdDz30kHH+/HnDMAzj9OnTRlFRkWEYhvHss88a0dHRxq9+9SsjOTnZdm1ubq7x9ttvG9HR0UabNm2MvXv3lvoMXnjhBSM6Otp47rnnrvjZpKam2o4fPnzYaN++vREdHW288MILtloMwzBWrVpltG3b1oiOjjY+//xzwzAMo7Cw0OjTp48RHR1tPPXUU8bZs2dt4/Pz843Zs2fbnpOYmHjN51/Npk2bjBYtWhjR0dHGu+++axQWFhqGYRgXLlwwJk6caLtfdHS0UVBQcM3PoETJ53/5fCq5rm/fvsahQ4dKnVu9erXRrl07Izo62vjb3/5W6lxMTIytjokTJ9o+w6KiIuOTTz6xnfvxxx9LXVcyrx9++OEyNZZcs27dujJ19+jRo9TYzz77zIiOjjY6depkfPXVV7bjRUVFxrJly2zf3wULFtjOHThwwDaHfvrpp1L3W7x4sdGyZUsjOjraSEpKsvsZAgBQE7AeGgAAVAuDBw/W448/Li8vL0nFG8O/8MILqlWrliRpy5YttrHx8fFKSkpSaGio3n//fTVr1sx2rnbt2nrjjTfUrl07nTlzxrZyRip+E6PFYlG9evU0e/Zs3XzzzbZz9erV0/Tp0xUdHa2srCy99957duucMGGCateuLUkKDg6WyWTSnj17tGzZMvn5+emDDz5Q27ZtbeN9fHz07LPPqn///srLy9OsWbMq9Dl98MEHys7OVvv27TVp0iRbLZLUs2dPPfnkk5KkhQsXSpL27Nmjs2fPytvbW6+//rrq1KljG+/l5aWxY8faPoeKrtR69913ZRiG7r33Xj3xxBO2VWUBAQGaNGlSmVV5FVFYWKgtW7bIZDLpxRdfLNVqKkk9evTQgAEDJF3562rZsmWpz9BkMmn48OG21saff/650uotkZ+frxkzZkiSJk2apPvuu892zmQyacCAAbYVYDNmzFBhYaGk4hWMkhQREVFmleLAgQM1dOhQ3XPPPcrPz6/0mgEAqC4IwQAAQLVQ0iZ4KV9fX9teWKdPn7YdX7FihSSpT58+8vf3L3OdyWSyhQuJiYm24yX7Nw0cOLBUGFTC29tbjz76qG2sYRilznt4eKhDhw5lrvvxxx8lSZ07dy6z/1SJ+++/X5K0evVqWa1Wu2PKo+TrefDBB+3u//TII4/om2++0bx58yRJrVu31ubNm7V582YFBweXGZ+fn2/7LHJycm64rosXL2rjxo222i5nMplse6dVBk9PT61YsULJycnq3bt3mfOGYdjmRm5urt179O7d2+5ecyWhalZWVqXVWyIpKUmnTp1SQEBAqX3GLnXffffJw8ND6enp+uWXXyTJ9vdgz549mjJlilJTU0td88orr+itt95S586dK71mAACqC/YEAwAA1cKVwqOSzckvDTJKVvYkJiZqz549dq87f/68JCk1NVWGYchkMunQoUOSZNuc3Z6Sc6dPn9bZs2dLBUeBgYF2N4/fv3+/JGnnzp0aOnSo3fvm5eVJKg6L0tPT1bBhwyvWcCV5eXlKT0+XVLyKyZ5atWqpefPmZY77+voqNTVVO3fu1JEjR3T06FEdOHBAe/futdVWVFR03TWVOH78uG3V0pX2NWvXrt0N3/9KfHx8lJmZqW3btik1NVVpaWk6ePCgdu/erXPnzkm68td1pRcnlHyPKxJWXknJXCkoKNDw4cOvOM5sNquoqEgHDx5U27Zt1bp1a917771aunSp5s6dq7lz56pRo0bq1q2b7rzzTvXo0cO2ahIAgJqKEAwAAFQLPj4+5R574cIFSbJtVH41VqtVFy9eVK1atWzXXdpCeLlLg4SLFy+WCsGuVGPJiqHMzExlZmZes/7z58/fUAh29uxZ2z/bWwF3JcnJyXrzzTe1adOmUseDg4PVq1cv/fLLL0pLS7vuei516aqpkuDyckFBQRV6xuUyMjI0ZcoUff/99yooKLAd9/PzU5s2bWS1Wq/a0ujt7X3V+1++ErAylHxO+fn52rp16zXHl4S5kjR16lR17dpVX3zxhZKTk3Xs2DF9+eWX+vLLL+Xj46OHHnpIzz///DW/LgAA3BUhGAAAcDt+fn6SpD/96U965JFHyn1dQECAzp07d9U2t5LVQyXjr6eekSNH6oUXXih3Pder5DlScUBXHikpKXrssceUm5urqKgoPfDAA2rZsqUiIyNtq+8efvjhCodglwaLFy5cUN26dcuMuVa75ZVCJ3vX5eXlacSIEUpJSVFQUJCGDh2qW2+9VZGRkWrcuLHMZrOmTZvmkH29KqLke9i6dWstWrTouq41mUwaPHiwBg8erNOnT2vjxo3atGmTVq1apWPHjtlaYF9++eVKrxsAgOqAPcEAAIDbiYiIkPS/1jJ7Tpw4oW3btslisdiOlez1tGvXritet3PnTklSnTp17O6hdaP1nDlzRj///LOOHz9+wyuMAgMDFRISctVnWSwWPfTQQ3r22WeVlZWljz76SLm5uWrWrJm+/PJLjRw5Ut27dy/VflrSYlkRTZo0sa2UK9nH6nJXqrlkA/1LV3Nd6tLvYYkVK1YoJSVFnp6e+vzzzzVhwgT16dNHERERtvudPHnyur8ORyuZK6mpqbb20csZhqGffvpJqampto3uL1y4oJ07d+rgwYOSpLp166p///569dVXtWLFClsb7ldffeWErwIAgKqJEAwAALidmJgYSdK33357xfbDl156SUOGDNHvf//7MtctWbKk1IqvEvn5+frss88kFb9d8Hrr2bBhg1JSUuyOeeuttzRs2DA9+uijpfaoKtmYvbzBWM+ePSX97+2Pl/v++++VnJys5ORk1a5dW8eOHZMkRUZGllpJVmLdunU6fvy4pIrtgeXt7W3boL7kM7zc559/bvd4SdhYEvBcymq12l5ocKmSlWsBAQFl3gwpSadOndLKlStt96gM1/u9suf2229X7dq1dfHixSuuBFu6dKlGjBih/v3724K86dOn64EHHtCUKVPKjPfw8FC3bt0kOWYfMwAAqgtCMAAA4HYGDBig6OhonT9/XqNGjSq1wujChQt67bXXtH79eplMJo0dO9Z2bujQoQoLC9OpU6c0btw4HT161HYuMzNTv/vd77Rv3z4FBATomWeeKXc9nTp1Uo8ePVRYWKgxY8aU2uspPz9fs2bN0hdffCFJGjNmjG2lkvS/lsuSIOpaRo8eLR8fH23ZskV/+ctfSrUKrl69WtOmTZMkjRo1StL/Vh6tW7dOW7ZssY0tLCzUN998o2effdZ27EpvUSyvZ555Rj4+PlqxYoWmTp1qW8VUWFioWbNmaenSpXavu+222yQVrxT7+OOPbSHTuXPn9NJLL9lehHCpklV9586d00cffVQqmNq2bZsef/xx2x5qFXnr5aVKvlcWi+WKq7iuxd/f3zYn33jjDS1cuLBUKLpixQq9+uqrkqT+/furcePGkorfGGkymbRy5UrNmTOn1Kq548eP67333pMk9erV64bqAgDAHbAnGAAAcDteXl6aNWuWRo8erd27d+uee+5RRESE/Pz8lJqaquzsbEnSiy++aFs5JRW3E7733nsaO3askpKSdNdddykqKkqenp7av3+/CgoKFBQUpDfffNPu6qKrmTp1qsaNG6fk5GQNHTpU4eHhqlOnjo4ePWrb3HzEiBF6+OGHS13XqlUrSdLWrVvVr18/RUVF6Z133rnic6KiojRlyhQ9//zzmj9/vhYvXqxmzZopMzPT9pKAQYMGadiwYZKK9yn75ptvdObMGQ0fPlxNmzZVQECA0tLSdO7cOfn7+6tDhw5KSkqqcPtg8+bN9dZbb+m5557T+++/rwULFqhJkyZKS0vTmTNndMstt9htlezVq5c6deqkLVu26I033tDcuXMVHBysgwcPqqCgQM8884xmzJhR6prY2Fhb3ZMmTdKcOXMUFhamjIwMpaeny2QyqXv37lq/fr0sFovtDaEVUfK9OnbsmO666y6Fhobqs88+u+77jhkzRkePHtWCBQv00ksvaerUqQoPD1d6erqt9bNjx456/fXXbdfceuutmjBhgqZNm6Y333xT//rXvxQeHq6cnBwdPXpUhYWFaty4sSZOnFihrxEAgOqMEAwAALilm2++WYsXL9Znn32m5cuXKyUlRbm5uQoODlaPHj306KOP6vbbby9z3S233KJvvvlGH330keLj43XkyBGZTCZFREQoNjZWw4YNK7VfVnkFBwdr/vz5WrRokb755hvt3btXJ0+eVGBgoHr16qUhQ4YoLi6uzHUDBw7UwYMH9dVXXyktLU0FBQWlVgbZ079/f7Vo0UJz587V+vXrtXfvXvn4+KhLly4aOnSo+vfvbxvbsGFDff3115o1a5Y2bNigEydOyGw2q0GDBrrvvvs0YsQIHTt2TCNGjNDGjRuVnZ19XW+evFzfvn21ZMkSvfvuu7bamjZtqvHjxysiIkK/+c1vylzj4eGhDz74QP/+97+1bNkyHT58WDk5OerWrZuefPJJBQUFlQnBzGazPvzwQ82bN0/Lli3T0aNHtW/fPtWvX18DBgzQ8OHD1bp1a3Xp0kVnz57V1q1bbSvOblTXrl1t4aPFYlF+fr5OnTql+vXrX9d9TCaT/vrXv+ruu+/Wf/7zH23btk27d++Wj4+P2rdvr3vuuUdDhgwp85bHJ554QlFRUVqwYIF27dqlffv2ydfXV61atVLfvn316KOPVuh7BwBAdWcyHPFuZwAAAOA6bdy4UY899pik4pcTeHry/2sBAEDlYU8wAAAAAAAAuD1CMAAAAAAAALg9QjAAAAAAAAC4PUIwAAAAAAAAuD02xgcAAAAAAIDbYyUYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANweIRgAAAAAAADcHiEYAAAAAAAA3B4hGAAAAAAAANze/wPH2PRfHyKRAgAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -465,18 +468,6 @@ "source": [ "The End. " ] - }, - { - "cell_type": "markdown", - "id": "e5b79da1", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "id": "b020ee56", - "metadata": {}, - "source": [] } ], "metadata": { From 6d836ffd8815835136159d0d483e2fe04c07c4c2 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Thu, 23 May 2024 01:10:24 -0400 Subject: [PATCH 38/39] add pyarrow dep --- env.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/env.yml b/env.yml index e2c8206..3243d1c 100644 --- a/env.yml +++ b/env.yml @@ -10,6 +10,7 @@ dependencies: - pydantic >=2 - fsspec - pillow + - pyarrow # Scientific - numpy From becae34ff5569f03e6b0de8eab0a70d1aa3938ab Mon Sep 17 00:00:00 2001 From: Cas Wognum Date: Thu, 23 May 2024 16:43:29 -0400 Subject: [PATCH 39/39] Update the documentation (#5) * Docs pass * Changed extension to parquet in CLI --- README.md | 2 + auroris/cli.py | 21 +++-- auroris/curation/_curator.py | 90 +++++++++++++------- auroris/curation/actions/_ac_stereoisomer.py | 46 +++++----- auroris/curation/actions/_base.py | 22 +++-- auroris/curation/actions/_deduplicate.py | 19 ++--- auroris/curation/actions/_discretize.py | 46 ++++------ auroris/curation/actions/_distribution.py | 27 +++--- auroris/curation/actions/_mol.py | 73 ++++++++-------- auroris/curation/actions/_outlier.py | 11 ++- auroris/report/_report.py | 8 +- auroris/report/broadcaster/_html.py | 8 +- auroris/report/broadcaster/_logger.py | 4 +- auroris/types.py | 2 + auroris/utils.py | 8 +- docs/api/actions.md | 13 +++ docs/api/actions/deduplication.md | 4 - docs/api/actions/discretization.md | 4 - docs/api/actions/mol.md | 4 - docs/api/actions/outlier_detection.md | 4 - docs/api/actions/stereo_ac.md | 4 - docs/api/functional.md | 4 +- docs/api/utils.md | 5 ++ docs/api/visualization.md | 4 +- env.yml | 6 +- mkdocs.yml | 21 ++--- pyproject.toml | 1 + 27 files changed, 246 insertions(+), 215 deletions(-) create mode 100644 docs/api/actions.md delete mode 100644 docs/api/actions/deduplication.md delete mode 100644 docs/api/actions/discretization.md delete mode 100644 docs/api/actions/mol.md delete mode 100644 docs/api/actions/outlier_detection.md delete mode 100644 docs/api/actions/stereo_ac.md create mode 100644 docs/api/utils.md diff --git a/README.md b/README.md index 829d913..48ba4cb 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,8 @@ curator = Curator( dataset, report = curator(dataset) ``` ### Run curation with command line +A `Curator` object is serializable, so you can save it to and load it from a JSON file to reproduce the curation. + ``` auroris [config_file] [destination] --dataset-path [data_path] ``` diff --git a/auroris/cli.py b/auroris/cli.py index 0bc3301..a3ccef8 100644 --- a/auroris/cli.py +++ b/auroris/cli.py @@ -1,8 +1,8 @@ +from typing import Optional + import datamol as dm -import pandas as pd import typer -from typing import Optional from auroris.curation import Curator from auroris.report.broadcaster import HTMLBroadcaster @@ -11,17 +11,24 @@ @app.command() def curate(config_path: str, destination: str, dataset_path: Optional[str] = None, overwrite: bool = False): - # Load data - dataset = pd.read_csv(dataset_path) if dataset_path else None + # Create the curator curator = Curator.from_json(config_path) + # Overwrite the source dataset if it is set + if dataset_path is not None: + curator.src_dataset_path = dataset_path + # Run curation - dataset, report = curator(dataset) + dataset, report = curator.transform() # Save dataset dm.fs.mkdir(destination, exist_ok=overwrite) - path = dm.fs.join(destination, "curated.csv") - dataset.to_csv(path, index=False) + path = dm.fs.join(destination, "curated.parquet") + dataset.to_parquet(path, index=False) + + # Save a copy of the curation config + config_destination = dm.fs.join(destination, "config.json") + curator.to_json(config_destination) # Save report as HTML report_destination = dm.fs.join(destination, "report") diff --git a/auroris/curation/_curator.py b/auroris/curation/_curator.py index 7e07413..d90a23c 100644 --- a/auroris/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -1,11 +1,11 @@ import json -from typing import List, Tuple, Union, Optional, Annotated +from typing import Annotated, List, Optional, Tuple, Union -from os import PathLike +import datamol as dm import fsspec +import pandas as pd from loguru import logger from pydantic import BaseModel, Field, field_serializer, field_validator -import pandas as pd from auroris.curation.actions import BaseAction from auroris.report import CurationReport @@ -15,30 +15,27 @@ class Curator(BaseModel): """ - A curator is a collection of actions that are applied to a dataset. - Can be serialized. + A curator is a serializable collection of actions that are applied to a dataset. + Attributes: + steps (List[BaseAction]): Ordered list of curation actions to apply to the dataset. + src_dataset_path: An optional path to load the source dataset from. Can be used to specify a reproducible workflow. + verbosity: Verbosity level for logging. + parallelized_kwargs: Keyword arguments to affect parallelization in the steps. """ # To know which Action object to create, we need a discriminated union. # This is the recommended way to add all subclasses in the type. # See e.g. https://github.com/pydantic/pydantic/issues/2200 # and https://github.com/pydantic/pydantic/issues/2036 - src_dataset_path: Optional[Union[str, PathLike]] = Field( - default=None, - description="Data path. The data must be loadable by `pd.read_csv` with default parameters.", - ) - steps: List[ Annotated[ - Union[tuple(BaseAction.__subclasses__())], - Field( - ..., - discriminator="name", - description="List of curation actions. Check all the available action .", - ), + Union[tuple(BaseAction.__subclasses__())], # type: ignore + Field(..., discriminator="name"), ] ] + + src_dataset_path: Optional[str] = None verbosity: VerbosityLevel = VerbosityLevel.NORMAL parallelized_kwargs: dict = Field(default_factory=dict) @@ -52,35 +49,56 @@ def _validate_verbosity(cls, v): def _serialize_verbosity(self, value: VerbosityLevel): return value.name - @field_validator("src_dataset_path", mode="before") - def _validate_src_dataset_path(cls, value: Union[str, PathLike]): - # Use pyarrow reader interface for parquet validation which is also used in `pandas.read_parquet` + @field_validator("src_dataset_path") + def _validate_src_dataset_path(cls, value: Optional[str]): + # If not set, no need to validate + if value is None: + return value + + # Efficient check to see if it's a valid path to a supported file if not is_parquet_file(value): try: pd.read_csv(value, nrows=5) - return value except Exception: raise ValueError( f"Dataset can't be loaded by `pandas.read_csv('{value}')` nor `pandas.read_parquet('{value}')`." f"Consider passing the DataFrame directly to `Curator.curate(dataset=...)`." ) + + # If it's set, but local, warn the user that this hinders reproducibility. + if dm.utils.fs.is_local_path(value): + logger.warning( + "Using a local path for `src_dataset_path` hinders reproducibility. " + "Consider uploading the file to a public cloud storage service." + ) return value def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFrame, CurationReport]: + """Runs the curation process. + + Args: + dataset: The dataset to be curated. If `src_dataset_path` is set, this parameter is ignored. + + Returns: + A tuple of the curated dataset and a report summarizing the changes made. + """ + if self.src_dataset_path is not None: if dataset is not None: logger.warning( - "`self.scr_dataset_path` takes precedence over the `dataset` parameter. Overwriting the dataset!" + "Both `self.scr_dataset_path` and the `dataset` parameter are specified. " + "Ignoring the `dataset` parameter." ) - if is_parquet_file(self.src_dataset_path): - dataset = pd.read_csv(self.src_dataset_path) - else: - dataset = pd.read_parquet(self.src_dataset_path) + + dataset = self.load_dataset(self.src_dataset_path) if dataset is None: raise ValueError("Running the curator requires a source dataset.") + # The report summarizes the changes made to the dataset report = CurationReport() + + # Changes are not made in place dataset = dataset.copy(deep=True) action: BaseAction @@ -97,6 +115,20 @@ def transform(self, dataset: Optional[pd.DataFrame] = None) -> Tuple[pd.DataFram return dataset, report + @staticmethod + def load_dataset(path: str): + """ + Loads a dataset, to be curated, from a path. + + Info: File-format support + This currently only supports CSV and Parquet files and uses the default + parameters for `pd.read_csv` and `pd.read_parquet`. If you need more flexibility, + consider loading the data yourself and passing it directly to `Curator.transform(dataset=...)`. + """ + if not is_parquet_file(path): + return pd.read_csv(path) + return pd.read_parquet(path) + def __call__(self, dataset): return self.transform(dataset) @@ -109,7 +141,6 @@ def from_json(cls, path: str): """ with fsspec.open(path, "r") as f: data = json.load(f) - return cls(**data) def to_json(self, path: str): @@ -118,10 +149,5 @@ def to_json(self, path: str): Args: path: The destination to save to. """ - serialization = self.model_dump() - # remove src_dataset_path if unavailable - if self.src_dataset_path is None: - serialization.pop("src_dataset_path") with fsspec.open(path, "w") as f: - json.dump(serialization, f) - return path + json.dump(self.model_dump(), f) diff --git a/auroris/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py index 4a88cde..10161a6 100644 --- a/auroris/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -1,10 +1,9 @@ -from typing import Dict, List, Optional, Literal -from pydantic import Field +from typing import Dict, List, Literal, Optional import datamol as dm import numpy as np import pandas as pd - +from pydantic import Field from auroris.curation.actions._base import BaseAction from auroris.curation.actions._outlier import modified_zscore @@ -64,19 +63,22 @@ def detect_streoisomer_activity_cliff( class StereoIsomerACDetection(BaseAction): """ Automatic detection of activity shift between stereoisomers. + + See [`auroris.curation.functional.detect_streoisomer_activity_cliff`][] for the docs of the + `stereoisomer_id_col`, `y_cols` and `threshold` attributes + + Attributes: + mol_col: Column with the SMILES or RDKit Molecule objects. + If specified, will be used to render an image for the activity cliffs. """ - stereoisomer_id_col: str = Field( - default="MOL_molhash_id_no_stereo", description="Column which identifies the stereoisomers." - ) - y_cols: List[str] = Field(..., description="List of columns for bioactivities.") - threshold: float = Field( - default=2.0, - description=" Threshold to identify the activity cliff. Currently, the difference of zscores between isomers are used for identification.", - ) - prefix: str = Field(default="AC_", description="Prefix for the adding columns.") - mol_col: str = Field(default="MOL_smiles", description="Column for molecule strings.") name: Literal["ac_stereoisomer"] = "ac_stereoisomer" + prefix: str = "AC_" + + stereoisomer_id_col: str = "MOL_molhash_id_no_stereo" + y_cols: List[str] = Field(default_factory=list) + threshold: float = 2.0 + mol_col: Optional[str] = "MOL_smiles" def transform( self, @@ -93,6 +95,11 @@ def transform( prefix=self.prefix, ) + # Log the following information to the report: + # - Newly added columns + # - Number of activity cliffs found + # - Image of the activity cliffs + if report is not None: for col in self.y_cols: col_with_prefix = self.get_column_name(col) @@ -106,13 +113,14 @@ def transform( f"Found {num_cliff} activity cliffs among stereoisomers " f"with respect to the {col} column." ) - to_plot = dataset.loc[has_cliff, self.mol_col] - legends = (col + dataset.loc[has_cliff, col].astype(str)).tolist() - image = dm.to_image([dm.to_mol(s) for s in to_plot], legends=legends, use_svg=False) - report.log_image( - image_or_figure=image, title="Detection of activity shifts among stereoisomers" - ) + if self.mol_col is not None: + to_plot = dataset.loc[has_cliff, self.mol_col] + legends = (col + dataset.loc[has_cliff, col].astype(str)).tolist() + image = dm.to_image([dm.to_mol(s) for s in to_plot], legends=legends, use_svg=False) + report.log_image( + image_or_figure=image, title="Detection of activity shifts among stereoisomers" + ) else: report.log( diff --git a/auroris/curation/actions/_base.py b/auroris/curation/actions/_base.py index f90fb37..9afaafc 100644 --- a/auroris/curation/actions/_base.py +++ b/auroris/curation/actions/_base.py @@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Dict, Optional import pandas as pd -from pydantic import BaseModel, model_validator, Field +from pydantic import BaseModel, model_validator from auroris.types import VerbosityLevel @@ -10,15 +10,23 @@ from auroris.report import CurationReport -ACTION_REGISTRY = [] - - class BaseAction(BaseModel, abc.ABC): """ An action in the curation process. + + Info: The importance of reproducibility + One of the main goals in designing `auroris` is to make it easy to reproduce the curation process. + Reproducibility is key to scientific research. This is why a BaseAction needs to be serializable and + uniquely identified by a `name`. + + Attributes: + name: The name that uniquely identifies the action. This is used to serialize and deserialize the action. + prefix: This prefix is used when an action adds columns to a dataset. + If not set, it defaults to the name in uppercase. """ - prefix: str = Field(default=None, description="If the action adds columns, use this prefix.") + name: str + prefix: str = None @model_validator(mode="after") @classmethod @@ -42,7 +50,3 @@ def transform( def __call__(self, dataset: pd.DataFrame): return self.transform(dataset) - - def __init_subclass__(cls, **kwargs): - super().__init_subclass__(**kwargs) - ACTION_REGISTRY.append(cls) diff --git a/auroris/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py index 75e4681..3abfe1c 100644 --- a/auroris/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -1,5 +1,4 @@ from typing import Dict, List, Literal, Optional, Union -from pydantic import Field import pandas as pd @@ -54,20 +53,18 @@ def deduplicate( class Deduplication(BaseAction): """ Automatic detection of outliers. + + See [`auroris.curation.functional.deduplicate`][] for the docs of the + `deduplicate_on`, `y_cols`, `keep` and `method` attributes """ - deduplicate_on: Optional[Union[str, List[str]]] = Field( - default=None, description="A subset of the columns to deduplicate on (can be default)." - ) - y_cols: Optional[Union[str, List[str]]] = Field(default=None, description="The columns to aggregate.") - keep: Literal["first", "last"] = Field( - default="first", description="Whether to keep the first or last copy of the duplicates." - ) - method: Literal["mean", "median"] = Field( - default="median", description="The method to aggregate the data." - ) name: Literal["deduplicate"] = "deduplicate" + deduplicate_on: Optional[Union[str, List[str]]] = None + y_cols: Optional[Union[str, List[str]]] = None + keep: Literal["first", "last"] = "first" + method: Literal["mean", "median"] = "median" + def transform( self, dataset: pd.DataFrame, diff --git a/auroris/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py index 8a619e7..7c4e9f5 100644 --- a/auroris/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -1,5 +1,4 @@ from typing import Dict, List, Literal, Optional, Union -from pydantic import Field import numpy as np import pandas as pd @@ -80,38 +79,25 @@ def discretize( class Discretization(BaseAction): """ Thresholding bioactivity columns to binary or multiclass labels. + + See [`auroris.curation.functional.discretize`][] for the docs of the + `thresholds`, `inplace`, `allow_nan` and `label_order` attributes + + Attributes: + input_column: The column to discretize. + log_scale: Whether a visual depiction of the discretization should be on a log scale. """ - input_column: str = Field(..., description="Column to be discretized.") - prefix: str = Field(default="CLS_", description="Prefix for added column names.") - thresholds: List[float] = Field(..., description="Interval boundaries that include the right bin edge.") - inplace: bool = Field( - default=False, - description="""Set to True to perform inplace discretization and avoid a copy - (if the input is already a numpy array or a scipy.sparse CSR / CSC - matrix and if axis is 1).""", - ) - allow_nan: bool = Field( - default=True, - description="Set to True to allow nans in the array for discretization. Otherwise, an error will be raised instead.", - ) - label_order: Literal["ascending", "descending"] = Field( - default="ascending", - description="""The continuous values are discretized to labels 0, 1, 2, .., N with respect to given - threshold bins [threshold_1, threshold_2,.., threshould_n]. - When set to 'ascending', the class label is in ascending order with the threshold - bins that `0` represents negative class or lower class, while 1, 2, 3 are for higher classes. - When set to 'descending' the class label is in ascending order with the threshold bins. - Sometimes the positive labels are on the left side of provided threshold. - E.g. For binarization with threshold [0.5], the positive label is defined - by`X < 0.5`. In this case, `label_order` should be `descending`.""", - ) - log_scale: bool = Field( - default=False, - description="""Whether visualize distribution in log scale. - See more in """, - ) name: Literal["discretize"] = "discretize" + prefix: str = "CLS_" + + input_column: str + thresholds: List[float] + + inplace: bool = False + allow_nan: bool = True + label_order: Literal["ascending", "descending"] = "ascending" + log_scale: bool = False def transform( self, diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py index 4422f73..20dd3b1 100644 --- a/auroris/curation/actions/_distribution.py +++ b/auroris/curation/actions/_distribution.py @@ -1,6 +1,7 @@ -from typing import Dict, List, Optional, Sequence, Literal -from pydantic import Field +from typing import Dict, List, Literal, Optional, Sequence + import pandas as pd +from loguru import logger from auroris.curation.actions._base import BaseAction from auroris.report import CurationReport @@ -10,18 +11,21 @@ class ContinuousDistributionVisualization(BaseAction): """ - Visualize a continuous distribution. + Visualize one or more continuous distribution(s). + + See [`auroris.visualization.visualize_continuous_distribution`][] for the docs of the + `log_scale` and `bins` attributes + + Attributes: + y_cols: The columns whose distributions should be visualized. """ - y_cols: Optional[List[str]] = Field( - default=None, description="List of columns for bioactivity for visualization." - ) - log_scale: bool = Field(default=False, description="Whether visualize distribution in log scale.") - bins: Optional[Sequence[float]] = Field( - default=None, description="The bin boundaries to color the area under the KDE curve." - ) name: Literal["distribution"] = "distribution" + y_cols: List[str] + log_scale: bool = False + bins: Optional[Sequence[float]] = None + def transform( self, dataset: pd.DataFrame, @@ -29,6 +33,9 @@ def transform( verbosity: VerbosityLevel = VerbosityLevel.NORMAL, parallelized_kwargs: Optional[Dict] = None, ): + if report is None: + logger.warning("No report provided. Skipping visualization.") + if report is not None: for y_col in self.y_cols: fig = visualize_continuous_distribution( diff --git a/auroris/curation/actions/_mol.py b/auroris/curation/actions/_mol.py index 1552f6a..495b7f0 100644 --- a/auroris/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -1,6 +1,5 @@ from functools import partial from typing import Dict, List, Literal, Optional, Tuple, Union -from pydantic import Field import datamol as dm import numpy as np @@ -233,31 +232,27 @@ def _num_stereo_centers(mol: dm.Mol) -> Tuple[int]: class MoleculeCuration(BaseAction): """ Automated molecule curation and chemistry space distribution. + + See [`auroris.curation.functional.curate_molecules`][] for the docs of the + `remove_salt_solvent`, `remove_stereo`, `count_stereoisomers`, and `count_stereocenters` attributes + + Attributes: + input_column: The name of the column that has the molecules (either `dm.Mol` objects or SMILES). + X_col: Column with custom features for each of the molecules. If None, will use ECFP. + y_cols: Column names for bioactivities, which will be used to colorcode the chemical space visualization. """ - input_column: str = Field( - ..., description="The name of the column that has the molecules (either `dm.Mol` objects or SMILES)." - ) - prefix: str = Field(default="MOL_", description="Prefix for added column names") - remove_salt_solvent: bool = Field( - default=True, description="When set to 'True', all disconnected salts and solvents" - ) - remove_stereo: bool = Field( - default=False, - description="Whether remove stereochemistry information from molecule. If it's known that the stereochemistry do not contribute to the bioactivity of interest, the stereochemistry information can be removed.", - ) - count_stereoisomers: bool = Field( - default=True, description="Whether count the number of stereoisomers of molecule." - ) - count_stereocenters: bool = Field( - default=True, description="Whether count the number of stereocenter of molecule." - ) - y_cols: Optional[List[str]] = Field(default=None, description="Column names for bioactivities") - fast: Optional[bool] = Field( - default=True, - description="Whether compute molecule features with default ECFP for visualizing distribution in chemical space.", - ) name: Literal["mol_curation"] = "mol_curation" + prefix: str = "MOL_" + + input_column: str + remove_salt_solvent: bool = True + remove_stereo: bool = False + count_stereoisomers: bool = True + count_stereocenters: bool = True + + X_col: Optional[str] = None + y_cols: Optional[Union[str, List[str]]] = None def transform( self, @@ -266,8 +261,8 @@ def transform( verbosity: VerbosityLevel = VerbosityLevel.NORMAL, parallelized_kwargs: Optional[Dict] = None, ) -> pd.DataFrame: + # Run the curation mols = dataset[self.input_column].values - parallelized_kwargs = parallelized_kwargs or {} mol_dict, num_invalid = curate_molecules( mols, @@ -287,6 +282,9 @@ def transform( dataset = pd.concat([dataset, df], axis=1) + # Log information to the report + # - New columns with the curated molecule information + if report is not None: for col in df.columns: report.log_new_column(col) @@ -294,12 +292,15 @@ def transform( smiles_col = self.get_column_name("smiles") smiles = dataset[smiles_col].dropna().values - # Lu: User can call visulize_chemspace for the customized molecular features. - featurizer = "ECFP" - with dm.without_rdkit_log(): - # Temporary disable logs because of deprecation warning - X = np.array([dm.to_fp(smi) for smi in smiles]) - report.log("Default `ecfp` fingerprint is used to compute the distributionin chemical space.") + if self.X_col is None: + featurizer = "ECFP" + with dm.without_rdkit_log(): + X = np.array([dm.to_fp(smi) for smi in smiles]) + report.log("Default `ecfp` fingerprint is used to visualize the chemical space.") + + else: + featurizer = self.X_col + X = dataset[self.X_col].values # list of data per column y = dataset[self.y_cols].T.values.tolist() if self.y_cols else None @@ -309,7 +310,6 @@ def transform( if self.count_stereocenters: # Plot all compounds with undefined stereocenters for visual inspection - undefined_col = self.get_column_name("num_undefined_stereo_center") defined_col = self.get_column_name("num_defined_stereo_center") @@ -324,10 +324,7 @@ def transform( defined = row[defined_col] legends.append(f"Undefined:{undefined}\n Definded:{defined}") - with create_figure( - n_plots=1, - n_cols=1, - ) as (image, _): + with create_figure(n_plots=1, n_cols=1) as (image, _): dm.to_image( to_plot[smiles_col].tolist(), legends=legends, use_svg=False, returnPNG=True ) @@ -335,9 +332,9 @@ def transform( report.log_image( image, title="Molecules with undefined stereocenters", - description=f"There are {num_mol_undefined} molecules with undefined stereocenter(s)." - f"It's recommanded to use and" - f"check the stereoisomers and activity cliffs in the dataset.", + description=f"There are {num_mol_undefined} molecules with undefined stereocenter(s). " + "It's recommended to use and " + "check the stereoisomers and activity cliffs in the dataset.", ) return dataset diff --git a/auroris/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py index 398169d..3f15ab0 100644 --- a/auroris/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -134,13 +134,20 @@ def modified_zscore(data: np.ndarray, consistency_correction: float = 1.4826): class OutlierDetection(BaseAction): """ Automatic detection of outliers. + + See [`auroris.curation.functional.detect_outliers`][] for the docs of the + `method` and `kwargs` attributes + + Attributes: + columns: The columns for which to detect outliers. """ + name: Literal["outlier_detection"] = "outlier_detection" + prefix: str = Field(default="OUTLIER_", description="Prefix for added column names.") + method: OutlierDetectionMethod = Field(..., description="Method name for outlier detection.") columns: List[str] = Field(..., description="Column names to detect outliers.") - prefix: str = Field(default="OUTLIER_", description="Prefix for added column names.") kwargs: Dict = Field(default_factory=dict) - name: Literal["outlier_detection"] = "outlier_detection" def transform( self, diff --git a/auroris/report/_report.py b/auroris/report/_report.py index 526147c..56504a0 100644 --- a/auroris/report/_report.py +++ b/auroris/report/_report.py @@ -8,7 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field, PrivateAttr from auroris import __version__ -from auroris.utils import fig2img, bytes2img +from auroris.utils import bytes2img, fig2img class AnnotatedImage(BaseModel): @@ -71,11 +71,7 @@ def log_new_column(self, name: str): def log_image( self, - image_or_figure: Union[ - ImageType, - Figure, - ByteString, - ], + image_or_figure: Union[ImageType, Figure, ByteString], title: Optional[str] = None, description: Optional[str] = None, ): diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py index d8f97ed..4694db8 100644 --- a/auroris/report/broadcaster/_html.py +++ b/auroris/report/broadcaster/_html.py @@ -1,7 +1,6 @@ import base64 -import re import os -import pathlib +import re from copy import deepcopy from importlib import resources @@ -56,8 +55,6 @@ def broadcast(self): if not self._embed_images: dm.fs.mkdir(self._image_dir, exist_ok=True) - pathlib.Path(__file__).parent.resolve() / "templates" - # Save all images image_counter = 0 for section in report.sections: @@ -100,8 +97,7 @@ def _img_to_html_src(self, path: str): Convert a path to a corresponding `src` attribute for an `` tag. Currently only supports local paths. """ - protocol = dm.utils.fs.get_protocol(path) - if protocol == "file": + if dm.utils.fs.is_local_path(path): return os.path.relpath(path, self._destination) else: raise ValueError("We only support images hosted locally.") diff --git a/auroris/report/broadcaster/_logger.py b/auroris/report/broadcaster/_logger.py index 0cad0ee..27dc124 100644 --- a/auroris/report/broadcaster/_logger.py +++ b/auroris/report/broadcaster/_logger.py @@ -17,7 +17,7 @@ class ColoredFormatter(logging.Formatter): FORMATS = { logging.DEBUG: grey + format + reset, - logging.INFO: grey + format + reset, + logging.INFO: blue + format + reset, logging.WARNING: yellow + format + reset, logging.ERROR: red + format + reset, logging.CRITICAL: bold_red + format + reset, @@ -61,7 +61,7 @@ def render_image(self, image: AnnotatedImage): self.logger.debug(f"[IMG]: Dimensions {width} x {height}") def on_section_start(self, section: Section): - self.logger.debug(f"===== {section.title} =====") + self.logger.info(f"===== {section.title} =====") def on_report_start(self, report: CurationReport): self.logger.critical("===== Curation Report =====") diff --git a/auroris/types.py b/auroris/types.py index 013135c..cfcaf55 100644 --- a/auroris/types.py +++ b/auroris/types.py @@ -2,6 +2,8 @@ class VerbosityLevel(IntEnum): + """The different verbosity levels""" + SILENT = 0 NORMAL = 1 VERBOSE = 2 diff --git a/auroris/utils.py b/auroris/utils.py index 095f3c3..ce345bb 100644 --- a/auroris/utils.py +++ b/auroris/utils.py @@ -1,12 +1,12 @@ from io import BytesIO from typing import ByteString + import fsspec -import pyarrow.parquet as pq import numpy as np +import pyarrow.parquet as pq from matplotlib.figure import Figure from PIL import Image from PIL.Image import Image as ImageType - from sklearn.utils.multiclass import type_of_target @@ -42,18 +42,18 @@ def img2bytes(image: ImageType): def bytes2img(image_bytes: ByteString): """Convert bytes to PIL image""" image_stream = BytesIO(image_bytes) - # Open the image using PIL image = Image.open(image_stream) return image def save_image(image: ImageType, path: str): + """Save an image to a fsspec-compatible path""" with fsspec.open(path, "wb") as fd: image.save(fd, format="png") def is_parquet_file(path): - """Verify parquet file""" + """Verify parquet file without actually loading it.""" try: pq.read_schema(path) return True diff --git a/docs/api/actions.md b/docs/api/actions.md new file mode 100644 index 0000000..714a080 --- /dev/null +++ b/docs/api/actions.md @@ -0,0 +1,13 @@ +::: auroris.curation.actions.BaseAction + options: + filters: ["!^_"] + +--- + +::: auroris.curation.actions + options: + show_root_heading: False + show_root_toc_entry: False + filters: ["!BaseAction", "!^_"] + +--- \ No newline at end of file diff --git a/docs/api/actions/deduplication.md b/docs/api/actions/deduplication.md deleted file mode 100644 index 1e6a0a5..0000000 --- a/docs/api/actions/deduplication.md +++ /dev/null @@ -1,4 +0,0 @@ - -::: auroris.curation.actions.Deduplication - options: - filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/discretization.md b/docs/api/actions/discretization.md deleted file mode 100644 index 3de0d20..0000000 --- a/docs/api/actions/discretization.md +++ /dev/null @@ -1,4 +0,0 @@ - -::: auroris.curation.actions.Discretization - options: - filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/mol.md b/docs/api/actions/mol.md deleted file mode 100644 index 8d95039..0000000 --- a/docs/api/actions/mol.md +++ /dev/null @@ -1,4 +0,0 @@ - -::: auroris.curation.actions.MoleculeCuration - options: - filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/outlier_detection.md b/docs/api/actions/outlier_detection.md deleted file mode 100644 index 5a7b0b3..0000000 --- a/docs/api/actions/outlier_detection.md +++ /dev/null @@ -1,4 +0,0 @@ - -::: auroris.curation.actions.OutlierDetection - options: - filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/stereo_ac.md b/docs/api/actions/stereo_ac.md deleted file mode 100644 index 97f93a1..0000000 --- a/docs/api/actions/stereo_ac.md +++ /dev/null @@ -1,4 +0,0 @@ - -::: auroris.curation.actions.StereoIsomerACDetection - options: - filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/functional.md b/docs/api/functional.md index 3518fa4..b0d1a1b 100644 --- a/docs/api/functional.md +++ b/docs/api/functional.md @@ -1,4 +1,6 @@ ::: auroris.curation.functional options: - filters: ["!^_"] \ No newline at end of file + filters: ["!^_"] + show_root_heading: False + show_root_toc_entry: False \ No newline at end of file diff --git a/docs/api/utils.md b/docs/api/utils.md new file mode 100644 index 0000000..3338f39 --- /dev/null +++ b/docs/api/utils.md @@ -0,0 +1,5 @@ +::: auroris.utils + options: + filters: ["!^_"] + show_root_heading: False + show_root_toc_entry: False \ No newline at end of file diff --git a/docs/api/visualization.md b/docs/api/visualization.md index 7dafb14..279d852 100644 --- a/docs/api/visualization.md +++ b/docs/api/visualization.md @@ -1,3 +1,5 @@ ::: auroris.visualization options: - filters: ["!^_"] \ No newline at end of file + filters: ["!^_"] + show_root_heading: False + show_root_toc_entry: False \ No newline at end of file diff --git a/env.yml b/env.yml index 3243d1c..0bab54f 100644 --- a/env.yml +++ b/env.yml @@ -45,8 +45,4 @@ dependencies: - markdown-include - mdx_truly_sane_lists - nbconvert - - mike >=1.0.0 - - - pip - - pip: - - griffe_fieldz \ No newline at end of file + - mike >=1.0.0 \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml index 52aec8a..9ca3ffc 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -18,16 +18,15 @@ nav: - Tutorials: - Getting Started: tutorials/getting_started.ipynb - API Reference: - - Curator: api/curator.md - - Actions: - - Deduplication: api/actions/deduplication.md - - Discretization: api/actions/discretization.md - - Molecule Curation: api/actions/mol.md - - Outlier Detection: api/actions/outlier_detection.md - - Stereoisomer AC: api/actions/stereo_ac.md - - Functional: api/functional.md - - Visualization: api/visualization.md - - Types: api/types.md + - Core: + - Curator: api/curator.md + - Actions: api/actions.md + - Functional API: + - Curation: api/functional.md + - Visualization: api/visualization.md + - Misc: + - Types: api/types.md + - Utils: api/utils.md - Community: https://discord.gg/vBFd8p6H7u - Polaris Hub: https://polarishub.io/ @@ -99,8 +98,6 @@ plugins: separate_signature: true show_signature_annotations: true line_length: 80 - extensions: - - griffe_fieldz: {include_inherited: true} # support pydantic data-class - mkdocs-jupyter: execute: False remove_tag_config: diff --git a/pyproject.toml b/pyproject.toml index 3810c7f..3e02eff 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,6 +43,7 @@ dependencies = [ "datamol >=0.12.1", "pillow", "fsspec", + "pyarrow", ] [project.optional-dependencies]