From 1a95140d90d62e215ebff8cbada2a803f1d93687 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Fri, 13 Dec 2024 19:50:50 -0600 Subject: [PATCH 01/12] refactor: extracted output writer factory --- mokapot/confidence.py | 129 +++++++++++++++++++++++++++--------------- 1 file changed, 82 insertions(+), 47 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index a59119f..979ea93 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -332,8 +332,13 @@ def assign_confidence( # just take the first one for info (and make sure the other are the same) curr_dataset = datasets[0] file_ext = curr_dataset.get_default_extension() - for dataset in datasets[1:]: - assert dataset.columns == curr_dataset.columns + for di, dataset in enumerate(datasets[1:]): + if dataset.columns != curr_dataset.columns: + raise ValueError( + "Datasets must have the same columns. " + f"Dataset 1 has columns {curr_dataset.columns} " + f"and dataset {di + 2} has columns {dataset.columns}" + ) # Level data for psm level level = "psms" @@ -361,49 +366,10 @@ def assign_confidence( level_data_path[level] = dest_dir / f"{file_root}{level}{file_ext}" level_hash_columns[level] = curr_dataset.protein_column - output_column_names = [ - "PSMId", - "peptide", - *extra_output_columns, - "score", - "q-value", - "posterior_error_prob", - "proteinIds", - ] - - output_column_names_proteins = [ - "mokapot protein group", - "best peptide", - "stripped sequence", - "score", - "q-value", - "posterior_error_prob", - ] - - @typechecked - def create_output_writer(path: Path, level: str, initialize: bool): - # Note: This method does not create a writer, it writes the data. - if level == "proteins": - output_columns = output_column_names_proteins - else: - output_columns = output_column_names - - # Create the writers - if is_sqlite: - writer = ConfidenceSqliteWriter( - sqlite_path, - columns=output_columns, - column_types=[], - level=level, - qvalue_column="q-value", - pep_column="posterior_error_prob", - ) - else: - writer = TabularDataWriter.from_suffix(path, output_columns, []) - - if initialize: - writer.initialize() - return writer + output_writers_factory = OutputWriterFactory( + extra_output_columns, + is_sqlite=is_sqlite, + ) if prefixes is None: prefixes = [None] * len(datasets) @@ -454,7 +420,7 @@ def create_output_writer(path: Path, level: str, initialize: bool): ) output_writers[level].append( - create_output_writer( + output_writers_factory.create_writer( outfile_targets, level, not append_to_output_file ) ) @@ -464,7 +430,7 @@ def create_output_writer(path: Path, level: str, initialize: bool): dest_dir / f"{file_prefix}decoys.{level}{file_ext}" ) output_writers[level].append( - create_output_writer( + output_writers_factory.create_output_writer( outfile_decoys, level, not append_to_output_file ) ) @@ -577,6 +543,75 @@ def hash_data_row(data_row): return out +class OutputWriterFactory: + """Factory class for creating output writers based on configuration.""" + + def __init__(self, extra_output_columns: list[str], is_sqlite: bool): + self.is_sqlite = is_sqlite + self.extra_output_columns = extra_output_columns + self.output_column_names = [ + "PSMId", + "peptide", + *extra_output_columns, + "score", + "q-value", + "posterior_error_prob", + "proteinIds", + ] + + self.output_column_names_proteins = [ + "mokapot protein group", + "best peptide", + "stripped sequence", + "score", + "q-value", + "posterior_error_prob", + ] + + def __str__(self) -> str: + out = "OutputWriterFactory(" + out += f"extra_output_columns={self.extra_output_columns}, " + out += f"is_sqlite={self.is_sqlite})" + return out + + def __repr__(self) -> str: + out = "OutputWriterFactory:" + out += f"\textra_output_columns={self.extra_output_columns}, " + out += f"\tis_sqlite={self.is_sqlite}" + out += f"\toutput_column_names={self.output_column_names}, " + out += "\toutput_column_names_proteins=" + out += f"{self.output_column_names_proteins}" + return out + + def create_writer( + self, + path: Path, + level: str, + initialize: bool, + ) -> TabularDataWriter | ConfidenceSqliteWriter: + """Create appropriate writer based on output type and level.""" + output_columns = ( + self.output_column_names_proteins + if level == "proteins" + else self.output_column_names + ) + + if self.is_sqlite: + return ConfidenceSqliteWriter( + path, + columns=output_columns, + column_types=[], + level=level, + qvalue_column="q-value", + pep_column="posterior_error_prob", + ) + + writer = TabularDataWriter.from_suffix(path, output_columns, []) + if initialize: + writer.initialize() + return writer + + @contextmanager @typechecked def create_sorted_file_reader( From 0466b71cd647e6f5a71cc812701c142353626975 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Fri, 13 Dec 2024 21:27:08 -0600 Subject: [PATCH 02/12] refactor: extracted level manager in confidence --- mokapot/confidence.py | 267 ++++++++++++++++++++++++++++++------------ 1 file changed, 191 insertions(+), 76 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index 979ea93..d24bc02 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -18,6 +18,7 @@ import logging from contextlib import contextmanager from pathlib import Path +from pprint import pformat from typing import Sequence, Iterator import numpy as np @@ -340,34 +341,16 @@ def assign_confidence( f"and dataset {di + 2} has columns {dataset.columns}" ) - # Level data for psm level - level = "psms" - levels = [level] - level_data_path = {level: dest_dir / f"{file_root}{level}{file_ext}"} - level_hash_columns = {level: curr_dataset.spectrum_columns} - - # Level data for higher rollup levels - extra_output_columns = [] - if do_rollup: - level_columns = curr_dataset.level_columns - - for level_column in level_columns: - level = level_column.lower() + "s" # e.g. Peptide to peptides - levels.append(level) - level_data_path[level] = dest_dir / f"{file_root}{level}{file_ext}" - level_hash_columns[level] = [level_column] - if level not in ["psms", "peptides", "proteins"]: - extra_output_columns.append(level_column) - - levels_or_proteins = levels - if proteins: - level = "proteins" - levels_or_proteins = [*levels, level] - level_data_path[level] = dest_dir / f"{file_root}{level}{file_ext}" - level_hash_columns[level] = curr_dataset.protein_column + level_manager = LevelManager.from_dataset( + dataset=curr_dataset, + do_rollup=do_rollup, + use_proteins=True if proteins else False, + dest_dir=dest_dir, + file_root=file_root, + ) output_writers_factory = OutputWriterFactory( - extra_output_columns, + level_manager.extra_output_columns, is_sqlite=is_sqlite, ) @@ -381,38 +364,18 @@ def assign_confidence( # column defs module, and further, have standardized columns # directly from the pin reader (applying the renaming itself) - level_column_names = [ - "PSMId", - dataset.target_column, - "peptide", - *extra_output_columns, - "proteinIds", - "score", - ] - level_input_column_names = [ - dataset.specId_column, - dataset.target_column, - dataset.peptide_column, - *extra_output_columns, - dataset.protein_column, - "score", - ] - - level_input_output_column_mapping = { - in_col: out_col - for in_col, out_col in strictzip( - level_input_column_names, - level_column_names, - ) - if in_col is not None - } + # Q: why is this done here? it seems constant, since all + # datasets have the same columns. + level_input_output_column_mapping = ( + level_manager.build_output_col_mapping(dataset) + ) file_prefix = file_root if prefix: file_prefix = f"{file_prefix}{prefix}." output_writers = {} - for level in levels_or_proteins: + for level in level_manager.levels_or_proteins: output_writers[level] = [] outfile_targets = ( @@ -441,7 +404,9 @@ def assign_confidence( score_reader, dest_dir, file_prefix, - level_hash_columns["psms"] if deduplication else None, + level_manager.level_hash_columns["psms"] + if deduplication + else None, max_workers, level_input_output_column_mapping, ) as sorted_file_reader: @@ -464,29 +429,32 @@ def assign_confidence( level_writers = { level: TabularDataWriter.from_suffix( - level_data_path[level], + level_manager.level_data_paths[level], columns=list(level_input_output_column_mapping.values()), column_types=level_column_types, buffer_size=CONFIDENCE_CHUNK_SIZE, buffer_type=BufferType.Dicts, ) - for level in levels + for level in level_manager.levels } - for writer in level_writers.values(): + for level, writer in level_writers.items(): + LOGGER.info(f"Initializing writer for level {level}: {writer}") writer.initialize() def hash_data_row(data_row): return str([ data_row[level_input_output_column_mapping.get(col, col)] - for col in level_hash_columns[level] + for col in level_manager.level_hash_columns[level] ]) - seen_level_entities = {level: set() for level in levels} + seen_level_entities = { + level: set() for level in level_manager.levels + } score_stats = OnlineStatistics() psm_count = 0 for data_row in sorted_file_iterator: psm_count += 1 - for level in levels: + for level in level_manager.levels: if level != "psms" or deduplication: psm_hash = hash_data_row(data_row) if psm_hash in seen_level_entities[level]: @@ -503,9 +471,13 @@ def hash_data_row(data_row): level_writers[level].append_data(out_row) score_stats.update_single(data_row["score"]) - for level in levels: + for level in level_manager.levels: count = len(seen_level_entities[level]) - level_writers[level].finalize() + curr_writer = level_writers[level] + LOGGER.info( + f"Finalizing writer for level {level}: {curr_writer}" + ) + curr_writer.finalize() if level == "psms": if deduplication: LOGGER.info( @@ -522,8 +494,8 @@ def hash_data_row(data_row): con = Confidence( dataset=dataset, - levels=levels_or_proteins, - level_paths=level_data_path, + levels=level_manager.levels_or_proteins, + level_paths=level_manager.level_data_paths, out_writers=output_writers, eval_fdr=eval_fdr, write_decoys=write_decoys, @@ -543,6 +515,160 @@ def hash_data_row(data_row): return out +# class MultiLevelWriter: + + +class LevelManager: + """Manages level-specific data and operations.""" + + def __init__( + self, + *, + level_columns: list[str], + default_extension: str, + spectrum_columns: list[str], + do_rollup: bool, + use_proteins: bool, + dest_dir: Path, + file_root: str, + ): + self.level_columns = level_columns + self.default_extension = default_extension + self.spectrum_columns = spectrum_columns + self.use_proteins = use_proteins + self.dest_dir = dest_dir + self.file_root = file_root + self.do_rollup = do_rollup + + self._initialize_levels() + self._setup_level_paths() + self._setup_hash_columns() + self._setup_protein_levels() + self._setup_extra_output_columns() + + # self.level_data_paths = {} + # self.level_hash_columns = {} + + @staticmethod + def from_dataset( + *, + dataset: PsmDataset, + do_rollup: bool, + use_proteins: bool, + dest_dir: Path, + file_root: str, + ): + level_columns = dataset.level_columns + default_extension = dataset.get_default_extension() + spectrum_columns = dataset.spectrum_columns + return LevelManager( + level_columns=level_columns, + default_extension=default_extension, + spectrum_columns=spectrum_columns, + do_rollup=do_rollup, + use_proteins=use_proteins, + dest_dir=dest_dir, + file_root=file_root, + ) + + def __repr__(self) -> str: + formatted_dict = pformat(self.__dict__) + return f"{self.__class__!s}({formatted_dict})" + + def _initialize_levels(self) -> list[str]: + """Initialize processing levels based on configuration.""" + levels = ["psms"] + if self.do_rollup: + level_columns = self.level_columns + levels.extend(col.lower() + "s" for col in level_columns) + + self.levels = levels + + def _setup_level_paths( + self, + ) -> None: + """Setup paths for each processing level.""" + self.level_data_paths = {} + file_ext = self.default_extension + for level in self.levels: + self.level_data_paths[level] = ( + self.dest_dir / f"{self.file_root}{level}{file_ext}" + ) + + def _setup_hash_columns(self) -> None: + """Setup hash columns for each level.""" + self.level_hash_columns = {"psms": self.spectrum_columns} + for level in self.levels[1:]: + if level != "proteins": + self.level_hash_columns[level] = [ + level.rstrip("s").capitalize() + ] + + def _setup_protein_levels(self) -> None: + levels_or_proteins = self.levels + if self.use_proteins: + levels_or_proteins = [*levels_or_proteins, "proteins"] + self.level_data_paths["proteins"] = ( + self.dest_dir / f"{self.file_root}proteins{self.file_ext}" + ) + self.level_hash_columns["proteins"] = self.protein_column + + self.levels_or_proteins = levels_or_proteins + + def _setup_extra_output_columns(self) -> None: + extra_output_columns = [] + if self.do_rollup: + level_columns = self.level_columns + + for level_column in level_columns: + level = level_column.lower() + "s" # e.g. Peptide to peptides + if level not in self.levels: + self.levels.append(level) + + self.level_data_paths[level] = ( + self.dest_dir + / f"{self.file_root}{level}{self.default_extension}" + ) + + # I am not sure why but over-writing some of the levels here is + # important, I think it has to do with with how the rollup + # levels are handled (columns are renamed). + self.level_hash_columns[level] = [level_column] + if level not in ["psms", "peptides", "proteins"]: + extra_output_columns.append(level_column) + + self.extra_output_columns = extra_output_columns + + def build_output_col_mapping(self, dataset: PsmDataset) -> dict: + level_column_names = [ + "PSMId", + dataset.target_column, + "peptide", + *self.extra_output_columns, + "proteinIds", + "score", + ] + level_input_column_names = [ + dataset.specId_column, + dataset.target_column, + dataset.peptide_column, + *self.extra_output_columns, + dataset.protein_column, + "score", + ] + + level_input_output_column_mapping = { + in_col: out_col + for in_col, out_col in strictzip( + level_input_column_names, + level_column_names, + ) + if in_col is not None + } + + return level_input_output_column_mapping + + class OutputWriterFactory: """Factory class for creating output writers based on configuration.""" @@ -568,20 +694,9 @@ def __init__(self, extra_output_columns: list[str], is_sqlite: bool): "posterior_error_prob", ] - def __str__(self) -> str: - out = "OutputWriterFactory(" - out += f"extra_output_columns={self.extra_output_columns}, " - out += f"is_sqlite={self.is_sqlite})" - return out - def __repr__(self) -> str: - out = "OutputWriterFactory:" - out += f"\textra_output_columns={self.extra_output_columns}, " - out += f"\tis_sqlite={self.is_sqlite}" - out += f"\toutput_column_names={self.output_column_names}, " - out += "\toutput_column_names_proteins=" - out += f"{self.output_column_names_proteins}" - return out + formatted_dict = pformat(self.__dict__) + return f"{self.__class__!s}({formatted_dict})" def create_writer( self, From 692a9f2b844ce7d562069c9b5e61864444c101c1 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Fri, 13 Dec 2024 22:11:38 -0600 Subject: [PATCH 03/12] refactor: extracted level writer group --- mokapot/confidence.py | 194 ++++++++++++++++++++++++++---------------- 1 file changed, 122 insertions(+), 72 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index d24bc02..a93b2c3 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -15,6 +15,8 @@ confidence estimates, rather than initializing the classes below directly. """ +from __future__ import annotations + import logging from contextlib import contextmanager from pathlib import Path @@ -266,7 +268,7 @@ def assign_confidence( datasets: list[PsmDataset], scores_list: list[np.ndarray[float]], max_workers: int = 1, - eval_fdr=0.01, + eval_fdr: float = 0.01, dest_dir: Path | None = None, file_root: str = "", prefixes: list[str | None] | None = None, @@ -422,75 +424,15 @@ def assign_confidence( row_type=BufferType.Dicts ) type_map = sorted_file_reader.get_schema(as_dict=True) - level_column_types = [ - type_map[name] - for name in level_input_output_column_mapping.values() - ] - - level_writers = { - level: TabularDataWriter.from_suffix( - level_manager.level_data_paths[level], - columns=list(level_input_output_column_mapping.values()), - column_types=level_column_types, - buffer_size=CONFIDENCE_CHUNK_SIZE, - buffer_type=BufferType.Dicts, - ) - for level in level_manager.levels - } - for level, writer in level_writers.items(): - LOGGER.info(f"Initializing writer for level {level}: {writer}") - writer.initialize() - - def hash_data_row(data_row): - return str([ - data_row[level_input_output_column_mapping.get(col, col)] - for col in level_manager.level_hash_columns[level] - ]) - - seen_level_entities = { - level: set() for level in level_manager.levels - } - score_stats = OnlineStatistics() - psm_count = 0 - for data_row in sorted_file_iterator: - psm_count += 1 - for level in level_manager.levels: - if level != "psms" or deduplication: - psm_hash = hash_data_row(data_row) - if psm_hash in seen_level_entities[level]: - if level == "psms": - # If we are on the psms level, we can skip - # checking the other levels - break - continue - seen_level_entities[level].add(psm_hash) - out_row = { - col: data_row[col] - for col in level_input_output_column_mapping.values() - } - level_writers[level].append_data(out_row) - score_stats.update_single(data_row["score"]) - - for level in level_manager.levels: - count = len(seen_level_entities[level]) - curr_writer = level_writers[level] - LOGGER.info( - f"Finalizing writer for level {level}: {curr_writer}" - ) - curr_writer.finalize() - if level == "psms": - if deduplication: - LOGGER.info( - f"\t- Found {count} PSMs from unique spectra." - ) - else: - LOGGER.info(f"\t- Found {psm_count} PSMs.") - LOGGER.info( - f"\t- The average score was {score_stats.mean:.3f} " - f"with standard deviation {score_stats.sd:.3f}." - ) - else: - LOGGER.info(f"\t- Found {count} unique {level}.") + level_writers = LevelWriterCollection.from_manager( + level_manager=level_manager, + type_map=type_map, + level_input_output_column_mapping=level_input_output_column_mapping, + deduplication=deduplication, + ) + + level_writers.sink_iterator(sorted_file_iterator) + level_writers.finalize() con = Confidence( dataset=dataset, @@ -506,7 +448,7 @@ def hash_data_row(data_row): peps_algorithm=peps_algorithm, qvalue_algorithm=qvalue_algorithm, stream_confidence=stream_confidence, - score_stats=score_stats, + score_stats=level_writers.score_stats, ) out.append(con) if not prefix: @@ -515,7 +457,112 @@ def hash_data_row(data_row): return out -# class MultiLevelWriter: +class LevelWriterCollection: + def __init__( + self, + levels: list[str], + level_data_paths: dict[str, Path], + schema_dict: dict[str, np.dtype], + level_input_output_column_mapping: dict[str, str], + level_hash_columns: dict[str, list[str]], + deduplication: bool, + ): + # Do I need to pass the levels? cant I use the keys of the data paths? + self.levels = levels + self.deduplication = deduplication + self.level_input_output_column_mapping = ( + level_input_output_column_mapping + ) + self.level_hash_columns = level_hash_columns + level_column_types = [ + schema_dict[name] + for name in level_input_output_column_mapping.values() + ] + + self.level_writers = { + level: TabularDataWriter.from_suffix( + level_data_paths[level], + columns=list(level_input_output_column_mapping.values()), + column_types=level_column_types, + buffer_size=CONFIDENCE_CHUNK_SIZE, + buffer_type=BufferType.Dicts, + ) + for level in levels + } + self.seen_level_entities = {level: set() for level in levels} + for level, writer in self.level_writers.items(): + LOGGER.info(f"Initializing writer for level {level}: {writer}") + writer.initialize() + + self.score_stats = OnlineStatistics() + self.psm_count = 0 + + def __repr__(self): + pretty_dict = pformat(self.__dict__) + return f"{self.__class__!s}({pretty_dict})" + + @staticmethod + def from_manager( + level_manager: LevelManager, + type_map: dict[str, np.dtype], + level_input_output_column_mapping: dict[str, str], + deduplication: bool, + ) -> LevelWriterCollection: + level_data_paths = level_manager.level_data_paths + levels = level_manager.levels + hash_columns = level_manager.level_hash_columns + return LevelWriterCollection( + levels=levels, + level_data_paths=level_data_paths, + schema_dict=type_map, + level_input_output_column_mapping=level_input_output_column_mapping, + level_hash_columns=hash_columns, + deduplication=deduplication, + ) + + def hash_data_row(self, data_row, level): + return str([ + data_row[self.level_input_output_column_mapping.get(col, col)] + for col in self.level_hash_columns[level] + ]) + + def sink_iterator(self, sorted_file_iterator): + for data_row in sorted_file_iterator: + self.psm_count += 1 + for level in self.levels: + if level != "psms" or self.deduplication: + psm_hash = self.hash_data_row(data_row, level=level) + if psm_hash in self.seen_level_entities[level]: + if level == "psms": + # If we are on the psms level, we can skip + # checking the other levels + break + continue + self.seen_level_entities[level].add(psm_hash) + out_row = { + col: data_row[col] + for col in self.level_input_output_column_mapping.values() + } + self.level_writers[level].append_data(out_row) + self.score_stats.update_single(data_row["score"]) + + def finalize(self): + for level in self.levels: + count = len(self.seen_level_entities[level]) + curr_writer = self.level_writers[level] + LOGGER.info(f"Finalizing writer for level {level}: {curr_writer}") + curr_writer.finalize() + if level == "psms": + if self.deduplication: + LOGGER.info(f"\t- Found {count} PSMs from unique spectra.") + else: + LOGGER.info(f"\t- Found {self.psm_count} PSMs.") + LOGGER.info( + f"\t- The average score was {self.score_stats.mean:.3f} " + f"with standard deviation {self.score_stats.sd:.3f}." + ) + else: + LOGGER.info(f"\t- Found {count} unique {level}.") class LevelManager: @@ -640,6 +687,9 @@ def _setup_extra_output_columns(self) -> None: self.extra_output_columns = extra_output_columns def build_output_col_mapping(self, dataset: PsmDataset) -> dict: + # Q: what would be the requirement here? + # Could we use the spectrum columns? since multiple + # columns can be used to identify a spectrum. level_column_names = [ "PSMId", dataset.target_column, From d4d3e8c32a895350994b2387a8a9271d6dd01046 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Sun, 15 Dec 2024 12:08:28 -0600 Subject: [PATCH 04/12] refactor: extracted more writer builder work to class --- mokapot/brew.py | 5 +- mokapot/confidence.py | 133 +++++++++++++++++------ mokapot/dataset.py | 16 ++- mokapot/model.py | 9 +- mokapot/parsers/pin.py | 3 +- tests/conftest.py | 5 - tests/unit_tests/test_confidence.py | 4 - tests/unit_tests/test_writer_flashlfq.py | 12 +- 8 files changed, 129 insertions(+), 58 deletions(-) diff --git a/mokapot/brew.py b/mokapot/brew.py index 245072c..2585acf 100644 --- a/mokapot/brew.py +++ b/mokapot/brew.py @@ -103,12 +103,15 @@ def brew( model = PercolatorModel() try: + # Q: what is this doing? Why does the randon number + # generater get set only if the model has an estimator? + # Shouldn't it assign it to all the models if they are passed? model.estimator model.rng = rng except AttributeError: pass - # Check that all of the datasets have the same features: + # Check that all of the datasets have the same features: feat_set = set(datasets[0].feature_columns) if not all([ set(dataset.feature_columns) == feat_set for dataset in datasets diff --git a/mokapot/confidence.py b/mokapot/confidence.py index a93b2c3..b6bb44e 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -352,13 +352,19 @@ def assign_confidence( ) output_writers_factory = OutputWriterFactory( - level_manager.extra_output_columns, + extra_output_columns=level_manager.extra_output_columns, is_sqlite=is_sqlite, + append_to_output_file=append_to_output_file, + write_decoys=write_decoys, ) if prefixes is None: prefixes = [None] * len(datasets) + level_input_output_column_mapping = level_manager.build_output_col_mapping( + curr_dataset + ) + out = [] for dataset, score, prefix in strictzip(datasets, scores_list, prefixes): @@ -366,40 +372,10 @@ def assign_confidence( # column defs module, and further, have standardized columns # directly from the pin reader (applying the renaming itself) - # Q: why is this done here? it seems constant, since all - # datasets have the same columns. - level_input_output_column_mapping = ( - level_manager.build_output_col_mapping(dataset) + output_writers, file_prefix = output_writers_factory.build_writers( + level_manager ) - file_prefix = file_root - if prefix: - file_prefix = f"{file_prefix}{prefix}." - - output_writers = {} - for level in level_manager.levels_or_proteins: - output_writers[level] = [] - - outfile_targets = ( - dest_dir / f"{file_prefix}targets.{level}{file_ext}" - ) - - output_writers[level].append( - output_writers_factory.create_writer( - outfile_targets, level, not append_to_output_file - ) - ) - - if write_decoys and not is_sqlite: - outfile_decoys = ( - dest_dir / f"{file_prefix}decoys.{level}{file_ext}" - ) - output_writers[level].append( - output_writers_factory.create_output_writer( - outfile_decoys, level, not append_to_output_file - ) - ) - score_reader = TabularDataReader.from_array(score, "score") with create_sorted_file_reader( dataset, @@ -566,7 +542,36 @@ def finalize(self): class LevelManager: - """Manages level-specific data and operations.""" + """Manages level-specific data and operations. + + This class is meant to be used internally by the `Confidence` class. + + Parameters + ---------- + level_columns : list of str + The columns that can be used to aggregate PSMs. + For example, peptides, modified peptides, precursors. + would generate "rollups" of the PSMs at the PSM (default) + and in addition to that, the peptide and modified peptide + columns would generate "peptide groups" of PSMs (each). + default_extension : str + The default extension to use for the output files. + The extension will be used to determine the output format + when initializing the `LevelWriterCollection` which internally + uses the `TabularDataWriter.from_suffix` method. + spectrum_columns : list of str + The columns that uniquely identify a mass spectrum. + do_rollup : bool + Do we apply rollup on peptides, modified peptides etc.? + use_proteins : bool + Whether to roll up protein-level confidence estimates. + dest_dir : Path + The directory in which to save the files. + file_root : str + The prefix added to all output file names. + The final file names will be: + `dest_dir / file_root+level+default_extension` + """ def __init__( self, @@ -644,6 +649,8 @@ def _setup_level_paths( def _setup_hash_columns(self) -> None: """Setup hash columns for each level.""" + + # Q: wouldnt the right thing here be to use spectrum_cols + peptide? self.level_hash_columns = {"psms": self.spectrum_columns} for level in self.levels[1:]: if level != "proteins": @@ -722,13 +729,24 @@ def build_output_col_mapping(self, dataset: PsmDataset) -> dict: class OutputWriterFactory: """Factory class for creating output writers based on configuration.""" - def __init__(self, extra_output_columns: list[str], is_sqlite: bool): + def __init__( + self, + *, + extra_output_columns: list[str], + is_sqlite: bool, + append_to_output_file: bool, + write_decoys: bool, + ): + # Q: are we deleting the sqlite ops? self.is_sqlite = is_sqlite + self.write_decoys = write_decoys self.extra_output_columns = extra_output_columns + self.append_to_output_file = append_to_output_file self.output_column_names = [ "PSMId", "peptide", *extra_output_columns, + # Q: should we prefix these with "mokapot"? "score", "q-value", "posterior_error_prob", @@ -750,6 +768,7 @@ def __repr__(self) -> str: def create_writer( self, + *, path: Path, level: str, initialize: bool, @@ -776,6 +795,50 @@ def create_writer( writer.initialize() return writer + def build_writers( + self, level_manager: LevelManager, prefix: str | None = None + ): + output_writers = {} + + file_prefix = level_manager.file_root + if prefix: + file_prefix = f"{file_prefix}{prefix}." + + for level in level_manager.levels_or_proteins: + output_writers[level] = [] + + name = [ + str(file_prefix), + "targets.", + str(level), + str(level_manager.default_extension), + ] + + outfile_targets = level_manager.dest_dir / "".join(name) + + output_writers[level].append( + self.create_writer( + path=outfile_targets, + level=level, + initialize=not self.append_to_output_file, + ) + ) + + if self.write_decoys and not self.is_sqlite: + outfile_decoys = ( + self.dest_dir + / f"{self.file_prefix}decoys.{level}{self.file_ext}" + ) + output_writers[level].append( + self.create_writer( + path=outfile_decoys, + level=level, + initialize=not self.append_to_output_file, + ) + ) + + return output_writers, file_prefix + @contextmanager @typechecked diff --git a/mokapot/dataset.py b/mokapot/dataset.py index b82c11f..0e70993 100644 --- a/mokapot/dataset.py +++ b/mokapot/dataset.py @@ -748,7 +748,7 @@ class OnDiskPsmDataset(PsmDataset): def __init__( self, filename_or_reader: Path | TabularDataReader, - columns, + *, target_column, spectrum_columns, peptide_column, @@ -756,7 +756,7 @@ def __init__( feature_columns, metadata_columns, metadata_column_types, # the columns+types could be a dict. - level_columns, + level_columns, # What is this supposed to be? filename_column, scan_column, specId_column, # Why does this have different capitalization? @@ -773,7 +773,10 @@ def __init__( else: self._reader = TabularDataReader.from_path(filename_or_reader) + columns = self.reader.get_column_names() self.columns = columns + # Q: Why ae columns asked for in the constructor? + # . Since we can read them from the reader ... self._target_column = target_column self._peptide_column = peptide_column self._protein_column = protein_column @@ -791,7 +794,6 @@ def __init__( self._specId_column = specId_column self._spectra_dataframe = spectra_dataframe - columns = self.reader.get_column_names() opt_cols = OptionalColumns( filename=filename_column, scan=scan_column, @@ -832,7 +834,7 @@ def check_columns(columns): check_column(self.expmass_column) check_column(self.rt_column) check_column(self.charge_column) - check_column(self.specId_column) + # check_column(self.specId_column) def get_default_extension(self) -> str: return self.reader.get_default_extension() @@ -852,6 +854,10 @@ def peptides(self) -> pd.Series: @property def specId_column(self) -> str: + # breakpoint() + # I am thinking on removing this ... since the "key" + # of a spectrum is all the columns that identify it uniquely. + # ... not this column that might or might not be present. return self._specId_column @property @@ -919,7 +925,7 @@ def __repr__(self) -> str: rep += f"Expmass column: {self.expmass_column}\n" rep += f"Rt column: {self.rt_column}\n" rep += f"Charge column: {self.charge_column}\n" - rep += f"SpecId column: {self.specId_column}\n" + # rep += f"SpecId column: {self.specId_column}\n" rep += f"Spectra DF: \n{spec_sec}\n" return rep diff --git a/mokapot/model.py b/mokapot/model.py index f76eb52..ac9fd20 100644 --- a/mokapot/model.py +++ b/mokapot/model.py @@ -224,6 +224,8 @@ def decision_function(self, dataset: LinearPsmDataset): numpy.ndarray A :py:class:`numpy.ndarray` containing the score for each PSM. """ + # Q: we should rename this methid to "score_dataset" ... + # ... or just remove it ... since it is redundant with `predict` if not self.is_trained: raise NotFittedError("This model is untrained. Run fit() first.") @@ -558,6 +560,10 @@ def _get_starting_labels(dataset: LinearPsmDataset, model): feat_pass : int The number of passing PSMs with the best feature. """ + + # Note: This function does sooo much more than getting the starting + # labels, we should at least rename it to something more descriptive. + # JSPP 2024-12-14 LOGGER.debug("Finding initial direction...") if model.direction is None and not model.is_trained: feat_res = dataset._find_best_feature(model.train_fdr) @@ -656,7 +662,7 @@ def _find_hyperparameters(model, features, labels): return new_est -def _get_weights(model, features): +def _get_weights(model, features) -> list[str] | None: """ If the model is a linear model, parse the weights to a list of strings. @@ -680,6 +686,7 @@ def _get_weights(model, features): assert len(intercept) == 1 weights = list(weights.flatten()) except (AttributeError, AssertionError): + LOGGER.debug("No coefficients in the current model.") return None col_width = max([len(f) for f in features]) + 2 diff --git a/mokapot/parsers/pin.py b/mokapot/parsers/pin.py index ae45213..06d16c1 100644 --- a/mokapot/parsers/pin.py +++ b/mokapot/parsers/pin.py @@ -221,6 +221,8 @@ def read_percolator( chunk_size=CHUNK_SIZE_COLUMNS_FOR_DROP_COLUMNS, ) df_spectra_list = [] + # Q: this really feels like a bad idea ... concurrent mutation of a list + # . where the elements are concrruently mutated datafames in-place. features_to_drop = Parallel(n_jobs=max_workers, require="sharedmem")( delayed(drop_missing_values_and_fill_spectra_dataframe)( reader=reader, @@ -252,7 +254,6 @@ def read_percolator( return OnDiskPsmDataset( perc_file, - columns=columns, target_column=labels, spectrum_columns=spectra, peptide_column=peptides, diff --git a/tests/conftest.py b/tests/conftest.py index 9e665f3..e516cf5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -208,8 +208,6 @@ def psms_ondisk() -> OnDiskPsmDataset: usecols=["ScanNr", "ExpMass", "Label"], ) # Q: why is the exp mass in the spectra dataframe? - with open(filename) as perc: - columns = perc.readline().rstrip().split("\t") psms = OnDiskPsmDataset( filename, target_column="Label", @@ -251,7 +249,6 @@ def psms_ondisk() -> OnDiskPsmDataset: filename_column=None, specId_column="SpecId", spectra_dataframe=df_spectra, - columns=columns, ) return psms @@ -264,7 +261,6 @@ def psms_ondisk_from_parquet() -> OnDiskPsmDataset: filename, columns=["ScanNr", "ExpMass", "Label"] ).to_pandas() df_spectra = convert_targets_column(df_spectra, "Label") - columns = pq.ParquetFile(filename).schema.names psms = OnDiskPsmDataset( filename, target_column="Label", @@ -309,7 +305,6 @@ def psms_ondisk_from_parquet() -> OnDiskPsmDataset: filename_column=None, specId_column="SpecId", spectra_dataframe=df_spectra, - columns=columns, ) return psms diff --git a/tests/unit_tests/test_confidence.py b/tests/unit_tests/test_confidence.py index b5548bb..98beb72 100644 --- a/tests/unit_tests/test_confidence.py +++ b/tests/unit_tests/test_confidence.py @@ -34,7 +34,6 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path): # incorrectly (namely the last and before last) pin_file, df, _, score_cols = psm_df_1000 - columns = list(pd.read_csv(pin_file, sep="\t").columns) df_spectra = pd.read_csv( pin_file, sep="\t", usecols=["scannr", "expmass", "target"] ) @@ -51,7 +50,6 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path): expmass_column="expmass", rt_column="ret_time", charge_column="charge", - columns=columns, protein_column="proteins", metadata_columns=[ "specid", @@ -143,7 +141,6 @@ def test_assign_confidence_parquet(psm_df_1000_parquet, tmp_path): """Test that assign_confidence() works with parquet files.""" parquet_file, df, _ = psm_df_1000_parquet - columns = pq.ParquetFile(parquet_file).schema.names df_spectra = pq.read_table( parquet_file, columns=["scannr", "expmass", "target"] ).to_pandas() @@ -160,7 +157,6 @@ def test_assign_confidence_parquet(psm_df_1000_parquet, tmp_path): expmass_column="expmass", rt_column="ret_time", charge_column="charge", - columns=columns, protein_column="proteins", metadata_columns=[ "specid", diff --git a/tests/unit_tests/test_writer_flashlfq.py b/tests/unit_tests/test_writer_flashlfq.py index a417ba8..b68b702 100644 --- a/tests/unit_tests/test_writer_flashlfq.py +++ b/tests/unit_tests/test_writer_flashlfq.py @@ -52,14 +52,14 @@ def is_flashlfq_df(df): } for col, coltype in EXPECTED_COLS.items(): assert col in df.columns, f"Column {col} not found in input" - assert isinstance( - df[col].iloc[0], coltype - ), f"Column {col} is not {coltype}" + assert isinstance(df[col].iloc[0], coltype), ( + f"Column {col} is not {coltype}" + ) # Check that the base sequence matches the pattern [A-Z]+ - assert ( - df["Base Sequence"].str.match("[A-Z]+").all() - ), "Base sequence must only contain amino acids" + assert df["Base Sequence"].str.match("[A-Z]+").all(), ( + "Base sequence must only contain amino acids" + ) return True From 789f0b55f2dedc71b5ca6023f950bb6f787066ee Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Sun, 15 Dec 2024 19:11:17 -0600 Subject: [PATCH 05/12] feat: score propagation and unscored confidence --- mokapot/brew.py | 11 ++- mokapot/confidence.py | 87 +++++++++++++++++++++++- mokapot/dataset.py | 77 +++++++++++++++++++-- mokapot/model.py | 9 ++- mokapot/qvalues.py | 12 ++-- mokapot/statistics.py | 13 ++-- pyproject.toml | 2 +- tests/unit_tests/test_confidence.py | 50 +++++++++++++- tests/unit_tests/test_writer_flashlfq.py | 8 ++- uv.lock | 12 ++-- 10 files changed, 246 insertions(+), 35 deletions(-) diff --git a/mokapot/brew.py b/mokapot/brew.py index 2585acf..c2758a1 100644 --- a/mokapot/brew.py +++ b/mokapot/brew.py @@ -25,6 +25,7 @@ ) from mokapot.model import PercolatorModel, Model from mokapot.parsers.pin import parse_in_chunks +from mokapot.utils import strictzip LOGGER = logging.getLogger(__name__) @@ -295,6 +296,8 @@ def brew( # Reverse all scores for which desc is False (this way, we don't have to # return `descs` from this function + # Q: why dont we just return a class that denotes if its descending? + # JSPP 2024-12-15 for idx, desc in enumerate(descs): if not desc: scores[idx] = -scores[idx] @@ -302,6 +305,10 @@ def brew( # Coherces the tuple to a list models = list(models) + + for score, dataset in strictzip(scores, datasets): + dataset.scores = score + return list(models), scores @@ -501,7 +508,9 @@ def _predict( @typechecked def _predict_with_ensemble( - dataset: PsmDataset, models: Iterable[Model], max_workers + dataset: PsmDataset, + models: Iterable[Model], + max_workers: int, ): """ Return the new scores for the dataset using ensemble of all trained models diff --git a/mokapot/confidence.py b/mokapot/confidence.py index b6bb44e..49faa0b 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -28,6 +28,7 @@ from joblib import Parallel, delayed from typeguard import typechecked + from mokapot.column_defs import get_standard_column_name from mokapot.constants import CONFIDENCE_CHUNK_SIZE from mokapot.dataset import PsmDataset, OptionalColumns @@ -58,6 +59,14 @@ LOGGER = logging.getLogger(__name__) +try: + import matplotlib.pyplot as plt +except ImportError: + LOGGER.warning( + "Matplotlib is not installed. Confidence plots will not be available." + ) + plt = None + # Classes --------------------------------------------------------------------- @typechecked @@ -266,7 +275,7 @@ def to_flashlfq(self, out_file="mokapot.flashlfq.txt"): @typechecked def assign_confidence( datasets: list[PsmDataset], - scores_list: list[np.ndarray[float]], + scores_list: list[np.ndarray[float]] | None = None, max_workers: int = 1, eval_fdr: float = 0.01, dest_dir: Path | None = None, @@ -334,7 +343,6 @@ def assign_confidence( # just take the first one for info (and make sure the other are the same) curr_dataset = datasets[0] - file_ext = curr_dataset.get_default_extension() for di, dataset in enumerate(datasets[1:]): if dataset.columns != curr_dataset.columns: raise ValueError( @@ -365,9 +373,23 @@ def assign_confidence( curr_dataset ) + scores_use = scores_list + if scores_use is None: + if any(dataset.scores is None for dataset in datasets): + feature = datasets[0].find_best_feature(eval_fdr).feature + scores_use = [ + dataset.read_data(columns=[feature.name])[ + feature.name + ].to_numpy() + for dataset in datasets + ] + # TODO: warn that no scores are present and will fall back + else: + scores_use = [dataset.scores for dataset in datasets] + out = [] - for dataset, score, prefix in strictzip(datasets, scores_list, prefixes): + for dataset, score, prefix in strictzip(datasets, scores_use, prefixes): # todo: nice to have: move this column renaming stuff into the # column defs module, and further, have standardized columns # directly from the pin reader (applying the renaming itself) @@ -1045,3 +1067,62 @@ def create_score_target_iterator(chunked_iterator: Iterator): scores = df_chunk["score"].values targets = ~df_chunk["is_decoy"].values yield scores, targets + + +def plot_qvalues(qvalues, threshold=0.1, ax=None, **kwargs): + """ + Plot the cumulative number of discoveries over range of q-values. + + Parameters + ---------- + qvalues : numpy.ndarray + The q-values to plot. + threshold : float, optional + Indicates the maximum q-value to plot. + ax : matplotlib.pyplot.Axes, optional + The matplotlib Axes on which to plot. If `None` the current + Axes instance is used. + **kwargs : dict, optional + Arguments passed to :py:func:`matplotlib.axes.Axes.plot`. + + Returns + ------- + matplotlib.pyplot.Axes + An :py:class:`matplotlib.axes.Axes` with the cumulative + number of accepted target PSMs or peptides. + """ + if ax is None: + if plt is None: + raise RuntimeError( + "Matplotlib is not installed. Confidence plots will not be " + "available." + ) + ax = plt.gca() + + # Calculate cumulative targets at each q-value + qvals = pd.Series(qvalues, name="qvalue") + qvals = qvals.sort_values(ascending=True).to_frame() + qvals["target"] = 1 + qvals["num"] = qvals["target"].cumsum() + qvals = qvals.groupby(["qvalue"]).max().reset_index() + qvals = qvals[["qvalue", "num"]] + + zero = pd.DataFrame({"qvalue": qvals["qvalue"][0], "num": 0}, index=[-1]) + qvals = pd.concat([zero, qvals], sort=True).reset_index(drop=True) + + xmargin = threshold * 0.05 + ymax = qvals.num[qvals["qvalue"] <= (threshold + xmargin)].max() + ymargin = ymax * 0.05 + + # Set margins + curr_ylims = ax.get_ylim() + if curr_ylims[1] < ymax + ymargin: + ax.set_ylim(0 - ymargin, ymax + ymargin) + + ax.set_xlim(0 - xmargin, threshold + xmargin) + ax.set_xlabel("q-value") + ax.set_ylabel("Discoveries") + + ax.step(qvals["qvalue"].values, qvals.num.values, where="post", **kwargs) + + return ax diff --git a/mokapot/dataset.py b/mokapot/dataset.py index 0e70993..e0b7bef 100644 --- a/mokapot/dataset.py +++ b/mokapot/dataset.py @@ -67,6 +67,20 @@ def as_dict(self): } +@dataclass +class BestFeatureProperties: + name: str + positives: int + fdr: float + descending: bool + + +@dataclass +class LabeledBestFeature: + feature: BestFeatureProperties + new_labels: np.ndarray + + class PsmDataset(ABC): """Store a collection of PSMs and their features. @@ -261,6 +275,21 @@ def read_data( ) -> pd.DataFrame | Generator[pd.DataFrame, None, None]: raise NotImplementedError + @abstractmethod + def find_best_feature(self, eval_fdr: float) -> LabeledBestFeature: + raise NotImplementedError + + @property + @abstractmethod + def scores(self) -> np.ndarray | None: + # q: should i rename this to mokapot_scores? + raise NotImplementedError + + @scores.setter + @abstractmethod + def scores(self, scores: np.ndarray | None): + raise NotImplementedError + class LinearPsmDataset(PsmDataset): """Store and analyze a collection of PSMs. @@ -659,7 +688,7 @@ def _targets_count_by_feature(self, desc, eval_fdr): index=self._feature_columns, ) - def _find_best_feature(self, eval_fdr): + def find_best_feature(self, eval_fdr: float) -> LabeledBestFeature: """ Find the best feature to separate targets from decoys at the specified false-discovery rate threshold. @@ -704,7 +733,16 @@ def _find_best_feature(self, eval_fdr): f"No PSMs found below the 'eval_fdr' {eval_fdr}." ) - return best_feat, best_positives, new_labels, best_desc + out = LabeledBestFeature( + feature=BestFeatureProperties( + name=best_feat, + positives=best_positives, + descending=best_desc, + fdr=eval_fdr, + ), + new_labels=new_labels, + ) + return out def _calibrate_scores(self, scores, eval_fdr, desc=True): calibrate_scores( @@ -741,6 +779,16 @@ def read_data( def get_default_extension(self) -> str: return ".csv" + @property + def scores(self) -> np.ndarray | None: + if not hasattr(self, "_scores"): + return None + return self._scores + + @scores.setter + def scores(self, scores: np.ndarray | None): + self._scores = scores + @typechecked class OnDiskPsmDataset(PsmDataset): @@ -981,7 +1029,7 @@ def _targets_count_by_feature(self, column, eval_fdr, desc): == 1 ).sum() - def find_best_feature(self, eval_fdr): + def find_best_feature(self, eval_fdr: float) -> LabeledBestFeature: best_feat = None best_positives = 0 new_labels = None @@ -1021,7 +1069,16 @@ def find_best_feature(self, eval_fdr): f"No PSMs found below the 'eval_fdr' {eval_fdr}." ) - return best_feat, best_positives, new_labels, best_desc + out = LabeledBestFeature( + feature=BestFeatureProperties( + name=best_feat, + positives=best_positives, + descending=best_desc, + fdr=eval_fdr, + ), + new_labels=new_labels, + ) + return out def update_labels(self, scores, target_column, eval_fdr=0.01, desc=True): df = self.read_data(columns=target_column) @@ -1123,6 +1180,16 @@ def read_data( else: return self.reader.read(columns=columns) + @property + def scores(self) -> np.ndarray | None: + if not hasattr(self, "_scores"): + return None + return self._scores + + @scores.setter + def scores(self, scores: np.ndarray | None): + self._scores = scores + @typechecked def _update_labels( @@ -1130,7 +1197,7 @@ def _update_labels( targets: np.ndarray[bool] | pd.Series, eval_fdr: float = 0.01, desc: bool = True, -) -> np.ndarray[bool] | pd.Series: +) -> np.ndarray[bool]: """Return the label for each PSM, given it's score. This method is used during model training to define positive examples, diff --git a/mokapot/model.py b/mokapot/model.py index ac9fd20..59772b1 100644 --- a/mokapot/model.py +++ b/mokapot/model.py @@ -566,8 +566,13 @@ def _get_starting_labels(dataset: LinearPsmDataset, model): # JSPP 2024-12-14 LOGGER.debug("Finding initial direction...") if model.direction is None and not model.is_trained: - feat_res = dataset._find_best_feature(model.train_fdr) - best_feat, feat_pass, start_labels, desc = feat_res + feat_res = dataset.find_best_feature(model.train_fdr) + best_feat, feat_pass, start_labels, desc = ( + feat_res.feature.name, + feat_res.feature.positives, + feat_res.new_labels, + feat_res.feature.descending, + ) LOGGER.info( "\t- Selected feature %s with %i PSMs at q<=%g.", best_feat, diff --git a/mokapot/qvalues.py b/mokapot/qvalues.py index e7e3589..b5a1bff 100644 --- a/mokapot/qvalues.py +++ b/mokapot/qvalues.py @@ -136,7 +136,7 @@ def tdc( unique_metric = np.flip(unique_metric) indices = np.flip(indices) - qvals = _fdr2qvalue(fdr, num_total, unique_metric, indices) + qvals = _fdr2qvalue(fdr, num_total, indices) qvals = np.flip(qvals) qvals = qvals[np.argsort(srt_idx)] @@ -144,7 +144,7 @@ def tdc( @nb.njit -def _fdr2qvalue(fdr, num_total, met, indices): +def _fdr2qvalue(fdr, num_total, indices): """Quickly turn a list of FDRs to q-values. All of the inputs are assumed to be sorted. @@ -155,8 +155,6 @@ def _fdr2qvalue(fdr, num_total, met, indices): A vector of all unique FDR values. num_total : numpy.ndarray A vector of the cumulative number of PSMs at each score. - met : numpy.ndarray - A vector of the scores for each PSM. indices : tuple of numpy.ndarray Tuple where the vector at index i indicates the PSMs that shared the unique FDR value in `fdr`. @@ -167,10 +165,9 @@ def _fdr2qvalue(fdr, num_total, met, indices): A vector of q-values. """ min_q = 1 - qvals = np.ones(len(fdr)) - group_fdr = np.ones(len(fdr)) + qvals = np.ones_like(fdr) prev_idx = 0 - for idx in range(met.shape[0]): + for idx in range(indices.shape[0]): next_idx = prev_idx + indices[idx] group = slice(prev_idx, next_idx) prev_idx = next_idx @@ -181,7 +178,6 @@ def _fdr2qvalue(fdr, num_total, met, indices): if curr_fdr < min_q: min_q = curr_fdr - group_fdr[group] = curr_fdr qvals[group] = min_q return qvals diff --git a/mokapot/statistics.py b/mokapot/statistics.py index 42c17b3..93764c9 100644 --- a/mokapot/statistics.py +++ b/mokapot/statistics.py @@ -10,7 +10,6 @@ ) -@typechecked @dataclass(slots=True) class OnlineStatistics: """A class for performing basic statistical calculations. @@ -26,14 +25,18 @@ class OnlineStatistics: sum : float The sum of all values encountered so far. Initialized to 0.0. mean : float - The mean value calculated based on the encountered values. Initialized to 0.0. + The mean value calculated based on the encountered values. + Initialized to 0.0. var : float - The variance value calculated based on the encountered values. Initialized to 0.0. + The variance value calculated based on the encountered values. + Initialized to 0.0. sd : float - The standard deviation value calculated based on the encountered values. + The standard deviation value calculated based on the + encountered values. Initialized to 0.0. M2n : float - The intermediate value used in calculating variance. Initialized to 0.0. + The intermediate value used in calculating variance. + Initialized to 0.0. """ diff --git a/pyproject.toml b/pyproject.toml index 31a6fde..47e81a1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,7 +32,6 @@ dependencies = [ "pandas>=1.0.3", "scikit-learn>=0.22.1", "numba>=0.48.0", - "matplotlib>=3.1.3", "lxml>=4.6.2", "triqler>=0.6.2", "joblib>=1.1.0", @@ -45,6 +44,7 @@ description = "Fast and flexible semi-supervised learning for peptide detection" dynamic = ["version"] license = {text = "Apache 2.0"} name = "mokapot" +optional-dependencies = {plot = ["matplotlib>=3.1.3"]} requires-python = ">=3.9,<3.13" # Upper threshold is required bc of numba [project.readme] diff --git a/tests/unit_tests/test_confidence.py b/tests/unit_tests/test_confidence.py index 98beb72..153a790 100644 --- a/tests/unit_tests/test_confidence.py +++ b/tests/unit_tests/test_confidence.py @@ -9,7 +9,8 @@ from pandas.testing import assert_frame_equal import mokapot -from mokapot import OnDiskPsmDataset, assign_confidence +from mokapot import OnDiskPsmDataset, assign_confidence, LinearPsmDataset +import pytest @contextlib.contextmanager @@ -23,7 +24,44 @@ def run_with_chunk_size(chunk_size): mokapot.confidence.CONFIDENCE_CHUNK_SIZE = old_chunk_size -def test_chunked_assign_confidence(psm_df_1000, tmp_path): +@pytest.fixture +def inmem_psms_ds(psm_df_builder): + """A small-ish PSM dataset""" + data = psm_df_builder(1000, 1000, score_diffs=[5.0]) + psms = LinearPsmDataset( + psms=data.df, + target_column="target", + spectrum_columns="specid", + peptide_column="peptide", + feature_columns=list(data.score_cols), + filename_column="filename", + scan_column="specid", + calcmass_column="calcmass", + expmass_column="expmass", + rt_column="ret_time", + charge_column="charge", + copy_data=True, + ) + return psms + + +@pytest.mark.parametrize("deduplication", [True, False]) +def test_assign_unscored_confidence(inmem_psms_ds, tmp_path, deduplication): + if deduplication: + pytest.skip("Deduplication is not working") + _foo = assign_confidence( + [inmem_psms_ds], + scores_list=None, + eval_fdr=0.01, + dest_dir=tmp_path, + max_workers=4, + deduplication=False, + ) + # TODO actually add assertions here ... + + +@pytest.mark.parametrize("deduplication", [True, False]) +def test_chunked_assign_confidence(psm_df_1000, tmp_path, deduplication): """Test that assign_confidence() works correctly with small chunks""" # After correcting the targets column stuff and @@ -79,6 +117,7 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path): dest_dir=tmp_path, max_workers=4, eval_fdr=0.02, + deduplication=deduplication, ) df_results_group = pd.read_csv(tmp_path / "targets.peptides.csv", sep="\t") @@ -137,7 +176,10 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path): ) -def test_assign_confidence_parquet(psm_df_1000_parquet, tmp_path): +@pytest.mark.parametrize("deduplication", [True, False]) +def test_assign_confidence_parquet( + psm_df_1000_parquet, tmp_path, deduplication +): """Test that assign_confidence() works with parquet files.""" parquet_file, df, _ = psm_df_1000_parquet @@ -187,6 +229,7 @@ def test_assign_confidence_parquet(psm_df_1000_parquet, tmp_path): dest_dir=tmp_path, max_workers=4, eval_fdr=0.02, + deduplication=deduplication, ) df_results_group1 = pd.read_parquet( tmp_path / "targets.peptides.parquet" @@ -201,6 +244,7 @@ def test_assign_confidence_parquet(psm_df_1000_parquet, tmp_path): dest_dir=tmp_path, max_workers=4, eval_fdr=0.02, + deduplication=deduplication, ) df_results_group2 = pd.read_parquet( tmp_path / "targets.peptides.parquet" diff --git a/tests/unit_tests/test_writer_flashlfq.py b/tests/unit_tests/test_writer_flashlfq.py index b68b702..4a961d4 100644 --- a/tests/unit_tests/test_writer_flashlfq.py +++ b/tests/unit_tests/test_writer_flashlfq.py @@ -108,13 +108,17 @@ def flashlfq_psms_ds_ondisk(psm_df_builder, tmp_path): return psms -def test_internal_flashlfq_ondisk(flashlfq_psms_ds_ondisk): +@pytest.parametrize("deduplication", [True, False]) +def test_internal_flashlfq_ondisk(flashlfq_psms_ds_ondisk, deduplication): + if deduplication: + pytest.skip("Deduplication is not working") + mods, scores = mokapot.brew([flashlfq_psms_ds_ondisk], test_fdr=0.1) conf = mokapot.assign_confidence( [flashlfq_psms_ds_ondisk], scores_list=scores, eval_fdr=0.1, - deduplication=False, # RN fails with deduplication = True + deduplication=deduplication, # RN fails with deduplication = True ) _tmp = _format_flashlfq(conf[0]) for col in EXPECTED_COLS: diff --git a/uv.lock b/uv.lock index fa6e884..24996b0 100644 --- a/uv.lock +++ b/uv.lock @@ -388,7 +388,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/98/65/13d9e76ca19b0ba5603d71ac8424b5694415b348e719db277b5edc985ff5/cryptography-44.0.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:761817a3377ef15ac23cd7834715081791d4ec77f9297ee694ca1ee9c2c7e5eb", size = 3915420 }, { url = "https://files.pythonhosted.org/packages/b1/07/40fe09ce96b91fc9276a9ad272832ead0fddedcba87f1190372af8e3039c/cryptography-44.0.0-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3c672a53c0fb4725a29c303be906d3c1fa99c32f58abe008a82705f9ee96f40b", size = 4154498 }, { url = "https://files.pythonhosted.org/packages/75/ea/af65619c800ec0a7e4034207aec543acdf248d9bffba0533342d1bd435e1/cryptography-44.0.0-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:4ac4c9f37eba52cb6fbeaf5b59c152ea976726b865bd4cf87883a7e7006cc543", size = 3932569 }, - { url = "https://files.pythonhosted.org/packages/4e/d5/9cc182bf24c86f542129565976c21301d4ac397e74bf5a16e48241aab8a6/cryptography-44.0.0-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:60eb32934076fa07e4316b7b2742fa52cbb190b42c2df2863dbc4230a0a9b385", size = 4164756 }, { url = "https://files.pythonhosted.org/packages/c7/af/d1deb0c04d59612e3d5e54203159e284d3e7a6921e565bb0eeb6269bdd8a/cryptography-44.0.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ed3534eb1090483c96178fcb0f8893719d96d5274dfde98aa6add34614e97c8e", size = 4016721 }, { url = "https://files.pythonhosted.org/packages/bd/69/7ca326c55698d0688db867795134bdfac87136b80ef373aaa42b225d6dd5/cryptography-44.0.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f3f6fdfa89ee2d9d496e2c087cebef9d4fcbb0ad63c40e821b39f74bf48d9c5e", size = 4240915 }, { url = "https://files.pythonhosted.org/packages/1a/07/5f165b6c65696ef75601b781a280fc3b33f1e0cd6aa5a92d9fb96c410e97/cryptography-44.0.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1923cb251c04be85eec9fda837661c67c1049063305d6be5721643c22dd4e2b7", size = 3922613 }, @@ -396,7 +395,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d0/c7/c656eb08fd22255d21bc3129625ed9cd5ee305f33752ef2278711b3fa98b/cryptography-44.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c5eb858beed7835e5ad1faba59e865109f3e52b3783b9ac21e7e47dc5554e289", size = 3915417 }, { url = "https://files.pythonhosted.org/packages/ef/82/72403624f197af0db6bac4e58153bc9ac0e6020e57234115db9596eee85d/cryptography-44.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f53c2c87e0fb4b0c00fa9571082a057e37690a8f12233306161c8f4b819960b7", size = 4155160 }, { url = "https://files.pythonhosted.org/packages/a2/cd/2f3c440913d4329ade49b146d74f2e9766422e1732613f57097fea61f344/cryptography-44.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:9e6fc8a08e116fb7c7dd1f040074c9d7b51d74a8ea40d4df2fc7aa08b76b9e6c", size = 3932331 }, - { url = "https://files.pythonhosted.org/packages/31/d9/90409720277f88eb3ab72f9a32bfa54acdd97e94225df699e7713e850bd4/cryptography-44.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9abcc2e083cbe8dde89124a47e5e53ec38751f0d7dfd36801008f316a127d7ba", size = 4165207 }, { url = "https://files.pythonhosted.org/packages/7f/df/8be88797f0a1cca6e255189a57bb49237402b1880d6e8721690c5603ac23/cryptography-44.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d2436114e46b36d00f8b72ff57e598978b37399d2786fd39793c36c6d5cb1c64", size = 4017372 }, { url = "https://files.pythonhosted.org/packages/af/36/5ccc376f025a834e72b8e52e18746b927f34e4520487098e283a719c205e/cryptography-44.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a01956ddfa0a6790d594f5b34fc1bfa6098aca434696a03cfdbe469b8ed79285", size = 4239657 }, { url = "https://files.pythonhosted.org/packages/1a/aa/ba8a7467c206cb7b62f09b4168da541b5109838627f582843bbbe0235e8e/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:f677e1268c4e23420c3acade68fac427fffcb8d19d7df95ed7ad17cdef8404f4", size = 3850615 }, @@ -1161,13 +1159,12 @@ wheels = [ [[package]] name = "mokapot" -version = "0.7.2.dev66+gd6ef287.d20241205" +version = "0.10.1.dev37+gd4d3e8c.d20241215" source = { editable = "." } dependencies = [ { name = "importlib-metadata" }, { name = "joblib" }, { name = "lxml" }, - { name = "matplotlib" }, { name = "numba" }, { name = "numpy" }, { name = "pandas" }, @@ -1178,6 +1175,11 @@ dependencies = [ { name = "typeguard" }, ] +[package.optional-dependencies] +plot = [ + { name = "matplotlib" }, +] + [package.dev-dependencies] dev = [ { name = "pre-commit" }, @@ -1200,7 +1202,7 @@ requires-dist = [ { name = "importlib-metadata", specifier = ">=5.1.0" }, { name = "joblib", specifier = ">=1.1.0" }, { name = "lxml", specifier = ">=4.6.2" }, - { name = "matplotlib", specifier = ">=3.1.3" }, + { name = "matplotlib", marker = "extra == 'plot'", specifier = ">=3.1.3" }, { name = "numba", specifier = ">=0.48.0" }, { name = "numpy", specifier = ">=1.4.0,<2.0.0" }, { name = "pandas", specifier = ">=1.0.3" }, From 59e649db95868ee7ebd1c8ccf99196ad3b20c05b Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Mon, 16 Dec 2024 15:35:27 -0600 Subject: [PATCH 06/12] feat(confidence): add data reading api --- mokapot/brew.py | 1 + mokapot/column_defs.py | 3 +- mokapot/confidence.py | 153 ++++++++++++++++++----- mokapot/tabular_data/base.py | 5 + mokapot/tabular_data/csv.py | 8 ++ mokapot/tabular_data/sqlite.py | 4 + mokapot/tabular_data/streaming.py | 8 ++ tests/system_tests/test_brew_rollup.py | 2 +- tests/system_tests/test_cli.py | 2 +- tests/unit_tests/test_writer_flashlfq.py | 2 +- 10 files changed, 151 insertions(+), 37 deletions(-) diff --git a/mokapot/brew.py b/mokapot/brew.py index c2758a1..7641fa9 100644 --- a/mokapot/brew.py +++ b/mokapot/brew.py @@ -306,6 +306,7 @@ def brew( # Coherces the tuple to a list models = list(models) + LOGGER.info("Assigning scores to PSMs...") for score, dataset in strictzip(scores, datasets): dataset.scores = score diff --git a/mokapot/column_defs.py b/mokapot/column_defs.py index de057f6..e801ec6 100644 --- a/mokapot/column_defs.py +++ b/mokapot/column_defs.py @@ -1,3 +1,4 @@ +Q_VALUE_COL_NAME = "mokapot_qvalue" STANDARD_COLUMN_NAME_MAP = { "SpecId": "psm_id", "PSMId": "psm_id", @@ -10,7 +11,7 @@ "ModifiedPeptide": "modified_peptide", "modifiedpeptide": "modified_peptide", # "q-value": "q_value", - "q-value": "q-value", + "q-value": Q_VALUE_COL_NAME, } diff --git a/mokapot/confidence.py b/mokapot/confidence.py index 49faa0b..13da83e 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -29,7 +29,7 @@ from typeguard import typechecked -from mokapot.column_defs import get_standard_column_name +from mokapot.column_defs import get_standard_column_name, Q_VALUE_COL_NAME from mokapot.constants import CONFIDENCE_CHUNK_SIZE from mokapot.dataset import PsmDataset, OptionalColumns from mokapot.peps import ( @@ -82,7 +82,7 @@ def __init__( eval_fdr: float = 0.01, write_decoys: bool = False, do_rollup: bool = True, - proteins=None, + proteins: pd.DataFrame | None = None, peps_error: bool = False, rng=0, peps_algorithm: str = "qvality", @@ -131,7 +131,7 @@ def __init__( self.write_decoys = write_decoys self.levels = levels self.do_rollup = do_rollup - self.proteins = proteins + self._proteins = proteins self.peps_error = peps_error self.rng = rng self.score_stats = score_stats @@ -165,7 +165,6 @@ def __repr__(self) -> str: rep += f"Eval FDR: {self.eval_fdr}\n" rep += f"Write decoys: {self.write_decoys}\n" rep += f"Do rollup: {self.do_rollup}\n" - rep += f"Proteins: {self.proteins}\n" rep += f"Peps error: {self.peps_error}\n" rep += f"Rng: {self.rng}\n" rep += f"Score stats: {self.score_stats}\n" @@ -181,7 +180,7 @@ def _assign_confidence( peps_algorithm: str = "qvality", qvalue_algorithm: str = "tdc", stream_confidence: bool = False, - score_stats=None, + score_stats: OnlineStatistics | None = None, eval_fdr: float = 0.01, ): """ @@ -262,14 +261,59 @@ def _write_protein_level_data(self, level_paths, proteins, rng): def get_optional_columns(self) -> OptionalColumns: return self.dataset.get_optional_columns() + def read(self, level: str) -> pd.DataFrame: + """Read the results for a given level.""" + if level not in self.levels: + raise ValueError( + f"Level {level} not found. Available levels are: {self.levels}" + ) + tmp = [x.read() for x in self.out_writers[level]] + return pd.concat(tmp) + + @property + def peptides(self) -> pd.DataFrame: + return self.read("peptides") + + @property + def psms(self) -> pd.DataFrame: + return self.read("psms") + @property - def peptides(self) -> pd.Series: - return self.dataset.peptides + def proteins(self) -> pd.DataFrame: + return self.read("proteins") def to_flashlfq(self, out_file="mokapot.flashlfq.txt"): """Save confidenct peptides for quantification with FlashLFQ.""" return to_flashlfq(self, out_file) + def plot_qvalues( + self, level: str, threshold: float = 0.1, ax=None, **kwargs + ): + """Plot the q-values for a given level. + + Parameters + ---------- + level : str + The level to plot. + threshold : float, optional + Indicates the maximum q-value to plot. + ax : matplotlib.pyplot.Axes, optional + The matplotlib Axes on which to plot. If `None` the current + Axes instance is used. + **kwargs : dict, optional + Arguments passed to :py:func:`matplotlib.axes.Axes.plot`. + + Returns + ------- + matplotlib.pyplot.Axes + A `matplotlib.axes.Axes` with the cumulative + number of accepted target PSMs or peptides. + """ + + all_read = [x.read() for x in self.out_writers[level]] + qvals = pd.concat(all_read)[Q_VALUE_COL_NAME] + return plot_qvalues(qvals, threshold=threshold, ax=ax, **kwargs) + # Functions ------------------------------------------------------------------- @typechecked @@ -315,8 +359,9 @@ def assign_confidence( dest_dir : Path or None, optional The directory in which to save the files. :code:`None` will use the current working directory. - prefixes : [str] + prefixes : [str] or None The prefixes added to all output file names. + If None, a single concatenated file will be created. write_decoys : bool, optional Save decoys confidence estimates as well? deduplication: bool @@ -375,8 +420,11 @@ def assign_confidence( scores_use = scores_list if scores_use is None: + LOGGER.info("No scores passed, attempting to find them.") if any(dataset.scores is None for dataset in datasets): + LOGGER.info("No scores found, attempting to find best feature.") feature = datasets[0].find_best_feature(eval_fdr).feature + LOGGER.info("Best feature found: %s", feature) scores_use = [ dataset.read_data(columns=[feature.name])[ feature.name @@ -385,6 +433,7 @@ def assign_confidence( ] # TODO: warn that no scores are present and will fall back else: + LOGGER.info("Scores found in psms, using them.") scores_use = [dataset.scores for dataset in datasets] out = [] @@ -395,20 +444,23 @@ def assign_confidence( # directly from the pin reader (applying the renaming itself) output_writers, file_prefix = output_writers_factory.build_writers( - level_manager + level_manager, + prefix=prefix, ) score_reader = TabularDataReader.from_array(score, "score") with create_sorted_file_reader( - dataset, - score_reader, - dest_dir, - file_prefix, - level_manager.level_hash_columns["psms"] - if deduplication - else None, - max_workers, - level_input_output_column_mapping, + dataset=dataset, + score_reader=score_reader, + dest_dir=dest_dir, + file_prefix=file_prefix, + deduplication_columns=( + level_manager.level_hash_columns["psms"] + if deduplication + else None + ), + max_workers=max_workers, + input_output_column_mapping=level_input_output_column_mapping, ) as sorted_file_reader: LOGGER.info("Assigning confidence...") LOGGER.info("Performing target-decoy competition...") @@ -450,12 +502,18 @@ def assign_confidence( ) out.append(con) if not prefix: - append_to_output_file = True + # Having None as a prefix means that all outputs will be + # written to a single file, thus after the first iteration + # we stop initializing the writers (bc that generates over-writing + # the files instead of appending to them). + output_writers_factory.append_to_output_file = True return out class LevelWriterCollection: + """ """ + def __init__( self, levels: list[str], @@ -519,6 +577,9 @@ def from_manager( ) def hash_data_row(self, data_row, level): + # TODO: benchmark if actually hashing here would be better. + # . It feels inefficient to keep large numbers of large strings + # in memory. return str([ data_row[self.level_input_output_column_mapping.get(col, col)] for col in self.level_hash_columns[level] @@ -620,9 +681,6 @@ def __init__( self._setup_protein_levels() self._setup_extra_output_columns() - # self.level_data_paths = {} - # self.level_hash_columns = {} - @staticmethod def from_dataset( *, @@ -770,7 +828,7 @@ def __init__( *extra_output_columns, # Q: should we prefix these with "mokapot"? "score", - "q-value", + Q_VALUE_COL_NAME, "posterior_error_prob", "proteinIds", ] @@ -780,7 +838,7 @@ def __init__( "best peptide", "stripped sequence", "score", - "q-value", + Q_VALUE_COL_NAME, "posterior_error_prob", ] @@ -808,7 +866,7 @@ def create_writer( columns=output_columns, column_types=[], level=level, - qvalue_column="q-value", + qvalue_column=Q_VALUE_COL_NAME, pep_column="posterior_error_prob", ) @@ -819,7 +877,32 @@ def create_writer( def build_writers( self, level_manager: LevelManager, prefix: str | None = None - ): + ) -> tuple[ + dict[str, list[TabularDataWriter] | list[ConfidenceSqliteWriter]], str + ]: + """Build output writers for each level. + + Parameters + ---------- + level_manager : LevelManager + The level manager. + prefix : str, optional + The prefix to use for the output files, by default None. + It will be used to create the file names whose pattern is + "{self.dest_dir}/{file_root}{prefix}.{level}{file_ext}". + + Returns + ------- + tuple[ + dict[ + str, + list[TabularDataWriter] | list[ConfidenceSqliteWriter] + ], + str + ] + A tuple containing the output writers and the file prefix. + + """ output_writers = {} file_prefix = level_manager.file_root @@ -847,10 +930,13 @@ def build_writers( ) if self.write_decoys and not self.is_sqlite: - outfile_decoys = ( - self.dest_dir - / f"{self.file_prefix}decoys.{level}{self.file_ext}" - ) + decoy_name = [ + str(file_prefix), + "decoys.", + str(level), + str(level_manager.default_extension), + ] + outfile_decoys = level_manager.dest_dir / "".join(decoy_name) output_writers[level].append( self.create_writer( path=outfile_decoys, @@ -886,7 +972,8 @@ def create_sorted_file_reader( input_output_column_mapping.get(name, name) for name in input_columns ] file_iterator = reader.get_chunked_data_iterator( - CONFIDENCE_CHUNK_SIZE, output_columns + chunk_size=CONFIDENCE_CHUNK_SIZE, + columns=output_columns, ) # Write those chunks in parallel, where the columns are given @@ -911,7 +998,7 @@ def create_sorted_file_reader( ] sorted_file_reader = MergedTabularDataReader( - readers, + readers=readers, priority_column="score", reader_chunk_size=CONFIDENCE_CHUNK_SIZE, ) @@ -950,7 +1037,7 @@ def _save_sorted_metadata_chunks( try: chunk_metadata.drop_duplicates(deduplication_columns, inplace=True) except KeyError as e: - msg = "Duplication error in the following columns: " + msg = "Duplication error trying to use the following columns: " msg += str(deduplication_columns) msg += f". Found: {chunk_metadata.columns} " msg += ". Please check the input data." diff --git a/mokapot/tabular_data/base.py b/mokapot/tabular_data/base.py index 8ade0e4..5fac3fc 100644 --- a/mokapot/tabular_data/base.py +++ b/mokapot/tabular_data/base.py @@ -310,6 +310,11 @@ def initialize(self): def finalize(self): pass + @abstractmethod + def read(self) -> pd.DataFrame: + # TODO: Evaluate if this method should allow lazier reading. + raise NotImplementedError + def __enter__(self): self.initialize() return self diff --git a/mokapot/tabular_data/csv.py b/mokapot/tabular_data/csv.py index 0e81771..e4113ba 100644 --- a/mokapot/tabular_data/csv.py +++ b/mokapot/tabular_data/csv.py @@ -1,5 +1,6 @@ from pathlib import Path from typing import Generator +import warnings import numpy as np import pandas as pd @@ -97,6 +98,10 @@ def __repr__(self): def initialize(self): # Just write header information + if Path(self.file_name).exists(): + warnings.warn( + f"CSV file {self.file_name} exists, but will be overwritten." + ) df = pd.DataFrame(columns=self.columns) df.to_csv(self.file_name, **self.stdargs) @@ -110,3 +115,6 @@ def append_data(self, data: pd.DataFrame): def get_associated_reader(self): return CSVFileReader(self.file_name, sep=self.stdargs["sep"]) + + def read(self): + return pd.read_csv(self.file_name, sep=self.stdargs["sep"]) diff --git a/mokapot/tabular_data/sqlite.py b/mokapot/tabular_data/sqlite.py index fc715f5..a9b814a 100644 --- a/mokapot/tabular_data/sqlite.py +++ b/mokapot/tabular_data/sqlite.py @@ -101,3 +101,7 @@ def append_data(self, data): row["q_value"] = row[self.qvalue_column] row["posterior_error_prob"] = row[self.pep_column] self.connection.executemany(query, data) + + def read(self, level: str = "psms"): + table_name, table_id_col, mokapot_id_col = self.level_cols[level] + return pd.read_sql_table(table_name, self.connection) diff --git a/mokapot/tabular_data/streaming.py b/mokapot/tabular_data/streaming.py index 3b5a2dd..5e67bc1 100644 --- a/mokapot/tabular_data/streaming.py +++ b/mokapot/tabular_data/streaming.py @@ -5,6 +5,7 @@ from __future__ import annotations import warnings +from pprint import pformat from typing import Generator, Callable, Iterator import numpy as np @@ -398,6 +399,13 @@ def __init__( self.finalized = False self.initialized = False + def __repr__(self): + IGNORE_KEYS = {"buffer"} + dict_repr = pformat({ + k: v for k, v in self.__dict__.items() if k not in IGNORE_KEYS + }) + return f"{self.__class__!s}({dict_repr})" + def __del__(self): if self.initialized and not self.finalized: warnings.warn( diff --git a/tests/system_tests/test_brew_rollup.py b/tests/system_tests/test_brew_rollup.py index 85bbf7b..aa34b69 100644 --- a/tests/system_tests/test_brew_rollup.py +++ b/tests/system_tests/test_brew_rollup.py @@ -149,7 +149,7 @@ def test_rollup_10000(rollup_src_dirs, suffix, tmp_path): df0 = TabularDataReader.from_path(file0).read() df1 = TabularDataReader.from_path(file1).read() - qval_column = "q-value" + qval_column = "mokapot_qvalue" assert_series_equal(df0[qval_column], df1[qval_column], atol=0.02) assert ( estimate_abs_int(df0.score, df1[qval_column] - df0[qval_column]) diff --git a/tests/system_tests/test_cli.py b/tests/system_tests/test_cli.py index 7b23234..f3dbb56 100644 --- a/tests/system_tests/test_cli.py +++ b/tests/system_tests/test_cli.py @@ -43,7 +43,7 @@ def test_basic_cli(tmp_path, scope_files): "PSMId", "peptide", "score", - "q-value", + "mokapot_qvalue", "posterior_error_prob", "proteinIds", ] diff --git a/tests/unit_tests/test_writer_flashlfq.py b/tests/unit_tests/test_writer_flashlfq.py index 4a961d4..d0d9a83 100644 --- a/tests/unit_tests/test_writer_flashlfq.py +++ b/tests/unit_tests/test_writer_flashlfq.py @@ -108,7 +108,7 @@ def flashlfq_psms_ds_ondisk(psm_df_builder, tmp_path): return psms -@pytest.parametrize("deduplication", [True, False]) +@pytest.mark.parametrize("deduplication", [True, False]) def test_internal_flashlfq_ondisk(flashlfq_psms_ds_ondisk, deduplication): if deduplication: pytest.skip("Deduplication is not working") From 2e43ce2e442a84e951555830d262fc0c60013189 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Mon, 16 Dec 2024 17:41:06 -0600 Subject: [PATCH 07/12] feat,experiment: Experimental qvalue-fdr estimation --- mokapot/confidence.py | 7 +++- mokapot/qvalues.py | 50 ++++++++++++++++++++++++++ mokapot/writers/flashlfq.py | 2 +- tests/system_tests/test_brew_rollup.py | 5 +++ tests/system_tests/test_parquet.py | 2 +- tests/system_tests/test_rollup.py | 2 +- tests/unit_tests/test_confidence.py | 8 +++-- 7 files changed, 69 insertions(+), 7 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index 13da83e..f2f2371 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -666,6 +666,7 @@ def __init__( use_proteins: bool, dest_dir: Path, file_root: str, + protein_column: str | None, ): self.level_columns = level_columns self.default_extension = default_extension @@ -674,6 +675,7 @@ def __init__( self.dest_dir = dest_dir self.file_root = file_root self.do_rollup = do_rollup + self.protein_column = protein_column self._initialize_levels() self._setup_level_paths() @@ -693,6 +695,7 @@ def from_dataset( level_columns = dataset.level_columns default_extension = dataset.get_default_extension() spectrum_columns = dataset.spectrum_columns + protein_column = dataset.protein_column return LevelManager( level_columns=level_columns, default_extension=default_extension, @@ -701,6 +704,7 @@ def from_dataset( use_proteins=use_proteins, dest_dir=dest_dir, file_root=file_root, + protein_column=protein_column, ) def __repr__(self) -> str: @@ -740,10 +744,11 @@ def _setup_hash_columns(self) -> None: def _setup_protein_levels(self) -> None: levels_or_proteins = self.levels + file_ext = self.default_extension if self.use_proteins: levels_or_proteins = [*levels_or_proteins, "proteins"] self.level_data_paths["proteins"] = ( - self.dest_dir / f"{self.file_root}proteins{self.file_ext}" + self.dest_dir / f"{self.file_root}proteins{file_ext}" ) self.level_hash_columns["proteins"] = self.protein_column diff --git a/mokapot/qvalues.py b/mokapot/qvalues.py index b5a1bff..0eac457 100644 --- a/mokapot/qvalues.py +++ b/mokapot/qvalues.py @@ -6,6 +6,7 @@ import numba as nb from typeguard import typechecked from typing import Callable +import os from mokapot.peps import ( peps_from_scores_hist_nnls, @@ -126,6 +127,10 @@ def tdc( ) # Calculate q-values + # Note: I really feel like unique values from floats is not the best idea + # ... + # a sane alternative would be to use a specific precision and make it + # an integer. unique_metric, indices = np.unique(scores, return_counts=True) # Some arrays need to be flipped so that we can loop through from @@ -136,7 +141,35 @@ def tdc( unique_metric = np.flip(unique_metric) indices = np.flip(indices) + # import time + + # t0 = time.time() qvals = _fdr2qvalue(fdr, num_total, indices) + # et = (time.time() - t0) * 1000 + # print(f"Base Time: {et}") + # t0 = time.time() + # qvals_np = np.minimum.accumulate(fdr) + # et = (time.time() - t0) * 1000 + # print(f"Numpy Time: {et}") + + # CARE = False + # if CARE and not np.allclose(qvals, qvals_np): + # rmse = np.sqrt(np.mean((qvals - qvals_np) ** 2)) + # print(f"RMSE: {rmse}") + # from matplotlib import pyplot as plt + + # diff_window = (qvals > 0.6) & (qvals < 0.75) + # print(f"Diff Qvals: {qvals[diff_window]}") + # print(f"Diff Qvals_np: {qvals[diff_window]}") + # print(f"Diff Qvals_fdr: {qvals[diff_window]}") + + # plt.scatter(x=qvals, y=qvals_np, alpha=0.3) + # plt.xlabel("Qvals") + # plt.ylabel("Qvals Numpy") + # plt.show() + # # if rmse > 1e-3: + # # raise RuntimeError("Numpy implementation is not close.") + qvals = np.flip(qvals) qvals = qvals[np.argsort(srt_idx)] @@ -173,6 +206,9 @@ def _fdr2qvalue(fdr, num_total, indices): prev_idx = next_idx fdr_group = fdr[group] + # Q: Why isnt this a constant? + # Shouldnt all the elements in the group be the same? + # JSPP 2024-12-16 n_group = num_total[group] curr_fdr = fdr_group[np.argmax(n_group)] if curr_fdr < min_q: @@ -183,6 +219,20 @@ def _fdr2qvalue(fdr, num_total, indices): return qvals +# Experimental for now ... will remove from the PR if needed. +if os.environ.get("MOKAPOT_QVALUES_USE_NUMPY", False): + import warnings + + warnings.warn( + "Using numpy implementation of q-value computation. " + "This is not recommended for production use." + "Set the environment variable MOKAPOT_QVALUES_USE_NUMPY=0 to disable." + ) + + def _fdr2qvalue(fdr, num_total, indices): + return np.minimum.accumulate(fdr) + + @typechecked def qvalues_from_scores( scores: np.ndarray[float], diff --git a/mokapot/writers/flashlfq.py b/mokapot/writers/flashlfq.py index 70157c9..d99a236 100644 --- a/mokapot/writers/flashlfq.py +++ b/mokapot/writers/flashlfq.py @@ -101,7 +101,7 @@ def _format_flashlfq(conf): # OLD: passing = peptides["mokapot q-value"] <= eval_fdr eval_fdr = conf.eval_fdr passing = pd.read_csv(conf.out_writers["peptides"][0].file_name, sep="\t") - passing = passing[passing["q-value"] < eval_fdr] + passing = passing[passing["mokapot_qvalue"] <= eval_fdr] cols_pull = opt_cols cols_pull["PSMId"] = conf.dataset.specId_column diff --git a/tests/system_tests/test_brew_rollup.py b/tests/system_tests/test_brew_rollup.py index aa34b69..48ae75a 100644 --- a/tests/system_tests/test_brew_rollup.py +++ b/tests/system_tests/test_brew_rollup.py @@ -151,6 +151,11 @@ def test_rollup_10000(rollup_src_dirs, suffix, tmp_path): qval_column = "mokapot_qvalue" assert_series_equal(df0[qval_column], df1[qval_column], atol=0.02) + + # Q: What is this meant to test? + # Why is the score expected to be "correlated" with the difference + # in q-values between the streaming and non-streaming implementations? + # JSPP 2024-12-16 assert ( estimate_abs_int(df0.score, df1[qval_column] - df0[qval_column]) < 0.002 diff --git a/tests/system_tests/test_parquet.py b/tests/system_tests/test_parquet.py index dca4407..2bfbb0e 100644 --- a/tests/system_tests/test_parquet.py +++ b/tests/system_tests/test_parquet.py @@ -25,7 +25,7 @@ def test_parquet_output(tmp_path): "PSMId", "peptide", "score", - "q-value", + "mokapot_qvalue", "posterior_error_prob", "proteinIds", ] diff --git a/tests/system_tests/test_rollup.py b/tests/system_tests/test_rollup.py index 267bc1b..25bab5a 100644 --- a/tests/system_tests/test_rollup.py +++ b/tests/system_tests/test_rollup.py @@ -235,7 +235,7 @@ def read_tsv(filename): df_base = read_tsv("base.targets.psms.csv") - qvc = "q-value" + qvc = "mokapot_qvalue" pvc = "posterior_error_prob" pd.testing.assert_frame_equal( df_streamed.drop(columns=[qvc, pvc]), df_base.drop(columns=[qvc, pvc]) diff --git a/tests/unit_tests/test_confidence.py b/tests/unit_tests/test_confidence.py index 153a790..bf88bf5 100644 --- a/tests/unit_tests/test_confidence.py +++ b/tests/unit_tests/test_confidence.py @@ -130,7 +130,7 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path, deduplication): "PSMId", "peptide", "score", - "q-value", + "mokapot_qvalue", "posterior_error_prob", "proteinIds", ] @@ -158,10 +158,12 @@ def test_chunked_assign_confidence(psm_df_1000, tmp_path, deduplication): # 0.0103092780336737, # 0.0103092780336737, # ]) - assert np.all(df_head["q-value"] < 0.015), ( + assert np.all(df_head["mokapot_qvalue"] < 0.015), ( "Good q-values should be lt 0.015" ) - assert np.all(df_tail["q-value"] > 0.9), "Bad q-values should be gt 0.9" + assert np.all(df_tail["mokapot_qvalue"] > 0.9), ( + "Bad q-values should be gt 0.9" + ) # assert df["posterior_error_prob"].tolist() == approx([ # 3.315389846699129e-05, From be91528e7e82db91e7fb9b2ef841c176cc4a2329 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Tue, 17 Dec 2024 13:56:00 -0600 Subject: [PATCH 08/12] chore,docs: updated basic docs to curr api and updated typing --- mokapot/confidence.py | 132 ++++++++++++++++++++++---------------- mokapot/dataset.py | 30 --------- mokapot/parsers/fasta.py | 18 +++--- mokapot/picked_protein.py | 14 +++- pyproject.toml | 2 +- uv.lock | 2 +- 6 files changed, 98 insertions(+), 100 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index f2f2371..950aae6 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -13,6 +13,8 @@ We recommend using the :py:func:`~mokapot.brew()` function to obtain these confidence estimates, rather than initializing the classes below directly. + +TODO: update this docstring. """ from __future__ import annotations @@ -38,6 +40,7 @@ peps_func_from_hist_nnls, PepsConvergenceError, ) +from mokapot.proteins import Proteins from mokapot.picked_protein import picked_protein from mokapot.qvalues import qvalues_from_scores, qvalues_func_from_hist from mokapot.statistics import OnlineStatistics, HistData @@ -70,8 +73,45 @@ # Classes --------------------------------------------------------------------- @typechecked -class Confidence(object): - """Estimate the statistical confidence for a collection of PSMs.""" +class Confidence: + """Calculate, Store and provide access to confidence estimates. + + This class stores confidence estimates (q-values and PEPs) computed for + different levels (PSMs, peptides, proteins) and provides methods + to access, save and visualize these estimates. + + Parameters + ---------- + dataset : PsmDataset + The dataset containing PSMs and metadata + levels : list[str] + Levels at which confidence estimation was performed + (e.g. ['psms','peptides']) + level_paths : dict[str, Path] + Paths to intermediate files for each confidence level + out_writers : dict[str, Sequence[TabularDataWriter]] + Writers for outputting results at each level + eval_fdr : float, optional + FDR threshold for evaluation metrics, by default 0.01 + write_decoys : bool, optional + Whether to write decoy results, by default False + do_rollup : bool, optional + Whether to perform protein inference, by default True + proteins : pd.DataFrame, optional + Protein annotations if protein inference is used + peps_error : bool, optional + Whether to raise error on PEP calculation failure, by default False + rng : int or np.random.Generator, optional + Random number generator for reproducibility + peps_algorithm : str, optional + Algorithm for PEP calculation, by default "qvality" + qvalue_algorithm : str, optional + Algorithm for q-value calculation, by default "tdc" + stream_confidence : bool, optional + Whether to stream confidence calculations, by default False + score_stats : OnlineStatistics, optional + Pre-computed score statistics if streaming + """ def __init__( self, @@ -82,7 +122,7 @@ def __init__( eval_fdr: float = 0.01, write_decoys: bool = False, do_rollup: bool = True, - proteins: pd.DataFrame | None = None, + proteins: Proteins | None = None, peps_error: bool = False, rng=0, peps_algorithm: str = "qvality", @@ -90,34 +130,6 @@ def __init__( stream_confidence: bool = False, score_stats=None, ): - """Initialize a Confidence object. - - Assign confidence estimates to a set of PSMs - - Estimate q-values and posterior error probabilities (PEPs) for PSMs and - peptides when ranked by the provided scores. - - Parameters - ---------- - dataset : OnDiskPsmDataset - An OnDiskPsmDataset. - rng : int or np.random.Generator, optional - A seed or generator used for cross-validation split creation and to - break ties, or ``None`` to use the default random number generator - state. - levels : list[str] - Levels at which confidence estimation was performed - level_paths : list[Path] - Files with unique psms and unique peptides. - out_paths : list[list[Path]] - The output files where the results will be written - eval_fdr : float - The FDR threshold at which to report performance. This parameter - has no affect on the analysis itself, only logging messages. - write_decoys : bool - Save decoys confidence estimates as well? - """ - self.dataset = dataset self._score_column = "score" self._target_column = dataset.target_column @@ -172,7 +184,7 @@ def __repr__(self) -> str: def _assign_confidence( self, - levels: list[str], + levels: list[str], # why is this passed if its a property of self? level_path_map: dict[str, Path], out_writers_map: dict[str, Sequence[TabularDataWriter]], write_decoys: bool = False, @@ -237,26 +249,28 @@ def _assign_confidence( level_path.unlink(missing_ok=True) - def _write_protein_level_data(self, level_paths, proteins, rng): + def _write_protein_level_data( + self, level_paths: dict[str, Path], proteins: Proteins, rng + ): psms = TabularDataReader.from_path(level_paths["psms"]).read() - proteins = picked_protein( - psms, - self._target_column, - self._peptide_column, - self._score_column, - proteins, - rng, + proteins_df = picked_protein( + peptides=psms, + target_column=self._target_column, + peptide_column=self._peptide_column, + score_column=self._score_column, + proteins=proteins, + rng=rng, ) - proteins = proteins.sort_values( + proteins_df = proteins_df.sort_values( by=self._score_column, ascending=False ).reset_index(drop=True) protein_writer = TabularDataWriter.from_suffix( file_name=level_paths["proteins"], - columns=proteins.columns.tolist(), - column_types=proteins.dtypes.tolist(), + columns=proteins_df.columns.tolist(), + column_types=proteins_df.dtypes.tolist(), ) - protein_writer.write(proteins) - LOGGER.info("\t- Found %i unique protein groups.", len(proteins)) + protein_writer.write(proteins_df) + LOGGER.info("\t- Found %i unique protein groups.", len(proteins_df)) def get_optional_columns(self) -> OptionalColumns: return self.dataset.get_optional_columns() @@ -326,16 +340,16 @@ def assign_confidence( file_root: str = "", prefixes: list[str | None] | None = None, write_decoys: bool = False, - deduplication=True, - do_rollup=True, - proteins=None, - append_to_output_file=False, - rng=0, - peps_error=False, - peps_algorithm="qvality", - qvalue_algorithm="tdc", - sqlite_path=None, - stream_confidence=False, + deduplication: bool = True, + do_rollup: bool = True, + proteins: Proteins | None = None, + append_to_output_file: bool = False, + rng: int | np.random.Generator = 0, + peps_error: bool = False, + peps_algorithm="qvality", # TODO make this an enum (2024-12-17) + qvalue_algorithm="tdc", # TODO make this an enum (2024-12-17) + sqlite_path: Path | None = None, + stream_confidence: bool = False, ) -> list[Confidence]: """Assign confidence to PSMs peptides, and optionally, proteins. @@ -512,8 +526,6 @@ def assign_confidence( class LevelWriterCollection: - """ """ - def __init__( self, levels: list[str], @@ -628,6 +640,8 @@ class LevelManager: """Manages level-specific data and operations. This class is meant to be used internally by the `Confidence` class. + But it basically bundles the output path creation logic and the column + +level mapping logic. Parameters ---------- @@ -654,6 +668,10 @@ class LevelManager: The prefix added to all output file names. The final file names will be: `dest_dir / file_root+level+default_extension` + protein_column : str, optional + The column that specifies which protein(s) the detected peptide might + have originated from. This column is not used to compute protein-level + confidence estimates, it is just propagated to the output. """ def __init__( diff --git a/mokapot/dataset.py b/mokapot/dataset.py index e0b7bef..286ed79 100644 --- a/mokapot/dataset.py +++ b/mokapot/dataset.py @@ -30,8 +30,6 @@ from mokapot import qvalues from mokapot import utils -from mokapot.parsers.fasta import read_fasta -from mokapot.proteins import Proteins from .tabular_data import TabularDataReader, DataFrameReader LOGGER = logging.getLogger(__name__) @@ -107,29 +105,6 @@ def rng(self, rng): """Set the random number generator""" self._rng = np.random.default_rng(rng) - def add_proteins(self, proteins, **kwargs): - """Add protein information to the dataset. - - Protein sequence information is required to compute protein-level - confidence estimates using the picked-protein approach. - - Parameters - ---------- - proteins : a Proteins object or str - The :py:class:`~mokapot.proteins.Proteins` object defines the - mapping of peptides to proteins and the mapping of decoy proteins - to their corresponding target proteins. Alternatively, a string - specifying a FASTA file can be specified which will be parsed to - define these mappings. - **kwargs : dict - Keyword arguments to be passed to the - :py:class:`mokapot.read_fasta()` function. - """ - if not isinstance(proteins, Proteins): - proteins = read_fasta(proteins, **kwargs) - - self._proteins = proteins - @abstractmethod def get_optional_columns(self) -> OptionalColumns: """Return a dictionary of optional columns and their names. @@ -657,11 +632,6 @@ def columns(self): """The columns of the dataset.""" return self.data.columns.tolist() - @property - def has_proteins(self): - """Has a FASTA file been added?""" - return self._proteins is not None - def _targets_count_by_feature(self, desc, eval_fdr): """ iterate over features and count the number of positive examples diff --git a/mokapot/parsers/fasta.py b/mokapot/parsers/fasta.py index ceb6140..98f7b10 100644 --- a/mokapot/parsers/fasta.py +++ b/mokapot/parsers/fasta.py @@ -14,14 +14,14 @@ def read_fasta( - fasta_files, - enzyme="[KR]", - missed_cleavages=2, - clip_nterm_methionine=False, - min_length=6, - max_length=50, - semi=False, - decoy_prefix="decoy_", + fasta_files: str | list[str] | tuple[str], + enzyme: str | re.Pattern = "[KR]", + missed_cleavages: int = 2, + clip_nterm_methionine: bool = False, + min_length: int = 6, + max_length: int = 50, + semi: bool = False, + decoy_prefix: str = "decoy_", ): """Parse a FASTA file, storing a mapping of peptides and proteins. @@ -310,7 +310,7 @@ def digest( # Private Functions ----------------------------------------------------------- -def _parse_fasta_files(fasta_files): +def _parse_fasta_files(fasta_files: str | list[str] | tuple[str]) -> list[str]: """Read a fasta file and divide into proteins Parameters diff --git a/mokapot/picked_protein.py b/mokapot/picked_protein.py index 10e1413..15a7a3a 100644 --- a/mokapot/picked_protein.py +++ b/mokapot/picked_protein.py @@ -5,15 +5,22 @@ import logging import pandas as pd +import numpy as np from mokapot import utils from mokapot.peptides import match_decoy +from mokapot.proteins import Proteins LOGGER = logging.getLogger(__name__) def picked_protein( - peptides, target_column, peptide_column, score_column, proteins, rng + peptides: pd.DataFrame, + target_column: str, + peptide_column: str, + score_column: str, + proteins: Proteins, + rng: int | np.random.Generator, ): """Perform the picked-protein approach @@ -25,6 +32,8 @@ def picked_protein( The column in `peptides` indicating if the peptide is a target. peptide_column : str The column in `peptides` containing the peptide sequence. + score_column : str + The column in `peptides` containing the score. proteins : Proteins object A Proteins object. rng : int or numpy.random.Generator @@ -142,6 +151,7 @@ def strip_peptides(sequences): sequences.str.replace(r"[\[\(].*?[\]\)]", "", regex=True) .str.replace(r"^.*?\.", "", regex=True) .str.replace(r"\..*?$", "", regex=True) + .str.strip("-") ) # Sometimes folks use lowercase letters for the termini or mods: @@ -153,7 +163,7 @@ def strip_peptides(sequences): return sequences -def group_with_decoys(peptides, proteins): +def group_with_decoys(peptides: pd.DataFrame, proteins: Proteins): """Retrieve the protein group in the case where the FASTA has decoys. Parameters diff --git a/pyproject.toml b/pyproject.toml index 47e81a1..3810c93 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -79,7 +79,7 @@ select = ["E", "F", "T20"] # T20 is for print() statements. [tool.ruff.lint.per-file-ignores] "__init__.py" = ["F401"] -"docs/*.ipynb" = ["T20"] +"docs/**/*.ipynb" = ["T20"] "test_parser_pepxml.py" = ["E501"] [tool.setuptools] diff --git a/uv.lock b/uv.lock index 24996b0..79c1ea8 100644 --- a/uv.lock +++ b/uv.lock @@ -1159,7 +1159,7 @@ wheels = [ [[package]] name = "mokapot" -version = "0.10.1.dev37+gd4d3e8c.d20241215" +version = "0.10.1.dev40+g2e43ce2.d20241217" source = { editable = "." } dependencies = [ { name = "importlib-metadata" }, From 680fc5b540e8729f3549abc98e2287aca464bbc4 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Tue, 17 Dec 2024 16:02:38 -0600 Subject: [PATCH 09/12] chore: updated basic n joint model docs code (md in progress) --- docs/source/vignettes/.gitignore | 3 + docs/source/vignettes/basic_python_api.ipynb | 551 +++++++++---------- docs/source/vignettes/joint_models.ipynb | 410 +++++++++----- 3 files changed, 542 insertions(+), 422 deletions(-) create mode 100644 docs/source/vignettes/.gitignore diff --git a/docs/source/vignettes/.gitignore b/docs/source/vignettes/.gitignore new file mode 100644 index 0000000..2983688 --- /dev/null +++ b/docs/source/vignettes/.gitignore @@ -0,0 +1,3 @@ + +joint_models/ +basic_python_api_output/ diff --git a/docs/source/vignettes/basic_python_api.ipynb b/docs/source/vignettes/basic_python_api.ipynb index 73548dc..ad0dc6e 100644 --- a/docs/source/vignettes/basic_python_api.ipynb +++ b/docs/source/vignettes/basic_python_api.ipynb @@ -23,7 +23,8 @@ "metadata": {}, "outputs": [], "source": [ - "pin_file = \"../../../data/phospho_rep1.pin\"" + "from pathlib import Path\n", + "pin_file = Path(\"../../../data/phospho_rep1.pin\")" ] }, { @@ -39,7 +40,7 @@ "metadata": {}, "outputs": [], "source": [ - "fasta_file = \"../../../data/human_sp_td.fasta\"" + "fasta_file = Path(\"../../../data/human_sp_td.fasta\")" ] }, { @@ -57,7 +58,6 @@ "metadata": {}, "outputs": [], "source": [ - "import os\n", "import mokapot\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -66,8 +66,12 @@ "np.random.seed(42)\n", "\n", "# Create an output directory\n", - "out_dir = \"basic_python_api_output\"\n", - "os.makedirs(out_dir, exist_ok=True)" + "out_dir = Path(\"basic_python_api_output\")\n", + "out_dir.mkdir(exist_ok=True)\n", + "mokapot_outs = (out_dir / \"mokapot\")\n", + "mokapot_outs.mkdir(exist_ok=True)\n", + "tide_outs = (out_dir / \"tide\")\n", + "tide_outs.mkdir(exist_ok=True)" ] }, { @@ -100,16 +104,57 @@ "source": [ "## Step 2: Read the PSMs\n", "\n", - "We'll now use mokapot to read the PSMs from the provided input file. The [read_pin()](https://mokapot.readthedocs.io/en/latest/api/functions.html#mokapot.read_pin) function returns [LinearPsmDataset](https://mokapot.readthedocs.io/en/latest/api/dataset.html#mokapot.dataset.LinearPsmDataset) object, which stores the PSMs and their associated features for analysis." + "We'll now use mokapot to read the PSMs from the provided input file. The [read_pin()](https://mokapot.readthedocs.io/en/latest/api/functions.html#mokapot.read_pin) function returns a list of [LinearPsmDataset](https://mokapot.readthedocs.io/en/latest/api/dataset.html#mokapot.dataset.LinearPsmDataset) object, which stores the PSMs and their associated features for analysis." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[OnDiskPsmDataset object\n", + " Reader: CSVFileReader(self.file_name=PosixPath('../../../data/phospho_rep1.pin'))\n", + " Spectrum columns: ['ScanNr', 'ExpMass']\n", + " Peptide column: Peptide\n", + " Protein column: Proteins\n", + " Feature columns: ['lnrSp', 'deltLCn', 'deltCn', 'Sp', 'IonFrac', 'RefactoredXCorr', 'NegLog10PValue', 'NegLog10ResEvPValue', 'NegLog10CombinePValue', 'PepLen', 'Charge1', 'Charge2', 'Charge3', 'Charge4', 'Charge5', 'enzN', 'enzC', 'enzInt', 'lnNumDSP', 'dM', 'absdM']\n", + " Metadata columns: ['SpecId', 'ScanNr', 'Peptide', 'Proteins', 'Label', 'CalcMass', 'ExpMass']\n", + " Metadata columns types: [dtype('O'), dtype('int64'), dtype('O'), dtype('O'), dtype('int64'), dtype('float64'), dtype('float64')]\n", + " Level columns: ['Peptide']\n", + " Filename column: None\n", + " Scan column: ScanNr\n", + " Calcmass column: CalcMass\n", + " Expmass column: ExpMass\n", + " Rt column: None\n", + " Charge column: None\n", + " Spectra DF: \n", + " ScanNr ExpMass Label\n", + " 0 16619 750.4149 True\n", + " 1 2025 751.4212 True\n", + " 2 1598 751.4223 True\n", + " 3 9595 750.4153 True\n", + " 4 8281 749.4421 True\n", + " ... ... ... ...\n", + " 55393 59499 6392.0034 False\n", + " 55394 62362 6455.8178 False\n", + " 55395 61067 6603.0532 False\n", + " 55396 62418 6684.0410 False\n", + " 55397 45960 6734.9956 False\n", + " \n", + " [55398 rows x 3 columns]]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "psms = mokapot.read_pin(pin_file)" + "psms = mokapot.read_pin(pin_file, max_workers=1)\n", + "psms" ] }, { @@ -126,7 +171,9 @@ "metadata": {}, "outputs": [], "source": [ - "psms.add_proteins(fasta_file)" + "from mokapot.parsers.fasta import read_fasta\n", + "\n", + "proteins = read_fasta(fasta_file)" ] }, { @@ -142,146 +189,85 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, + "outputs": [], + "source": [ + "# moka_conf, models = mokapot.brew(psms)\n", + "models, scores = mokapot.brew(psms)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/mokapot/targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/mokapot/targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/mokapot/targets.proteins.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "moka_conf = mokapot.assign_confidence(psms, dest_dir=mokapot_outs, proteins=proteins)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SpecIdLabelScanNrExpMassCalcMassPeptidemokapot scoremokapot q-valuemokapot PEPProteins
0target_0_48845_5_-1True488455269.57565269.5728R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...11.2154980.0000536.305117e-16sp|P68104|EF1A1_HUMAN
1target_0_45243_4_-1True452433945.87593945.8706R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L10.6010630.0000536.305117e-16sp|Q15365|PCBP1_HUMAN
2target_0_51371_4_-1True513714051.12234051.1086K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D10.5508550.0000536.305117e-16sp|P08670|VIME_HUMAN
3target_0_41715_3_-1True417154473.83594473.8286K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE...9.9646990.0000536.305117e-16sp|P24534|EF1B_HUMAN
4target_0_48913_5_-1True489135269.57375269.5728R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...9.8743740.0000536.305117e-16sp|P68104|EF1A1_HUMAN
\n", - "
" - ], "text/plain": [ - " SpecId Label ScanNr ExpMass CalcMass \\\n", - "0 target_0_48845_5_-1 True 48845 5269.5756 5269.5728 \n", - "1 target_0_45243_4_-1 True 45243 3945.8759 3945.8706 \n", - "2 target_0_51371_4_-1 True 51371 4051.1223 4051.1086 \n", - "3 target_0_41715_3_-1 True 41715 4473.8359 4473.8286 \n", - "4 target_0_48913_5_-1 True 48913 5269.5737 5269.5728 \n", - "\n", - " Peptide mokapot score \\\n", - "0 R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... 11.215498 \n", - "1 R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L 10.601063 \n", - "2 K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D 10.550855 \n", - "3 K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE... 9.964699 \n", - "4 R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... 9.874374 \n", - "\n", - " mokapot q-value mokapot PEP Proteins \n", - "0 0.000053 6.305117e-16 sp|P68104|EF1A1_HUMAN \n", - "1 0.000053 6.305117e-16 sp|Q15365|PCBP1_HUMAN \n", - "2 0.000053 6.305117e-16 sp|P08670|VIME_HUMAN \n", - "3 0.000053 6.305117e-16 sp|P24534|EF1B_HUMAN \n", - "4 0.000053 6.305117e-16 sp|P68104|EF1A1_HUMAN " + "[Confidence object\n", + " Dataset: \n", + " \tOnDiskPsmDataset object\n", + " \tReader: CSVFileReader(self.file_name=PosixPath('../../../data/phospho_rep1.pin'))\n", + " \tSpectrum columns: ['ScanNr', 'ExpMass']\n", + " \tPeptide column: Peptide\n", + " \tProtein column: Proteins\n", + " \tFeature columns: ['lnrSp', 'deltLCn', 'deltCn', 'Sp', 'IonFrac', 'RefactoredXCorr', 'NegLog10PValue', 'NegLog10ResEvPValue', 'NegLog10CombinePValue', 'PepLen', 'Charge1', 'Charge2', 'Charge3', 'Charge4', 'Charge5', 'enzN', 'enzC', 'enzInt', 'lnNumDSP', 'dM', 'absdM']\n", + " \tMetadata columns: ['SpecId', 'ScanNr', 'Peptide', 'Proteins', 'Label', 'CalcMass', 'ExpMass']\n", + " \tMetadata columns types: [dtype('O'), dtype('int64'), dtype('O'), dtype('O'), dtype('int64'), dtype('float64'), dtype('float64')]\n", + " \tLevel columns: ['Peptide']\n", + " \tFilename column: None\n", + " \tScan column: ScanNr\n", + " \tCalcmass column: CalcMass\n", + " \tExpmass column: ExpMass\n", + " \tRt column: None\n", + " \tCharge column: None\n", + " \tSpectra DF: \n", + " \t\tUnset\n", + " \t\n", + " Levels: ['psms', 'peptides', 'proteins']\n", + " Level paths: {'psms': PosixPath('basic_python_api_output/mokapot/psms.csv'), 'peptides': PosixPath('basic_python_api_output/mokapot/peptides.csv'), 'proteins': PosixPath('basic_python_api_output/mokapot/proteins.csv')}\n", + " Out writers: {'psms': [CSVFileWriter(self.file_name=PosixPath('basic_python_api_output/mokapot/targets.psms.csv'),self.columns=['PSMId', 'peptide', 'score', 'mokapot_qvalue', 'posterior_error_prob', 'proteinIds'],self.stdargs={'sep': '\\t', 'index': False})], 'peptides': [CSVFileWriter(self.file_name=PosixPath('basic_python_api_output/mokapot/targets.peptides.csv'),self.columns=['PSMId', 'peptide', 'score', 'mokapot_qvalue', 'posterior_error_prob', 'proteinIds'],self.stdargs={'sep': '\\t', 'index': False})], 'proteins': [CSVFileWriter(self.file_name=PosixPath('basic_python_api_output/mokapot/targets.proteins.csv'),self.columns=['mokapot protein group', 'best peptide', 'stripped sequence', 'score', 'mokapot_qvalue', 'posterior_error_prob'],self.stdargs={'sep': '\\t', 'index': False})]}\n", + " Eval FDR: 0.01\n", + " Write decoys: False\n", + " Do rollup: True\n", + " Peps error: False\n", + " Rng: 0\n", + " Score stats: OnlineStatistics(min=-4.48121575197243, max=11.092598293745384, n=101599, sum=45383.74404487357, mean=0.4466947907447275, M2n=390155.2088566294, ddof=1, unbiased=True)]" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "moka_conf, models = mokapot.brew(psms)\n", - "moka_conf.psms.head()" + "moka_conf" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -305,123 +291,92 @@ " \n", " \n", " \n", - " SpecId\n", - " Label\n", - " ScanNr\n", - " ExpMass\n", - " CalcMass\n", - " Peptide\n", - " mokapot score\n", - " mokapot q-value\n", - " mokapot PEP\n", - " Proteins\n", + " PSMId\n", + " peptide\n", + " score\n", + " mokapot_qvalue\n", + " posterior_error_prob\n", + " proteinIds\n", " \n", " \n", " \n", " \n", " 0\n", - " target_0_48845_5_-1\n", - " True\n", - " 48845\n", - " 5269.5756\n", - " 5269.5728\n", - " R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...\n", - " 11.215498\n", - " 0.000073\n", + " target_0_51371_4_-1\n", + " K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D\n", + " 11.092598\n", + " 0.000079\n", " 6.305117e-16\n", - " sp|P68104|EF1A1_HUMAN\n", + " sp|P08670|VIME_HUMAN\n", " \n", " \n", " 1\n", - " target_0_45243_4_-1\n", - " True\n", - " 45243\n", - " 3945.8759\n", - " 3945.8706\n", - " R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L\n", - " 10.601063\n", - " 0.000073\n", + " target_0_48845_5_-1\n", + " R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...\n", + " 11.061756\n", + " 0.000079\n", " 6.305117e-16\n", - " sp|Q15365|PCBP1_HUMAN\n", + " sp|P68104|EF1A1_HUMAN\n", " \n", " \n", " 2\n", - " target_0_51371_4_-1\n", - " True\n", - " 51371\n", - " 4051.1223\n", - " 4051.1086\n", - " K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D\n", - " 10.550855\n", - " 0.000073\n", + " target_0_41715_3_-1\n", + " K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE...\n", + " 10.039874\n", + " 0.000079\n", " 6.305117e-16\n", - " sp|P08670|VIME_HUMAN\n", + " sp|P24534|EF1B_HUMAN\n", " \n", " \n", " 3\n", - " target_0_41715_3_-1\n", - " True\n", - " 41715\n", - " 4473.8359\n", - " 4473.8286\n", - " K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE...\n", - " 9.964699\n", - " 0.000073\n", + " target_0_54061_3_-1\n", + " K.YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER.K\n", + " 9.843314\n", + " 0.000079\n", " 6.305117e-16\n", - " sp|P24534|EF1B_HUMAN\n", + " sp|Q9NQC3|RTN4_HUMAN\n", " \n", " \n", " 4\n", - " target_0_31886_3_-1\n", - " True\n", - " 31886\n", - " 3450.7612\n", - " 3450.7544\n", - " R.AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK.G\n", - " 9.778672\n", - " 0.000073\n", + " target_0_40746_5_-1\n", + " K.KLVHNALANLDGHPEDKPTHIIFGS[79.97]DS[79.97]ECE...\n", + " 9.830909\n", + " 0.000079\n", " 6.305117e-16\n", - " sp|Q9NRL3|STRN4_HUMAN\n", + " sp|Q76FK4|NOL8_HUMAN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " SpecId Label ScanNr ExpMass CalcMass \\\n", - "0 target_0_48845_5_-1 True 48845 5269.5756 5269.5728 \n", - "1 target_0_45243_4_-1 True 45243 3945.8759 3945.8706 \n", - "2 target_0_51371_4_-1 True 51371 4051.1223 4051.1086 \n", - "3 target_0_41715_3_-1 True 41715 4473.8359 4473.8286 \n", - "4 target_0_31886_3_-1 True 31886 3450.7612 3450.7544 \n", - "\n", - " Peptide mokapot score \\\n", - "0 R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... 11.215498 \n", - "1 R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L 10.601063 \n", - "2 K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D 10.550855 \n", - "3 K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE... 9.964699 \n", - "4 R.AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK.G 9.778672 \n", + " PSMId peptide \\\n", + "0 target_0_51371_4_-1 K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D \n", + "1 target_0_48845_5_-1 R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... \n", + "2 target_0_41715_3_-1 K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE... \n", + "3 target_0_54061_3_-1 K.YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER.K \n", + "4 target_0_40746_5_-1 K.KLVHNALANLDGHPEDKPTHIIFGS[79.97]DS[79.97]ECE... \n", "\n", - " mokapot q-value mokapot PEP Proteins \n", - "0 0.000073 6.305117e-16 sp|P68104|EF1A1_HUMAN \n", - "1 0.000073 6.305117e-16 sp|Q15365|PCBP1_HUMAN \n", - "2 0.000073 6.305117e-16 sp|P08670|VIME_HUMAN \n", - "3 0.000073 6.305117e-16 sp|P24534|EF1B_HUMAN \n", - "4 0.000073 6.305117e-16 sp|Q9NRL3|STRN4_HUMAN " + " score mokapot_qvalue posterior_error_prob proteinIds \n", + "0 11.092598 0.000079 6.305117e-16 sp|P08670|VIME_HUMAN \n", + "1 11.061756 0.000079 6.305117e-16 sp|P68104|EF1A1_HUMAN \n", + "2 10.039874 0.000079 6.305117e-16 sp|P24534|EF1B_HUMAN \n", + "3 9.843314 0.000079 6.305117e-16 sp|Q9NQC3|RTN4_HUMAN \n", + "4 9.830909 0.000079 6.305117e-16 sp|Q76FK4|NOL8_HUMAN " ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "moka_conf.peptides.head()" + "moka_conf[0].peptides.head()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -448,55 +403,55 @@ " mokapot protein group\n", " best peptide\n", " stripped sequence\n", - " mokapot score\n", - " mokapot q-value\n", - " mokapot PEP\n", + " score\n", + " mokapot_qvalue\n", + " posterior_error_prob\n", " \n", " \n", " \n", " \n", " 0\n", - " sp|P68104|EF1A1_HUMAN\n", - " R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...\n", - " RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHTAH...\n", - " 11.215498\n", - " 0.000291\n", + " sp|P08670|VIME_HUMAN\n", + " K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D\n", + " KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR\n", + " 11.092598\n", + " 0.000292\n", " 6.305117e-16\n", " \n", " \n", " 1\n", - " sp|Q15365|PCBP1_HUMAN\n", - " R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L\n", - " CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK\n", - " 10.601063\n", - " 0.000291\n", + " sp|P68104|EF1A1_HUMAN\n", + " R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT...\n", + " RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHTAH...\n", + " 11.061756\n", + " 0.000292\n", " 6.305117e-16\n", " \n", " \n", " 2\n", - " sp|P08670|VIME_HUMAN\n", - " K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D\n", - " KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR\n", - " 10.550855\n", - " 0.000291\n", + " sp|P24534|EF1B_HUMAN\n", + " K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE...\n", + " ALGKYGPADVEDTTGSGATDSKDDDDIDLFGSDDEEESEEAK\n", + " 10.039874\n", + " 0.000292\n", " 6.305117e-16\n", " \n", " \n", " 3\n", - " sp|P24534|EF1B_HUMAN\n", - " K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE...\n", - " ALGKYGPADVEDTTGSGATDSKDDDDIDLFGSDDEEESEEAK\n", - " 9.964699\n", - " 0.000291\n", + " sp|Q9NQC3|RTN4_HUMAN\n", + " K.YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER.K\n", + " YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER\n", + " 9.843314\n", + " 0.000292\n", " 6.305117e-16\n", " \n", " \n", " 4\n", - " sp|Q9NRL3|STRN4_HUMAN\n", - " R.AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK.G\n", - " AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK\n", - " 9.778672\n", - " 0.000291\n", + " sp|Q76FK4|NOL8_HUMAN\n", + " K.KLVHNALANLDGHPEDKPTHIIFGS[79.97]DS[79.97]ECE...\n", + " KLVHNALANLDGHPEDKPTHIIFGSDSECETEETSTQEQSHPGEEWVK\n", + " 9.830909\n", + " 0.000292\n", " 6.305117e-16\n", " \n", " \n", @@ -505,34 +460,34 @@ ], "text/plain": [ " mokapot protein group best peptide \\\n", - "0 sp|P68104|EF1A1_HUMAN R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... \n", - "1 sp|Q15365|PCBP1_HUMAN R.CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK.L \n", - "2 sp|P08670|VIME_HUMAN K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D \n", - "3 sp|P24534|EF1B_HUMAN K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE... \n", - "4 sp|Q9NRL3|STRN4_HUMAN R.AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK.G \n", + "0 sp|P08670|VIME_HUMAN K.KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR.D \n", + "1 sp|P68104|EF1A1_HUMAN R.RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHT... \n", + "2 sp|P24534|EF1B_HUMAN K.ALGKYGPADVEDTTGSGATDSKDDDDIDLFGS[79.97]DDEEE... \n", + "3 sp|Q9NQC3|RTN4_HUMAN K.YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER.K \n", + "4 sp|Q76FK4|NOL8_HUMAN K.KLVHNALANLDGHPEDKPTHIIFGS[79.97]DS[79.97]ECE... \n", "\n", - " stripped sequence mokapot score \\\n", - "0 RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHTAH... 11.215498 \n", - "1 CSDAAGYPHATHDLEGPPLDAYSIQGQHTISPLDLAK 10.601063 \n", - "2 KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR 10.550855 \n", - "3 ALGKYGPADVEDTTGSGATDSKDDDDIDLFGSDDEEESEEAK 9.964699 \n", - "4 AAAAVAAAASSCRPLGSGAGPGPTGAAPVSAPAPGPGPAGK 9.778672 \n", + " stripped sequence score \\\n", + "0 KLHEEEIQELQAQIQEQHVQIDVDVSKPDLTAALR 11.092598 \n", + "1 RGNVAGDSKNDPPMEAAGFTAQVIILNHPGQISAGYAPVLDCHTAH... 11.061756 \n", + "2 ALGKYGPADVEDTTGSGATDSKDDDDIDLFGSDDEEESEEAK 10.039874 \n", + "3 YQFVREPEDEEEEEEEEEEDEDEDLEELEVLER 9.843314 \n", + "4 KLVHNALANLDGHPEDKPTHIIFGSDSECETEETSTQEQSHPGEEWVK 9.830909 \n", "\n", - " mokapot q-value mokapot PEP \n", - "0 0.000291 6.305117e-16 \n", - "1 0.000291 6.305117e-16 \n", - "2 0.000291 6.305117e-16 \n", - "3 0.000291 6.305117e-16 \n", - "4 0.000291 6.305117e-16 " + " mokapot_qvalue posterior_error_prob \n", + "0 0.000292 6.305117e-16 \n", + "1 0.000292 6.305117e-16 \n", + "2 0.000292 6.305117e-16 \n", + "3 0.000292 6.305117e-16 \n", + "4 0.000292 6.305117e-16 " ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "moka_conf.proteins.head()" + "moka_conf[0].proteins.head()" ] }, { @@ -544,11 +499,27 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/tide/targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/tide/targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file basic_python_api_output/tide/targets.proteins.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] + } + ], "source": [ - "tide_conf = psms.assign_confidence()" + "# Brewing the data modifies the PSMs, so we need to make a a new\n", + "# clean copy of our data.\n", + "psms = mokapot.read_pin(pin_file, max_workers=1)\n", + "tide_conf = mokapot.assign_confidence(psms, dest_dir=tide_outs, proteins=proteins)" ] }, { @@ -562,23 +533,27 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ + "# Since we have lists but a single input file, we can just take the first\n", + "# element\n", + "tide_conf = tide_conf[0]\n", + "moka_conf = moka_conf[0]\n", + "\n", + "\n", "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", "colors = (\"#343131\", \"#24B8A0\")\n", "\n", @@ -603,33 +578,33 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "PSMs gained by mokapot: 1149\n", - "Peptides gained by mokapot: 872\n", - "Proteins gained by mokapot: 89\n" + "PSMs gained by mokapot: 1128\n", + "Peptides gained by mokapot: 888\n", + "Proteins gained by mokapot: 86\n" ] } ], "source": [ "# PSMs\n", - "moka_psms = (moka_conf.psms[\"mokapot q-value\"] <= 0.01).sum()\n", - "tide_psms = (tide_conf.psms[\"mokapot q-value\"] <= 0.01).sum()\n", + "moka_psms = (moka_conf.psms[\"mokapot_qvalue\"] <= 0.01).sum()\n", + "tide_psms = (tide_conf.psms[\"mokapot_qvalue\"] <= 0.01).sum()\n", "print(f\"PSMs gained by mokapot: {moka_psms - tide_psms}\")\n", "\n", "# Peptides\n", - "moka_peps = (moka_conf.peptides[\"mokapot q-value\"] <= 0.01).sum()\n", - "tide_peps = (tide_conf.peptides[\"mokapot q-value\"] <= 0.01).sum()\n", + "moka_peps = (moka_conf.peptides[\"mokapot_qvalue\"] <= 0.01).sum()\n", + "tide_peps = (tide_conf.peptides[\"mokapot_qvalue\"] <= 0.01).sum()\n", "print(f\"Peptides gained by mokapot: {moka_peps - tide_peps}\")\n", "\n", "# Proteins\n", - "moka_prots = (moka_conf.proteins[\"mokapot q-value\"] <= 0.01).sum()\n", - "tide_prots = (tide_conf.proteins[\"mokapot q-value\"] <= 0.01).sum()\n", + "moka_prots = (moka_conf.proteins[\"mokapot_qvalue\"] <= 0.01).sum()\n", + "tide_prots = (tide_conf.proteins[\"mokapot_qvalue\"] <= 0.01).sum()\n", "print(f\"Proteins gained by mokapot: {moka_prots - tide_prots}\")" ] }, @@ -637,30 +612,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, we will save the results as tab-delimited text files:" + "In prior versions of mokapor we had to save the results, now those get saved automatically\n", + "during the confidence assignment.\n", + "\n", + "We can see where they are using the `level_paths` attribute of the confidence object." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['basic_python_api_output/mokapot.psms.txt',\n", - " 'basic_python_api_output/mokapot.peptides.txt',\n", - " 'basic_python_api_output/mokapot.proteins.txt']" + "{'psms': PosixPath('basic_python_api_output/mokapot/psms.csv'),\n", + " 'peptides': PosixPath('basic_python_api_output/mokapot/peptides.csv'),\n", + " 'proteins': PosixPath('basic_python_api_output/mokapot/proteins.csv')}" ] }, - "execution_count": 13, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "result_files = moka_conf.to_txt(dest_dir=out_dir)\n", - "result_files" + "moka_conf.level_paths" ] }, { @@ -675,7 +652,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -689,7 +666,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/docs/source/vignettes/joint_models.ipynb b/docs/source/vignettes/joint_models.ipynb index 958e931..d1ce912 100644 --- a/docs/source/vignettes/joint_models.ipynb +++ b/docs/source/vignettes/joint_models.ipynb @@ -19,16 +19,18 @@ "\n", "To run this notebook, you'll need to have [mokapot](../index.rst#installation) installed and have the input files saved on your computer in the same directory. You can find these files here: [scope2_FP97AA.pin](https://github.com/wfondrie/mokapot/raw/master/data/scope2_FP97AA.pin), [scope2_FP97AB.pin](https://github.com/wfondrie/mokapot/raw/master/data/scope2_FP97AB.pin), [scope2_FP97AC.pin](https://github.com/wfondrie/mokapot/raw/master/data/scope2_FP97AC.pin)\n", "\n", - "We can set the path to the input files here:" + "We can set the path to the input files here and the location we will use to save the results:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "pin_dir = \"../../../data\"" + "pin_dir = \"../../../data\"\n", + "out_dir_separate = \"./joint_models/separate\"\n", + "out_dir_joint = \"./joint_models/joint\"" ] }, { @@ -42,24 +44,24 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['../../../data/scope2_FP97AA.pin',\n", - " '../../../data/scope2_FP97AB.pin',\n", - " '../../../data/scope2_FP97AC.pin']" + "[PosixPath('../../../data/scope2_FP97AA.pin'),\n", + " PosixPath('../../../data/scope2_FP97AB.pin'),\n", + " PosixPath('../../../data/scope2_FP97AC.pin')]" ] }, - "execution_count": 2, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import os\n", + "from pathlib import Path\n", "import mokapot\n", "import numpy as np\n", "import pandas as pd\n", @@ -72,11 +74,7 @@ "colors = (\"#343131\", \"#24B8A0\")\n", "\n", "# Find the input files:\n", - "pin_files = [\n", - " os.path.join(pin_dir, f)\n", - " for f in os.listdir(pin_dir)\n", - " if f.startswith(\"scope2_FP97A\") and f.endswith(\".pin\")\n", - "]\n", + "pin_files = list(Path(pin_dir).rglob(\"scope2_FP97A*.pin\"))\n", "\n", "pin_files" ] @@ -90,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -116,27 +114,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Analyzing ../../../data/scope2_FP97AA.pin\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:Learned model did not improve over the best feature. Now scoring by the best feature for each collection of PSMs.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Analyzing ../../../data/scope2_FP97AA.pin\n", "Analyzing ../../../data/scope2_FP97AB.pin\n", "Analyzing ../../../data/scope2_FP97AC.pin\n" ] @@ -145,17 +130,24 @@ "source": [ "# A dictionary to store the results:\n", "sep_results = {}\n", + "base_location = Path(out_dir_separate)\n", "\n", "# Loop through the input files, analyzing each with mokapot:\n", "for pin in pin_files:\n", " # Read PSMs and run mokapot\n", " print(f\"Analyzing {pin}\")\n", - " psms = mokapot.read_pin(pin)\n", - " results, models = mokapot.brew(psms)\n", + " out_loc = base_location / pin.stem\n", + " out_loc.mkdir(exist_ok=True, parents=True) # We make sure the output directory exists\n", + " psms = mokapot.read_pin(pin, max_workers=1)\n", + " \n", + " models, scores = mokapot.brew(psms, max_workers=1)\n", + " conf = mokapot.assign_confidence(psms, dest_dir=base_location / pin.stem, max_workers=1)\n", "\n", " # Add results to our result dictionary:\n", - " rep = os.path.split(pin)[-1].replace(\".pin\", \"\")\n", - " sep_results[rep] = results" + " # We are selecting the first element \n", + " sep_results[pin.stem] = conf[0]\n", + "\n", + "# TODO: Check if the models third model is meant to throw a warning" ] }, { @@ -169,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -193,112 +185,81 @@ " \n", " \n", " \n", - " SpecId\n", - " Label\n", - " ScanNr\n", - " ExpMass\n", - " CalcMass\n", - " Peptide\n", - " mokapot score\n", - " mokapot q-value\n", - " mokapot PEP\n", - " Proteins\n", + " PSMId\n", + " peptide\n", + " score\n", + " mokapot_qvalue\n", + " posterior_error_prob\n", + " proteinIds\n", " \n", " \n", " \n", " \n", " 0\n", - " target_0_11040_3_-1\n", - " True\n", - " 11040\n", - " 2789.4179\n", - " 2789.4084\n", - " K.LVQDVANNTNEEAGDGTTTATVLAR.S\n", - " 23.598709\n", - " 0.000912\n", - " 2.917290e-19\n", - " sp|P10809|CH60_HUMAN\n", - " \n", - " \n", - " 1\n", " target_0_8060_3_-1\n", - " True\n", - " 8060\n", - " 2154.1931\n", - " 2154.1860\n", " K.GAEAANVTGPGGVPVQGSK.Y\n", - " 21.533703\n", - " 0.000912\n", - " 2.563543e-17\n", + " 3.850000\n", + " 0.000462\n", + " 4.050871e-13\n", " sp|P67809|YBOX1_HUMAN\n", " \n", " \n", + " 1\n", + " target_0_12043_3_-1\n", + " K.GVVPLAGTDGETTTQGLDGLSER.C\n", + " 3.468646\n", + " 0.000462\n", + " 4.927086e-12\n", + " sp|P09972|ALDOC_HUMAN\n", + " \n", + " \n", " 2\n", - " target_0_11114_3_-1\n", - " True\n", - " 11114\n", - " 2618.3554\n", - " 2617.3450\n", - " K.QTTVSNSQQAYQEAFEISK.K\n", - " 20.623930\n", - " 0.000912\n", - " 1.841793e-16\n", - " sp|P31946|1433B_HUMAN\n", + " target_0_11040_3_-1\n", + " K.LVQDVANNTNEEAGDGTTTATVLAR.S\n", + " 3.139778\n", + " 0.000462\n", + " 4.249085e-11\n", + " sp|P10809|CH60_HUMAN\n", " \n", " \n", " 3\n", - " target_0_12043_3_-1\n", - " True\n", - " 12043\n", - " 2502.2946\n", - " 2502.2815\n", - " K.GVVPLAGTN[0.98]GETTTQGLDGLSER.C\n", - " 19.626017\n", - " 0.000912\n", - " 1.601810e-15\n", - " sp|P04075|ALDOA_HUMAN\n", + " target_0_10722_3_-1\n", + " R.GSTAPVGGGAFPTIVER.E\n", + " 3.112971\n", + " 0.000462\n", + " 5.064860e-11\n", + " sp|Q15084|PDIA6_HUMAN\n", " \n", " \n", " 4\n", - " target_0_10221_3_-1\n", - " True\n", - " 10221\n", - " 2424.1862\n", - " 2424.1812\n", - " K.EQQEAIEHIDEVQNEIDR.L\n", - " 18.178486\n", - " 0.000912\n", - " 3.691655e-14\n", - " sp|P0DME0|SETLP_HUMAN\\tsp|Q01105|SET_HUMAN\n", + " target_0_11114_3_-1\n", + " K.QTTVSNSQQAYQEAFEISK.K\n", + " 3.099323\n", + " 0.000462\n", + " 5.538586e-11\n", + " sp|P31946|1433B_HUMAN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " SpecId Label ScanNr ExpMass CalcMass \\\n", - "0 target_0_11040_3_-1 True 11040 2789.4179 2789.4084 \n", - "1 target_0_8060_3_-1 True 8060 2154.1931 2154.1860 \n", - "2 target_0_11114_3_-1 True 11114 2618.3554 2617.3450 \n", - "3 target_0_12043_3_-1 True 12043 2502.2946 2502.2815 \n", - "4 target_0_10221_3_-1 True 10221 2424.1862 2424.1812 \n", - "\n", - " Peptide mokapot score mokapot q-value \\\n", - "0 K.LVQDVANNTNEEAGDGTTTATVLAR.S 23.598709 0.000912 \n", - "1 K.GAEAANVTGPGGVPVQGSK.Y 21.533703 0.000912 \n", - "2 K.QTTVSNSQQAYQEAFEISK.K 20.623930 0.000912 \n", - "3 K.GVVPLAGTN[0.98]GETTTQGLDGLSER.C 19.626017 0.000912 \n", - "4 K.EQQEAIEHIDEVQNEIDR.L 18.178486 0.000912 \n", + " PSMId peptide score \\\n", + "0 target_0_8060_3_-1 K.GAEAANVTGPGGVPVQGSK.Y 3.850000 \n", + "1 target_0_12043_3_-1 K.GVVPLAGTDGETTTQGLDGLSER.C 3.468646 \n", + "2 target_0_11040_3_-1 K.LVQDVANNTNEEAGDGTTTATVLAR.S 3.139778 \n", + "3 target_0_10722_3_-1 R.GSTAPVGGGAFPTIVER.E 3.112971 \n", + "4 target_0_11114_3_-1 K.QTTVSNSQQAYQEAFEISK.K 3.099323 \n", "\n", - " mokapot PEP Proteins \n", - "0 2.917290e-19 sp|P10809|CH60_HUMAN \n", - "1 2.563543e-17 sp|P67809|YBOX1_HUMAN \n", - "2 1.841793e-16 sp|P31946|1433B_HUMAN \n", - "3 1.601810e-15 sp|P04075|ALDOA_HUMAN \n", - "4 3.691655e-14 sp|P0DME0|SETLP_HUMAN\\tsp|Q01105|SET_HUMAN " + " mokapot_qvalue posterior_error_prob proteinIds \n", + "0 0.000462 4.050871e-13 sp|P67809|YBOX1_HUMAN \n", + "1 0.000462 4.927086e-12 sp|P09972|ALDOC_HUMAN \n", + "2 0.000462 4.249085e-11 sp|P10809|CH60_HUMAN \n", + "3 0.000462 5.064860e-11 sp|Q15084|PDIA6_HUMAN \n", + "4 0.000462 5.538586e-11 sp|P31946|1433B_HUMAN " ] }, - "execution_count": 5, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -318,23 +279,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "# A dictionary to store the results:\n", "joint_results = {}\n", + "out_dir_combined = Path(out_dir_joint)\n", + "output_prefixes = [ x.stem for x in pin_files ]\n", + "\n", + "# Again we make sure that the output directory exists:\n", + "out_dir_combined.mkdir(exist_ok=True)\n", "\n", "# Read each input file:\n", - "psms_list = [mokapot.read_pin(f) for f in pin_files]\n", + "psms_list = mokapot.read_pin(pin_files, max_workers=1)\n", "\n", "# Run mokapot on all of the files:\n", - "results, brew = mokapot.brew(psms_list)\n", + "models, scores = mokapot.brew(psms_list)\n", + "confs = mokapot.assign_confidence(psms_list, dest_dir=out_dir_combined, prefixes=output_prefixes)\n", "\n", "# Add results to our result dictionary:\n", - "for pin, result in zip(pin_files, results):\n", - " rep = os.path.split(pin)[-1].replace(\".pin\", \"\")\n", - " joint_results[rep] = result" + "for pin, conf in zip(pin_files, confs):\n", + " joint_results[pin.stem] = conf" ] }, { @@ -348,19 +314,195 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PSMIdpeptidescoremokapot_qvalueposterior_error_probproteinIds
3546target_0_4697_2_-1-.MAEAGK.V-0.5487900.1020580.645097sp|Q7Z4M0|RE114_HUMAN
3979target_0_7282_2_-1-.MAGGMK.V-0.6778720.1917090.875404sp|O14524|NEMP1_HUMAN
5175target_0_12287_3_-1-.MALGLLIAVPLLLQAAPRGAAHYEMMGTCR.M-1.3963360.3740611.000000sp|Q7Z5L3|C1QL2_HUMAN
5055target_0_12268_3_-1-.MATEN[0.98]GAVELGIQN[0.98]PSTDKAPK.G-1.1037170.3577221.000000sp|Q9H1R3|MYLK2_HUMAN
3323target_0_3673_2_-1-.MDNQAER.E-0.4573170.0595490.470527sp|Q9BWW8|APOL6_HUMAN
.....................
452target_0_3700_2_-1R.YYGGGSEGGR.A1.0556410.0005220.000062sp|P14866|HNRPL_HUMAN
3368target_0_6172_3_-1R.YYGINDPVADK.L-0.4769680.0664890.507022sp|Q9NW64|RBM22_HUMAN
638target_0_7942_2_-1R.YYPTEDVPR.K0.8263210.0005220.000256sp|Q02878|RL6_HUMAN
4985target_0_3659_2_-1R.YYQVAR.D-1.0121550.3476341.000000sp|Q969U6|FBXW5_HUMAN
1734target_0_9733_2_-1R.YYTVFDR.D0.2041120.0005220.011981sp|P07339|CATD_HUMAN
\n", + "

5221 rows × 6 columns

\n", + "
" + ], "text/plain": [ - "
" + " PSMId peptide score \\\n", + "3546 target_0_4697_2_-1 -.MAEAGK.V -0.548790 \n", + "3979 target_0_7282_2_-1 -.MAGGMK.V -0.677872 \n", + "5175 target_0_12287_3_-1 -.MALGLLIAVPLLLQAAPRGAAHYEMMGTCR.M -1.396336 \n", + "5055 target_0_12268_3_-1 -.MATEN[0.98]GAVELGIQN[0.98]PSTDKAPK.G -1.103717 \n", + "3323 target_0_3673_2_-1 -.MDNQAER.E -0.457317 \n", + "... ... ... ... \n", + "452 target_0_3700_2_-1 R.YYGGGSEGGR.A 1.055641 \n", + "3368 target_0_6172_3_-1 R.YYGINDPVADK.L -0.476968 \n", + "638 target_0_7942_2_-1 R.YYPTEDVPR.K 0.826321 \n", + "4985 target_0_3659_2_-1 R.YYQVAR.D -1.012155 \n", + "1734 target_0_9733_2_-1 R.YYTVFDR.D 0.204112 \n", + "\n", + " mokapot_qvalue posterior_error_prob proteinIds \n", + "3546 0.102058 0.645097 sp|Q7Z4M0|RE114_HUMAN \n", + "3979 0.191709 0.875404 sp|O14524|NEMP1_HUMAN \n", + "5175 0.374061 1.000000 sp|Q7Z5L3|C1QL2_HUMAN \n", + "5055 0.357722 1.000000 sp|Q9H1R3|MYLK2_HUMAN \n", + "3323 0.059549 0.470527 sp|Q9BWW8|APOL6_HUMAN \n", + "... ... ... ... \n", + "452 0.000522 0.000062 sp|P14866|HNRPL_HUMAN \n", + "3368 0.066489 0.507022 sp|Q9NW64|RBM22_HUMAN \n", + "638 0.000522 0.000256 sp|Q02878|RL6_HUMAN \n", + "4985 0.347634 1.000000 sp|Q969U6|FBXW5_HUMAN \n", + "1734 0.000522 0.011981 sp|P07339|CATD_HUMAN \n", + "\n", + "[5221 rows x 6 columns]" ] }, - "metadata": { - "needs_background": "light" + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "joint_results[\"scope2_FP97AA\"].peptides.sort_values(by=\"peptide\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], @@ -400,19 +542,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABZE0lEQVR4nO3dd1yV5fvA8c8FKCjO3HsvREXFUbl32/w2VMyRaallWi7c5l5lllrubXv4/WXOHFkOcOPeijhwiwIy7t8f55EvIigqcA5wvV+v58U59zPu6yBy8dzPPcQYg1JKKeVonOwdgFJKKRUfTVBKKaUckiYopZRSDkkTlFJKKYekCUoppZRD0gSllFLKISVbghKRuSJySUQC4pR/JCKHRWS/iEyIVe4rIsesfc1jlVcXkX3WvqkiIskVs1JKKceRnHdQ84EWsQtEpCHwGlDZGFMRmGSVewCtgYrWOdNFxNk6bQbQFShjbfddUymlVNrkklwXNsZsEpHicYq7AeOMMeHWMZes8teA76zykyJyDKgpIqeAbMaYLQAishBoCfz5qPpz585tihePW71SSilHs2PHjsvGmDxxy5MtQSWgLFBXREYDYUAfY4wfUAjYGuu4QKsswnodtzxeItIV290WRYsWxd/fP2mjV0opleRE5HR85SndScIFyAnUBvoCP1jPlOJ7rmQeUh4vY8xMY4y3McY7T54HkrFSSqlUJKUTVCDwi7HZDkQDua3yIrGOKwwEWeWF4ylXSimVxqV0gvoNaAQgImWBjMBlYDnQWkRcRaQEts4Q240x54FbIlLbutNqD/yewjErpZSyg2R7BiUiy4AGQG4RCQSGAXOBuVbX87tAB2ObTn2/iPwAHAAigR7GmCjrUt2w9QjMhK1zxCM7SCillEr9JK0ut+Ht7W20k4RSSjk+EdlhjPGOW64zSSillHJImqDi+HPFCl556SVqVq/OKy+9xJ8rVtg7JKWUSpdSehyUQ/tzxQrGjBpFWFgYABfOn2fMqFEAvPDii/YMTSml0h29g4pl+rRpMcnpnrCwMKZPm2aniJRSiZUlS5bHOn7Dhg28/PLLyRTNoz1uvLHNnz+foKDkH3EzfPhwJk2a9NTHPClNULFcvHDhscqVUsoeUipB2ZsmqFjy5c//WOVKqSeTnM96N2zYQIMGDXjjjTcoX748Pj4+3OutvHLlSsqXL0+dOnX45ZdfYs65ffs27777LjVq1KBq1ar8/rttuOX8+fN57bXXaNGiBeXKlWPEiBEx5yxevJiaNWvi5eXF+++/T1SUbWRMlixZGDRoEFWqVKF27dpcvHgRgJMnT/Lss89So0YNhgwZcl/MEydOpEaNGlSuXJlhw4YBcOrUKSpUqECXLl2oWLEizZo1IzQ0lJ9++gl/f398fHzw8vIiNDT0vms1aNCA3r17U69ePSpUqICfnx+tWrWiTJkyDB48OOa4zz//HE9PTzw9PZkyZUpM+ejRoylXrhxNmjTh8OHDMeXHjx+nRYsWVK9enbp163Lo0KEHvvdTp07Fw8ODypUr07p168T/oyXEGJMmt+rVq5vHteKPP0ydZ5813lWr3reNGTXqsa+llIpffP/P6jz7rFnxxx9PdV13d3djjDHr16832bJlM2fPnjVRUVGmdu3a5u+//zahoaGmcOHC5siRIyY6Otq8+eab5qWXXjLGGOPr62sWLVpkjDHm2rVrpkyZMiYkJMTMmzfP5M+f31y+fNncuXPHVKxY0fj5+ZkDBw6Yl19+2dy9e9cYY0y3bt3MggULjDHGAGb58uXGGGP69u1rRo4caYwx5pVXXok55uuvv46Jd9WqVaZLly4mOjraREVFmZdeesls3LjRnDx50jg7O5tdu3YZY4x58803Y2KsX7++8fPzi/f7UL9+fdOvXz9jjDFTpkwxBQoUMEFBQSYsLMwUKlTIXL582fj7+xtPT08TEhJibt26ZTw8PMzOnTtjym/fvm1u3LhhSpUqZSZOnGiMMaZRo0bmyJEjxhhjtm7daho2bGiMMWbYsGExxxQoUMCEhYXFfB8TC/A38fwe104SsdzrCDF92jQuXrhA3nz5yJQpE3/83//R6o03KFeunJ0jVCr1e9iz3qTqjFSzZk0KF7bNkubl5cWpU6fIkiULJUqUoEyZMgC0a9eOmTNnArB69WqWL18e8ywlLCyMM2fOANC0aVNy5coFQKtWrdi8eTMuLi7s2LGDGjVqABAaGkrevHkByJgxY8yzrerVq7NmzRoA/vnnH37++WcA3nnnHfr37x9T9+rVq6latSoAISEhHD16lKJFi1KiRAm8vLxirnXq1KlEff5XX30VgEqVKlGxYkUKFCgAQMmSJTl79iybN2/m9ddfx93dPeZz/f3330RHR/P666+TOXPm+64TEhLCv//+y5tvvhlTR3h4+AP1Vq5cGR8fH1q2bEnLli0TFevDaIKK44UXX7zvP8mVK1d4p21b+vfty8LFi8mWLZsdo1Mq9UuJZ72urq4xr52dnYmMjAQgofVOjTH8/PPPD/wRum3btgfOERGMMXTo0IGxY8c+cK0MGTLEnBO77oTqN8bg6+vL+++/f1/5qVOnHvgccZvzEnLvPCcnp/uu4eTkRGRkZEyTZ3ziizE6OpocOXKwe/fuh9b7xx9/sGnTJpYvX87IkSPZv38/Li5Pnmb0GdQj5MqVi3ETJnDxwgWGDh5MdHS0vUNSKlWz17Pe8uXLc/LkSY4fPw7AsmXLYvY1b96cr776KuYX965du2L2rVmzhqtXrxIaGspvv/3G888/T+PGjfnpp5+4dMm2pN3Vq1c5fTreFSNiPP/883z33XcALFmy5L66586dS0hICADnzp2LuW5CsmbNyq1btxL70R9Qr149fvvtN+7cucPt27f59ddfqVu3LvXq1ePXX38lNDSUW7du8d///heAbNmyUaJECX788UfAllT37Nlz3zWjo6M5e/YsDRs2ZMKECVy/fj3mMz0pTVBxLA86Qf2NP1F21QLqb/yJ5UEnqFylCr0//ZR/Nm9mzuzZ9g5RqVSte48euLm53Vfm5uZG9x49krVeNzc3Zs6cyUsvvUSdOnUoVqxYzL4hQ4YQERFB5cqV8fT0vK8TQ506dXjnnXfw8vLiP//5D97e3nh4eDBq1CiaNWtG5cqVadq0KefPn39o/V9++SXTpk2jRo0a3LhxI6a8WbNmtG3blmeffZZKlSrxxhtvPDL5dOzYkQ8++CDeThKJUa1aNTp27EjNmjWpVasW7733HlWrVqVatWq8/fbbMZ+1bt26MecsWbKEOXPmUKVKFSpWrBjTkeSeqKgo2rVrR6VKlahatSq9e/cmR44cjx1bbDoXXyzLg04waP+/hEVHxZS5OTkzuuJzvFKgBMOHDuXPFSv4YupUnn/++aQOWal0488VK2Ke9ebLn5/uPXo45GD4+fPn4+/vz9dff23vUNK0hObi02dQsUw+uvO+5AQQFh3F5KM7ebVgSXwHDuTokSMMHTSIhUuWUKhQgov7KqUeIu6zXqXio018sZwPu/3QcrdMmZgwaRLR0dH069PngZ5ISqm0pWPHjnr3ZEeaoGIp4OYeb3k+18wxrwsXKcJno0Zx5PBhxo0d+9DeMEoppZ6cJqhYPi1TDTcn5wfKc2RwJTJW77269erRuUsX/vjvf/nVGteglFIqaWmCiuXVgiUZXfE5Crq5I0BBN3feLFSGQyHXGH5w6313S126duXZ555j4oQJBOzbZ7+glVIqjdJefInw+dGdzDixj0/LVOODkpViym/cuEF7Hx8io6JYvHQpOXPmTJL6lFIqPdEVdZ9C79JVebVASSYf3cnyoBMx5dmzZ2f8xIlcv3aNgQMG3DdiXCmVsh62fEVQUBBvvPHGI68xZsyYpAwpQQ0aNOBRf0An5pi0ThNUIogIYzyfo1bO/AwI+IdtV/83JUv5ChXo7+uLv58fM6ZPt2OUSqmEFCxYkJ9++umRx6VUglKJowkqkVydnJlWtQFFM2el+671HAu5HrPv1dde4/VWrVg4fz5/rVtntxiVSi3im7ElKRhj6Nu3L56enlSqVInvv/8esM1r5+npCdgG37Zq1YoWLVpQpkwZ+vXrB8CAAQMIDQ3Fy8sLHx+fB66dJUsW+vfvT/Xq1WnSpAnbt2+nQYMGlCxZkuXLlwO2SWY7deoUM5vC+vXrAdtksq1bt6Zy5cq8/fbb983+sHr1ap599lmqVavGm2+++dTTA6Up8U1xnha2J1luIzHO3rllav/1nam/4UdzKexOTHl4eLhp366dqV+njjl58mSy1K1UWvD7uePGc/UiU3rl/JjNc/Ui8/u54091XXd3d/PTTz+ZJk2amMjISHPhwgVTpEgRExQUZE6ePGkqVqxojDFm3rx5pkSJEub69esmNDTUFC1a1Jw5cybmGgkBzIoVK4wxxrRs2dI0bdrU3L171+zevdtUqVLFGGPMpEmTTMeOHY0xxhw8eNAUKVLEhIaGmsmTJ5tOnToZY4zZs2ePcXZ2Nn5+fiY4ONjUrVvXhISEGGOMGTdunBkxYoQx5uFLaqQ1JLDcht5BPabCmbIwq1oTrkaE03XnOu5ERgC2KfbHT5hAhgwZ6NenD3fu3LFzpEo5pofN2PK0Nm/eTJs2bXB2diZfvnzUr18fPz+/B45r3Lgx2bNnx83NDQ8Pj0dO9Aq2/+MtWrQAbMtY1K9fnwwZMlCpUqWYZTA2b97MO++8A9gmpy1WrBhHjhxh06ZNtGvXDrAtSVG5cmUAtm7dyoEDB3j++efx8vJiwYIFiYolvUi2BCUic0XkkogExCobLiLnRGS3tb0Ya5+viBwTkcMi0jxWeXUR2WftmyoJzZefgjyz52JK5XocuHmVXns3xYyRyl+gAKPHjuX0qVOMHDFCB/EqFY9HzdjyNBL7fy6h5TgeJvYyGrGXsbi3hMWj6k9oqY2mTZuye/dudu/ezYEDB5gzZ06iPkN6kJx3UPOBFvGUf2GM8bK2FQAi4gG0Bipa50wXkXsjZmcAXYEy1hbfNVNco7xFGOZRi/XBgYw8tD3mB7NmrVp069GDtWvWsCzWlPpKKZuEZmxJqPxx1KtXj++//56oqCiCg4PZtGkTNWvWTPT5GTJkICIi4qnqv7eUxpEjRzhz5gzlypW7rzwgIIC9e/cCULt2bf755x+OHTsGwJ07dzhy5MgT15/WJFuCMsZsAq4m8vDXgO+MMeHGmJPAMaCmiBQAshljtljtlAuBlskS8BNoW6QcXYp7svTsYWaf2h9T3qFjRxo0bMjUL79k544ddoxQKccT34wtbk7OfFqm2hNfMzIyEldXV15//XUqV65MlSpVaNSoERMmTCD/Y6wz1bVr15hVYZ9E9+7diYqKolKlSrz99tvMnz8fV1dXunXrRkhICJUrV2bChAkxSTNPnjzMnz+fNm3aULlyZWrXrs2hQ4eeqO60KFkH6opIceD/jDGe1vvhQEfgJuAPfGqMuSYiXwNbjTGLrePmAH8Cp4BxxpgmVnldoL8x5uUE6uuK7W6LokWLVk+JttxoY/hk7yb+uHCKL6vU58X8xQEIuXWLDu3bExISwuKlS8mTJ0+yx6JUarE86ASTj+7kfNhtCri582mZarxasOQTX2/Pnj106dKF7du3J2GUKqU4ykDdGUApwAs4D0y2yuN7rmQeUh4vY8xMY4y3McY7pRKCkwjjPevgnSMvfff9jf+1iwBkyZqVCZMmcef2bQb06/dUzQZKpTWvFizJxvpvcKR5BzbWf+OpktM333xDmzZtGDVqVBJGqBxBiiYoY8xFY0yUMSYamAXcaxwOBIrEOrQwEGSVF46n3KG4OjszvWpDCrlloduu9Zy4bVsts1SpUgwZNoy9e/bw5Rdf2DlKpdKmDz74gAMHDtCsWTN7h6KSWIomKOuZ0j2vA/d6+C0HWouIq4iUwNYZYrsx5jxwS0RqW7332gP3rzPsIHJmdGN29SY4ifDejrVcCbcNxGvWvDlt2rbl++++488VK+wcpVJKpR7J2c18GbAFKCcigSLSGZhgdRnfCzQEegMYY/YDPwAHgJVAD2PMvYES3YDZ2DpOHMf2bMohFc2clZlVGxEcHkrXXX8RGmXretrz44+pWrUqo0eN4qj20FFKqUTR2cyTwdpLZ+i+az1N8hbhK68GOIsTly9f5p22bcmUKRMLFi8ma9asdolNKaUcjaN0kkgXmuQtyuDyNVlz6SxjDtmSZO7cuRk7fjxB588zbMgQomMtgKiUUupBmqCSSftiFehUzIOFZw4y79QBALyqVqVX7978vWkT8+fOtXOESinl2DRBJaMB5bxpnq8YYw/7seqibUzW261b0/yFF/hmxgy2btli5wiVUspxaYJKRk4iTKpUB68cefh079/sun4JEWHQ4MGULFWKwQMHEhTkcL3mlVLKIWiCSmZuzi7MqNqI/G6ZeX/nX5y+fZNMmTIxYdIkIqOiGNC3L+Hh4fYOUymlHI4mqBSQK6Mbc6o1AaDzzrVcvRtG0aJFGfHZZxw8eJCJ48fbOUKllHo8ybXoZGyaoFJIMfdsfFutERfC7tBt11+ERUVSv0EDOr37Lr//9hu//fqrvUNUSqlEWR50gkH7/yUo7DYGCAq7zaD9/yZ5ktIElYKq5sjLpEp12XU9mD77NhNtDO9360at2rWZMG4c+/fvf/RFlFLKzpJz0cnYNEGlsBb5izGgnDerLp5mwhF/nJ2dGTV6NLly5WJA375cv3bN3iEqpdRDJeeik7FpgrKDTsU8eKdoeeacOsCi0wfJkTMn4ydN4sqVKwweNIioqKhHX0QppezAGIO7c4Z49yXFopOxaYKyAxFhUPkaNMlbhFGH/Fh36QweHh70GzCAbVu38u2MGfYOUSmlHmCMYfLRnYREReAcZzWkp110Mj6aoOzEWZz4vHI9PLPnoteeTey9cZmWr7/Oay1bMm/uXDZu2GDvEJVSKoYxhvFH/Pn2ZABtipRlnOfzFHRzR4CCbu6MrvjcU63rFR+dLNbOroSH8sa2FYRGRfJjrRfJ65yRLu++y5mzZ1m4eDFFixa1d4hKqXTOGMOoQ34sPHOQd4qWZ0j5mthWQEoaOlmsg8rlmok51ZsQZQzv7VxLqMD4iRNxcXamX58+hIaG2jtEpVQ6Fm0Mww9uY+GZg3Qq5pHkyelhNEE5gJLu2ZletSFn74TQbfdfPJMvH6PGjOHE8eOMHjWKtHqXq5RybNHGMGT/FpaePUyX4p74lvNOseQEmqAcRo2c+ZhYqQ7+1y7RP2AzNWvX5oNu3Vj15598/9139g5PKZXORJlofAP+4YdzR+lesjJ9y1ZL0eQE4JKitamHeqlACc6F3WbikR0UzpSFT959l4CAAKZ88QXly5fHq2pVe4eolEoHIqOjGRDwD7+fP0HPUl58VLqKXeLQOygH06V4RdoUKcu3JwP4/txRRowcScECBRjQvz+Xg4PtHZ5SKo2LiI6mz76/+f38CT4pU9VuyQk0QTkcEWFo+Vo0yFOY4Qe2sSPsBhMmTSIkJISBAwYQGRFh7xCVUmnU3egoeu/dxB8XTtGvbHW6laxs13g0QTkgFycnplSuR4VsOfl4z0bC8j7DoMGD2bVrF1O//NLe4Sml0qDw6Cg+3rORVRdPM7CcN11KeNo7JE1QjsrdJQOzqjUhZwZXuu5cR+WG9Xi7dWuWLV3K6lWr7B2eUioNCY+K4sPdG1h76SzDKtSiU/GK9g4J0ATl0PK4ZmJW9SaERUfy3o61dPqwB5WrVGHkiBEcP37c3uEppdKAsKhIuu36iw3BgYz0eJZ2RcvbO6QYmqAcXJksOZju1ZDTd27Ra/9mRo4bR2Z3d/r16UPIrVv2Dk8plYqFRkXy/s6/2HwliDEVn6N1kbL2Duk+yZagRGSuiFwSkYB49vURESMiuWOV+YrIMRE5LCLNY5VXF5F91r6pktId8R1A7VwFGOv5PFuvXuDzi0cYM3Ys5wIDGTF8uA7iVUo9kduREby3Yy1br15gvGcd3ixcxt4hPSA576DmAy3iFopIEaApcCZWmQfQGqhonTNdRJyt3TOArkAZa3vgmunBawVL0rt0VX4/f4JN2Z3p+fHHbFi/ngXz59s7NKVUKhNiJSf/a5eYWKkOrxcqZe+Q4pVsCcoYswm4Gs+uL4B+QOw//V8DvjPGhBtjTgLHgJoiUgDIZozZYmy3CguBlskVs6PrVrISbxUqw/QTe3GpX5OmzZoxY9o0tm3bZu/QlFKpxK2Iu3TyX8OuG8FMqVIvyWcgT0op+gxKRF4Fzhlj9sTZVQg4G+t9oFVWyHodtzyh63cVEX8R8Q9Og4NaRYThHrWpm6sgQw9upeFHXSlWvDiDfX25cP68vcNTSjm4GxHhdPRfzf6bV5hapT4v5C9u75AeKsUSlIhkBgYBQ+PbHU+ZeUh5vIwxM40x3sYY7zx58jxZoA4ug5MTU70aUDZLTvoe3ELXUcOJiIigf79+3L17197hKaUc1LW7YXTwX83BW9f4yqsBzfIVs3dIj5SSd1ClgBLAHhE5BRQGdopIfmx3RkViHVsYCLLKC8dTnq5lccnArGqNyZohI8MvHOCj4UM4sH8/kydOtHdoSikHdOVuGO39V3M05Dozqjakcd4ijz7JAaRYgjLG7DPG5DXGFDfGFMeWfKoZYy4Ay4HWIuIqIiWwdYbYbow5D9wSkdpW7732wO8pFbMjy+eWmdnVmnA7KpJ5bmG8/W5Hfvn5Z5b/rt8epdT/XA4P5R2/VZy8fZNvqjaifp7Cjz7JQTwyQYnIxyKSTWzmiMhOEWmWiPOWAVuAciISKCKdEzrWGLMf+AE4AKwEehhjoqzd3YDZ2DpOHAf+fOSnSifKZc3J114NOH77OntrlaNazZqMHzuWQwcP2js0pZQDuBR+Bx+/VQSGhjCrWmPq5k7wEb5DeuSS7yKyxxhTxRqb1AMYAswzxlRLiQCfVGpZ8j0p/HLuGP0D/uHl3EU4PHgiGZydWbB4MTly5LB3aEopO7kQdpv2fqu5GH6HWdUaU/OZ/PYOKUFPs+T7vY4KL2JLTHuIv/OCspNWhUrTs1QV/u/yWbyH9CY4OJghgwYRFRX16JOVUmlOUGgIPttXcSk8lHnVmzp0cnqYxCSoHSKyGluCWiUiWYHo5A1LPa4PS1WhVcFSLLt1noa+vdi6ZQuzZ860d1hKqRQWGBqCj98qrkWEMd+7KdVy5rV3SE8sMQmqMzAAqGGMuQNkBDola1TqsYkIIys+y3O5CvBL5giqt3uT2bNm8femTfYOTSmVQk7fuUnb7Su5FXGXBd7N8MqRuofbJCZBGcAD6Gm9dwfcki0i9cQyOjnzdZUGlHLPwbbKxShS25uhgwdz9syZR5+slErVTt6+gc/2VYRFRbKgRjMqZc/96JMcXGIS1HTgWaCN9f4WMC3ZIlJPJWuGjMyq1hh3FxcuvtGI6Gzu9O/bl7DQUHuHppRKJsdDbtDObxURJpqFNZpRMVsue4eUJBKToGoZY3oAYQDGmGvYmvmUgyqQyZ2Z1ZpwOzoKl4/bc/TMacaMHq0znyuVBh0NuYaP30qijWFxjeaUz/qMvUNKMolJUBHWzOIGQETyoJ0kHJ5Htmf4yqsB50wEOfu/z4qVK/nxhx/sHZZSKgkdunUVn+2rcBZhcY0WlMmSw94hJanEJKipwK9AXhEZDWwGxiRrVCpJ1M1diM88anMykxPZ3m/N5MmT2bMn7jy9SqnUaP/NK7zjtxpXZ2eW1GhBqSzZ7R1SkntkgjLGLMG2PMZY4DzQ0hjzY3IHppLGW4XL0q1kJc4WzYPLS/Xx7dePK1eu2DsspdRT2HvjMu39VpPZ2YUlNVpQ3D2bvUNKFgkmKBF55t4GXAKWAUuBi1aZSiV6l67KqwVKcqm2JxeL5WPggAFERkbaOyyl1BPYdT2YDv6ryZYhI0tqtqBo5qz2DinZPOwOagfgb30NBo4AR63XO5I/NJVURIQxns9RK2d+brdqzLarF5j21Vf2Dksp9Zh2XLtEJ/81PJPBjaU1WlA4UxZ7h5SsEkxQxpgSxpiSwCrgFWNMbmNMLuBl4JeUClAlDVcnZ6ZVbUDxLNmJeLcVC1b+H2vXrLF3WEqpRNp29QLv7lhDXtdMLKnZnAKZ3O0dUrJLTCeJGsaYFffeGGP+BOonX0gquWTP4Mqc6k3Iljkzd7u+ybCJ4zl54oS9w1JKPcK/V87z3o61FHBzZ0nNFuR3S/vJCRKXoC6LyGARKS4ixURkEKBP2VOpQpmyMKtaEyRbFq77vMgnA/oTEhJi77CUUgn4+/I5uu5cR9HMWVlSozl5XDPZO6QUk5gE1QbIg62r+W9AXv43q4RKhTyz52KqVwMi8ufi8PMVGfHZCB3Eq5QD2hAcyPs7/6KEezYW1WhOrnSUnCBx3cyvGmM+NsZUtbaPjTFXUyI4lXwa5inMcI/aRJQvwQr3aBYtWmjvkJRSsay7dIbuu9ZTLmtOFnk355mM6W8KVJeEdojIFGNMLxH5L9YsErEZY15N1shUsmtbpByBd24xC5j052Y8KnjgXaOGvcNSKt1bdfE0vfZsxCNbLuZVb0q2DOlzdrkEExSwyPo6KSUCUfbRp2x1zoTcYNULdeg5/xt+LVqUfPny2TsspdKtFRdO8cneTVTOnps51ZqQNZ0mJ3h4N/N7Y528jDEbY2+AV4pEp5KdkwiTvRrg6ZaN4Befp9uEUdy9e9feYSmVLv0edILeezZRNUce5lZvmq6TEySuk0SHeMo6JnEcyo5cnZ2Z9+yL5HNxJaBORYZ9PcXeISmV7vxy7hh99/1NjZz5mFOtCVlcMtg7JLt72FRHbaznTyVEZHmsbT3azTzNyZHRlaV1X8Utoyu/FHDju/9bbu+QlEo3fgw8yoCAf3g2VwFmVW9MZk1OwMOfQf2LbXLY3MDkWOW3gL3JGZSyj6KZszK/9gu02bqCERcOUeFgaapU8LB3WEqlaUvPHmbYga3Uy12IaV4NcHN+2K/l9OVhz6BOG2M2GGOeBQ4D2YFsQJAxRmcaTaOq5crPuHK1iCyUl04bfuPajRv2DkmpNGvR6YMMO7CVhnkKM71qQ01OcTzyGZSIdAa2A62AN4CtIvJuIs6bKyKXRCQgVtlIEdkrIrtFZLWIFIy1z1dEjonIYRFpHqu8uojss/ZNFRF53A+pHs/rpSvSOVthbpUsxFvLZhIVFWXvkJRKc+ad2s9nh7bTNG8RvvZqgKuTs71DcjiJ6STRD6hqjOlojOkAVAf6J+K8+UCLOGUTjTGVjTFewP8BQwFExANoDVS0zplureILMAPoCpSxtrjXVMlgwHNNqBPuwqkSeen2w3x7h6NUmvLtiX2MOexPi3zF+LJKAzKmwuT054oVvPLSS9SsXp1XXnqJP1esePRJjykxCSoQ23One24BZx91kjFmE3A1TtnNWG/d+d8A4NeA74wx4caYk8AxoKaIFACyGWO2GNtcPAuBlomIWSWB2S+3ocjlENbncGbKxlX2DkepNGHa8T1MOrqTl/IX54vK9cjglJhfw47lzxUrGDNqFBfOn8cYw4Xz5xkzalSSJ6nEfGfOAdtEZLiIDAO2AsdE5BMR+eRxKxSR0SJyFvDBuoMCCnF/0gu0ygpZr+OWJ3TtriLiLyL+wcHBjxuaisPZyYlfXmuP++XrTL8VyKoj++0dklKpljGGqcd2M+XYbloWLMmkSnVxSYXJCWD6tGmEhYXdVxYWFsb0adOStJ7EfHeOY5sk9t7dzu/YevdltbbHYowZZIwpAiwBPrSK43uuZB5SntC1ZxpjvI0x3nny5Hnc0FQ8cmTJypI6r+B86za9Dv7LkWua+JV6XMYYvji2i6+O7+E/hUozzvP5VJucAC6cPx9v+cULF5K0nkd2GTHGjAAQEXdjzO0krHsp8AcwDNudUZFY+woDQVZ54XjKVQqqWKIUo8544nv5MK03/s6aF3zS3azKSj0pYwwTjuxg9qn9vF24LJ951MYpFff1un79Oq6uroSHhz+wL1/+/ElaV2J68T0rIgeAg9b7KiIy/UkqE5Eysd6+ChyyXi8HWouIq4iUwNYZYrsx5jxwS0RqW7332mO7g1Mp7D/1G9HmhhO3XIS31v1EWJSONFDqUYwxjDnsx+xT+/EpUi7VJ6e9e/bQrm1bIiMjcXG5//7Gzc2N7j16JGl9ibnHnAI0x5o9whizB6j3qJNEZBmwBSgnIoFWd/VxIhIgInuBZsDH1jX3Az8AB4CVQA9jzL2+zd2A2dg6ThwH/kz0p1NJamiH96i65xRnJIqum/8gWteQUipB0cbw2cFtzD99kA5FKzCsQq1Um5yio6NZtGABXbt0wcXFhXkLFjB0+HDyFyiAiJC/QAEGDh7MCy++mKT1yqMWqhORbcaYWiKyyxhT1SrbY4ypkqSRJDFvb2/j7+9v7zDSnBs3bvDSxOFcrOtF23wlGeFV194hKeVwoo1h6IGtfB94hM7FK9K/bHVS6xDO69evM2LoUDZv3kzjJk0YPGQIWbI+dveDhxKRHcYY77jlibmDOisizwFGRDKKSB+s5j6V/mTPnp3ZPl3JtG0fSy+eYMFJ7dmnVGxRJppB+//l+8AjfFCiUqpOTnv27MGnTRu2bdtG3/79GTt+fJInp4dJTIL6AOjB/7p8e1nvVTpVvkIFRnrVxWX/cUYf9mPtpTP2DkkphxBlohkQ8A8/nTvGR6Wq8EmZqqkyOUVHR7Nw/nzef+89MmbIwNz583nr7bdT/LM8NEGJSEtsS2ssNMbkM8bkNca0M8bobObp3GuvvkbbcDecAi/Sc9cG9lzX7ucqfYuMjqbP3s38FnSCXqW96FnaK1Ump+vXrvFJr158NXUqDRs1YtGSJZSvUMEusTxsuY3pQG8gFzBSRIakWFQqVej/aR+qbj1M9LUbvOe/hjN3bj36JKXSoIjoaHrv3cT/XThJnzLV6FHKoR/RJ2jP7t34tG3L9m3b6DdgAGPGjUvRJr24HnYHVQ9oZIzxBRqgUwypODJmzMgXo8aQ/6d13Lp9m87+a7h+98GxEUqlZXejo/h4z0ZWXjyNbzlv3i9Zyd4hPbbo6GgWzJ/P+126xDTpvfnWW3a/A3xYgrp7r6u3MeYO8c/qoNK5/PnzM6GvL5kX/pczt2/wwa6/CNfZz1U6ER4dxUe7N7Dm0hmGlK/Ju8Ur2jukx3b92jV6f/wxX99r0lu61G5NenE9LEGVt5bG2Csi+2K932eNY1IKgJq1avHxK61w+24lO65fon/AZh0jpdK88Kgoeuxaz1/BgYzwqE37Yo7xS/1x7N61C582bfDbvp3+vr62Jr0sWewdVoyHTXWU+r7bym7ad+hAwL59rF75D3+0gEKZstC3bHV7h6VUsgiNiqTbrr/498p5Rld8lrcKl7V3SI8lOjqahQsW8M306RQsWJB5CxZQrnx5e4f1gAQTlDHmdEoGolI3EWHY8OEcb9+e07sOMxNbkmpbpJy9Q1MqSd2JjOD9XX+x7eoFxnk+T6tCpe0d0mO5du0aw4YMYcu//9K0WTMGDh7sUHdNsen6wirJZMmalYmTJtGxQwdc8uZmBNso4OZOwzyFH32yUqlASGQEXXauZee1YCZWqstrBUvaO6THsnvXLgb5+nL9+nUGDBxIq//8x+4dIR4m9c73rhxSqVKlGDJkCFEzv+eZO3fptWcjATd02JxK/W5F3qXzjjXsuh7M55VTV3KKjo5m/rx5fNC1K66ursydP5//vPGGQycnePg4qHXW1/EpF45KC5o1b47Pm29x94v5uEVG03XnOs6Fhtg7LKWe2M2Iu3T0X8PeG5eZUrk+LxUoYe+QEu3atWv06tmTaV99RaPGjVm4ZIlDPm+Kz8PuoAqISH3gVRGpKiLVYm8pFaBKnT7q2ZPqZcoh05dxJ/IunXes5UaEjpFSqc/1u+F08F/NwZtX+cqrAS3yF7N3SIm2a+dOfFq3Zoe/P74DBzJ67FiHfd4UnwRnMxeRN4DOQB0g7rTgxhjTKJljeyo6m7n9Xb58mXfatiWyZGECWzWgeo58zPFugquTs71DUypRrt4No6P/Go6FXGda1Yap5nnqvYG330yfTuHChRkzfjzlyjluh6XHns3cGPOTMeYFYIIxpmGczaGTk3IMuXPnZtyECdzaGUCl3SfZdu0CgwL+5VFLvCjlCK6Eh9LebzUnbt/g22qNUk1yunbtGh9/9BHTv/6aJk2bsmDxYodOTg/zyE4SxpiRIvKqiEyytpdTIjCVNlTx8qL3J59w8rvfqX89it/Pn2DKsd32DkuphwoOD6Wd3ypO37nJzGqNqZu7kL1DSpSdO3bg07o1O3fswHfQIEaNGZOqmvTiSsyS72OxrXx7wNo+tsqUSpS33n6b5i+8wJ4J02iQIRvTT+zlh8Aj9g5LqXhdDLtDO7+VBIXdZnb1JjyXq4C9Q3qk6Oho5s6eTbf33ydT5szMW7jQ4buQJ0ZiVtTdC3gZY6Kt987ALmNM5RSI74npMyjHEhoaSqcOHQi+cpn8n33CjttXmZWK/jJV6cP50Nu847+Ky+GhzK7eBO+c+ewd0iNdvXqVYYMHs3XrVpq3aIHvoEG4u7vbO6zH8jQr6gLkiPU6e5JEpNKVTJkyMWHSJKIiIjHffk8Z9+x8tHsDB25etXdoSgFwLjSEtn4ruXI3jHnezVJFctpxr0lv504GDh7MyNGjU11yepjEJKixwC4RmS8iC4AdwJjkDUulRUWLFmXEyJEcDdhPpU0BZM2Qka4713I+9La9Q1Pp3Jk7t/DZvpKbEXdZ4N2Mqjny2Dukh7rXpNf9/ffJ7O7OvIULeb1Vq1TfpBdXYjpJLANqA79Y27PGmO+SOzCVNtWvX593O3dmzY8/0/aacDsqkvd2ruVWxF17h6bSqVO3b+Ljt5LbUZEsrNGMytlz2zukh7p69So9P/yQGdOn07R5cxYuXkzZsqlrstrESlQTnzHmvDFmuTHmd2PMheQOSqVtXT/4gFq1a7No7ET65ijBids3+HDPBiKio+0dmkpnTty+gY/fSsKjoljo3YyK2XLZO6SH2uHvj0/r1rY59YYMYeSoUWmqSS8unYtPpThnZ2dGjR5Nrly5WDZkJIOKV+HfK+cZvF/HSKmUczTkOj7bVxJlDItrNKdCtmfsHVKCoqKimDN7Nt0/+MDWpLdgAS1ffz3NNenFlWwJSkTmisglEQmIVTZRRA5ZCx/+KiI5Yu3zFZFjInJYRJrHKq9uLZJ4TESmSlr/F0kncuTMyfhJk7h69SpbvviGD0tW5peg43x9fI+9Q1PpwOFb12jntwpBWFyjOWWz5rR3SAm6cuUKPT/8kG+mT6eZ1aRXJo026cX10AQlIk6xE8xjmg+0iFO2BvC0uqgfAXytejyA1kBF65zpVnd2gBlAV6CMtcW9pkqlPDw86DdgANu3bcNl1T+0KliKqcf38Mu5Y/YOTaVhB25e5R2/VWQQJ5bUbE7pLDnsHVKC/P388GnThj27dzN46FA+S+NNenE9NEFZY5/2iEjRx72wMWYTcDVO2WpjTKT1ditwb+6Q14DvjDHhxpiTwDGgpogUALIZY7YYW9vPQqDl48aiHNdrLVvy2uuvM3/uXJpdjuC5XAUYtP9f/rkSZO/QVBoUcOMK7f1W4ebswpKazSnh7pijZqKiopg9axY9unUjS5YszF+4kNdatkzzTXpxJaaJrwCwX0TWicjye1sS1P0u8Kf1uhBwNta+QKuskPU6bnm8RKSriPiLiH9wcHAShKhSQt9+/ahQoQIjhw2j3zOlKOWegw93b+DwrWv2Dk2lIbuvB9PefxVZM2RkSY3mFMuczd4hxetek963M2bQvEULFi5eTOkyZewdll0kJkGNAF4GPgMmx9qemIgMAiKBJfeK4jnMPKQ8XsaYmcYYb2OMd548jj2OQf2Pq6sr4ydOxMXFhc/6D+Arj+dxd3bhvZ1ruRCmY6TU09t57RId/deQI4MrS2o0p0jmrPYOKV6xm/SGDB3KiJEjyZw5s73DspvEjIPaCJwCMliv/YCdT1qhiHTAlvB8zP+6bAUCRWIdVhgIssoLx1Ou0pgCBQsyeswYTp44wZyJk/m2amNuRdyly851hERG2Ds8lYr5XbvIuzvWkMc1E0trtqBgJsebPDUqKopZM2fSo1s3slpNeq+mwya9uBIzWWwX4CfgW6uoEPDbk1QmIi2A/sCrxpg7sXYtB1qLiKuIlMDWGWK7MeY8cEtEalu999oDvz9J3crx1apdm27du7Nq5Ur2rVjNV14NOBpynZ67dYyUejJbr5yn84615HNzZ0nN5uR3c7wOBleuXOGjHj2Y+c03NG/RggXpuEkvrsQ08fUAngduAhhjjgJ5H3WSiCwDtgDlRCRQRDoDXwNZgTUisltEvrGuuR/4Adts6SuBHsaYKOtS3YDZ2DpOHOd/z61UGtShUyfq1a/PlC++IOvZS4z0eJa/rwQx/MBWHSOlHsvmy0F02bmOwpmysKRGc/K6Ol5Tmd/27fi0acPevXu1SS8eiZnNfJsxppaI7DLGVBURF2CnzmauksutW7fo0K4dd0JDWbxkCQuvn2XGiX18UqYq3Uo69I+dchAbgwPpvns9JTNnZ36NZuTK6GbvkO4TFRXF3NmzmTVzJsWKFWPshAmULl3a3mHZzdPMZr5RRAYCmUSkKfAj8N+kDlCpe7JmzcqESZO4HRKCb//+fFTMk9cKlOTzo7v4PeiEvcNTDm7dpbN027We0u45WOiAyeny5ct82L07M7/9lhdfesnWpJeOk9PDJCZBDQCCgX3A+8AKYHByBqVU6TJlGDx0KLt37+arqVMZ4/kctXLmxzfgH7ZeOW/v8JSDWn3xNB/t3kCFrDlZWKMZOR0sOW3ftg2fNm3Yt28fQ4cPZ/hnn2mT3kO4POoAY0y0tczGNmxdvA8bfRigUkDzFi3Yt28fy5YuxbNSJaY1akDrbX/Sffd6vq/1ImUceAYAlfL+vHCKT/ZuwjNbbuZWb0LWDBntHVKMqKgo5syaxexZsyhevDjTv/mGUqVK2Tssh5eYXnwvYeucMBVbJ4djIvJCcgemFMDHvXpRxcuLkSNGcPlMILOrN8HNyYUuO9YSHB5q7/CUg/jv+RP03ruJKtnzMNfbsZLT5cuX+bBbN2bNnMmLL7/MgsWLNTklUmI6SRwCXjbGHLPelwL+MMaUT4H4nph2kkg7goODade2LVnc3VmwaBGnou/i47eSEu7ZWFKjBe4uGewdorKj34KO03/fP3jnzMvMao0d6udh27ZtDB00iNt37tB/wABeefVVe4fkkJ6mk8Sle8nJcgK4lGSRKfUIefLkYey4cZw7d47hw4bhkTUnX1apz8Gb1+i1dxOROkYq3fox8Cj99m2m1jP5mOVAySkqKopvZ8zgo+7dyZ4jBwsWLdLk9AQSTFAi0kpEWmGbh2+FiHS0ZoH4L7bZJJRKMdWqV6dnr15s3LCBhQsW0CBPYYZ51GJDcCAjD23XMVLp0HdnjzBw/788n6sgM6s1JrODJKfLwcH06NaN2bNm8dLLL7Ng0SJt0ntCD+sk8Uqs1xeB+tbrYMBxF09RaVabtm0J2LePGdOmUcHDg7a1anEuNISZJwMolCkLXUt42jtElUIWnznEiIPbaJCnMF9XaYCrs/OjT0oB95r07ty5w7ARI3j5lVcefZJKUIIJyhjTKSUDUepRRITBQ4dy7NgxBvv6smjJEj4tU41zoSFMPLKDQm7uvFSghL3DVMls/ukDjD7kR5O8RZhSpT6uTvZPTvfm0ps7ezbFS5RgxsyZlCxZ0t5hpXqJ6cVXQkQ+F5Ffkni5DaUeW+bMmZkwaRIRERH079ePiLt3Ge9ZB++ceem7bzN+1y7aO0SVjGafDGD0IT+a5S3Klw6SnIKDg+n+wQfMmTWLl195hQWLFmlySiKJ6STxG7bZzL8iiZbbUOppFC9enGEjRnBg/34mT5yIq7MzM7waUSRzFrrt/IsTt2/YO0SVDGac2Mv4Izt4MX9xplSpT0YHSE7btm7Fp3VrDuzfz7ARIxg6fDiZMmWyd1hpRmISVJgxZqoxZr0xZuO9LdkjU+ohGjZqRIdOnfj1l19Y/ttv5MjoyqxqTXBxcqLzjrVc1jFSacpXx/bw+dFdvFqgJJMr1SWDU2J+dSWfyMhIZkyfzkc9epDzmWdYsHixPm9KBon5V/5SRIaJyLMiUu3eluyRKfUIH3TrRo2aNRk/bhyHDh6kaOaszKzWmMvhoby/6y9CoyLtHaJ6SsYYvji6i6nHd9OqYCkmVHoeFzsnp2Crl97c2bN55dVXWbBwoTbpJZPEDNQdC7yDbTaJewNOjDGmUTLH9lR0oG76cO3aNdq1bYuzkxMLlywhR44crL10hu671tM4bxG+9mqAs9j3F5p6MsYYJh3dycyTAbxVqAwjKz6Lk50X8Nu6ZQtDBw8mNDSUAQMH8tLLL9s1nrTiaQbqvg6UNMbUN8Y0tDaHTk4q/ciZMycTJk7k8uXLDBk0iKioKJrkLcqQ8jVZe+ksow/56RipVMgYw7jD/sw8GUDbIuXsnpwiIyOZMW0aPT/8kJzPPMPCxYs1OaWAxCSoPUCOZI5DqSdW0dOTPv36sXXLFmbNnAnAO8Uq8G4xDxadOcT80wfsHKF6HMYYRh7aztzTB3inaHmGV6hl1+R0r5fe3DlzePW111iwcCEltEkvRTxyNnMgH3BIRPyA8HuFxhidt0M5jNdbtSJg3z7mzJpFxYoVqVuvHv3LeXMu7DZjD/tTwC0LLfIXs3eY6hGijWH4wa0sO3uEd4t5MKCcN2LH5LTl338ZNmQIYWFhjBg5khdfeslusaRHiXkGVT++ckfvyafPoNKfsLAw3nv3Xc4FBrJw8WKKFC1KWFQk7f1Xc+DmVRbVaEbVHHntHaZKQLQxDNm/hR/OHaVrCU/6lKlmt+QUGRnJzG++Yd7cuZQqXZpx48dTvIQOAk8uCT2DemSCSq00QaVP586do72PD/ny5WPu/Pm4ZcrE1bthvLVtBTcj7vJDrRcp7p7N3mGqOKJMNL4B//Jr0HF6lKzMx6W97JacLl26xGBfX3bt2sVrr79Onz59cNOxTcnqiTtJiMgtEblpbWEiEiUiN5MnTKWeTqFChRg5ejTHjh1jzOjRGGN4JqMbc6o1AeC9nWu5ejfMzlGq2CKjo+m37x9+DTpOz1Je9CpT1W7Jacu//+LTujWHDh1ixMiRDB4yRJOTHT0yQRljshpjslmbG/AfbAsXKuWQnnv+ebp+8AF/rljBjz/8AEAx92x8W60RF8Lu8MGuvwjTMVIOISI6mj77/mb5+RN8WqYaH5WuYpc4IiMjmfbVV/T88ENy587NwsWL9XmTA3jsASLGmN8A7WauHNq7nTtTp04dPp88mT179gBQNUdeJlWqy+7rwfTZt5noNNq8nVrcjY6i156N/HHhFP3LVueDkpXsEsfFixfp1rUr8+fNo+XrrzNv4UJ93uQgEtPE1yrW9oaIjAMe+T9bROaKyCURCYhV9qaI7BeRaBHxjnO8r4gcE5HDItI8Vnl1Edln7Zsq9uzSo1INJycnRowaRf78+fHt148rV64A0CJ/MXzLebPq4mnGH9ZnlPYSHh1Fz90bWX3pDIPK1+A9Oy2V8u8//9CuTRsOHz7MZ6NGMWjIENzc3OwSi3pQYu6gXom1NQduAa8l4rz5QIs4ZQFAK2BT7EIR8QBaAxWtc6aLyL2ZIGcAXYEy1hb3mkrFK1u2bEyYNImbN28ycMAAIiNtzXodi3nQvmgF5p4+wMLTB+0cZfoTHhVFj13rWRd8luEVatGxmEeKxxAZGcnXX33Fxx99ZGvSW7KEF158McXjUA+XmGdQnWJtXYwxo40xj1zy3RizCbgap+ygMeZwPIe/BnxnjAk3xpwEjgE1RaQAkM0Ys8XYuhsuBFom4nMpBUDZsmUZOGgQO3fs4OuvvgJs60oNLO9N07xFGHVoO2svnbFzlOlHWFQkH+z6i42XzzHS41l8ipZP8RjuNektmDeP11u1sjXpFS+e4nGoR0twoK6IDH3IecYYMzIJ4ygEbI31PtAqi7Bexy1XKtFefPllAgICWLJoEZ6enjRp2hRncWJy5Xq081tF7z2bWFyjOVVy5LF3qGnancgIPtj1F1uvXmCs53O8UahMisfwzz//MGzIECLu3mXk6NG0eOGFFI9BJd7D7qBux7MBdAb6J3Ec8T1XMg8pj/8iIl1FxF9E/IODg5MsOJX69f70UypVqsRnw4dz8sQJADI5uzCzaiPyuGai666/OHPnlp2jTLtuR0bw3s51bLt6kQmV6qR4coqMiOCrqVPp9dFH5M2ThwWLF2tySgUSTFDGmMn3NmAmkAnoBHwHJPVEVIFAkVjvCwNBVnnheMoTinmmMcbbGOOdJ4/+Naz+J0OGDIydMIFMmTLRt08fQkJCAMjlmonZ1ZsQbQxddq7lmo6RSnK3Iu/Secdadl6/xKTKdWhZsFSK1n/hwgU+eP99Fs6fT6v//Ie5CxZok14q8dBnUCLyjIiMAvZiaw6sZozpn5hnUI9pOdBaRFxFpAS2zhDbjTHngVsiUtvqvdce+D2J61bpRL58+RgzbhyBZ88ycsSImFnOS7pnZ0bVhgSGhtB913rCo6LsHGnacSviLu/6r2XPjWC+qFyPVwqk7CSr/2zeTLu2bTl65AijxozBd9Ag7aWXiiSYoERkIuCHrddeJWPMcGPMtcReWESWAVuAciISKCKdReR1EQkEngX+EJFVAMaY/cAPwAFgJdDDGHPvt0Q3YDa2jhPHgT8f90MqdU91b28+7NmTv9atY/HChTHl3jnzMcGzDv7XL9E/QMdIJYUbEeF08F/N/ptXmFqlAS/kL55idUdGRPDVl1/Sq2dP8ubNy8IlS2jeQjsApzYJzsUnItHYZi+P5P7nPoKtk4RDT2imc/GphBhj8O3fn/V//cXX06dTo2bNmH2zTgYw4cgOuhT3pF+56naMMnW7djeMjv5rOBpyna+9GtAob5FHn5RELly4wCBfX/bu2UOr//yH3p9+qndNDi6hufgS7MVnjNFlSFWaJCIMGTaM48eOMcjXl0VLl5IvXz4A3itekcDQEGadCqBw5iy0LVLOztGmPlfuhtHRbzUn7tzgm6qNqJcn5Trebv77b4YPHUpERASjx46lWfPmjz5JOSxNQipdcnd3Z8KkSYSHhzOgb1/u3r0LWMmrfE0a5inMiAPb+OvSWTtHmrpcDg/lHb9VnLxzk2+rNk6x5BQZEcHUKVPo/fHH5M2Xj0VLl2pySgM0Qal0q0TJkgwdPpyAgAA+nzw5ptzFyYkplevhke0Zeu3dRMCNK3aMMvW4FH4HH79VBIaGMLtaY+rkLpgi9V44f56uXbqwaOFC/vPmm8xbsICiRYumSN0qeWmCUula4yZNeKd9e37+8Uf+77//jSnP7JKBmdUa80wGV7ruXEdgaIgdo3R858Nu47N9FRfDbjOnehNq5yqQIvX+vWkT7dq25cTx44weO5YBvr64urqmSN0q+WmCUule9w8/pLq3N+PGjOHw4f/NxJXHNROzqjchPDqK93as5UZEuB2jdFxBoSH4bF9JcHgoc6s3pUbOfMle570mvU969SJf/vwsXLJEm/TSIE1QKt1zcXFh9NixZM+enX59+nDz5v/W4yyTJQfTqzbkzJ1b9Ni1gfBoHSMV29k7t/DxW8X1iHAWeDelWs68yV5n7Ca9N958k7nz52uTXhqlCUopIFeuXIwdP55LFy8ydPBgoqOjY/bVeiY/4zyfZ9u1CwwM+JeEhmakN6dv38THbxW3Iu6y0Dtl5jLctHEjPm3acOL4ccaMG0d/bdJL0zRBKWWpXKUKn/Tpwz+bNzNn1qz79r1asCSflKnK8vMn+OLYLjtF6DhO3r6Bj99KwqIiWVijOZ7ZcyVrfZEREXz5xRd82rs3BQoWZNGSJTRt1ixZ61T2l+A4KKXSozfefJP9AQHMmjkTj4oVeb5OnZh9H5SoxLnQEGac2EfhTFl4q3BZO0ZqP8dCrtPebzVRGBbVaE65rDmTtb7zQUEM8vVl3759vPHmm/T65BO9a0on9A5KqVhEhAG+vpQuU4YhgwYRGBh4377hFWpTL3chhh7Yyqbgc3aM1D6O3LpGO79VGAyLUyA5bdq40dZL78QJxo4fr0166YwmKKXicMuUiQkTJwLQv29fwsL+N8O5i5MTX1apT9ksOem5ZwMHbl5N6DJpzsGbV2nntwoXEZbUbEGZLDmSra6IiAi++Pzz+5r0mjRtmmz1KcekCUqpeBQuUoTPRo3iyOHDjBs79r6OEVlcMjCrWmOyZXCl6861nA+9/ZArpQ37b16hvf9qXJ2dWVKjBSXdsydbXeeDgujauTNLFy/mzbfeYs68eRTRXnrpkiYopRJQp25dunTtyh///S+//PzzffvyuWVmdrXG3I6K5L2da7kVcddOUSa/vTcu095vNZmdXVhSowXF3JNvnuiNVpPeyVOnGDdhAv0GDNAmvXRME5RSD/Fe16489/zzTJowgYB9++7bVzZrTqZ5NeTE7Rt8uHsDd9PgGKld1y/RwX812TJkZGnNFhTNnDVZ6rnXpNend28KFizI4iVLaNykSbLUpVIPTVBKPYSTkxOfjRpF3rx56d+vH1ev3v/M6blcBRhd8Tn+vXqewfu3pKkxUv7XLtLJfw25MrqxtGYLCmXKkiz1BAUF0cVq0nvr7beZM38+hYuk3PIcynFpglLqEbJnz86ESZO4cf06gwYMIDIy8r79rQqVpmcpL34NOs7Xx/fYKcqkte3qBTrvWEs+t8wsqdGCAm7uyVLPxg0baNemDaesJr2+/fuTMWPGZKlLpT6aoJRKhHLly9Pf1xd/f39mTJv2wP4PS1WmVcFSTD2+h5/PHbNDhEnn3yvneW/HWgq6ubO4RgvyuWVO8joiIiL4YvJk+nzyCYULF9YmPRUvHairVCK98uqr7A8IYOGCBVT09KRR48Yx+0SEURWf40L4HQbv/5f8bpl5PlfKLDeRlP6+fI5uu9ZTPHM2Fng3JZdrpiSvIygoiIEDBrA/IIC3W7emZ69eetek4qV3UEo9hk/69KGipyefDR/OqZMn79uXwcmJr6s0oJR7Dj7cvYHDt67ZKconsz44kPd3/kVJ9+wsrNEsWZLThvXrY5r0xk+cSJ9+/TQ5qQRpglLqMWTMmJFxEyaQIUMG+vXpw507d+7bnzVDRmZVb4y7swvv7VzLhbDUMUZq7aUz9Ni1nnJZc7LQuxnPZHRL0utHRETw+aRJ9P30UwoXKcLipUvvuwNVKj6aoJR6TPnz52f02LGcPn2akSNGPNBzr4CbO7OqNeFWRARddq7jVqRjj5FaeeE0H+3egEe2Z1jg3YwcGZN23NG5c+d47913WbZ0KW+3acPsuXMpXLhwktah0iZNUEo9gZq1atH9ww9Zu2YNS5cseWB/hWzP8JVXfY6GXOfj3RuJiLV8hyP54/xJeu3dSOXsuZnn3ZRsGZK2uW39X3/Rrk0bzpw+bWvS69tXm/RUommCUuoJte/QgQYNG/LVl1+yY8eOB/bXzV2IkR7P8veVIIYf2OpwY6R+DzrOJ3v/pmqOPMyp3pSsLkmXOCIiIpg8cSL9+vShSNGiLNImPfUEki1BichcEbkkIgGxyp4RkTUictT6mjPWPl8ROSYih0Wkeazy6iKyz9o3VUQkuWJW6nGICMNGjKBQ4cIM7N+fS5cuPXDMm4XL0L1kZX44d5QZJ/bFcxX7+PncMfru20zNZ/Ixp1oTsrhkSLJr32vS+27ZMlprk556Csl5BzUfaBGnbACwzhhTBlhnvUdEPIDWQEXrnOki4mydMwPoCpSxtrjXVMpusmTJwoRJkwgNDcW3f38iIiIeOKZXaS9eK1CSL47t4veg43aI8n4/BB7BN+AfnstVgJnVGpM5CZNT7Ca9CZMm8ak26amnkGwJyhizCYi7FsFrwALr9QKgZazy74wx4caYk8AxoKaIFACyGWO2GFv7yMJY5yjlEEqVKsXgoUPZu2cPUz7//IH9IsIYz+eo/Ux+fAP+ZeuV83aI0mbJmUMM2r+FerkL8W3VxmRyTpqhkHfv3mWS1aRXtFgxFi9bRsNGjZLk2ir9SulnUPmMMecBrK95rfJCwNlYxwVaZYWs13HLlXIozZo3p62PDz98/z0r/vjjgf0ZnZyZ5tWQYpmz0n33eo6GXE/xGBeePsjwg9tolKcw06o2xNXZ+dEnJUJgYCDvderE98uW0aZtW2bPnUuhQvrfVD09R+kkEd9zJfOQ8vgvItJVRPxFxD84ODjJglMqMT7q2ZOq1aoxZvRojh458sD+bBkyMrt6E9ycXOiyYy2Xwu/Ec5XkMffUfkYe2k7TvEX5yqsBrk5Jk5z+WreOdm3bEhgYyMTJk/mkTx8yZEi6JkOVvqV0grpoNdthfb33VDkQiD19cWEgyCovHE95vIwxM40x3sYY7zx58iRp4Eo9ikuGDIwZN46sWbLQr08fbt269cAxhTJlYVb1xlyLCKfrznXcjnzwmVVS+/bEPsYe9ueFfMX4skp9MiZBcrp79y6TJkygf9++FC9enMXLltGgYcMkiFap/0npBLUc6GC97gD8Hqu8tYi4ikgJbJ0htlvNgLdEpLbVe699rHOUcji5c+dm3IQJnL9wgWFDhhAdz/initly8WWV+hy8eY1eezcRmYxjpL4+vodJR3fycv4SfF65Hhmcnv6/fEyT3nff0dbHh1lz5lCwYOqbd1A5vuTsZr4M2AKUE5FAEekMjAOaishRoKn1HmPMfuAH4ACwEuhhjLm3+ls3YDa2jhPHgT+TK2alkkIVLy96f/IJf2/axLy5c+M9pkGewgz3qMWG4EA+O7QtycdIGWP48thuvjy2m5YFSzKpch1ckiA5rVu79r4mvd6ffqpNeirZJNts5saYNgnsine0njFmNDA6nnJ/wDMJQ1Mq2b319tsE7NvHtzNm4OHhwbPPPffAMW2KlCMwNISZJwMonCkrXUskzY+5MYbPj+7im5P7eKNQaUZVfBZnebrkdPfuXb784gt++P57Knp6MmbcOL1rUsnOUTpJKJWmiAgDBw+mVKlSDBk0iKCg+B+dflqmGi/lL87EIzv4v/Mn4z3mcRhjGH9kB9+c3EfrwmUZXfG5p05OgWfP8l6nTvzw/fe0bddOm/RUitEEpVQyyZQpExMmTSIqKor+ffoQHh7+wDFOIoyvVAfvnHnpt28zftcuPnF9xhhGH/Jjzqn9tCtSjs88auP0lBOvrFu7lnY+PgQGBjLp88/p/ckn2qSnUowmKKWSUZGiRRk+ciSHDh1iwrhx8T5rcnVyZoZXI4pkzkK3nX9x4vaNx64n2hhGHNzGgjMH6VisAkMr1OJpZgULDw9nwrhxDOjXjxJWL736DRo88fWUehKaoJRKZvXr1+fdzp1Z/vvv/Pbrr/EekyOjK7OrNcHFyYnOO9ZyOTw00dePNoahB7aw5Oxh3itekYHlajxVcrrXpPfjDz/g8847zNQmPWUnmqCUSgFdP/iA2rVrM3H8ePbv3x/vMUUyZ2VmtcZcDg/l/Z3ruJOIMVJRJpqB+//l+8CjdCtZiX5lqz9Vclq7Zg3tfHwICgpi0hdf0Kt3b23SU3ajCUqpFODs7MzIMWPInTs3/fv25fq1+JeDr5w9N1Oq1CPg5lU+2fs3USbhMVJRJpoBAf/w87lj9CxVhd6lqz5xcgoPD2f82LH49u9va9JbupT69es/0bWUSiqaoJRKITly5GDcxIlcu3qVQQMHEhUVFe9xjfMWZXD5GqwLPsvoQ37xPreKjI7m071/81vQCXqXrspHpb2eODmdPXOGzp068dOPP8Y06RXQJj3lADRBKZWCPDw86DdgANu3beOb6dMTPO6dYhXoXNyDRWcOMe/0gfv2RURH02vvJv64cIq+ZavTvVTlJ45nzerVvOPjw/mgICZrk55yMMk2UFcpFb/XWrZk3759zJ83j4qengnOYdevrDfnQm8z7rA/QaG3WXPpDEFht3FzciYsOoqB5bzpVLziE8UQHh7OF59/zs8//kilSpUYM24c+QsUeJqPpVSS0zsopeygb79+VPDwYPiwYZw+fTreY5xEmFipDsUyZ2PBmYMEhd0GICw6ChcRcmXM9ER1nzlzhnc7duTnH3/knfbtmTl7tiYn5ZA0QSllB66uroyfMAEXFxf69elDaGj83crdnF0IjYp8oDzSGCYf3fnY9a5etYr2Pj5cvHCBz6dMoWevXrhok55yUJqglLKTAgULMnrMGE6eOMHokSMTnDA2oXWjzlt3VIkRHh7OuDFjGOTrS8lSpVi8dCl169V7oriVSimaoJSyo1q1a9Ote3dWrVzJd8uWxXtMATf3xyqPK6ZJ76efaN+hAzNnzdImPZUqaIJSys46dOpE/QYN+HLKFHbtfLDZ7tMy1XCLs8igm5Mzn5ap9shrr161infatuXihQt88eWXfPTxx9qkp1INTVBK2ZmTkxPDR4ygYIEC+A4YwOXg4Pv2v1qwJKMrPkdBN3cEKOjmzuiKz/FqwZIJXjMsLIyxo0czyNeX0mXKsHjZMurUrZvMn0SppCVJvVCao/D29jb+/v72DkOpRDt29CidOnSgfPnyzPj22ye+0zl9+jS+/ftz9MgR2nfoQLfu3fWuSTk0EdlhjPGOW653UEo5iNJlyjB46FB2797N1C+/fKJrrFq5kvY+Ply6dIkpU6dqk55K1XSgrlIOpHmLFuzbt49lS5dS0dOT5i1aJOq8sLAwPp80iV9/+YXKVaoweuxY8ufPn8zRKpW8NEEp5WB69erFoYMHGfXZZ5QqXZrSpUs/9PhTp04xsH9/jh49SvuOHenWrZveNak0QZv4lHIwLhkyMG78eNyzZKF/nz6E3LqV4LGrVq6kQ7t2XAoOtjXp9eypyUmlGZqglHJAufPkYey4cZw7d47hw4YRHX3/shthYWGMGTWKwQMHUqZsWZYsW8bzderYKVqlkoc28SnloKpWq0bPXr34YvJkBvn6EhAQwMULF8iVOzfOzs5cvHCBDp068UG3bri46H9llfboT7VSDqxN27asWb2atWvWxJTdGyfVrn17PvzoI3uFplSys0sTn4h8LCIBIrJfRHpZZc+IyBoROWp9zRnreF8ROSYih0WkuT1iVsoeRIRLly7Fuy920lIqLUrxBCUinkAXoCZQBXhZRMoAA4B1xpgywDrrPSLiAbQGKgItgOki4hzftZVKi4ITSFAXL1xI4UiUSln2uIOqAGw1xtwxxkQCG4HXgdeABdYxC4CW1uvXgO+MMeHGmJPAMWzJTal0IV8C45kSKlcqrbBHggoA6olILhHJDLwIFAHyGWPOA1hf81rHFwLOxjo/0Cp7gIh0FRF/EfEPjjOfmVKpVfcePXBzc7uvzM3Nje49etgpIqVSRop3kjDGHBSR8cAaIATYAzy4Itv/SHyXSeDaM4GZYJuL7ylDVcohvPDiiwBMnzaNixcukC9/frr36BFTrlRaZZdefMaYOcAcABEZg+2u6KKIFDDGnBeRAsC9hvdAbHdY9xQGglIyXqXs7YUXX9SEpNIde/Xiy2t9LQq0ApYBy4EO1iEdgN+t18uB1iLiKiIlgDLA9pSNWCmlVEqz1zion0UkFxAB9DDGXBORccAPItIZOAO8CWCM2S8iPwAHsDUF9jDGRNkpbqWUUinEXk18D6ycZoy5AjRO4PjRwOjkjksppZTj0Ln4lFJKOSRNUEoppRySJiillFIOSYxJm8OFRCQYOP0Ul8gNXE6icJRKKvpzqRxNUvxMFjPG5IlbmGYT1NMSEX9jjLe941AqNv25VI4mOX8mtYlPKaWUQ9IEpZRSyiFpgkrYTHsHoFQ89OdSOZpk+5nUZ1BKKaUckt5BKaWUckiaoJRSSjkkTVBxiMhcEbkkIgH2jkUpABEpIiLrReSgiOwXkY/tHZNSIuImIttFZI/1czkiyevQZ1D3E5F62BZSXGiM8bR3PEpZ66MVMMbsFJGswA6gpTHmgJ1DU+mYiAjgbowJEZEMwGbgY2PM1qSqQ++g4jDGbAKu2jsOpe4xxpw3xuy0Xt8CDgKF7BuVSu+MTYj1NoO1JekdjyYopVIRESkOVAW22TkUpRARZxHZjW0F9DXGmCT9udQEpVQqISJZgJ+BXsaYm/aORyljTJQxxgsoDNQUkSR9LKIJSqlUwGrj/xlYYoz5xd7xKBWbMeY6sAFokZTX1QSllIOzHkbPAQ4aYz63dzxKAYhIHhHJYb3OBDQBDiVlHZqg4hCRZcAWoJyIBIpIZ3vHpNK954F3gEYistvaXrR3UCrdKwCsF5G9gB+2Z1D/l5QVaDdzpZRSDknvoJRSSjkkTVBKKaUckiYopZRSDkkTlFJKKYekCUoppZRD0gSlUpSIGBGZHOt9HxEZnkTXni8ibyTFtR5Rz5vWzOLr45QXF5FQqxv4ARFZaA2wfZI6OorI19brD0Sk/RNcI4eIdH+S+uO51nwROWnNXH3E+mxPNB+giHg9TTd5EeklIpkf85wGIpKkXaBV8tMEpVJaONBKRHLbO5DYRMT5MQ7vDHQ3xjSMZ99xa+qXStimf3nraWMzxnxjjFn4BKfmAJIkQVn6GmOqAOWAXdjGwGR8gut4AU8zjqsX8FgJSqVOmqBUSosEZgK94+6IewckIiHW1wYislFEfrD+eh8nIj7WWjT7RKRUrMs0EZG/reNets53FpGJIuInIntF5P1Y110vIkuBffHE08a6foCIjLfKhgJ1gG9EZGJCH9IYEwVsx5p1XESqW59hh4isspbQQEQ2iMgUEfnXqqdmPHEMF5E+1uvSIrLWupPZKSKlRCSLiKyz3u8TkdesU8cBpaw7uonW+X1jfR9GWGXuIvKHdc0AEXk7oc9lfTZjjPkCuAC8YF2jmYhssWL40Zo3EBGpYX22Pda/V3bgM+BtK663rfrnWnHtuhe/9e82yfpMe0XkIxHpCRTElhzXP6LuFiJySEQ2A60e9pmUgzLG6KZbim3Y1trKBpwCsgN9gOHWvvnAG7GPtb42AK5jG7nuCpwDRlj7PgamxDp/JbY/vMoAgYAb0BUYbB3jCvgDJazr3gZKxBNnQeAMkAdwAf7CtgYT2OYc847nnOJAgPXaDVgPVMa2DMG/QB5r39vA3FjXmmW9rhfr/I7A19br4UAf6/U24PVYdWS24stmleUGjgESOx5rXzNsfxyI9T36P6vO/9yLwTouezyf7b5/G6tsCtDfqnMTtrWBsMqGAhmBE0ANqzybFWvMZ7PKxwDtrNc5gCOAO9AN2/yDLta+Z6yvp4DcsT5vfHW7AWetnwMBfgD+z94//7o93uaCUinMGHNTRBYCPYHQRJ7mZ4w5DyAix4HVVvk+IHZT2w/GmGjgqIicAMpj+8VcOdbdWXZsv7juAtuNMSfjqa8GsMEYE2zVuQTbL/PfHhFnKbEtP1AG+MkYs1dsMzx7AmtEBMAZOB/rnGVgW4tMRLKJNb9ZXGJbrLCQMeZX6/gwqzwDMEZsi21GY7tryxfPJZpZ2y7rfRYrzr+BSdZd4v8ZY/5+xGeMCcn6WhvwAP6xPl9GrOnCgPPGGD8r3ptWvPHF9eq9u0RsyaUotrndvjHGRFrnx7dOW0J1lwdOGmOOWnUuxvaHikpFNEEpe5kC7ATmxSqLxGp2Fttvm9jPN8JjvY6O9T6a+3+O487dZbD9Iv3IGLMq9g4RaYDtDio+D/wWTaTjxhgvqwlvg4i8CpwE9htjnk3gnPhifpyYfLDd6VU3xkSIyClsv+TjO3+sMebbB3aIVMf2XGisiKw2xnyWQF2xVQXWWdddY4xpE+ealR/yWeLG9R9jzOE450sizk+obq9E1q0cmD6DUnZh/TX8A7YOB/ecAqpbr1/D1jT2uN4UESfruVRJ4DCwCuhm3WkgImVFxP0R19kG1BeR3GLrQNEG2JjYIKy7vQGArxVDHhF51qo/g4hUjHX421Z5HeCGMeZGAte8CQSKSEvreFex9WbLDlyyklNDoJh1yi0ga6xLrALejfWMppCI5BWRgsAdY8xiYBJQ7WGfTWx6YmtyXQlsBZ4XkdLW/swiUhbbzNYFRaSGVZ5VRFwSiOsjKyEhIlWt8tXAB9Y5iMgz8Xyuh9VdQv73fPK+BKZSB01Qyp4mY3uGcM8sbElhO1CLhO9uHuYwtkTyJ/CB1Qw2GzgA7BSRAOBbHtF6YCUYX2zPkfYAO40xvz9mLL9he0ZUC3gDGC8ie4DdwHOxjrsmIv8C33B/wo7PO0BPsc0g/S+QH1gCeIuIP7a7qUPWZ7iCrekrQEQmGmNWA0uBLSKyD/gJ2y/6SsB2q2lyEDAqgbonWvEfwdYE2tAYc9dqBu0ILLPi2gqUN8bcxZZ8v7LOW8P/ns153OskAYzE9sfIXuvfZ6RV32xszwH3Wue3tcpnAn+KyPqH1B2GrUnvD6uTxOlHfF+VA9LZzJWyIxHZgK0DhL+9Y1HK0egdlFJKKYekd1BKKaUckt5BKaWUckiaoJRSSjkkTVBKKaUckiYopZRSDkkTlFJKKYf0//B0ssHOP77aAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACrGElEQVR4nOzdd1RU19rH8e/M0DuIgNgrYkMUa6yxxtzEVKMxsRGT2HsvgF3sPbFFTUy3JJpERY0Su6CIInYFFQELvcOc9w/jvCGWAAJDeT5rzVp3Zu/Z53dY3vBw9jl7qxRFURBCCCGEEMWeWt8BhBBCCCFE/pDCTgghhBCihJDCTgghhBCihJDCTgghhBCihJDCTgghhBCihJDCTgghhBCihJDCTgghhBCihJDCTgghhBCihDDQd4DiQqvVEhERgaWlJSqVSt9xhBBCCFFKKIpCQkICzs7OqNUvviYnhV0ORUREULFiRX3HEEIIIUQpdfv2bSpUqPDCPlLY5ZClpSXw+IdqZWWl5zRCCCGEKC3i4+OpWLGirhZ5ESnscujJ9KuVlZUUdkIIIYQodDm5FUyvD0/4+/vzxhtv4OzsjEqlYufOnU/1CQ0N5c0338Ta2hpzc3OaNGlCeHi4rj01NZUhQ4ZQpkwZLCwsePfdd4mKiso2Rnh4OK+//jpmZmY4ODgwbtw4MjMzC/r0hBBCCCEKlV4Lu6SkJNzc3Fi1atUz269fv06rVq2oXbs2hw4dIjg4mGnTpmFiYqLrM2rUKHbt2sVPP/3E4cOHiYiI4J133tG1Z2Vl8frrr5Oens6xY8fYvHkzmzZtYvr06QV+fkIIIYQQhUmlKIqi7xDw+PLijh07eOutt3Sf9ezZE0NDQ77++utnficuLo6yZcvy7bff8t577wFw6dIlXF1dOX78OM2bN+ePP/7gf//7HxERETg6OgLwxRdfMGHCBO7fv4+RkVGO8sXHx2NtbU1cXJxMxQohhBCi0OSmBimy69hptVp+++03atWqRZcuXXBwcKBZs2bZpmsDAwPJyMigY8eOus9q165NpUqVOH78OADHjx+nfv36uqIOoEuXLsTHxxMSElJo5yOEEEIIUdCKbGEXHR1NYmIi8+bNo2vXruzbt4+3336bd955h8OHDwMQGRmJkZERNjY22b7r6OhIZGSkrs8/i7on7U/anictLY34+PhsLyGEEEKIoqzIPhWr1WoB6N69O6NGjQKgYcOGHDt2jC+++IK2bdsW6PHnzp2Lj49PgR5DCCGEECI/Fdkrdvb29hgYGFCnTp1sn7u6uuqeinVyciI9PZ3Y2NhsfaKionByctL1+fdTsk/eP+nzLJMmTSIuLk73un379suekhBCCCFEgSqyhZ2RkRFNmjTh8uXL2T6/cuUKlStXBqBx48YYGhpy4MABXfvly5cJDw+nRYsWALRo0YLz588THR2t6+Pn54eVldVTReM/GRsb69ask7XrhBBCCFEc6HUqNjExkWvXrune37x5k6CgIOzs7KhUqRLjxo3jgw8+oE2bNrRv3549e/awa9cuDh06BIC1tTWenp6MHj0aOzs7rKysGDZsGC1atKB58+YAdO7cmTp16vDxxx/j6+tLZGQkU6dOZciQIRgbG+vjtIUQQgghCoaiR3/++acCPPXq27evrs+GDRuUGjVqKCYmJoqbm5uyc+fObGOkpKQogwcPVmxtbRUzMzPl7bffVu7du5etz61bt5TXXntNMTU1Vezt7ZUxY8YoGRkZucoaFxenAEpcXFyez1cIIYR4HkDZsWOHvmPkiJeXl+Lm5qbvGAUut+d58+ZNBVDOnj2brzlyU4Po9Ypdu3btUP5jGb0BAwYwYMCA57abmJiwatWq5y5yDFC5cmV+//33POcsaFlZWQSdPcuDBw+wt7enobs7Go1G37GEEELkQL9+/YiNjX3m7kki5zZt2sTIkSOfum9e5E6RfSq2tDh44ACLFizIdg+gg4MDY8aN49UOHfSYTAghhBDFTZF9eKI0OHjgABPGj89W1AFE37/PhPHjOfiPh0KEEELkTFZWFoEBAezds4fAgACysrIK9fjt2rVj+PDhjB8/Hjs7O5ycnPD29s7W5+rVq7Rp0wYTExPq1KmDn5/fU+Pcvn2bHj16YGNjg52dHd27d+fWrVu69n79+vHWW2/h4+ND2bJlsbKy4vPPPyc9PV3XR6vVMnfuXKpWrYqpqSlubm78/PPPuvZDhw6hUqk4cOAAHh4emJmZ0bJly6ceXJw3bx6Ojo5YWlri6elJamrqU3nXr1+Pq6srJiYm1K5dm9WrV+vabt26hUqlYvv27bRv3x4zMzPc3Nx0mwkcOnSI/v37ExcXh0qlQqVSPfUze8Lb25uGDRuyceNGKlWqhIWFBYMHDyYrKwtfX1+cnJxwcHBg9uzZ2b4XHh5O9+7dsbCwwMrKih49ejy1asbLnue/xcTE0Lt3b8qWLYupqSk1a9bkq6++em7/fJGvk8AlWH7fY5eZmal069JF8XB3f/arUSPl9a5dlczMzHw5nhBClAYH9u9/6r+t3bp0UQ7s319gx+zbt6/SvXt33fu2bdsqVlZWire3t3LlyhVl8+bNikqlUvbt26coiqJkZWUp9erVUzp06KAEBQUphw8fVtzd3bPdY5eenq64uroqAwYMUIKDg5WLFy8qH374oeLi4qKkpaXpjmthYaF88MEHyoULF5Tdu3crZcuWVSZPnqzLMmvWLKV27drKnj17lOvXrytfffWVYmxsrBw6dEhRlP+/171Zs2bKoUOHlJCQEKV169ZKy5YtdWP88MMPirGxsbJ+/Xrl0qVLypQpUxRLS8ts95598803Srly5ZRt27YpN27cULZt26bY2dkpmzZtUhTl/+89q127trJ7927l8uXLynvvvadUrlxZycjIUNLS0pSlS5cqVlZWyr1795R79+4pCQkJz/x5e3l5KRYWFsp7772nhISEKL/++qtiZGSkdOnSRRk2bJhy6dIlZePGjQqgnDhxQvczb9iwodKqVSslICBAOXHihNK4cWOlbdu2BXKeT+6xGzJkiNKwYUPl9OnTys2bNxU/Pz/l119/zeG/rP+XmxpECrscyu/CLuD06ecXdf94BZw+nS/HE0KIku7A/v2KR6NGz/xD2aNRowIr7p5V2LVq1SpbnyZNmigTJkxQFEVR9u7dqxgYGCh3797Vtf/xxx/ZCruvv/5acXFxUbRara5PWlqaYmpqquzdu1d3XDs7OyUpKUnXZ82aNYqFhYWSlZWlpKamKmZmZsqxY8eyZfH09FR69eqlKMr/F3b7//Gz+e233xRASUlJURRFUVq0aKEMHjw42xjNmjXLVvBUr15d+fbbb7P1mTlzptKiRQtFUf6/4Fm/fr2uPSQkRAGU0NBQRVEU5auvvlKsra2V/+Ll5aWYmZkp8fHxus+6dOmiVKlSRcnKytJ95uLiosydO1dRFEXZt2+fotFolPDw8KeOf+rUqXw/zyeF3RtvvKH079//P8/pv+SmBpGpWD158OBBvvYTQojSLCsri0ULFsCzHsj7+7PFCxcW2rRsgwYNsr0vV66c7rab0NBQKlasiLOzs679ydqrT5w7d45r165haWmJhYUFFhYW2NnZkZqayvXr13X93NzcMDMzyzZOYmIit2/f5tq1ayQnJ9OpUyfdGBYWFmzZsiXbGP/OW65cOYBseZs1a5at/z/zJiUlcf36dTw9PbMdZ9asWbk6Tm5UqVIFS0tL3XtHR0fq1KmDWq3O9tm/f+YVK1bUtdepUwcbGxtCQ0Pz/TyfGDRoEN9//z0NGzZk/PjxHDt2LNfnmlvy8ISe2Nvb52s/IYQozYLOnn1xgaAoREVFEXT2LI09PAo8j6GhYbb3KpVKt1VmTiQmJtK4cWO2bt36VFvZsmVzPAbAb7/9Rvny5bO1/Xsd13/mValUADnO++Q469ate6ow+vcKDy9znOeN82Ssl/2Z/5fcnOcTr732GmFhYfz+++/4+fnRoUMHhgwZwsKFC/Mt179JYacnDd3dcXBwIPr+/Wf/hcnjvzYaursXcjIhhCh+itMsiKurK7dv3+bevXu6q1YnTpzI1qdRo0b88MMPODg4vHDno3PnzpGSkoKpqaluHAsLCypWrIidnR3GxsaEh4e/1P7qrq6unDx5kj59+ug++2deR0dHnJ2duXHjBr17987zcYyMjArsiuqTn/nt27d1V+0uXrxIbGysbheqgjrPsmXL0rdvX/r27Uvr1q0ZN26cFHYlkUajYcy4cUwYPx5UqmcWd6PHjpX17IQQIgeK0yxIx44dqVWrFn379mXBggXEx8czZcqUbH169+7NggUL6N69OzNmzKBChQqEhYWxfft2xo8fT4UKFQBIT0/H09OTqVOncuvWLby8vBg6dChqtRpLS0vGjh3LqFGj0Gq1tGrViri4OI4ePYqVlRV9+/bNUd4RI0bQr18/PDw8eOWVV9i6dSshISFUq1ZN18fHx4fhw4djbW1N165dSUtLIyAggJiYGEaPHp2j41SpUoXExEQOHDigm2L+5zTzy+jYsSP169end+/eLF26lMzMTAYPHkzbtm3x+PsKbkGc5/Tp02ncuDF169YlLS2N3bt34+rqmi/n9Dxyj50evdqhA/N9fXF4zmV1c3PzQk4khBDF05NZEP6e3nuKSlVkZkHUajU7duwgJSWFpk2b8sknnzy1NIeZmRn+/v5UqlSJd955B1dXV93yG/+8gtehQwdq1qxJmzZt+OCDD3jzzTezLRMyc+ZMpk2bxty5c3F1daVr16789ttvVK1aNcd5P/jgA6ZNm8b48eNp3LgxYWFhDBo0KFufTz75hPXr1/PVV19Rv3592rZty6ZNm3J1nJYtW/L555/zwQcfULZsWXx9fXP83f+iUqn45ZdfsLW1pU2bNnTs2JFq1arxww8/FOh5GhkZMWnSJBo0aECbNm3QaDR8//33+XZezzxXRfmPrR8EAPHx8VhbWxMXF/fCy+J58e+dJ/bv38/PP/6Io5MT3//4IxYWFvl6PCGEKImerA0KZJ8F+bvYm+/rW6IWfpcdL0qP3NQgcsWuCNBoNDT28KBL16409vBg+IgRlK9QgajISJYuWaLveEIIUSw8bxbE0cGhxBV1QjyP3GNXBJmamjLdy4vPBg7klx076NChAy1attR3LCGEKPJe7dCBtu3ayf7botSSqdgcKsip2OdZtGAB33/3HQ4ODnz/00/Z1uwRQgghROkgU7ElxJChQ6lYsSLR0dEsWbRI33GEEEIIUcRJYVeEmZiaMt3bG5VKxa5ff+XokSP6jiSEEEKIIkwKuyKuobs7vf5eCHH2zJnEx8frOZEQQgghiiop7IqBQYMHU6lyZe7fv8/iAlytWgghhBDFmxR2xYCJiQle3t6o1Wp+270b/8OH9R1JCCGEEEWQFHbFRAM3N3p/9BEAc2bPJi4uTs+JhBBCCFHUSGFXjHw2aBBVqlTh4YMHLMzHrVaEEEIUjkOHDqFSqYiNjdV3lJfSrl07Ro4cmeP+mzZtwsbGpsDyiP8nhV0xYmxsjJePD2q1mj1//MGhP//UdyQhhCj1+vXrx1tvvZWjvi1btuTevXtYW1sXyPhCSGFXzNSrX5+P+/YFYO7s2cTGxOg5kRBCiJwyMjLCyckJ1d/71wqR36SwK4Y+/ewzqlarxqNHj1ggU7JCCJFNlqLl5KNIdt27wclHkWQp2kI7dlpaGsOHD8fBwQETExNatWrF6dOnde3/nop9MkW5d+9eXF1dsbCwoGvXrty7dw8Ab29vNm/ezC+//IJKpUKlUnHo0KFnHrtdu3YMGzaMkSNHYmtri6OjI+vWrSMpKYn+/ftjaWlJjRo1+OOPP7J97/DhwzRt2hRjY2PKlSvHxIkTyczM1LUnJSXRp08fLCwsKFeuHIuesWB+WloaY8eOpXz58pibm9OsWbPn5hQFSwq7YsjIyAgvHx80Gg379u7l4IED+o4khBBFwt6oMNod3sZHp/cyOvgvPjq9l3aHt7E3KqxQjj9+/Hi2bdvG5s2bOXPmDDVq1KBLly48evToud9JTk5m4cKFfP311/j7+xMeHs7YsWMBGDt2LD169NAVe/fu3aPlC/YO37x5M/b29pw6dYphw4YxaNAg3n//fVq2bMmZM2fo3LkzH3/8McnJyQDcvXuXbt260aRJE86dO8eaNWvYsGEDs2bN0o05btw4Dh8+zC+//MK+ffs4dOgQZ86cyXbcoUOHcvz4cb7//nuCg4N5//336dq1K1evXn2ZH6fIC0XkSFxcnAIocXFx+o6is3rlSsXD3V3p9OqryqNHj/QdRwgh9GpP5C2l5p5NSo1/vWr+/doTeatAjtu3b1+le/fuSmJiomJoaKhs3bpV15aenq44Ozsrvr6+iqIoyp9//qkASkxMjKIoivLVV18pgHLt2jXdd1atWqU4Ojo+Nf5/adu2rdKqVSvd+8zMTMXc3Fz5+OOPdZ/du3dPAZTjx48riqIokydPVlxcXBStVpvt+BYWFkpWVpaSkJCgGBkZKT/++KOu/eHDh4qpqakyYsQIRVEUJSwsTNFoNMrdu3ez5enQoYMyadIk3XlaW1v/5zmIZ8tNDSJX7Ioxz4EDqV6jBjExMfjOm6fvOEIIoTdZipZZoadQntH25LPZl04V6LTs9evXycjI4JVXXtF9ZmhoSNOmTQkNDX3u98zMzKhevbrufbly5YiOjs5ThgYNGuj+t0ajoUyZMtSvX1/3maOjI4Bu/NDQUFq0aJHtnr9XXnmFxMRE7ty5w/Xr10lPT6dZs2a6djs7O1xcXHTvz58/T1ZWFrVq1cLCwkL3Onz4MNevX8/TeYi8M9B3AJF3RkZGePv40K9PH/b7+fFqhw506txZ37GEEKLQBcREE5mW/Nx2BbiXmkxATDTN7JwKL1gOGBoaZnuvUqlQlGeVqHkb65+fPSngtNr8K3ATExPRaDQEBgai0WiytVlYWOTbcUTOyBW7Yq62qyv9BwwAYP68eTx8+FDPiYQQovBFv6Coy0u/vKhevTpGRkYcPXpU91lGRganT5+mTp06eR7XyMiIrKys/Ij4FFdXV44fP56tkDx69CiWlpZUqFCB6tWrY2hoyMmTJ3XtMTExXLlyRffe3d2drKwsoqOjqVGjRraXk1PRKqJLAynsSoABn3xCzVq1iIuNZf7cuXn+S08IIYorB2OzfO2XF+bm5gwaNIhx48axZ88eLl68yMCBA0lOTsbT0zPP41apUoXg4GAuX77MgwcPyMjIyLfMgwcP5vbt2wwbNoxLly7xyy+/4OXlxejRo1Gr1VhYWODp6cm4ceM4ePAgFy5coF+/fqjV/18+1KpVi969e9OnTx+2b9/OzZs3OXXqFHPnzuW3337Lt6wiZ6SwKwEMDQ0fPyVrYMCfBw/it2+fviMJIUSh8rB1wMnYjOetDqcCypmY4WHrkO/H1mq1GBg8vrNp3rx5vPvuu3z88cc0atSIa9eusXfvXmxtbfM8/sCBA3FxccHDw4OyZctmuyL4ssqXL8/vv//OqVOncHNz4/PPP8fT05OpU6fq+ixYsIDWrVvzxhtv0LFjR1q1akXjxo2zjfPVV1/Rp08fxowZg4uLC2+99RanT5+mUqVK+ZZV5IxKkcs7ORIfH4+1tTVxcXFYWVnpO84zrVu7lrVffIG1tTXf//QT9vb2+o4khBCFZm9UGMOCDgFke4jiSbG3omE7ujhWzvfjdu3alRo1arBy5cp8H1sIyF0NIlfsSpD+/fvjUrs2cXFxzJszR6ZkhRClShfHyqxo2A7Hf023OpmYFUhRFxMTw+7duzl06BAdO3bM17GFyCu5YpdDxeGKHcDVK1fo89FHZGZmMmPWLF7r1k3fkYQQolBlKVoCYqKJTkvGwfjx9KtGlf/XMd5++21Onz5N3759mTVrlmwTJgpMbmoQKexyqLgUdgAb169nzerVWFlZ8f1PP1G2bFl9RxJCCCFEHslUbDGT3/sa9unXD1dXV+Lj45kza5ZMyQohhBClhCxQrGd7o8KYFXoq28KaTsZmTHVtmuf7QQwMDJju40Of3r058tdf/P7bb7z+v//lV2QhhBBCFFFyxU6PnjzB9e/V0qPSkhkWdOilNq2uUaMGn37+OQALfX3zvD2NEEIIIYoPKez0pDD2Nfzo44+pW68eiYmJzJ45U6ZkhRBCiBJOCjs9yc2+hnllYGDAdG9vjIyMOHb0KLt++SXPYwkhhBCi6JPCTk8Ka1/DatWq8fmgQQAsXryYyMjIlxpPCCGEEEWXFHZ6Upj7Gn740UfUr1+fpMREZs+YIVOyQgghRAklhZ2e/Ne+hpB/+xpqNBqm+/hgbGzMiRMn2Lljx0uPKYQQQoiiRwo7PdGo1Ex1bQrw3OKue7nq+bZaepUqVRg0ZAgAy5Ys4V5ERL6MK4QQQoiiQwo7PXrevoZmmsfLC353+zJ3UxLz7Xg9e/XCrWFDkpKSmClTskIIIUSJI1uK5VBBbin2730NG1iX4aNTewmOf0gDa3u+a9oVI7UmX44VFhZG7169SEtNZeLkybz73nv5Mq4QQgghCoZsKVbMaFRqmtk58Ua5ajSzc8JUY8iyhu2wNjAiOO4B8y4H5NuxKleuzJChQ4HHU7J3797Nt7GFEEIIoV96Lez8/f154403cHZ2RqVSsXPnzmzt/fr1Q6VSZXt17do1W59Hjx7Ru3dvrKyssLGxwdPTk8TE7NOXwcHBtG7dGhMTEypWrIivr29Bn9pLq2BqgW/9VgB8HX6J3+7dzLexP+jZE3d3d1JSUpjl44NW+3J70wohhBCiaNBrYZeUlISbmxurVq16bp+uXbty79493eu7777L1t67d29CQkLw8/Nj9+7d+Pv78+mnn+ra4+Pj6dy5M5UrVyYwMJAFCxbg7e3N2rVrC+y88surDhX5rGo9AKaEHONGUly+jKtWq5nm5YWJiQkBAQH8/NNP+TKuEEIIIfSryNxjp1Kp2LFjB2+99Zbus379+hEbG/vUlbwnQkNDqVOnDqdPn8bDwwOAPXv20K1bN+7cuYOzszNr1qxhypQpREZGYmRkBMDEiRPZuXMnly5dynG+grzH7kUytVr6BuzjVEwUtSxs+Ln565j+/XDFy/rx++9Z4OuLiYkJ3/34IxUqVMiXcYUQQgiRf0rUPXaHDh3CwcEBFxcXBg0axMOHD3Vtx48fx8bGRlfUAXTs2BG1Ws3Jkyd1fdq0aaMr6gC6dOnC5cuXiYmJee5x09LSiI+Pz/bSBwO1miVubbA3MuFKYixeF0/k29Os7/XoQWMPD1JTU5nh7S1TskIIIUQxV6QLu65du7JlyxYOHDjA/PnzOXz4MK+99hpZWVkAREZG4uCQfQFfAwMD7OzsdFtnRUZG4ujomK3Pk/cv2l5r7ty5WFtb614VK1bMz1PLFQdjM5a6tUWNih0R1/n57rV8GVetVjN1+nRMTU05e+YMP/7wQ76MK4QQQgj9KNKFXc+ePXnzzTepX78+b731Frt37+b06dMcOnSowI89adIk4uLidK/bt28X+DFfpJmdEyNrNgTAJ/QkofGP8mXcChUqMHzkSABWrljB7fDwfBlXCCGEEIWvSBd2/1atWjXs7e25du3xFSsnJyeio6Oz9cnMzOTRo0c4OTnp+kRFRWXr8+T9kz7PYmxsjJWVVbaXvn1WtT5t7cuTps1i2LlDJGSk58u477z7Lh5NmpCWmoqPt7fuiqgQQgghipdiVdjduXOHhw8fUq5cOQBatGhBbGwsgYGBuj4HDx5Eq9XSrFkzXR9/f38yMjJ0ffz8/HBxccHW1rZwT+AlqVUqFtRvhbOJOWHJCUy8cDRf7rd78pSsmZkZ54KC+OFfTx4LIYQQonjQa2GXmJhIUFAQQUFBANy8eZOgoCDCw8NJTExk3LhxnDhxglu3bnHgwAG6d+9OjRo16NKlCwCurq507dqVgQMHcurUKY4ePcrQoUPp2bMnzs7OAHz44YcYGRnh6elJSEgIP/zwA8uWLWP06NH6Ou2XYmtkwnK3thiq1OyLDmdTWGi+jOvs7MyIUaMAWL1qFWFhYfkyrhBCCCEKj14Lu4CAANzd3XF3dwdg9OjRuLu7M336dDQaDcHBwbz55pvUqlULT09PGjduzF9//YWxsbFujK1bt1K7dm06dOhAt27daNWqVbY16qytrdm3bx83b96kcePGjBkzhunTp2db6664cbMpy0SXx08C+14J4Gxs9H98I2fefucdmjVvTlpaGj5eXjIlK4QQQhQzRWYdu6JOX+vYPY+iKIwM9uf3yFs4mZjxS4s3sDMyeelxI+/do2ePHiQlJTF85Eg+7tMnH9IKIYQQIq9K1Dp24tlUKhWz67akqpkVkanJjA3+C20+1OhO5coxaswYAL5YvZpbN/NvKzMhhBBCFCwp7IoxCwNDVjRsh4law18PI1h9Izhfxn2ze3datGxJeno63l5eZGZm5su4QgghhChYUtgVcy6WtnjXaQ7A8mtBHH0Y8dJjqlQqpkybhoWFBSEXLrD1m29eekwhhBBCFDwp7EqAd8vX4P3yNVGA0cF/EZma9NJjOjo6MnrsWAC+XLOGGzduvPSYQgghhChYUtiVENNdm1Lb0pZH6amMOudPRj7s+/q/N96gVatWZGRk4D19ukzJCiGEEEWcFHYlhInGgBVu7TDXGBIQG83iq2deekyVSsWkqVOxtLQk9OJFvt68OR+SCiGEEKKgSGFXglQxt2JevVcAWH8rhP3RL7/vq4ODA2PHjQNg7Zdfcu3q1ZceUwghhBAFQwq7EqarU2X6VXYFYPz5I4QnJ7z0mK+9/jqt27QhMzMTHy8vMv+xPZsQQgghig4p7EqgcbUa09C6LAmZGQw/d4i0l9xBQqVSMXnKFKysrLh06RKbNm3Kn6BCCCGEyFdS2JVARmoNy93aYmtoTEj8I2ZfPvXSY9qXLcu4CRMA2LBuHVeuXHnpMYUQQgiRv6SwK6HKmZqzqEFrVMB3t6/wS8TLL1fSpWtX2rVvr5uSzZApWSGEEKJIkcKuBGttX57B1RoAMO3ica4mxr7UeCqViomTJ2NtY8OVy5f5asOGfEgphBBCiPwihV0JN6yGGy3typGSlcmwoEMkZb7cVbYyZcow/u8p2Y0bN3L50qX8iCmEEEKIfCCFXQmnUalZ3KA1jsamXE+KY9rF4yiK8lJjdurcmVc7dCArMxPv6dNlSlYIIYQoIqSwKwXKGJuy1K0tGpWKXfdu8t2dl3vwQaVSMWHSJGxsbLh27Rrr163Lp6RCCCGEeBlS2JUSHraOjKnZCIBZoae4EPfwpcazs7NjwqRJAGz+6itCL1586YxCCCGEeDlS2JUin1SpS0eHimQoWoadO0RcRtpLjdexUyc6dupEVlYW3l5epKen51NSIYQQQuSFFHaliEqlYn69VlQwteBOSiITzh996fvtJkyciJ2dHTeuX2fdl1/mU1IhhBBC5IUUdqWMlaERK9zaYahSc+D+bdbfCnmp8WxsbZk4eTIAWzZvJiTk5cYTQgghRN5JYVcK1bMuw1TXpgAsunqG0zFRLzVe+1dfpUvXrmi1WnymTyct7eWmeIUQQgiRN1LYlVK9KtTizXLVyFIURp47zIO0lJcab+z48diVKcPNmzdZ+8UX+ZRSCCGEELkhhV0ppVKpmFGnOdXNrYlOS2F0sD9ZijbP49nY2DB5yhQAvvn6a84HB+dXVCGEEELkkBR2pZi5gSErGrbDVGPA8UeRrLh27qXGa9uuHa916/Z4Stbbm9TU1HxKKoQQQoickMKulKtpYcOsOi0AWH0jGP/7d19qvDHjxmFvb0/YrVt8sWZNfkQUQgghRA5JYSd407kavSrWQgHGnv+LeylJeR7L2tqayVOnAvDtN99w7tzLXQUUQgghRM5JYScAmOLSlLpWdsRkpDH83GHStVl5Hqt1mza8/sYbKIrCDC8vUlNe7sEMIYQQQuSMFHYCAGONhuVu7bA0MCQo7j4LrgS+1Hhjxo6lbNmyhIeHs3rVqnxKKYQQQogXkcJO6FQys2RB/VYAbAoL5Y/IW3key9LSkinTpwPw/XffcfbMmfyIKIQQQogXkMJOZNPBoRKfVKkLwKQLx7iVFJ/nsV555RXe7N798ZSstzcpMiUrhBBCFCgp7MRTRtdshIeNA0lZGQwLOkRqVmaexxo1ejQOjo7cuXOHVStW5GNKIYQQQvybFHbiKYZqNUvd2lLGyIRLiTH4hJ7M81gWlpZM+3tK9ofvvycw8OXu3RNCCCHE80lhJ57J0cSMxQ3aoAJ+vnuNbXev5Xms5i1a8NbbbwMww9ub5OTkfEophBBCiH+Swk48V8sy5RheoyEA3hdPcDkhJs9jjRg1CicnJyLu3mXFsmX5lFAIIYQQ/ySFnXihwdUa0LqMM6naLIYGHSIhMz1P41hYWDDVywuAn3/6idOnTuVnTCGEEEIghZ34D2qVioUNWuNkYsat5HimXDiGoih5GqtZs2a8+957AMz08SEpKe87XAghhBDiaVLYif9kZ2TCcre2GKhU/BEVxtfhl/I81rARI3B2dubevXssX7o0/0IKIYQQQgo7kTPuNg6Mr+UBwLzLAQTF3s/TOObm5kz7e0p2+7ZtnDxxIt8yCiGEEKWdFHYix/pVdqWLY2UyFC3Dzx0mJj01T+N4NGnC+z16ADBzxgwSExPzM6YQQghRaklhJ3JMpVIxt25LKptZci81iXHnj6DN4/12Q4cPp3yFCkRFRrJ0yZJ8TiqEEEKUTlLYiVyxNDRihVs7jNUaDj+4y5c3z+dpHDMzM6b/PSX7y44dHD92LD9jCiGEEKWSFHYi11yt7PBybQbA0qtBnHh4L0/jNGrcmA969QJg1owZJCQk5FtGIYQQojSSwk7kyfsVavKOc3W0KIwK9ic6LW+7SQwZOpSKFSsSHR3NkkWL8jmlEEIIUXCyFC0nH0Wy694NTj6KJEvR6jsSKiWvi5KVMvHx8VhbWxMXF4eVlZW+4xQJKVmZvH/idy4nxtDE1pEtHp0xUOf+b4Wgs2f59JNPUBSFpcuX80qrVgWQVgghhMg/e6PCmBV6ish/XNhwMjZjqmtTujhWztdj5aYGkSt2Is9MNQYsb9gWc40Bp2OiWHrtbJ7GaejuTq8PPwRg9syZxMfH52dMIYQQIl/tjQpjWNChbEUdQFRaMsOCDrE3KkxPyaSwEy+pmrk1c+q9AsCXNy9wMPp2nsYZNHgwlSpX5v79+yxeuDA/IwohhBD5JkvRMiv0FM+a7nzy2exLp/Q2LavXws7f35833ngDZ2dnVCoVO3fufG7fzz//HJVKxdJ/7Vbw6NEjevfujZWVFTY2Nnh6ej61LlpwcDCtW7fGxMSEihUr4uvrWwBnU3p1c6rCx5VqAzD+/BHupOR+XToTU1O8vL1Rq9X8tns3/ocP53dMIYQQ4qUFxEQ/daXunxTgXmoyATHRhRfqH/Ra2CUlJeHm5saqVate2G/Hjh2cOHECZ2fnp9p69+5NSEgIfn5+7N69G39/fz799FNde3x8PJ07d6Zy5coEBgayYMECvL29Wbt2bb6fT2k20cWDBtb2xGWmMzzoEGnarFyP0cDNjQ979wZgzuzZxMXF5XdMIYQQ4qXk9GHBvD5U+LL0Wti99tprzJo1i7fffvu5fe7evcuwYcPYunUrhoaG2dpCQ0PZs2cP69evp1mzZrRq1YoVK1bw/fffExERAcDWrVtJT09n48aN1K1bl549ezJ8+HAWL15coOdW2hipNSx3a4uNoTHn4x8y99LpPI3z2aBBVKlShYcPHrBQrqwKIYQoYsoYGD/94TOeQ31mv0JQpO+x02q1fPzxx4wbN466des+1X78+HFsbGzw8PDQfdaxY0fUajUnT57U9WnTpg1GRka6Pl26dOHy5cvExMQU/EmUIuVNLVhY//ETrVtvX2b3vZu5HsPExAQvHx/UajV7/viDQ3/+md8xhRBCiDwzuHkX0tL///3VMMw3/QLpGY8/UBRUsQkY3orQS74iXdjNnz8fAwMDhg8f/sz2yMhIHBwcsn1mYGCAnZ0dkZGRuj6Ojo7Z+jx5/6TPs6SlpREfH5/tJf5b27IVGFStPgBTQo5xPTH306n16tfnoz59AJg7ezaxUoALIYQoAhRFYcOjMDA2AkVBEx6J+Ve/YHglDKPAi7ord6a7D/Po4UO9ZCyyhV1gYCDLli1j06ZNqFSqQj/+3Llzsba21r0qVqxY6BmKq+HVG9LczonkrEyGnTtEcmZGrsf49LPPqFqtGo8ePWKBTMkKIYQoAlZeP8dB1eN754wOBWCx9idUikKaRx3SmzdAFZeI2dbfMAq5jr29vV4yFtnC7q+//iI6OppKlSphYGCAgYEBYWFhjBkzhipVqgDg5OREdHT2p04yMzN59OgRTk5Ouj5RUVHZ+jx5/6TPs0yaNIm4uDjd6/btvC3jURoZqNUsbtCGskamXE2MxSv0BLldB9vY2BgvHx80Gg379u7l4IEDBZRWCCGE+G8bboWw/Po5AOz2n8Js3zFUWVq0Ziao0jMwX7cNK9+vMLp4A0dHRxq6u+slZ5Et7D7++GOCg4MJCgrSvZydnRk3bhx79+4FoEWLFsTGxhIYGKj73sGDB9FqtTRr1kzXx9/fn4yM/79q5Ofnh4uLC7a2ts89vrGxMVZWVtleIufKGpuyxK0NalTsjLjBj3eu5nqMunXr0qdvXwDmzZkj90QKIYTQi+9uX2be5QAA+pWpjMnxc7o2dXIqRsFXMbx5lyfzi6PHjkWj0eghqZ4Lu8TERF3RBnDz5k2CgoIIDw+nTJky1KtXL9vL0NAQJycnXFxcAHB1daVr164MHDiQU6dOcfToUYYOHUrPnj11S6N8+OGHGBkZ4enpSUhICD/88APLli1j9OjR+jrtUqOZnROjaz7+i2XGpZOExOf+foNPPv2U6jVqEBMTg++8efkdUQghhHihXyKu43XxBAC9y1bh6LT5JCcnU6FixaemWx0dHJjv68urHTroIyoABno7MhAQEED79u11758UW3379mXTpk05GmPr1q0MHTqUDh06oFareffdd1m+fLmu3dramn379jFkyBAaN26Mvb0906dPz7bWnSg4A6vWIzA2mj/v32FY0CF2tngDK0Oj//7i34yMjPD28aFfnz7s9/Pj1Q4d6NS5cwEmFkIIIR7bFxXGhAtHUYD3HKoQPGMp96OiqFq1KmvXr8fSyoqgs2d58OAB9vb2NHR319uVuidUSm5vfiqlcrMBr8guNj2Nt47v4m5qEp0cKrKqYftcPxDzxZo1bFi3DmsbG3746SfKlClTQGmFEEII+OvBXT47c5AMRcubDpWJWrCWy5cu4eTkxPqvvnpqxY2ClJsapMjeYydKDhsjY5Y3bIehSo1f9G2+CruY6zE8P/mEmjVrEhcby/y5c3P9MIYQQgiRU6djohh89k8yFC2d7CsQv2Yrly9dwtbWlpVr1hRqUZdbUtiJQtHA2p4ptZsAsOBKIIG53EPP0NAQrxkz0BgY8OfBg/jt21cQMYUQQpRywXEPGBh4gFRtFm3KOGO89TeCAgIxNzdn+cqVVK5cWd8RX0gKO1FoPqzowutOVchUFEacO8zD9NRcfd/FxQVPT08AfOfN48GDBwURUwghRCl1JSEGz8D9JGVl0NTWkXK7j3Dk0CGMjY1ZtHQptV1d9R3xP0lhJwqNSqViVt2WVDO3IiotmTHB/mQp2lyN0X/AAGq5uBAXF8e8OXNkSlYIIUS+uJUUT9+AfcRmpOFmbU/9IyHs/XUXGo2GOfPm0bhxY31HzBEp7EShsjAwZIVbO0zUGo4+vMfq68G5+r6BoSHePj4YGBhw+NAh9vzxRwElFUIIUVpEpCTSJ2AfD9JTqW1pS/uQe2z7ZisA0728aNO2rZ4T5pwUdqLQ1bK0ZWbdFgCsuH6Ovx7czdX3a9aqxSd/L1ez0NeX+/fv53tGIYQQpcP9tBT6BOzjXmoS1cyteDcilU2rVgOPFxru9r//6Tlh7khhJ/TiLefqfFChJgowJvgv7qUm5er7ffv2xdXVlfj4eObMmiVTskIIIXItJj2VfgH7CEtOoIKpBf0TjVg9dz4AngMH0uvDD/WcMPeksBN6M612M1wt7YjJSGPkucNkaHN+v52BoSHTfXwwNDTkyF9/8ftvvxVgUiGEECVNQmY6noH7uZIYi4OxKcNVZVg63QdFUXi/Rw8++/xzfUfMEynshN4YazSsaNgWSwNDzsTeZ9HVwP/+0j/UqFGDgZ99Bjyeko2Ozt0SKkIIIUqnlKxMPj1zgPPxD7E1NGaSRSUWTZhMVmYmXbp2Zez48bleSL+oyHVhl5KSQnJysu59WFgYS5cuZZ+sKybyoLKZFfPqvQLAhlsX2RcVlqvvf9ynD3Xq1iUxMZHZM2fKlKwQQogXStNmMfjsnwTERGNhYIhP2VosHjOBtNRUWr7yCt4+PqjVxfe6V66Td+/enS1btgAQGxtLs2bNWLRoEd27d2fNmjX5HlCUfJ0dKzOgch0AJlw4SlhyfI6/a2BggJePD0ZGRhw7epRdv/5aUDGFEEIUc5laLaPO+XPkYQSmGgPmVmjA0tETSEhIwK1hQ+b7+mJgaKjvmC8l14XdmTNnaN26NQA///wzjo6OhIWFsWXLFpYvX57vAUXpMLZWYxrZlCUxM4NhQYdJzcrM8XerVaumuxdi8aJFREZGFlRMIYQQxZRWUZh44Sh+0eEYqdXMr9qINWMn8ejhQ2rWrMmSZcswMTXVd8yXluvCLjk5GUtLSwD27dvHO++8g1qtpnnz5oSF5W4aTYgnDNVqlrq1xdbQmNCER8y6dCpX3+/98cfUr1+fJJmSFUII8S+KouB18QS/3LuBgUrFvJpN2DzJi4i7d6lQoQLLV63S1TbFXa4Luxo1arBz505u377N3r176dy5MwDR0dFYWVnle0BRepQzMWdxgzaogB/uXGVnxPUcf1ej0TDdxwdjY2NOHD/OLzt3FlhOIYQQxYeiKMy/EsD3d66gAma7NGOH9zyuX7uGvb09K9eswd7eXt8x802uC7vp06czduxYqlSpQtOmTWnR4vFCs/v27cPd3T3fA4rSpZW9M0OruwEw/eIJriTE5Pi7VapU4fPBgwFYungx9yIiCiSjEEKI4mPl9XNsuHURgBm1m/Hn/GWcDw7GysqKFatXU758eT0nzF8qJQ9zVpGRkdy7dw83NzfdkyOnTp3CysqK2rVr53vIoiA+Ph5ra2vi4uLkymQBy1K0eAbu5+jDe1Qzt2Jb8/9hYZCzm1mzsrL49JNPCD53jqbNmrFy9epi+8i6EEKIl7PxVghzLwcAMLmWB1e+2MJ+Pz9MTExYtWYNDdzc9JwwZ3JTg+TpeV4nJycsLS3x8/MjJSUFgCZNmpTYok4ULo1KzaIGbXA0NuNGUjxTQ47l+J45jUbDdG9vjE1MOHXyJDu2bSvgtEIIIYqi729f0RV1o2o0JPLbnez388PAwIAFixYVm6Iut3Jd2D18+JAOHTpQq1YtunXrxr179wDw9PRkzJgx+R5QlE5ljExY5tYWjUrFb5G3+Pb25Rx/t3LlygweMgSApUuWcPdu7vaiFUIIUbz9EnGD6RePA/Bp1Xoof/zF9m3bUKlUzJg1i+Z/30ZWEuW6sBs1ahSGhoaEh4djZmam+/yDDz5gz549+RpOlG6NbR0YX6sxALMvnSY47kGOv9uzVy/c3d1JSUlhlo8P2lxsVyaEEKL48osKZ8KFIyjARxVdKHfqIps2bgRg4uTJdPr7oc+SKteF3b59+5g/fz4VKlTI9nnNmjVluROR7/pXrkMnh0pkKFqGBx0iNj0tR99Tq9VM8/LCxMSEgIAAtv38cwEnFUIIoW9/PbjLiHOHyVIU3naujtvVSJYtXgLA4KFDeefdd/WcsODlurBLSkrKdqXuiUePHmFsbJwvoYR4QqVSMa/eK1Q0teBuahLjLxxBm8P77SpWqsTQ4cMBWL50KXfu3CnIqEIIIfTodEwUg8/+SYaipYtjZbrcT2fuzFnA47VO+/Xvr+eEhSPXhV3r1q11W4rB41+8Wq0WX19f2rdvn6/hhACwMjRiRcN2GKnV/Hn/DutuXsjxd9/v0YNGjRuTmprKDG9vmZIVQogS6HzcAwYGHiBVm0Vb+/J8lG7GtEmT0Gq1vPHmm4wYObLUrJCQ68LO19eXtWvX8tprr5Gens748eOpV68e/v7+zJ8/vyAyCkFdqzJMr90MgMVXz3LyUc62DXsyJWtqasrZM2f46ccfCzKmEEKIQnYlIYYBgftJysqgqa0jQ4ydmDB6NBkZGbRr357JU6eWmqIO8lDY1atXjytXrtCqVSu6d+9OUlIS77zzDmfPnqV69eoFkVEIAHpUqMlbztXQojDqnD/301Jy9L0KFSowbMQIAFYsX87t8PCCjCmEEKKQ3EqKp1+AH7EZabhZ2zOlTHXGDx9OcnIyHk2aMGvOHAwMDPQds1DlaYHi0kgWKC4akjMzeO/k71xNjKW5nRObPDqhUf333ydarZYhgwYRcPo0DRs25Mv163WLawshhCh+IlIS6XVqDxGpSdS2sGVxpYaM/PQzoqOicK1ThzVffom5ubm+Y+aL3NQgOSrsgoODc3zwBg0a5LhvcSKFXdFxPTGOd07sJjkrk0HV6jO6ZqMcfS8iIoJePXqQnJzMqDFj+LB37wJOKoQQoiDcT0vhw1N7uJUcT1UzK1a7NGfi50MIu3WLKlWqsG7DBmxsbfUdM9/ke2GnVqtRqVQoipJtnvrJV//5WVZWVl5zF2lS2BUtu+/dZFSwPwDrGnWgXdkK//GNx7b//DNz58zB2NiYrd9/T+XKlQsyphBCiHwWk57KR6f3ciUxlvIm5qyv1wafYSO5dOkSjk5OrN+4EScnJ33HzFf5vqXYzZs3uXHjBjdv3mTbtm1UrVqV1atXExQURFBQEKtXr6Z69epsk+2bRCH5X7mq9K7oAsC480eISEnM0ffefvddmjZrRlpaGj5eXiX2DxEhhCiJEjLT8Qzcz5XEWByMTVnn1o6Fk6Zy6dIlbG1tWbl6dYkr6nIr1/fYNW3aFG9vb7p165bt899//51p06YRGBiYrwGLCrliV/SkabPodfIPzsc/pIG1Pd817YqRWvOf34u8d4+ePXqQlJTEiFGj+OjjjwshrRBCiJeRkpXJgEA/AmKisTU0ZkujTqzzmYX/4cOYm5vzxdq11HZ11XfMApHvV+z+6fz581StWvWpz6tWrcrFixdzO5wQeWas1rC8YTusDYwIjnvAvL83e/4vTuXKMXL0aADWrFrFrZs3CzKmEEKIl5SmzWLI2T8JiInGwsCQDY068P2S5fgfPoyRkRGLli4tsUVdbuW6sHN1dWXu3Lmkp6frPktPT2fu3Lm4yg9VFLIKphb41m8FwNfhl/gj8laOvtf9rbdo3qIF6enpMiUrhBBFWKZWy6hz/vz1MAJTjQHrG3Vg/4Yt/LZrFxqNhjnz59O4cWN9xywycl3YffHFF+zdu5cKFSrQsWNHOnbsSIUKFdi7dy9ffPFFQWQU4oVedajIp1XrATDpwlFuJMX953dUKhVTp0/HwsKCCxcusPXrrws6phBCiFzSKgoTLxzFLzocQ5WaNe7tObdtF99u3QrANC8v2rZtq+eURUue1rFLSkpi69atXLp0CXh8Fe/DDz8sMevFPIvcY1e0ZWq19AnYx+mYKGpZ2PBz89cx1fz3opS//vILM318MDQ05JvvvqNatWqFkFYIIcR/URQFr9ATfHf7ChqVilUN2xFz+CTz584FKFXLVuX7cidCCrviIDotme7HdvEgPZV3nKsz/+8p2hdRFIVRI0Zw9MgRXOvUYeOmTaVulXIhhChqFEVh/pVANtwKQQUsatAa4+CrTJ08GUVRGPDJJwwaPFjfMQtNvhd2v/76K6+99hqGhob8+uuvL+z75ptv5i5tMSGFXfFw4uE9+gb4oUVhTt2WvF+h5n9+Jzo6mp7vv09CQgKDhw6l/4ABhZBUCCHE86y4do7l14MAmF23BRXC7jN61CiyMjN57/33GT9xYqna/7VAFiiOjIzEwcHhhdswqVSqEnsTuhR2xceaG8EsvnoWY7WGn5p1w9XK7j+/89vu3XhPn46BgQFfb91KjZr/XRAKIYTIf1/dCmHO36scTHZpQqO4DIYMGkRaaiqdu3Rh5uzZpW5LyHxf7kSr1eLg4KD73897ldSiThQvn1WtT1v78qRpsxh27hAJGen/+Z1ur79O6zZtyMzMxMfLi8yMjEJIKoQQ4p9+uH1FV9SNrNGQVukGjBo+nLTUVFq0bIn3jBmlrqjLrVz/dLZs2UJaWtpTn6enp7Nly5Z8CSXEy1CrVCyo3wpnE3PCkhOYFHKM/7owrVKpmDxlClZWVly6dInNmzcXUlohhBAAv0bcYNrF4wAMrFKPNw1tGTZ0KAkJCTRwc8N3wQIMDQ31nLLoy3Vh179/f+Linl5OIiEhgf79++dLKCFelq2RCcvc2mKoUrM3KozN4aH/+R37smUZO348AOvXruXKlSsFHVMIIQTgFxXO+AtHUIDeFV3ob1uRYUOH8vDBA2rUqMGSZcswMTXVd8xiIdeFnaIoz7xh8c6dO1hbW+dLKCHyQ0Obskx08QBg/uUAzsZG/+d3ur72Gu3at5cpWSGEKCRHHkQw4txhshSFt52rM7K8K8OGDuXunTuUr1CBFatWyb3tuZDjdR3c3d1RqVSoVCo6dOiQbUmIrKwsbt68SdeuXQskpBB59XGl2gTERPFHVBjDzx3mlxZvYGdk8tz+KpWKiZMnc/bsWa5cvsxXGzcy8LPPCjGxEEKUHgExUQw6e5AMRUsXx8pMq+7OiMFDuH7tGvb29qxcvRr7smX1HbNYyXFh99ZbbwEQFBREly5dsLCw0LUZGRlRpUoV3n333XwPKMTLUKlUzK7XktCEGG4lxzM2+C/WN+6I+gWPyZcpU4bxEyYwZdIkNmzYQJu2bXGpXbsQUwshRMl3Ie4hA88cIFWbRVv78sx3bc7E0WM4HxyMpaUlK1atokKFCvqOWezkeoHizZs388EHH2Bi8vyrHiWRLHdSvF1OiOG9E7+Rqs1iZI2GDKnu9sL+iqIwcfx4Dh44QM2aNdn8zTdy064QQuSTq4kx9D61l5iMNJraOrK2YXtmT/fCb98+TExMWLVmDQ3cXvzf6dIk35c7+ae+fftiYmJCQEAAX3/9NV9//TWBgYF5DitEYXCxtMW7TnMAll0L4tjDey/sr1KpmDBpEjY2Nly9epUN69cXRkwhhCjxwpLi6Xvaj5iMNBpY2/OF+6usWLgIv337MDAwwHfhQinqXkKuC7u7d+/SunVrmjZtyogRIxgxYgRNmjShVatW3LlzpyAyCpEv3i1fg/fK10ABRgf7E5Wa/ML+dnZ2TJg0CYBNGzcSevFiIaQUQoiSKyIlkT4B+7ifnkJtC1s2NOrIN2vXse3nn1GpVPjMnEmLli31HbNYy3Vh5+npSUZGBqGhoTx69IhHjx4RGhqKVqvlk08+KYiMQuQbL9dm1Law5WF6KiPPHSZDq31h/46dOtGxUyeysrLw9vIiPf2/FzsWQgjxtPtpKfQN8CMiNYmqZlZ85dGJ33/8iY0bNgAwcdIkOnfpoueUxV+uC7vDhw+zZs0aXFxcdJ+5uLiwYsUK/P39czWWv78/b7zxBs7OzqhUKnbu3Jmt3dvbm9q1a2Nubo6trS0dO3bk5MmT2fo8evSI3r17Y2VlhY2NDZ6eniQmJmbrExwcTOvWrTExMaFixYr4+vrm7qRFiWGiMWBFw3aYawwJiI1m8dUz//mdCRMnYmdnx43r11m/dm0hpBRCiJIlNj2N/gF+3EqOp7yJOZs9OnNi336WLF4MwOAhQ3jnvff0nLJkyHVhV7FiRTKesbZXVlYWzs7OuRorKSkJNzc3Vq1a9cz2WrVqsXLlSs6fP8+RI0eoUqUKnTt35v79+7o+vXv3JiQkBD8/P3bv3o2/vz+ffvqprj0+Pp7OnTtTuXJlAgMDWbBgAd7e3qyVX9ClVhVzK+bVewWA9bdCOBAd/sL+Nra2uinZzZs2ERISUuAZhRCipEjITMcz0I/LiTE4GJuy2aMzV06eZtaMGQB8+NFH9BswQM8pSxAll3bu3Kk0bdpUOX36tO6z06dPK82bN1d27NiR2+F0gP/8flxcnAIo+/fvVxRFUS5evKgA2bL88ccfikqlUu7evasoiqKsXr1asbW1VdLS0nR9JkyYoLi4uOQq35Njx8XF5ep7ouiaefGkUmPPJqXR/m+V8KT4/+w/ZdIkxcPdXXn/nXeU1NTUQkgohBDFW3JmhtLr5B9KjT2blCYHvlOuJMQoAadPKy2bNVM83N0V7+nTFa1Wq++YRV5uapBcX7Hr168fQUFBNGvWDGNjY4yNjWnWrBlnzpxhwIAB2NnZ6V75KT09nbVr12JtbY3b30/LHD9+HBsbGzw8PHT9OnbsiFqt1k3ZHj9+nDZt2mBkZKTr06VLFy5fvkxMTEy+ZhTFy3iXxjS0Lkt8ZjrDzh0iLSvrhf3Hjh+PXZky3Lx5k7VffllIKYUQonhK02YxNOgQp2OisDAw5CuPTmSGRzBm1CjS09Np1749U6ZNe+ZuViLvcrxA8RNLly4tgBjPt3v3bnr27ElycjLlypXDz88Pe3t7ACIjI3FwcMjW38DAADs7OyIjI3V9qlatmq2Po6Ojrs3W1vaZx01LSyMtLU33Pj4+Pt/OSRQNRmoNy93a0v34LkLiHzH78ilm1Gnx3P42NjZMnjKFsaNH882WLbRr1476DRoUYmIhhCgeMrVaRp3zx//BXUw1Bqxv1BHzh/EMHDqUpKQkPDw8mDVnTrZdrET+yPVPtG/fvgWR47nat29PUFAQDx48YN26dfTo0YOTJ08+VdDlt7lz5+Lj41OgxxD6V87UnIX1W/PJmf18d/sKHjaOvOlc7bn927Zrx2vduvHH77/j4+3NN99+W+oW6xZCiBfRKgqTQo7iFx2OoUrNGvf2lE/N4pMhQ4iNjcXV1ZUFixdjbGys76glUq6nYgGuX7/O1KlT6dWrF9HRjzdW/+OPPwrkpnJzc3Nq1KhB8+bN2bBhAwYGBmz4+9FoJycn3fGfyMzM5NGjRzg5Oen6REVFZevz5P2TPs8yadIk4uLidK/bt2/n52mJIqRN2fIMrvb4ytu0i8e5mhj7wv5jxo3D3t6esFu3+HLNmkJIKIQQxYOiKHiHnmBnxA00KhXLG7aljtqUoUOGEBUZSeUqVVi2cmW2bUlF/srTcif169fn5MmTbN++Xbe0yLlz5/Dy8sr3gP+m1Wp1U6QtWrQgNjY2284XBw8eRKvV0qxZM10ff3//bE/y+vn54eLi8txpWABjY2OsrKyyvUTJNayGGy3typGclcmwoEMkZT795PcT1tbWTJ46FYCt33zDuXPnCiumEEIUWYqi4HslkO9uX0EFLKjfiuZmdowYOpSwW7dwdHJi5erVL/zdK15ergu7iRMnMmvWLPz8/LI9kPDqq69y4sSJXI2VmJhIUFAQQUFBANy8eZOgoCDCw8NJSkpi8uTJnDhxgrCwMAIDAxkwYAB3797l/fffB8DV1ZWuXbsycOBATp06xdGjRxk6dCg9e/bULb3y4YcfYmRkhKenJyEhIfzwww8sW7aM0aNH5/bURQmmUalZ1KA1DsamXE+KY/rFEygv2Ea5dZs2vP7GGyiKwgwvL1JTUgoxrRBCFD2rbgSz/tbjmbtZdVvQ2a4840aPJjQ0FBsbG1auXv3CmTKRT3L7yK25ubly48YNRVEUxcLCQrl+/bqiKIpy8+ZNxdjYOFdj/fnnnwrw1Ktv375KSkqK8vbbbyvOzs6KkZGRUq5cOeXNN99UTp06lW2Mhw8fKr169VIsLCwUKysrpX///kpCQkK2PufOnVNatWqlGBsbK+XLl1fmzZuX29OW5U5KiVOPIhWXvZuVGns2Kd+GX3ph3/j4eOW1zp0VD3d3ZfHChYWUUAghip6NNy8oNfZsUmrs2aRsvBmiZGRkKGNGjVI83N2Vtq1aKRdDQvQdsVjLTQ2iUpQXXJZ4hgoVKvDjjz/SsmVLLC0tOXfuHNWqVWPHjh2MHTuW69ev53vxWRTEx8djbW1NXFycTMuWcOtuXsD3SiCGKjU/NutGPesyz+179OhRRg4bhkql4st163Bv1KgQkwohhP79cPsKUy8eB2BEjYYMrlqfmT4+7N61CyMjI5avXEnjfyxLJnIvNzVIrqdie/bsyYQJE4iMjESlUqHVajl69Chjx46lT58+eQ4tRFHxSZW6dChbkQxFy7Bzh4jLSHtu31deeYU3u3d/PCXr7U2KTMkKIUqRXyNuMO3vou6TKnUZXLU+y5YuZfeuXWg0GubMmydFXSHLdWE3Z84cateuTcWKFUlMTKROnTq0adOGli1bMvXvG8qFKM5UKhXz679CBVML7qQkMvHC0Rfebzdq9GgcHB25c+cOq1auLMSkQgihP/ujwxl/4QgK8GFFF8bXaszmr77i22++AWDq9Om0bddOrxlLo1xPxT5x+/Ztzp8/T2JiIu7u7tSsWTO/sxUpMhVb+lyIe0iPk7+ToWiZUKsxn1St99y+x48dY/jQoQB8sW4djRs3LqyYQghR6I48iODTMwfIULS85VyN+fVasWPbNubNmQM8/oP3w48+0nPKkqNApmK1Wi3z58/nlVdeoUmTJqxatYr27dvTo0ePEl/UidKpnnUZpro2BWDh1TOcjol6bt8WLVvy1ttvAzDD25vk5ORCySiEEIUtICaKwUF/kqFo6exQibl1X2H/vn3MnzsXgAGenlLU6VGOC7vZs2czefJkLCwsKF++PMuWLWPIkCEFmU0IvetVoRZvlKtKlqIw6txhHqY9/x66EaNG4eTkRMTdu6xcvrwQUwohROG4EPeQgWcOkJKVSRv78ixxa8PpEyfwmjYNRVF49733+HzwYH3HLNVyXNht2bKF1atXs3fvXnbu3MmuXbvYunUrWq22IPMJoVcqlYqZdVpQ3dyaqLQURgf/RZby7H/zFhYWTP17ke6ffvyR06dOFWZUIYQoUFcTYxgQ6EdiZgZNbB1Z2bAdoecvMH7sWDIzM+nUuTPjJkxApVLpO2qpluPCLjw8nG7duuned+zYEZVKRURERIEEE6KoMDcwZEXDdphqDDj26B4rrj1/p4lmzZrx7nvvATDTx4ekpKTCiimEEAUmLCmevqf9iMlIo4FVGb5s9Cp3b9xk1PDhpKam0qJlS3xmzkSj0eg7aqmX48IuMzPzqc3ODQ0Ns23VJURJVdPChpl1WgCw+kYwfz24+9y+w0aMwNnZmXv37rFi2bLCiiiEEAXiXkoSfQL2cT89BRcLWzY07kRcZDRDhwwhISGBBm5uzF+wAENDQ31HFeTiqVi1Ws1rr72GsbGx7rNdu3bx6quvYm5urvts+/bt+Z+yCJCnYgXAtJDjfH/nCraGxvzS4g3KmZo/s1/A6dMM+uwzAFauXk2z5s0LM6YQQuSLB2kpfHhqDzeT46liZsV3TbtCfCKfeHpy984datSowZfr18vvxQJWIE/F9u3bFwcHB6ytrXWvjz76CGdn52yfCVGSTa3dlLpWdsRkpDEi+DDp2qxn9vNo0oT3e/QAYOaMGSQmJhZmTCGEeGmx6Wn0C/DjZnI85U3M2eLRGaO0DIYNGcLdO3coX6ECK1atkqKuiMnzOnaljVyxE0+EJyfw1vFdJGRm0K+yK1NqN31mv+TkZD7s2ZO7d+7w1ttvM2XatEJOKoQQeZOQmU6/AD+C4x5Q1siU75p2xUFtyNDBgwk+d44y9vas37iRChUq6DtqqVCgW4oJUdpVMrPEt34rADaFhbInMuyZ/czMzJj291OyO3fs4PixY4WWUQgh8iolK5PPzhwkOO4BtobGbG7SCWcjUyaMG0fwuXNYWlqyctUqKeqKKCnshMiDjg6V8KxSF4BJIUe5lRT/zH6NGzfmg169AJg1cyaJCQmFllEIIXIrTZvF0KBDnI6JwsLAkI2NO1HN1Arv6dM5fuwYxiYmLFm+nBqyMUGRJYWdEHk0pmYjPGwcSMzMYFjQIVKzMp/Zb8jQoVSsWJHoqCiWLF5cyCmFECJnMrVaRp/zx//BXUzUGtY16kBdKzsW+Pqyb+9eDAwM8F2wADc3N31HFS8ghZ0QeWSoVrPErQ12RiZcSoxhRuizFyQ2NTVlurc3KpWKX3/5haNHjhRyUiGEeDGtojAp5Cj7osMxVKlZ4/4qHraOfLFmDdt++gmVSoXPzJm0fOUVfUcV/yFHhV2jRo2IiYkBYMaMGbIPphB/czIxZ3GD1qiAn+5eZdvda8/s19DdnV4ffgjA7JkziY9/9tStEEIUNkVR8Ak9yc6IG2hUKpY3bEsre2e+3bqVjevXAzBh0iQ6d+mi56QiJ3JU2IWGhupW0Pfx8ZGlG4T4h1fKODO8RkMAvC+e4HJCzDP7DRo8mEqVK3P//n0WL1pUiAmFEOLZFEVhwZUzfHv7MipgQf1WdHSoxG+7d7Pk7/9ODRo8WLejjij6DHLSqWHDhvTv359WrVqhKAoLFy7EwsLimX2nT5+erwGFKA4GV2vAmZho/noYwbCgQ2xr8TqWBkbZ+pj8PSU7cMAAfvt7ce82bdvqKbEQQjzeSWfdrQsAzKzTgjfKVePw4cPM9PEB4MPevenv6anPiCKXcrSO3eXLl/Hy8uL69eucOXOGOnXqYGDwdE2oUqk4c+ZMgQTVN1nHTvyXR+mpdD++i8jUZLo5VWFpgzbP3Ax72ZIlfPP115Sxt+eHn36Shb2FEHrx1a2LzLl8GoDJLh70r1KXwIAAhg8dSnp6Oq+/8QbTvbxQq+V2fH3LTQ2S6wWK1Wo1kZGRODg4vFTI4kYKO5ETZ2Oj+fDUHjIVhem1m/JxZden+qSmpvLxhx9y69YtXuvWjRmzZukhqRCiNPvxzhWmhBwHYHj1hgyr4UboxYsM+uwzkpKSaNuuHfN8fZ95EUcUvgJdoFir1Za6ok6InHK3cWB8LQ8A5l4OICj2/lN9TExM8PLxQa1W88fvv3Pozz8LO6YQohTbde8GU/8u6jyr1GVo9QbcunWL4UOHkpSURGMPD2bPnStFXTGVp+ur169fZ9iwYXTs2JGOHTsyfPhwrl+/nt/ZhCiW+lV2pYtjZTIULSPOHSYmPfWpPvXq1+ejPn0AmDtnDrGxsYWcUghRGh2IDmfc+SMoQK+KtZhQqzFRUVEMHTyY2NhYXF1dWbh4McbGxvqOKvIo14Xd3r17qVOnDqdOnaJBgwY0aNCAkydPUrduXfz8/AoioxDFikqlYm7dllQ2syQiNYlx54+gfcYdD59+9hlVq1Xj0cOHLPT11UNSIURpcvRhBMOCDpOlKLzlXA1v1+bExcYybPBgoiIjqVylCstWrnzuw5GieMj1PXbu7u506dKFefPmZft84sSJ7Nu3Tx6eEOJvF+Mf0ePk76Rpsxhd051B1Ro81SckJATPfv3Iyspi/oIFvNqhgx6SCiFKusCYaPoH+pGSlUlnh0osc2tLWkoKgz77jNCLF3FwdGTDxo04lSun76jiGQr0HrvQ0FA8n/Ho84ABA7h48WJuhxOixKpjZYeXazMAll4N4sTDe0/1qVu3Ln369gVg3pw5uoXAhRAiv1yIe8gnZ/aTkpVJG/vyLHZrQ1ZGBmNHjSL04kVsbGxYtXq1FHUlRK4Lu7JlyxIUFPTU50FBQfJQhRD/8l75GrztXB0tCqOC/YlOe3rXlk8+/ZTqNWoQExOD77+uhAshxMu4mhjDgEA/EjMzaGLryMqG7dBoFaZOnkxAQABmZmYsW7mSKlWr6juqyCe5LuwGDhzIp59+yvz58/nrr7/466+/mDdvHp999hkDBw4siIxCFFsqlQqfOs1xsbDlQXoqo875k6nVZutjZGSEl7c3Go2G/X5++O3bp6e0QoiSJCw5nn4BfsRkpNHAqgxfNnoVE7WGObNmcejPPzEyMmLRkiXUqVNH31FFPsr1PXaKorB06VIWLVpEREQEAM7OzowbN47hw4c/c0HWkkDusRMv40ZSHO8c301SViafVa3H2FqNn+rzxZo1bFi3DhsbG374+Wfs7Oz0kFQIURLcS0mi16k/uJuaRC0LG75p0gUbQ2OWLV3K1q+/Rq1WM3/BAtq1b6/vqCIHCnSB4n9KSEgAwNLSMq9DFBtS2ImX9XvkLUacOwzAl+6v8qpDxWztGRkZ9P3oI65evcqrHTowz9e3xP6hJIQoOA/SUvjw1B5uJsdTxcyKb5t2payxKV9t3MjqlSsBmO7tzRtvvqnnpCKnCvThiX+ytLQsFUWdEPmhm1MVPq5UG4Dx549wJyUxW7uhoSFeM2agMTDg4IEDMiUrhMi12PQ0+gf4cTM5HmcTczZ7dKKssSnbf/5ZV9SNHD1airoSTDaAE6IQTXDxoIG1PXGZ6QwPOkSaNitbu4uLi+6pc99583jw4IE+YgohiqHEzAw8z+znUmIMZY1M2eLRGWdTC/z27WPe3LkA9B8wgN4ffaTnpKIgSWEnRCEyVmtY7tYWawMjzsc/ZN6l00/16T9gALVcXIiLi2PenDm8xN0SQohSIiUrk8/OHCA47gE2hsZs8uhEZXMrjh87xvSpU1EUhXfefZdBQ4boO6ooYFLYCVHIyptasKBBawC+uX2Z3+7dzNZuYGiIt48PBgYGHD50iD1//KGPmEKIYiJdm8WwoEOcionCXGPIxsYdqWVpS/C5c4wfO5bMzEw6de7M+IkT5b7dUiBXhV1GRgYdOnTg6tWrBZVHiFKhfdkKDKpWH4ApIce4nhiXrb1mrVp88umnACz09eXB/fuFnlEIUfRlarWMDv6Lww/uYqLWsK5xB+pb23Pt2jVGjRhBamoqzVu0wGfmTDQajb7jikKQq8LO0NCQ4ODggsoiRKkyvHpDmtk6kZSVybBzh0jOzMjW3rdvX1xdXYmPj2fO7NkyJSuEyEarKEwOOcbeqDAMVWpWu7enia0jd+7cYdjgwcTHx1O/QQN8Fy7E0NBQ33FFIcn1VOxHH33Ehg0bCiKLEKWKgVrNErc2lDUy5WpiLN6hJ7MVbwaGhkz38cHQ0JC//P35/bff9JhWCFGUKIrCjNCT7Ii4jkalYnnDtrS2L8+DBw8YNngwDx48oHqNGixZtgxTU1N9xxWFyCC3X8jMzGTjxo3s37+fxo0bY25unq198eLF+RZOiJKurLEpS9za0Of0PnZEXMfD1oEeFWrp2mvUqMHAzz5j9cqVLPT1pUnTprJ1nxClnKIoLLhyhq23L6MCfOu1oqNDJRISEhg+ZAh37tzBuXx5Vq5ahbW1tb7jikKW6yt2Fy5coFGjRlhaWnLlyhXOnj2rez1rD1khxIs1s3NidE13AHxCTxIS/zBb+8d9+lCnbl0SExOZM2uWTMkKUcqtvhHMulsXAJhRpwVvOlcjNSWFUSNGcPXqVcrY27Nq9Wrsy5bVc1KhDy+180RpIjtPiIKkVRQ+P3uQP+/foZKpJTtb/A9LQyNd+40bN/ioVy8yMjKY5uXFm9276zGtEEJfvrp1kTmXHy+TNMnFgwFV6pKRkcHY0aM5dvQolpaWfLluHTVr1fqPkURxUig7T1y7do29e/eSkpICIFcRhHgJapUK33qtKG9iTnhKAhMuHM32/6lq1arx+aBBACxetIjIyEh9RRVC6MlPd67qirrh1d0YUKUuWq0WHy8vjh09irGJCUuWLZOirpTLdWH38OFDOnToQK1atejWrRv37t0DwNPTkzFjxuR7QCFKCxsjY5Y3bIehSo1fdDhfhV3M1t7744+pX78+SYmJzJ45U/6YEqIU2X3vJlNCjgHgWaUuQ6u7Pb7Xbv589u7Zg8bAAN8FC3Br2FC/QYXe5bqwGzVqFIaGhoSHh2NmZqb7/IMPPmDPnj35Gk6I0qaBtT2TazcBYMGVQM7EROvaNBoN0729MTIy4sTx4/yyc6eeUgohCtOB6HDGnf8LBehVsRYTajVGpVLx5Rdf8PNPP6FSqZgxcyYtX3lF31FFEZDrwm7fvn3Mnz+fChUqZPu8Zs2ahIWF5VswIUqr3hVdeN2pCpmKwvBzh3mYnqprq1K1qm5LoKWLFxP59xVzIUTJdPRhBMOCDpOpKHQvVw1v1+aoVCq++/ZbNqxbB8D4iRPp3KWLnpOKoiLXhV1SUlK2K3VPPHr0CGNj43wJJURpplKpmFW3JdXMrYhKS2Zs8F9kKVpde68PP6SBmxtJSUnMnDFDpmSFKKECY6IZdPZPMhQtnRwqMa/eK6hVKn7bvZvFCxcC8Pngwbz3/vt6TiqKklwXdq1bt2bLli269yqVCq1Wi6+vL+3bt8/XcEKUVhYGhqxwa4eJWsORhxGsvv7/O748mZI1Njbm1MmT7Ni2TY9JhRAFIST+IZ+c2U9KViatyzizxK0NBmo1hw8fZqaPD/D4j7wBnp56TiqKmlwXdr6+vqxdu5bXXnuN9PR0xo8fT7169fD392f+/PkFkVGIUqmWpS0z6rQAYMX1cxx5EKFrq1y5MoOHDgVg2dKlREREPHMMIUTxczUxlv4BfiRmZuBh68Aq9/YYqzUEBgYyecIEsrKyeP2NNxg5ejQqlUrfcUURk+vCrl69ely5coVWrVrRvXt3kpKSeOeddzh79izVq1fP1Vj+/v688cYbODs7o1Kp2PmPm8EzMjKYMGEC9evXx9zcHGdnZ/r06fPUL7BHjx7Ru3dvrKyssLGxwdPTk8TExGx9goODad26NSYmJlSsWBFfX9/cnrYQevF2+er0KF8TBRgd7M+91CRdW89evXB3dyc5OZmZPj5otdrnDySEKBbCkuPpF7CPmIw06luVYW2jDphqDLgUGsqYkSNJT0+nTdu2TJ02DbU6zyuWiRIsT/8qrK2tmTJlCj/++CO///47s2bNoly5crkeJykpCTc3N1atWvVUW3JyMmfOnGHatGmcOXOG7du3c/nyZd58881s/Xr37k1ISAh+fn7s3r0bf39/Pv30U117fHw8nTt3pnLlygQGBrJgwQK8vb1Zu3Zt7k9cCD2Y5toUV0s7YjLSGHnuMBl/F3BqtZppXl4Ym5gQcPo0237+Wc9JhRAv415KEn1P7yM6LYVaFjZsaNwRSwMjwsLCGD50KElJSTRq3Jg58+ZhYJDrHUFFKZGnnSdiYmLYsGEDoaGhANSpU4f+/ftjZ2eX9yAqFTt27OCtt956bp/Tp0/TtGlTwsLCqFSpEqGhodSpU4fTp0/j4eEBwJ49e+jWrdvjvfKcnVmzZg1TpkwhMjISI6PHK/lPnDiRnTt3cunSpRznk50nhD6FJcfz1vHdJGZm4FmlDhNdmujafvj+exb6+mJiYsJ3P/741BPrQoii70FaCh+e2sPN5HiqmFnxbdOulDU2JTIykoEDBhAZGUnt2rVZs3YtFhYW+o4rClmB7jzh7+9PlSpVWL58OTExMcTExLB8+XKqVq2Kv79/nkPnRFxcHCqVChsbGwCOHz+OjY2NrqgD6NixI2q1mpMnT+r6tGnTRlfUAXTp0oXLly8TExPz3GOlpaURHx+f7SWEvlQ2s2JevcdrVG24dRG/qHBd2/s9etCocWNSU1NlSlaIYig2PY3+AX7cTI7H2cSczR6dKGtsSmxMDMMGDyYyMpJKlSuzbOVKKerEf8p1YTdkyBA++OADbt68yfbt29m+fTs3btygZ8+eDPl7fa2CkJqayoQJE+jVq5euWo2MjMTBwSFbPwMDA+zs7HRbLkVGRuLo6Jitz5P3L9qWae7cuVhbW+teFStWzM/TESLXujhWZkDlOgBMuHCEsOTHf2w8mZI1NTXlTGAgP/34oz5jCiFyITEzA88z+7mUGIO9kQmbPTrjbGpBUlISw4cN49atWzg4OrJq9eqXmhUTpUeuC7tr164xZswYNBqN7jONRsPo0aO5du1avoZ7IiMjgx49eqAoCmvWrCmQY/zbpEmTiIuL071u375dKMcV4kXG1mpMI5uyJGRmMDzoMGlZWQBUqFCBYSNGALBi+XJuh4e/aBghRBGQmpXJ52cOEhz3ABtDYzZ7dKaKuRVpaWmMHT2a0IsXsbaxYeWqVTjl4T52UTrlurBr1KiR7t66fwoNDcXNzS1fQv3Tk6IuLCwMPz+/bHPLTk5OREdHZ+ufmZnJo0ePcHJy0vWJiorK1ufJ+yd9nsXY2BgrK6tsLyH0zVCtZqlbW2wNjbmY8IiZl07p2t597z08mjQhLTWVGd7eMiUrRBGWrs1iaNAhTsZEYq4xZGPjjtSytCUzM5OpkycTcPo0ZmZmLF+5kqrVquk7rihGclTYBQcH617Dhw9nxIgRLFy4kCNHjnDkyBEWLlzIqFGjGDVqVL6Ge1LUXb16lf3791OmTJls7S1atCA2NpbAwEDdZwcPHkSr1dKsWTNdH39/fzIyMnR9/Pz8cHFxwdbWNl/zClEYypmYs6hBa1TAD3eusDPiOvD/U7JmZmYEBQXx/Xff6TeoEOKZMrVaxgT/xeEHdzFRa1jXuAP1re1RFIW5s2dz6M8/MTQ0ZOHixdSpU0ffcUUxk6OnYtVqNSqV6j+3LlKpVGT9PTWUE4mJibrpW3d3dxYvXkz79u2xs7OjXLlyvPfee5w5c4bdu3dnu0/Ozs5O9zDEa6+9RlRUFF988QUZGRn0798fDw8Pvv32W+DxAxcuLi507tyZCRMmcOHCBQYMGMCSJUuyLYvyX+SpWFHULL8WxIrr5zDVGLCteTdqWjz+Q2X7zz8zd84cjI2N2fr991SuXFnPSYUQT2gVhYkXjrIj4jqGKjVfNnqV1vblURSF5UuX8s3XX6NWq5m/YAHtZDcn8bfc1CA5KuzCwsJyfPDc/BI5dOjQM7ch69u3L97e3lStWvWZ3/vzzz9p164d8HiB4qFDh7Jr1y7UajXvvvsuy5cvz/bkUHBwMEOGDOH06dPY29szbNgwJkyYkOOcIIWdKHqyFC0DAvdz7OE9qplbs73565gbGKIoCkMHD+bUyZM0cHNj7fr12e6JFULoh6Io+ISeZOvty2hUKla4taOTYyUANn31FatWrABgmpcXb3bvrs+ooojJ98JOSGEniqaHaSl0P76LqLQUXneqwpIGbVCpVETeu0fPHj1ISkpixKhRfPTxx/qOKkSppigKC6+eYe3NC6iABfVb09358b1z27dtY+7s2QDy/1fxTAVe2EVERHDkyBGio6OfukF7+PDhuR2uWJDCThRVgTHR9D69hyxFwdu1Gb0r1QZg544dzJ45EyMjI7Z+9x1VnnMFXAhR8FZfD2bJtbMAzKzTgp4VawGw38+PyRMnoigK/fr3Z8iwYfqMKYqoAi3sNm3axGeffYaRkRFlypTJtgGxSqXixo0beUtdxElhJ4qyDbdCmHc5AEOVmh+avaa7EXv40KGcOH6cevXqsf6rr2RKVgg92BR2kdmXTgMw0cUDzyp1AThx/DijRowgMzOTd959l4mTJ2f7nSrEEwW688S0adOYPn06cXFx3Lp1i5s3b+peJbWoE6KoG1C5Dp0cKpKhaBl+7jBxGWmoVCqmTp+OuYUFFy5cYOvXX+s7phClzk93ruqKuuHV3XRF3fngYMaNGUNmZiYdO3Vi/MSJUtSJfJHrwi45OZmePXuiVuf6q0KIAqJSqZhXrxUVTS24k5LIuPNH0CoKjo6OjB4zBoAv1qyRP76EKES7791kSsgxADyr1GFo9cdrvV67do2Rw4eTmppK8+bNmTFrllxNF/km19WZp6cnP/30U0FkEUK8BCtDI1Y0bIeRWs2f9++w7uYFAN54801eadWKjIwMfLy8yMzM1HNSIUq+A9G3GXf+LxSgZ4VaTKjlgUql4u7duwwbPJj4+Hjq16+P76JFGBoa6juuKEFyfY9dVlYW//vf/0hJSaF+/fpP/YNcvHhxvgYsKuQeO1FcfH/7CtMuHkejUrHFozNN7R7v0PLBe++RmJjI4KFD6T9ggL5jClFiHXt4j4Fn9pOu1fJmuWosqN8KtUrFgwcPGDhgAHfu3KF6jRp8uW4d1tbW+o4rioECvcdu7ty57N27l6ioKM6fP8/Zs2d1r6CgoLxmFkLkkw8q1KR7uWpkKQojz/lzPy0FBwcHxo4fD8DaL74osH2dhSjtzsRE8/nZg6RrtXRyqMj8eq+gVqlISEhg+NCh3LlzB+fy5VmxapUUdaJA5PqKna2tLUuWLKFfv34FFKlokit2ojhJzszgvZO/czUxluZ2Tmzy6IQaFWNGjeIvf39cXV3ZuGkTBjIFJES+CYl/yMen95KQmUGrMs580ehVjNUaUlNSGDpkCOeCgrArU4b1GzZQsVIlfccVxUiBXrEzNjbmlVdeyXM4IUTBMzMwZLlbW8w0Bpx4FMmya0GoVComT5mClZUVoaGhbN68Wd8xhSgxribG0j/Aj4TMDDxsHVjt3h5jtYbMjAwmTpjAuaAgLCwsWLlqlRR1okDlurAbMWIEK/7e9kQIUXTVsLBhVt0WAKy5cZ7D9+9gX7asbkp2/dq1XL1yRZ8RhSgRwpLj6Rewj5iMNOpblWFtow6YagzQarV4e3tz9MgRjE1MWLp8OTVr1dJ3XFHC5Xoq9u233+bgwYOUKVOGunXrPvXwxPbt2/M1YFEhU7GiuPK+eIKtty9jY2jMLy3+RzkTc8aPHcuhP/+klosLm7dskSlZIfLoXmoSvU7+wd3UJGpZ2PBNky7YGpmgKAoL5s/npx9/RGNgwKIlS2S2S+RZgU7F2tjY8M4779C2bVvs7e2xtrbO9hJCFC2TajehvlUZYjPSGH7uMBmKlgmTJmFtbc2Vy5f5auNGfUcUolh6mJZCv4B93E1NorKZJZs8OmNrZAI8fkjppx9/RKVS4TNjhhR1otDkaa/Y0kiu2Ini7HZyAm8d3018Zjp9KrkyzbUp+/buZcqkSWgMDNj89de4uLjoO6YQxUZcRhofnd7LpYQYypmY813TrpQ3tQDg++++Y9GCBQCMnziR93v00GdUUQIU6BU7IUTxU9HMEt/6rQDYEh7KH5G36NS5M6926EBWZiY+06eTkZGh55RCFA+JmRl4Bu7nUkIM9kYmbPHorCvqft+9W1fUfTZokBR1otDl+opd1apVX7ifXUndskiu2ImSYMGVQNbevIC5xpAdLV7HOi2LD957j9jYWDwHDuTzQYP0HVGIIi01K5NPAg9wMiYSG0NjvmnSBRdLWwD8Dx9m/NixZGVl0bNXL0aPHSv7v4p8kZsaxCC3g48cOTLb+4yMDM6ePcuePXsYN25cbocTQhSiUTXcORt7n9MxUQwLOsxPzbsxYdIkJk2YwKaNG2nbti2uderoO6YQRVK6NouhQYc4GROJucaQjY076oq6M4GBTJ44kaysLLq9/jqjxoyRok7oRb7dY7dq1SoCAgL46quv8mO4Ikeu2ImSIjotmTeP7eJheirvlq/BvHqvMGnCBPb7+VG9Rg22fPMNRkZG+o4pRJGSqdUyKtifPVFhmKg1bPToRBNbRwAuX7rEZ59+SlJiIq3btMF3wQJ50lzkK73cY/faa6+xbdu2/BpOCFFAHIzNWNqgDWpUbLt7jZ/uXGX8xInY2tpy/do11q9dq++IQhQpWkVhcsgx9kSFYahSs9q9va6oCwsLY9iQISQlJuLeqBFz5s2Tok7oVb4Vdj///DN2dnb5NZwQogA1L1OOETUaAuATepJIjcLEyZMB2LxpEyEhIXpMJ0TRoSgKM0NPsiPiOhqViqVubWhtXx6AqKgohg4aRExMDC61a7N4yRJMTEz0nFiUdrm+x87d3T3bfQOKohAZGcn9+/dZvXp1voYTQhScz6vV50xsNIcf3GX4ucNsb/s6Xbp2Ze+ePfh4efH11q0YGxvrO6YQerXo6hm+uX0ZFTC/3it0dqwMQGxMDMMGDyYyMpJKlSuzfOVKLCwt9RtWCPJQ2L311lvZ3qvVasqWLUu7du2oXbt2fuUSQhQwtUrFgvqt6H58N7eS45l84Rgzxo3j9OnT3Lxxg7Vffsmw4cP1HVMIvVlzI5gvb14AwKdOc7o7VwcgKSmJEcOHc/PmTRwcHVm5apXMWIkiQxYoziF5eEKUVEGx9/nw1B4yFC1Tajeh6s1oxo4ejVqtZv3GjdRv0EDfEYUodJvDQpl16RQAE1088KxSF4D09HRGDh/O6VOnsLaxYd369VStVk2fUUUpIAsUCyFyrKFNWSa4eAAw/3IAVg3r8lq3bmi1WmZ4e5OamqrnhEIUrp/uXNUVdcOqu+mKuszMTKZOnszpU6cwMzNj2YoVUtSJIifHhZ1arUaj0bzwZWCQ65ldIUQR0KdSbV5zrEymojDi3GE8Rw6njL09t27d4ss1a/QdT4hC89u9m0wJOQbAgMp1GFbdDXh8P/m8OXP48+BBDA0NWbBoEXXr1tVnVCGeKcdTsb/88stz244fP87y5cvRarUl9q97mYoVJV1CZjrvHP+NW8nxtC7jTJ9EQ8aNHo1KpWLdxo24ubnpO6IQBepA9G2GBv1JpqLwQYVazKzTXPew4PKlS/l6yxbUajXzfH1p/+qrek4rSpPc1CAvdY/d5cuXmThxIrt27aJ3797MmDGDypUr53W4Ik0KO1EaXEp4xHsnfidNm8XIGg25v2U7v+3aRaVKldj63XeYmJrqO6IQBeLYw3sMPLOfdK2WN8pVZUH9VmhUjye1Nm/axMrlywGYNn06b/7rIUIhClqB32MXERHBwIEDqV+/PpmZmQQFBbF58+YSW9QJUVrUtrTDu04zAJZfO0frgX0oW7Ys4eHhrJHljEQJdTY2mkFnD5Ku1dLJoSLz6/1/Ubdj+3ZdUTd85Egp6kSRl6vCLi4ujgkTJlCjRg1CQkI4cOAAu3btol69egWVTwhRyN4rX5P3ytdAi8KUqwEMnjIJgO++/ZazZ87oOZ0Q+Ssk/iGegftJzsqkVRlnlri1xVD9+Ffjgf37mTdnDgB9+/fn4z599BlViBzJcWHn6+tLtWrV2L17N9999x3Hjh2jdevWBZlNCKEnXq7NqG1hy8P0VLaapPC/7t0fr8Dv40NKSoq+4wmRL64mxtI/wI+EzAw8bBxY7d4eY7UGgJMnTjB18mS0Wi1vv/MOQ4YO1XNaIXImx/fYqdVqTE1N6dixIxqN5rn9tm/fnm/hihK5x06UNreS4nnr+G6SsjLo51yLY+NnEB0VxQe9ejF23Dh9xxPipYQnJ/DhqT+ISkuhnlUZtnh0xtLQCIAL588z+PPPSUlJoWOnTsyaM+eFv/eEKGgFco9dnz596NGjB3Z2dlhbWz/3JYQoGaqYWzG3XksANkVcodukUQD88N13BAYG6jOaEC/lXmoSfQP2EZWWQk0LGzY27qgr6q5fv86IYcNISUmhWfPm+MycKUWdKFZk54kckit2orSaFXqKzeGhWBkY0SngJgd++JnyFSrw7fffY2Zmpu94QuTKw7QUPjy9hxtJ8VQ2s+Tbpl1xMH787zgiIoJP+vfn/v371K9fn5Vr1si/cVEkyM4TQoh8M96lMQ2tyxKfmc7FV+riUN6Zu3fu6J4UFKK4iMtIo1+gHzeS4ilnYs5mj866ou7hw4cMHTSI+/fvU616dZYsXy5FnSiWpLATQryQkVrDMrc22BgaE5oUS8XRAwH46ccfOX3qlJ7TCZEziZkZfBJ4gEsJMdgbmbDZoxPlTS0ASEhIYNiQIdy+fRtnZ2dWrl4ttxaJYksKOyHEf3I2tWBR/daogAPpsTQc+DEAs2bMICkpSb/hhPgPqVmZfH7mIEFx97ExNGaTR2eqmj8u3FJTUhg9YgRXr1zBrkwZVq5eTdmyZfWcWIi8k8JOCJEjbcqWZ1C1BgCcrFEWuzq1iIiIYMWyZXpOJsTzpWuzGBp0iJMxkZhrDNnQuCMulrYAZGZkMGnCBIKCgrCwsGDFqlVUrFRJz4mFeDlS2Akhcmx4DTda2DmRos0irW93FEMDtv38MydPntR3NCGekqnVMjb4Lw4/uIuJWsPaRq/SwNoeAK1Wi7e3N0eOHMHYxIQly5ZRq1YtPScW4uVJYSeEyDGNSs3iBm1wMDblrjadsiMHoACzfHxITEzUdzwhdLSKwpSQY/wRFYahSs1q9/Y0tXMCQFEUFi1YwN4//kBjYMB8X18aurvrObEQ+UMKOyFErtgbm7LUrS0alYprdqaYdW5FZGQky5Ys0Xc0IYDHhdusS6fYHnEdjUrFErc2tLYvr2tf9+WX/PjDD6hUKrx9fHilVSs9phUif0lhJ4TItSa2joyu2QiA++09yHQuy84dOzh+7JiekwkBi6+e5evwS6iA+fVeoYtjZV3b9999x7q1awEYO348XV97TU8phSgYUtgJIfLkkyp1ebVsBTJRUH36AVoTY2bNnEliQoK+o4lSbM2NYL64eR4AnzrN6e5cXdf2+2+/sWjBAgA+/fxzenzwgV4yClGQpLATQuSJWqXCt34rKphakGCsQfn4TaKioliyeLG+o4lSanNYKIuvngVgQq3G9Kroomv7y9+fGd7eAHzQqxefDByoj4hCFDgp7IQQeWZtaMwKt3YYqtQkVHMmvXUjfv3lF44eOaLvaKKU+enOVWZderxg9tDqbnxStZ6u7UxgIJMmTCArK4vXunVj9JgxqFQqfUUVokBJYSeEeCn1rMswpXYTAFJfa0VmZWdmz5xJfHy8npOJ0uL3yFtMDTkOQP/KdRhe3U3XdvnSJUaPGkVaWhqt27RhupcXarX86hMll/zrFkK8tA8ruvBGuaooKhWpH/2PqOREFi9apO9YohQ4GH2bMcH+aFH4oEJNJrl46K7GhYeHM3zoUJISE3Fv1Ig58+ZhYGio58RCFCy9Fnb+/v688cYbODs7o1Kp2LlzZ7b27du307lzZ8qUKYNKpSIoKOipMVJTUxkyZAhlypTBwsKCd999l6ioqGx9wsPDef311zEzM8PBwYFx48aRmZlZgGcmROmiUqmYWacF1c2tybQwJblnV3bv3o3/4cP6jiZKsOMP7zHs3CEyFYU3ylXFp05zXVEXFRXF0EGDePToES61a7N4yRJMTEz0nFiIgqfXwi4pKQk3NzdWrVr13PZWrVoxf/78544xatQodu3axU8//cThw4eJiIjgnXfe0bVnZWXx+uuvk56ezrFjx9i8eTObNm1i+vTp+X4+QpRm5gaGrGjYDlONAZk1KpHaoRlzZ88mLi5O39FECXQ2NprPzx4kXaulo0NF5tdrhUb1+FdabGwsw4YM4d69e1SqVInlK1diYWmp58RCFA6VoiiKvkPA47/4d+zYwVtvvfVU261bt6hatSpnz56lYcOGus/j4uIoW7Ys3377Le+99x4Aly5dwtXVlePHj9O8eXP++OMP/ve//xEREYGjoyMAX3zxBRMmTOD+/fsYGRnlKF98fDzW1tbExcVhZWX10ucrREn1S8R1xp4/AoqC+Vc7ebNmPWbMmqXvWKIECYl/yMen95KQmcErZcrxZaMOGKs1wOMLAkMGDSLkwgUcHBxYv3Ej5Zyd9ZxYiJeTmxqkWN9jFxgYSEZGBh07dtR9Vrt2bSpVqsTx449vpD1+/Dj169fXFXUAXbp0IT4+npCQkELPLERJ1925Oj0r1AKViuQPuvLbUX8OHzqk71iihLiWGEv/AD8SMjPwsHFgdcP2uqIuPT2dcWPGEHLhAtbW1qxYvVqKOlHqFOvCLjIyEiMjI2xsbLJ97ujoSGRkpK7PP4u6J+1P2p4nLS2N+Pj4bC8hRM5Mrd2UulZ2KOamJPV6jdlz5xAbG6vvWKKYC09OoF/APmIy0qhnVYa1jTpgZvD4YYisrCymTZnC6VOnMDU1ZdmKFVSrVk3PiYUofMW6sCtIc+fOxdraWveqWLGiviMJUWwYazQsd2uHpcaQrMrORDR1ZaGvr75jiWIsMjWJvgH7iEpLoYa5NRsad8TS8PGtNIqiMHf2bA4eOIChoSELFy+mbr16/zGiECVTsS7snJycSE9Pf+pKQFRUFE5OTro+/35K9sn7J32eZdKkScTFxelet2/fzt/wQpRwlcws8W3weHP1tFaN2HX7KgcPHNBzKlEcPUxLoW+AH3dSEqlkasnmJp2xM/r/J1xXLl/OLzt3olarmTVnDk2bNdNjWiH0q1gXdo0bN8bQ0JAD//hlcfnyZcLDw2nRogUALVq04Pz580RHR+v6+Pn5YWVlRZ06dZ47trGxMVZWVtleQojc6ehQCc8qdQFIfq8TM1evICYmRs+pRHESl5FGv0A/biTFUc7EnC1NOuNgbKZr37JpE1s2bwZg8tSpvNqhg76iClEkGOjz4ImJiVy7dk33/ubNmwQFBWFnZ0elSpV49OgR4eHhREREAI+LNnh8pc3JyQlra2s8PT0ZPXo0dnZ2WFlZMWzYMFq0aEHz5s0B6Ny5M3Xq1OHjjz/G19eXyMhIpk6dypAhQzA2Ni78kxailBlTsxFnY6I5w30i/teKub7z8Z07T9+xRDGQmJnBJ4EHuJQQg72RCZs9OlHe1ELXvnPHDlYsXw7A8BEj6P6MVRWEKG30esUuICAAd3d33N3dARg9ejTu7u66NeZ+/fVX3N3def311wHo2bMn7u7ufPHFF7oxlixZwv/+9z/effdd2rRpg5OTE9u3b9e1azQadu/ejUajoUWLFnz00Uf06dOHGTNmFOKZClF6GarVLGvYFmu1AVrnsvxmlsV+Pz99xxJFXGpWJoPOHiQo7j7WBkZs8uhMVXNrXfvBAweYO3s2AH369ePjvn31FVWIIqXIrGNX1Mk6dkK8nKMPI+h3eh+oVNj/doTfvOdjZ2en71iiCErXZjEk6BCH7t/BXGPAZo/OuNmU1bWfPHmSUcOHk5GRwVtvv83kqVN1O04IURKVmnXshBDFxytlnBlarQEADzo1Y/LyxcjfleLfshQt484f4dD9OxirNXzZqEO2ou7C+fOMGz2ajIwMOnTsyMTJk6WoE+IfpLATQhSaYTXdcTexBiND/qxhz659e/QdSRQhWkVh8oVj/B55C0OVmtUN29PM7v9XL7h+/Tojhw8nJSWFZs2bM2PWLDQajR4TC1H0SGEnhCg0apWKNS26YpmpoC1ry7TQk9y/f1/fsUQRoCgKsy6dYnvEdTQqFUvc2tCmbHlde0REBMMGDyYuLo569erhu3BhjreEFKI0kcJOCFGoyhiZ8GWzzqi0WpJdq/LZ1rUyJStYfPUsX4dfAmBevVfo4lhZ1/bw4UOGDhrE/fv3qVqtGkuWL8fMzOx5QwlRqklhJ4QodE3snfG0rwrA+Zrl+PKPX/WcSOjTFzfO88XN8wB4uzbjLefqurbEhASGDx3K7du3cXZ2ZuXq1U9tIymE+H9S2Akh9GK8R1tqJWvBQMPSxDtcv3dX35GEHmwJC2XR1TMAjK/VmN6VauvaUlNTGT1yJFcuX8bOzo4Vq1fj4OCgr6hCFAtS2Akh9EKlUvFN1x6YxCeRZW1Bn/3byNJq9R1LFKKf715l5qVTAAyp1oCBVf9/f9fMjAwmTZjA2bNnMbewYPmqVVSqVElfUYUoNqSwE0Loja2pOQvrtISMTKIdrBmzZ5u+I4lC8nvkLaZcOA5Av8qujKjRUNem1WqZ4ePDkb/+wtjYmCVLl+Li4qKnpEIUL1LYCSH0qkvdhnRLfPyfot9Uiey5HqrnRKKgHYy+zZhgf7Qo9Chfk8kuTXRr0SmKwuJFi/jj99/RGBgwz9cX90aN9JxYiOJDCjshhN4tfPcjyl6PALWasReOEpWapO9IooAcf3iPYecOkakovFGuKjPqNs+2wPD6dev44bvvAPDy9qZV69b6iipEsSSFnRBC7wwNDVnf+T00UQ9JMzGk7587yJT77Uqcs7HRfH72IOlaLR0dKjK/Xis0qv//NfTj99+z9u+9wMeNH89r3brpK6oQxZYUdkKIIqFOjZp8qrKDtHSuq7OYfe6IviOJfHQx/hGegftJzsqkZZlyLG3QFkP1//8K2vPHHyzw9QXg088+o0fPnvqKKkSxJoWdEKLIGPHhx7icvgzAN9E3ORh9W8+JRH64nhhH/0A/EjIzaGzjwJqG7TH+x1ZgR48cwdvLC4APevbkk08/1VdUIYo9KeyEEEWGRqNh5YAhmJ58vFjtyDMHuZOSqOdU4mXcTk6gb8A+HqWnUtfKjnWNOmBmYKhrDzp7lgnjxpGVmclr3boxeuzYbPfcCSFyRwo7IUSRUqVqVUZXbYDmdiQpKhh82o80bZa+Y4k8iExNok/APqLSkqlhbs3Gxp2wNPz//V2vXLnCqBEjSEtLo1Xr1kz38kKtll9LQrwM+X+QEKLI+fjD3jQ+exNVciqhKfHMu3Ra35FELj1MS6FvgB93UhKpZGrJ5iadsTMy0bXfDg9n2JAhJCYm4u7uztz58zEwNHzBiEKInJDCTghR5Gg0GuaMn4T1joMAfHP7Mr/du6nnVCKn4jPS6R+4nxtJcTiZmLGlSWccjM107dHR0QwdPJhHDx9Sy8WFxUuXYmJi8oIRhRA5JYWdEKJIqly5MqO6vInxn4+v1k26cJQbSXF6TiX+S1JmBp6B+wlNeEQZIxO2eHSmvKmFrj0uLo5hQ4YQERFBxYoVWb5yJRaWlnpMLETJIoWdEKLI6tmrF83uJ6O5cYcUbRbDgg6RkpWp71jiOdKyshh09iBBcfexNjBik0cnqppb69qTk5MZOWwYN65fx8HBgZVr1lCmTBk9Jhai5JHCTghRZKnVary9vLHdfhBVfBJXEmPxungCRVH0HU38S4ZWy7Bzhzj+KBJzjQEbGnektqWdrj09PZ3xY8dy4cIFrK2tWbF6Nc7OznpMLETJJIWdEKJIq1ipEiM9B2L2/R+g1bIj4jo/3b2q71jiH7IULWPP/8Wf9+9grNbwZaMOuNmU/f/2rCy8pk3j5IkTmJqasmzFCqpVq6bHxEKUXFLYCSGKvPd79KCZnRMm+44D4BN6kovxj/ScSgBoFYUpIcf5PfIWhio1qxu2p5mdk65dURTmzZnDfj8/DA0NWbB4MXXr1dNjYiFKNinshBBFnlqtZpqXFzanQjC4dJN0rZZhQYdIyEjXd7RSTVEUZl06xba711CjYnGDNrQpWz5bn1UrV7Jzxw7UajWz5syhWbNmekorROkghZ0QolioUKECw0eMwOzHvahjEwhPSWDChaNyv50eLbl2lq/DLwEwr94rdHWqnK396y1b2PzVVwBMmjKFVzt0KPSMQpQ2UtgJIYqNd997j6Z162O29TdUWVr8osPZFHZR37FKpS9vnGfNjcdbv3m7NuPt8tWztf+6cyfLly4FYNjw4bz19tuFHVGIUkkKOyFEsaFWq5nm7Y3VowRMfjsMgO+VQM7EROs5WenydVgoC6+eAWBcrcb0rlQ7W/vBAweYPWsWAH369qVPv36FHVGIUksKOyFEseLs7MyIkSMxOh6M8YVrZCoKw88d5mF6qr6jlQrb7l5jxqVTAAyp1oBPq2Z/EOLUyZNMnTwZrVZL97ffZujw4fqIKUSpJYWdEKLYefvdd2nWrBkmP+3DND6ZqLRkxgb/RZai1Xe0Eu2PyFtMvnAMgH6VXRlRo2G29pCQEMaNGUNGRgavdujApMmTUalUekgqROklhZ0QothRqVRMnTYNC0MjDDZux0CBIw8jWH39vL6jlVh/3r/D6OD/a+/O42O69z+OvyaTZBLZI5FFrNWm1og9qpaKra2ifl3UtVWpJbbatcQesYu9vS2q1U2rermo2oKSRgixb1FBFoREEtlmvr8/1NyOWIIwMf08H495PMz5fs85n++Rmbxz1kgMKN4u/Txj/OuahLb4s2cZNGAAWVlZ1Ktfn0lTpqDVas1YsRD/TBLshBDPJB9fXwZ/9BHa5KvYr9kCwPwzsey+esnMlVmevVcTCYndRr5SvO5dgYlVG5iEusRLlwjp14+069epWq0aM2bNwtbW1owVC/HPJcFOCPHMate+PQ2CgtBGH8br9EUU8NGhnSRlZ5q7NItx4PplPjywlVyDgeaeZZhevRFazf9+daSmphLSrx8pKSlUqFiRuRERlChRwowVC/HPJsFOCPHM0mg0fDx2LA6OjmSvWINXniI1N5vBByPJM8j5do/raHoqH8T8RpY+n4buPswLaIKN1f9+bWTcuMHAkBDOnz+Pj48PCxYtwtXV1XwFCyEk2Akhnm3e3t58NHQomnw9eQu/poSVlpjrKcz663Yc4tGcyUijR8xm0vNzqe1aisWBzdD97Zy57OxsPhoyhBPHj+Pu7s6CxYspVaqUGSsWQoAEOyGEBWj7xhu81KgRhuSrlNl2K9B9fu4Im5PPm7myZ1NC1g267fuV1Nxsqjq781mt5pSwtjG25+flMWbUKA7s34+DoyMRCxZQtmxZM1YshLhNgp0Q4pmn0WgY88knODo6krxxO/Uybh2GHXl4F+ezbpi5umdLUnYmXff9SnJOFpUcXPiidgucbP53IYTBYGDSxInsjIxEp9MxZ+5c/F988T5LFEI8TRLshBAWoVSpUgwbMQKAMzOWUlnnxI38PAbEbidHrzdzdc+Gq7nZdNu3mQs3Myhr78TyOi1xt7UztiulmDNrFv9dvx6tVktYeDiBtWqZsWIhxJ0k2AkhLMarr71Go5dfRp+bi/3X63Cz0XH0RiqT/3pSgri39LxceuzbzNnMNLztSrCibku87Eyvbv383//m22++ASB0wgRebtzYHKUKIe5Dgp0QwmLcPiTr7OzM2ZhYWl7MRAN8e+Ekay+dMXd5xVZmfh4f7P+NYzdSKWlrx4o6LfGzdzTp88P337N08WIAho0YQZtXXzVHqUKIB5BgJ4SwKJ6ensZDslvmL6WTqx8AY4/u5VTGNXOWVizl6PX0PbCVA9cv42xty7LaLajo4GLSZ9PGjcwIDwegV+/evPPuu+YoVQhRCBLshBAWp3WbNjRp2pT8/HxOzfs3QW7e3NTnExK7g8z8PHOXV2zkGQwMOLidPalJOGit+bx2MJWd3U367N61i9Bx41BK8fY779Drww/NVK0QojAk2AkhLI5Go2HUmDG4uLhw6vgJah08h5fOnrOZaXxyZA9KKXOXaHZ6ZWB43E62Xb6AzkrL0lrNqenqadIn9sABRo4YgT4/n9Zt2jB0+HCTR4kJIYofCXZCCIvk4eHBiFGjAPj2s8/5yK0CWo2GdUnxrEo4YebqzMugFJ8c2cP6pHPYaKxYWLMp9d29TfqcPHmSIYMGkZOdTaNGjQgdPx4rK/mVIURxJ59SIYTFatGyJc1eeQV9fj6rp85kyHM1AZhyPJq4tCvmLc5MlFJMOR7N6ounsULD7BqNaeLpZ9In4fx5BvTvT0ZGBjVr1iQsPBxrG5t7LFEIUZxIsBNCWKzbh2RdXV05deoUhl9306JUGfKUgYEHd5CWl2PuEp+6OacP8OX5YwCEVWtIa+9yJu2XL18mpF8/Uq9e5fkXXmD2vHnY2dubo1QhxCOQYCeEsGju7u6MHD0agBVffEEPGw/K2Dty4WYGI+J2YfgHnW+39Gwci8/GATC+cn3eLF3JpD0tLY2Qfv24dOkSZcqUYf7ChTg5OZmjVCHEI5JgJ4SweMEtWhDcogV6vZ5ZEyczu+pL2FpZsfXyBf597oi5y3sqVv55jJmnbj1Hd/gLtelc1vQxYDdv3mTIwIGcPXMGT09PFixeTMmSJc1RqhDiMZg12EVGRtK2bVt8fX3RaDT8/PPPJu1KKcaNG4ePjw/29vYEBwdz6tQpkz6pqal07twZZ2dnXF1d6dmzJxkZGSZ9Dh06xMsvv4ydnR1lypRh+vTpT3poQohiZsSoUbi5uXHm9Gl+/2Y1Y1+sD8DsU/v5IzXJzNU9WT9ePM3Ev56+0a9iDXpXqGbSnpuby4ihQ4mLi8PFxYX5ixbh6+trjlKFEI/JrMEuMzOTgIAAFi5ceNf26dOnExERwZIlS4iKisLBwYFWrVqRnZ1t7NO5c2eOHDnC5s2bWbduHZGRkfTu3dvYnp6eTsuWLSlXrhwxMTHMmDGD8ePH8+mnnz7x8Qkhig83NzdGjRkDwIrly6mWlks7n4rolWLIoUiu5Nw0c4VPxoakc4w5/DsA3cpWZnClmibter2e0LFj2bt3L/b29syNiOC5554zQ6VCiCKhiglArVmzxvjeYDAob29vNWPGDOO069evK51Op7755hullFJHjx5VgIqOjjb22bBhg9JoNOrixYtKKaUWLVqk3NzcVE5OjrHPyJEjlb+//0PVl5aWpgCVlpb2KMMTQhQTY0aNUnUCA9VbHTuq1MwM1XrnGlVp43LV5Y+NKt+gN3d5RWpbSoJ6cdMKVWnjcjU6brcyGAwm7QaDQU2ZNEnVCQxUDerWVXv37DFTpUKI+3mYDFJsz7GLj48nKSmJ4OBg4zQXFxfq16/Pnj17ANizZw+urq7UqVPH2Cc4OBgrKyuioqKMfRo3boytra2xT6tWrThx4gTXrt378UI5OTmkp6ebvIQQz77hI0fiXrIk8WfP8tW/P2d+zaaU0FqzJzWJiNMHzV1ekYlKTSIkdjv5SvGad3kmVW1Q4ObCixYsYM1PP2FlZcXkqVOp36CBmaoVQhSVYhvskpJunfPi5eVlMt3Ly8vYlpSURKlSpUzara2tcXd3N+lzt2X8fR13ExYWhouLi/FVpkyZxxuQEKJYcHV1ZczHHwPw1ZdfcvPseSZVCQJg0dlD7Lh8wZzlFYkD1y/Te/8Wcgx6XvH0Y0b1l9FqTL/uv1q5kuXLlgEwaswYmv/tj2ghxLOr2AY7cxs9ejRpaWnGV0JCgrlLEkIUkSZNm9K6TRsMBgMTx4+npbsv75XxB2BY3C4u3cx4wBKKr6PpqXwQ8xtZ+nwauvsQEdAUmzueGPHL2rXMmzMHgJCBA+nw5pvmKFUI8QQU22Dn7X3r8TbJyckm05OTk41t3t7epKSkmLTn5+eTmppq0uduy/j7Ou5Gp9Ph7Oxs8hJCWI5hI0ZQ0sODc+fOsXTxYsa8WJdqziW5npfDwIM7yDXozV3iQzuTkUaPmM2k5+dSy9WTxYHN0Gm1Jn22bd3KlEmTAOjStSvdunc3Q6VCiCel2Aa7ChUq4O3tzZYtW4zT0tPTiYqKIijo1mGToKAgrl+/TkxMjLHP1q1bMRgM1K9f39gnMjKSvLw8Y5/Nmzfj7++Pm5vbUxqNEKK4cXFxMR6S/fqrrzged5iIgCY4W9tyMO0K00/EPGAJxUtC1g267fuV1Nxsqji581mtYEpYmz4GLPqPP/h49GgMBgPt2rdnwKBBZqpWCPGkmDXYZWRkEBsbS2xsLHDrgonY2FjOnz+PRqNh8ODBTJ48mV9++YW4uDi6du2Kr68v7du3B6By5cq0bt2aXr168ccff7B7925CQkJ49913jfdgeu+997C1taVnz54cOXKE7777jnnz5vHRRx+ZadRCiOKicZMmvPb66yilmBgaiqfGmunVGwGw4vwxNiSdM2+BhZScnUW3fb+SnJPFcw4ufFGnBc42tiZ9jhw5wrCPPiIvL4+mzZoxasyYAhdTCCEswJO/SPfetm3bpoACr27duimlbl2KP3bsWOXl5aV0Op1q3ry5OnHihMkyrl69qjp16qQcHR2Vs7Oz6tGjh7px44ZJn4MHD6pGjRopnU6nSpcuraZNm/bQtcrtToSwTGlpaapNy5aqTmCgmj1zplJKqfDj+1SljctVwOav1dmM62au8P6u5NxUrf66ZUuzHatV0s3MAn3OnjmjmjdrpuoEBqo+vXur7OxsM1QqhHhUD5NBNEr9gx6U+BjS09NxcXEhLS1NzrcTwsLs3rWLwQMHotFoWPrZZ1SvWZMu+zax71oKLzq68X2DV7HXWpu7zALS83LpEr2JozdS8dKV4Nv6bfCzdzTpk5SYSM/33yclOZkqVauyaMkSHBwczFSxEOJRPEwGKbbn2AkhxNPyUqNGtH3jDZRSTJowgbycHObWaEJJWzuOZ1xjwrEoc5dYQGZ+Hh/s/42jN1IpaWvHl3VbFgh1qamp9O/Xj5TkZCpUqMC8iAgJdUJYOAl2QggBDBk6lFJeXiQkJLBwwQK87Eowp0ZjrNDw48XTrL546sELeUpy9Hr6HtjKgeuXcba2ZVntFlR0cDHpk5GRwaCQEM7/+Sfe3t7MX7QIV7lgTAiLJ8FOCCEAJycnPhk7FoDvvvmGmJgYgkr6MLBSAADjj0Zx/EaqOUsEIM9gYODB7exJTcJBa83ntYOp7Oxu0ic7O5uhQ4Zw/Phx3NzcWLB4cYEbtQshLJMEOyGE+EtQw4a069ABgEkTJpCVlUXfijVo4lGaHIOeAbE7uJGfa7b69MrA8LidbL18AZ2VlqW1mlPT1dOkT35+Ph+PHs3+mBgcHByIWLCAcuXKmaliIcTTJsFOCCH+ZvCQIXh5e3PxwgUWRERgpdEwo3ojfOwcOJeVzpjDv2OOa84MSjH2yF7WJ53DRmPFgppNqe9uepN1g8HA5IkTidyxA51Ox6y5c3mxcuWnXqsQwnwk2AkhxN84OjoyNjQUgB++/57oP/7AzdaOeQFNsNFYsTH5T748f/yp1qSUYurxaH64eAorNMyq8TJNPf0K9Jk7ezbr161Dq9Uyddo0ateu/VTrFEKYnwQ7IYS4Q/369XmzY0cAJk+cSGZmJoGunoz0rwNA+Il9HLh++anVM/d0LCvOHwMgrFpD2niXL9Dni88/55tVqwAYFxpK4yZNnlp9QojiQ4KdEELcxcDBg/Hx8eHSpUvMnzcPgK5lX6SNVznylIFBB3dwLTf7idex9Gwci84eAmB85fq8WbpSgT6rf/iBJYsWAfDRsGG8+vrrT7wuIUTxJMFOCCHuwsHBwXhI9sfVq4mKikKj0TClWkPKl3AmMTuT4XG7MDzB8+2+On+cmaf2AzDs+Vp0LvtigT6bNm5k+rRpAPTs1YtO7733xOoRQhR/EuyEEOIe6tarx/+99RYAkydMICMjAydrW+bXbILOSsuOKxdZcjbuiaz7p4unjTdG7luxOh9WrF6gz+7duwkdNw6lFG+9/TYf9unzRGoRQjw7JNgJIcR9DBg0CN/SpUlKSmLenDkAvOjkzvgq9QGYdzqWPVcTi3SdG5LOMfrw7wB0LVuZIZUCC/Q5GBvLyOHD0efn06p1a4aNGIFGoynSOoQQzx4JdkIIcR8lSpRg3PjxAPy8Zg17fr8VuP6v9PN0LF0JA4ohhyJJzs4qkvVtv3yBoYd2YkDxf6Ur8fGLdQsEtlMnTzJk0CBysrNp+NJLjJ8wASsr+ToXQkiwE0KIB6pduzbvvPsuAJMnTSLjxg0AQivXx9/Rjau52Qw5FEm+wfBY64lKTSIkdjt5ysBr3uWZXDUIqztC3YWEBEL69+fGjRsE1KxJ+PTpWNvYPNZ6hRCWQ4KdEEIUQv8BA/Dz8yMlOZk5s2cDYK+1Zn7NJjhobYi+lsyc0wceefmx1y/z4f4t5Bj0vOLpx4zqL6PVmH5FX758mf79+pF69SrPP/88c+bNw87e/rHGJYSwLBLshBCiEOzt7Rk3fjwajYZf1q5l965dAFRwcCGsWkMAPo0/zJaU8w+97GPpqfSM+Y1MfT4N3X2ICGiKzR2HVtPS0hjQvz+XLl7Ez8+PiIULcXJyevyBCSEsigQ7IYQopMBatXi3UycApkyaRHp6OgBtvMvTteytR3eNiNtNQtaNQi/zbGYa3WM2k56fSy1XTxYFNkOn1Zr0uXnzJkMGDeLM6dN4eHiwYPFiPDw8imhUQghLIsFOCCEeQr/+/SlbtiyXL19m9qxZxukj/WsT4OJBen4uAw/uIMegf+CyLtzMoNu+X0nNzaaKkzuf1QrGwdr0fLm8vDxGDB1K3KFDODs7M3/RIkqXLl3k4xJCWAYJdkII8RDs7O0ZN2ECGo2G9f/5D5E7dgBga6UlIqAJrjY6DqdfZerx6PsuJzk7i67Rm0jKzuI5Bxe+qNMCZxtbkz56vZ5xn3zC3r17sbOzY868eVSqVPDJE0IIcZsEOyGEeEgBAQG8969/ARA2ZQppaWkA+No7MrN6IwBWJZzgl0tn7zr/1dxsuu/7lYSbGfjZO7K8TgtK2tqZ9FFKMX3aNH7bvBlra2tmzJpFjYCAJzgqIYQlkGAnhBCPoE/fvpQrX54rV64wa8YM4/Qmnn70/espEWOP7uHkjWtEpSbxn8SzRKUmcS03m/f3beZ0ZhpeuhJ8Wacl3nYOBZa/eOFCfvrxRzQaDRMnT6ZBUNBTG5sQ4tmlUeoJPujQgqSnp+Pi4kJaWhrOzs7mLkcIUQzEHTrEB++/j8FgYObs2TRp2hQAvTLQY99m9qQmYa3RkP+3r1kbjRV5yoC7rR2r6rbmOUeXAsv9+quvmPvXLVVGf/wxb3bs+FTGI4Qonh4mg8geOyGEeETVa9TgX126ADB1yhSuX78OgFZjRVufigAmoQ4gT926iXHvCtXuGup+WbvWGOr6hYRIqBNCPBQJdkII8Rh69+lDhQoVSL16lZnTpwO39thFnI6973wr/jyKXpk+qWL7tm1MmTQJgM5dutC9R48nUrMQwnJJsBNCiMeg0+kInTgRrVbLpo0b2bplC/uupZCUc/9nxyZmZ7HvWorx/b7oaMaMGoXBYKDtG28waPDgAs+IFUKIB5FgJ4QQj6lq1ap06doVgGlTpxKfklio+VL+Cn9Hjx5l6JAh5OXl0bRZM8Z88omEOiHEI5FgJ4QQRaDXhx9S8bnnuHbtGtuWLi/UPKV0JTgXH8+gkBCysrKoU7cuk6dOxdra+skWK4SwWBLshBCiCNja2jJ+wgS0Wi37d+zE89if3GufmwbwsSuBX7aB/v36cf36dSpXqcLM2bPR6XRPs2whhIWRYCeEEEWkcpUqdPvrggebn7eiycgqEO5uvx/s7c+gkBBSkpMpX748EfPn4+BQ8H52QgjxMCTYCSFEEfqgVy+ef/55stLTCdp+mFK29ibt3nYlmPF8PdZMmMaf587h5e3N/EWLcHVzM1PFQghLIsFOCCGKkI2NDaETJqC1tubI7j2MuenAWOfydFfOjHUuz/o6bdgwbQ7Hjx/Hzc2NBYsW4e3tbe6yhRAWQp48UUjy5AkhxMP4dMkSPvv0UzQaDX//mrW1tSU3NxcHBweWfPopL1aubMYqhRDPAnnyhBBCmFn5ChUAuPNv59zcXAD+1aWLhDohRJGTYCeEEEVMr9czb86c+/b5ec0a9Hr9U6pICPFPIcFOCCGKWOyBA6SkpNy3T3JyMrEHDjylioQQ/xQS7IQQoohduXKlSPsJIURhSbATQogi5uHhUaT9hBCisCTYCSFEEasZGEipUqXgXs971Wjw8vKiZmDg0y1MCGHxJNgJIUQR02q1DB0+/NabO8PdX+8/GjYMrVb7lCsTQlg6CXZCCPEEvNK8OeHTp1PK09NkulepUoRPn84rzZubqTIhhCWTGxQXktygWAjxKPR6PbEHDnDlyhU8PDyoGRgoe+qEEA/lYTKI9VOqSQgh/pG0Wi2169QxdxlCiH8IORQrhBBCCGEhJNgJIYQQQlgICXZCCCGEEBZCgp0QQgghhIWQYCeEEEIIYSGKfbC7ceMGgwcPply5ctjb29OwYUOio6ON7Uopxo0bh4+PD/b29gQHB3Pq1CmTZaSmptK5c2ecnZ1xdXWlZ8+eZGRkPO2hCCGEEEI8UcU+2H3wwQds3ryZlStXEhcXR8uWLQkODubixYsATJ8+nYiICJYsWUJUVBQODg60atWK7Oxs4zI6d+7MkSNH2Lx5M+vWrSMyMpLevXuba0hCCCGEEE9Esb5B8c2bN3FycmLt2rW89tprxum1a9emTZs2TJo0CV9fX4YOHcqwYcMASEtLw8vLi+XLl/Puu+9y7NgxqlSpQnR0NHX+upfUxo0befXVV7lw4QK+vr6FqkVuUCyEEEIIc3iYDFKs99jl5+ej1+uxs7MzmW5vb8+uXbuIj48nKSmJ4OBgY5uLiwv169dnz549AOzZswdXV1djqAMIDg7GysqKqKioe647JyeH9PR0k5cQQgghRHFWrIOdk5MTQUFBTJo0iUuXLqHX6/nqq6/Ys2cPiYmJJCUlAeDl5WUyn5eXl7EtKSmJUqVKmbRbW1vj7u5u7HM3YWFhuLi4GF9lypQp4tEJIYQQQhStYh3sAFauXIlSitKlS6PT6YiIiKBTp05YWT3Z0kePHk1aWprxlZCQ8ETXJ4QQQgjxuIr9s2Kfe+45duzYQWZmJunp6fj4+PDOO+9QsWJFvL29AUhOTsbHx8c4T3JyMjVr1gTA29ublJQUk2Xm5+eTmppqnP9udDodOp3O+P72qYhySFYIIYQQT9Pt7FGoyyLUMyY1NVW5uLiopUuXKoPBoLy9vdXMmTON7WlpaUqn06lvvvlGKaXU0aNHFaD27dtn7LNp0yal0WjUxYsXC73ehIQEBchLXvKSl7zkJS95meWVkJDwwLxSrK+KBdi0aRNKKfz9/Tl9+jTDhw/Hzs6OnTt3YmNjQ3h4ONOmTWPFihVUqFCBsWPHcujQIY4ePWq86KJNmzYkJyezZMkS8vLy6NGjB3Xq1GHVqlWFrsNgMHDp0iWcnJzQaDRFPs709HTKlClDQkKCXHUrhIWRz7cQlutpfL6VUty4cQNfX98HnopW7A/FpqWlMXr0aC5cuIC7uzsdO3ZkypQp2NjYADBixAgyMzPp3bs3169fp1GjRmzcuNHkStqvv/6akJAQmjdvjpWVFR07diQiIuKh6rCyssLPz69Ix3Y3zs7O8sUvhIWSz7cQlutJf75dXFwK1a/Y77H7p5D75AlhueTzLYTlKm6f72J/VawQQgghhCgcCXbFhE6nIzQ01ORKXCGEZZDPtxCWq7h9vuVQrBBCCCGEhZA9dkIIIYQQFkKCnRBCCCGEhZBgJ4QQQghhISTYmVlkZCRt27bF19cXjUbDzz//bO6ShBBFJCwsjLp16+Lk5ESpUqVo3749J06cMHdZQogisHjxYmrUqGG8f11QUBAbNmwwd1kS7MwtMzOTgIAAFi5caO5ShBBFbMeOHfTv35+9e/eyefNm8vLyaNmyJZmZmeYuTQjxmPz8/Jg2bRoxMTHs27ePV155hXbt2nHkyBGz1iVXxRYjGo2GNWvW0L59e3OXIoR4Ai5fvkypUqXYsWMHjRs3Nnc5Qogi5u7uzowZM+jZs6fZaij2jxQTQghLkZaWBtz68hdCWA69Xs8PP/xAZmYmQUFBZq1Fgp0QQjwFBoOBwYMH89JLL1GtWjVzlyOEKAJxcXEEBQWRnZ2No6Mja9asoUqVKmatSYKdEEI8Bf379+fw4cPs2rXL3KUIIYqIv78/sbGxpKWlsXr1arp168aOHTvMGu4k2AkhxBMWEhLCunXriIyMxM/Pz9zlCCGKiK2tLZUqVQKgdu3aREdHM2/ePJYuXWq2miTYCSHEE6KUYsCAAaxZs4bt27dToUIFc5ckhHiCDAYDOTk5Zq1Bgp2ZZWRkcPr0aeP7+Ph4YmNjcXd3p2zZsmasTAjxuPr378+qVatYu3YtTk5OJCUlAeDi4oK9vb2ZqxNCPI7Ro0fTpk0bypYty40bN1i1ahXbt29n06ZNZq1LbndiZtu3b6dZs2YFpnfr1o3ly5c//YKEEEVGo9HcdfqyZcvo3r370y1GCFGkevbsyZYtW0hMTMTFxYUaNWowcuRIWrRoYda6JNgJIYQQQlgIefKEEEIIIYSFkGAnhBBCCGEhJNgJIYQQQlgICXZCCCGEEBZCgp0QQgghhIWQYCeEEEIIYSEk2AkhhBBCWAgJdkIIIYQQFkKCnRCi0M6dO4dGoyE2NtbcpRgdP36cBg0aYGdnR82aNc1ay/Lly3F1dTW+Hz9+vNlrEo/nzv9TIYo7CXZCPEO6d++ORqNh2rRpJtN//vnnez6+ytKFhobi4ODAiRMn2LJly1373N5uGo0GGxsbKlSowIgRI8jOzn6itQ0bNuyeNT2KpxUymjZtatxeOp2O0qVL07ZtW3766aciX5dGo+Hnn38u0mVKGBP/ZBLshHjG2NnZER4ezrVr18xdSpHJzc195HnPnDlDo0aNKFeuHCVLlrxnv9atW5OYmMjZs2eZM2cOS5cuJTQ09JHXWxiOjo73rak469WrF4mJiZw5c4Yff/yRKlWq8O6779K7d29zlyaEuA8JdkI8Y4KDg/H29iYsLOyefe52CHDu3LmUL1/e+L579+60b9+eqVOn4uXlhaurKxMnTiQ/P5/hw4fj7u6On58fy5YtK7D848eP07BhQ+zs7KhWrRo7duwwaT98+DBt2rTB0dERLy8vunTpwpUrV4ztTZs2JSQkhMGDB+Ph4UGrVq3uOg6DwcDEiRPx8/NDp9NRs2ZNNm7caGzXaDTExMQwceJENBoN48ePv+c20el0eHt7U6ZMGdq3b09wcDCbN282WVdYWBgVKlTA3t6egIAAVq9ebWzfvn07Go2G9evXU6NGDezs7GjQoAGHDx++5zrv9v/wxRdfULVqVXQ6HT4+PoSEhBjbZs+eTfXq1XFwcKBMmTL069ePjIwM4/p79OhBWlqacW/a7fHm5OQwbNgwSpcujYODA/Xr12f79u3G5f7555+0bdsWNzc3HBwcqFq1Kv/973/vWTdAiRIl8Pb2xs/PjwYNGhAeHs7SpUv57LPP+O2334z9EhISePvtt3F1dcXd3Z127dpx7ty5Qo359s9jhw4d0Gg0Jj+fa9eupVatWtjZ2VGxYkUmTJhAfn6+sf369et8+OGHeHl5GX8O161b91jbCW7t7StbtiwlSpSgQ4cOXL169b7bSYjiRoKdEM8YrVbL1KlTmT9/PhcuXHisZW3dupVLly4RGRnJ7NmzCQ0N5fXXX8fNzY2oqCj69OnDhx9+WGA9w4cPZ+jQoRw4cICgoCDatm1r/AV4/fp1XnnlFQIDA9m3bx8bN24kOTmZt99+22QZK1aswNbWlt27d7NkyZK71jdv3jxmzZrFzJkzOXToEK1ateKNN97g1KlTACQmJlK1alWGDh1KYmIiw4YNK9S4Dx8+zO+//46tra1xWlhYGF9++SVLlizhyJEjDBkyhH/9618FQuvw4cOZNWsW0dHReHp60rZtW/Ly8gq13sWLF9O/f3969+5NXFwcv/zyC5UqVTK2W1lZERERwZEjR1ixYgVbt25lxIgRADRs2JC5c+fi7OxMYmKiyXhDQkLYs2cP3377LYcOHeKtt96idevWxu3Uv39/cnJyiIyMJC4ujvDwcBwdHQtV899169YNNzc34yHZvLw8WrVqhZOTEzt37mT37t04OjrSunVr417Y+405OjoagGXLlpGYmGh8v3PnTrp27cqgQYM4evQoS5cuZfny5UyZMgW4FcLbtGnD7t27+eqrrzh69CjTpk1Dq9U+1naKioqiZ8+ehISEEBsbS7NmzZg8efJDbychzEoJIZ4Z3bp1U+3atVNKKdWgQQP1/vvvK6WUWrNmjfr7xzk0NFQFBASYzDtnzhxVrlw5k2WVK1dO6fV64zR/f3/18ssvG9/n5+crBwcH9c033yillIqPj1eAmjZtmrFPXl6e8vPzU+Hh4UoppSZNmqRatmxpsu6EhAQFqBMnTiillGrSpIkKDAx84Hh9fX3VlClTTKbVrVtX9evXz/g+ICBAhYaG3nc53bp1U1qtVjk4OCidTqcAZWVlpVavXq2UUio7O1uVKFFC/f777ybz9ezZU3Xq1EkppdS2bdsUoL799ltj+9WrV5W9vb367rvvlFJKLVu2TLm4uBjb7/x/8PX1VR9//PEDx33bDz/8oEqWLGl8f+fylVLqzz//VFqtVl28eNFkevPmzdXo0aOVUkpVr15djR8/vtDrbdKkiRo0aNBd2+rXr6/atGmjlFJq5cqVyt/fXxkMBmN7Tk6Osre3V5s2bVJKPXjMgFqzZk2B2qdOnWoybeXKlcrHx0cppdSmTZuUlZWV8efpTo+6nTp16qReffVVk/Z33nmnwLKEKM6szRkqhRCPLjw8nFdeeaXQe6nupmrVqlhZ/W/HvZeXF9WqVTO+12q1lCxZkpSUFJP5goKCjP+2tramTp06HDt2DICDBw+ybdu2u+4ROnPmDC+88AIAtWvXvm9t6enpXLp0iZdeeslk+ksvvcTBgwcLOcL/adasGYsXLyYzM5M5c+ZgbW1Nx44dATh9+jRZWVm0aNHCZJ7c3FwCAwNNpv197O7u7vj7+xvHfj8pKSlcunSJ5s2b37PPb7/9RlhYGMePHyc9PZ38/Hyys7PJysqiRIkSd50nLi4OvV5v3K635eTkGM/vGzhwIH379uXXX38lODiYjh07UqNGjQfWfDdKKeOFOgcPHuT06dM4OTmZ9MnOzubMmTOFGvPdHDx4kN27dxv30AHo9XrjtoiNjcXPz6/AmO+nMNvp2LFjdOjQwaQ9KCjI5PC/EMWdBDshnlGNGzemVatWjB49mu7du5u0WVlZoZQymXa3w4U2NjYm729fNXrnNIPBUOi6MjIyaNu2LeHh4QXafHx8jP92cHAo9DKLgoODg/EQ4BdffEFAQACff/45PXv2NJ7Htn79ekqXLm0yn06nK5L129vb37f93LlzvP766/Tt25cpU6bg7u7Orl276NmzJ7m5ufcMdhkZGWi1WmJiYtBqtSZtt8P1Bx98QKtWrVi/fj2//vorYWFhzJo1iwEDBjzUGPR6PadOnaJu3brGddeuXZuvv/66QF9PT0+TPxoeRkZGBhMmTODNN98s0GZnZ/fAbXmvZT5oOwlhCSTYCfEMmzZtGjVr1sTf399kuqenJ0lJSSZ7V4ry3nN79+6lcePGAOTn5xMTE2M8Ib5WrVr8+OOPlC9fHmvrR/+KcXZ2xtfXl927d9OkSRPj9N27d1OvXr3Hqt/KyooxY8bw0Ucf8d5771GlShV0Oh3nz583Wdfd7N27l7JlywJw7do1Tp48SeXKlR+4TicnJ8qXL8+WLVto1qxZgfaYmBgMBgOzZs0yBqLvv//epI+trS16vd5kWmBgIHq9npSUFF5++eV7rr9MmTL06dOHPn36MHr0aD777LOHDnYrVqzg2rVrxj2dtWrV4rvvvqNUqVI4OzvfdZ77jRlu/XFx55hq1arFiRMnTM4//LsaNWpw4cIFTp48ede9do+6nSpXrkxUVJTJtL179961rxDFlVw8IcQzrHr16nTu3JmIiAiT6U2bNuXy5ctMnz6dM2fOsHDhQjZs2FBk6124cCFr1qzh+PHj9O/fn2vXrvH+++8Dt07UT01NpVOnTkRHR3PmzBk2bdpEjx49CvyyfZDhw4cTHh7Od999x4kTJxg1ahSxsbEMGjToscfw1ltvodVqWbhwIU5OTgwbNowhQ4awYsUKzpw5w/79+5k/fz4rVqwwmW/ixIls2bKFw4cP0717dzw8PGjfvn2h1jl+/HhmzZpFREQEp06dMq4DoFKlSuTl5TF//nzOnj3LypUrC1xUUr58eTIyMtiyZQtXrlwhKyuLF154gc6dO9O1a1d++ukn4uPj+eOPPwgLC2P9+vUADB48mE2bNhEfH8/+/fvZtm3bA8NoVlYWSUlJXLhwgb179zJy5Ej69OlD3759jSGtc+fOeHh40K5dO3bu3El8fDzbt29n4MCBxgtu7jfm22PasmULSUlJxlv4jBs3ji+//JIJEyZw5MgRjh07xrfffssnn3wCQJMmTWjcuDEdO3Zk8+bNxMfHs2HDBuMh00fdTgMHDmTjxo3MnDmTU6dOsWDBAjkMK549Zj7HTwjxEP5+8cRt8fHxytbWVt35cV68eLEqU6aMcnBwUF27dlVTpkwpcPHEncu620nz5cqVU3PmzDGuC1CrVq1S9erVU7a2tqpKlSpq69atJvOcPHlSdejQQbm6uip7e3v14osvqsGDBxtPsr/fyfl/p9fr1fjx41Xp0qWVjY2NCggIUBs2bDDpU9iLJ+4cq1JKhYWFKU9PT5WRkaEMBoOaO3eu8vf3VzY2NsrT01O1atVK7dixQyn1v4sn/vOf/6iqVasqW1tbVa9ePXXw4EHj8h508YRSSi1ZssS4Dh8fHzVgwABj2+zZs5WPj4+yt7dXrVq1Ul9++aUC1LVr14x9+vTpo0qWLKkA47hzc3PVuHHjVPny5Y3L7dChgzp06JBSSqmQkBD13HPPKZ1Opzw9PVWXLl3UlStX7rm9mjRpogAFKFtbW+Xj46Nef/119dNPPxXom5iYqLp27ao8PDyUTqdTFStWVL169VJpaWmFGvMvv/yiKlWqpKytrU1+Pjdu3KgaNmyo7O3tlbOzs6pXr5769NNPje1Xr15VPXr0UCVLllR2dnaqWrVqat26dY+1nZRS6vPPP1d+fn7K3t5etW3bVs2cOVMunhDPFI1Sd5yII4QQooDt27fTrFkzrl27Jk81EEIUW3IoVgghhBDCQkiwE0IIIYSwEHIoVgghhBDCQsgeOyGEEEIICyHBTgghhBDCQkiwE0IIIYSwEBLshBBCCCEshAQ7IYQQQggLIcFOCCGEEMJCSLATQgghhLAQEuyEEEIIISyEBDshhBBCCAvx/77Uz5J+KdlZAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -435,7 +575,7 @@ " detected in a number of replicates.\n", " \"\"\"\n", " peps = {\n", - " k: set(p.peptides[\"Peptide\"][p.peptides[\"mokapot q-value\"] <= 0.01])\n", + " k: set(p.peptides[\"peptide\"][p.peptides[\"mokapot_qvalue\"] <= 0.01])\n", " for k, p in res_dict.items()\n", " }\n", "\n", @@ -499,7 +639,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -513,7 +653,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.11.11" } }, "nbformat": 4, From 4ece54863b49a7899eec1eb6324a034d581aff0b Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Tue, 17 Dec 2024 17:22:29 -0600 Subject: [PATCH 10/12] chore: updated notebook --- docs/source/vignettes/joint_models.ipynb | 311 ++++++++++++++--------- 1 file changed, 189 insertions(+), 122 deletions(-) diff --git a/docs/source/vignettes/joint_models.ipynb b/docs/source/vignettes/joint_models.ipynb index d1ce912..0dc8a1e 100644 --- a/docs/source/vignettes/joint_models.ipynb +++ b/docs/source/vignettes/joint_models.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -55,7 +55,7 @@ " PosixPath('../../../data/scope2_FP97AC.pin')]" ] }, - "execution_count": 13, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -114,17 +114,59 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Analyzing ../../../data/scope2_FP97AA.pin\n", - "Analyzing ../../../data/scope2_FP97AB.pin\n", + "Analyzing ../../../data/scope2_FP97AA.pin\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AA/targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AA/targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing ../../../data/scope2_FP97AB.pin\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AB/targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AB/targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Analyzing ../../../data/scope2_FP97AC.pin\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AC/targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/separate/scope2_FP97AC/targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] } ], "source": [ @@ -136,15 +178,21 @@ "for pin in pin_files:\n", " # Read PSMs and run mokapot\n", " print(f\"Analyzing {pin}\")\n", + "\n", + " # For each of them, we create an output location.\n", " out_loc = base_location / pin.stem\n", - " out_loc.mkdir(exist_ok=True, parents=True) # We make sure the output directory exists\n", + " # We make sure the output directory exists\n", + " out_loc.mkdir(exist_ok=True, parents=True)\n", + "\n", + " # Read PSMs and run mokapot.\n", " psms = mokapot.read_pin(pin, max_workers=1)\n", - " \n", " models, scores = mokapot.brew(psms, max_workers=1)\n", " conf = mokapot.assign_confidence(psms, dest_dir=base_location / pin.stem, max_workers=1)\n", "\n", " # Add results to our result dictionary:\n", - " # We are selecting the first element \n", + " # We are selecting the first element because both brew and assign_confidence\n", + " # return a list, where 1 element is given per input file (the combined example\n", + " # will show how to handle multiple files).\n", " sep_results[pin.stem] = conf[0]\n", "\n", "# TODO: Check if the models third model is meant to throw a warning" @@ -161,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -196,48 +244,48 @@ " \n", " \n", " 0\n", - " target_0_8060_3_-1\n", - " K.GAEAANVTGPGGVPVQGSK.Y\n", - " 3.850000\n", - " 0.000462\n", - " 4.050871e-13\n", - " sp|P67809|YBOX1_HUMAN\n", - " \n", - " \n", - " 1\n", " target_0_12043_3_-1\n", " K.GVVPLAGTDGETTTQGLDGLSER.C\n", - " 3.468646\n", - " 0.000462\n", - " 4.927086e-12\n", + " 3.142521\n", + " 0.000453\n", + " 1.191094e-11\n", " sp|P09972|ALDOC_HUMAN\n", " \n", " \n", - " 2\n", + " 1\n", " target_0_11040_3_-1\n", " K.LVQDVANNTNEEAGDGTTTATVLAR.S\n", - " 3.139778\n", - " 0.000462\n", - " 4.249085e-11\n", + " 3.125541\n", + " 0.000453\n", + " 1.340957e-11\n", " sp|P10809|CH60_HUMAN\n", " \n", " \n", + " 2\n", + " target_0_11114_3_-1\n", + " K.QTTVSNSQQAYQEAFEISK.K\n", + " 3.116248\n", + " 0.000453\n", + " 1.430812e-11\n", + " sp|P31946|1433B_HUMAN\n", + " \n", + " \n", " 3\n", - " target_0_10722_3_-1\n", - " R.GSTAPVGGGAFPTIVER.E\n", - " 3.112971\n", - " 0.000462\n", - " 5.064860e-11\n", - " sp|Q15084|PDIA6_HUMAN\n", + " target_0_12180_3_-1\n", + " K.TVTNAVVTVPAYFNDSQR.Q\n", + " 2.525352\n", + " 0.000453\n", + " 8.845228e-10\n", + " sp|P11142|HSP7C_HUMAN\n", " \n", " \n", " 4\n", - " target_0_11114_3_-1\n", - " K.QTTVSNSQQAYQEAFEISK.K\n", - " 3.099323\n", - " 0.000462\n", - " 5.538586e-11\n", - " sp|P31946|1433B_HUMAN\n", + " target_0_11284_3_-1\n", + " K.SQIFSTASDN[0.98]QPTVTIK.V\n", + " 2.523156\n", + " 0.000453\n", + " 8.981859e-10\n", + " sp|P11021|BIP_HUMAN\n", " \n", " \n", "\n", @@ -245,21 +293,21 @@ ], "text/plain": [ " PSMId peptide score \\\n", - "0 target_0_8060_3_-1 K.GAEAANVTGPGGVPVQGSK.Y 3.850000 \n", - "1 target_0_12043_3_-1 K.GVVPLAGTDGETTTQGLDGLSER.C 3.468646 \n", - "2 target_0_11040_3_-1 K.LVQDVANNTNEEAGDGTTTATVLAR.S 3.139778 \n", - "3 target_0_10722_3_-1 R.GSTAPVGGGAFPTIVER.E 3.112971 \n", - "4 target_0_11114_3_-1 K.QTTVSNSQQAYQEAFEISK.K 3.099323 \n", + "0 target_0_12043_3_-1 K.GVVPLAGTDGETTTQGLDGLSER.C 3.142521 \n", + "1 target_0_11040_3_-1 K.LVQDVANNTNEEAGDGTTTATVLAR.S 3.125541 \n", + "2 target_0_11114_3_-1 K.QTTVSNSQQAYQEAFEISK.K 3.116248 \n", + "3 target_0_12180_3_-1 K.TVTNAVVTVPAYFNDSQR.Q 2.525352 \n", + "4 target_0_11284_3_-1 K.SQIFSTASDN[0.98]QPTVTIK.V 2.523156 \n", "\n", " mokapot_qvalue posterior_error_prob proteinIds \n", - "0 0.000462 4.050871e-13 sp|P67809|YBOX1_HUMAN \n", - "1 0.000462 4.927086e-12 sp|P09972|ALDOC_HUMAN \n", - "2 0.000462 4.249085e-11 sp|P10809|CH60_HUMAN \n", - "3 0.000462 5.064860e-11 sp|Q15084|PDIA6_HUMAN \n", - "4 0.000462 5.538586e-11 sp|P31946|1433B_HUMAN " + "0 0.000453 1.191094e-11 sp|P09972|ALDOC_HUMAN \n", + "1 0.000453 1.340957e-11 sp|P10809|CH60_HUMAN \n", + "2 0.000453 1.430812e-11 sp|P31946|1433B_HUMAN \n", + "3 0.000453 8.845228e-10 sp|P11142|HSP7C_HUMAN \n", + "4 0.000453 8.981859e-10 sp|P11021|BIP_HUMAN " ] }, - "execution_count": 18, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -279,9 +327,28 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AA.targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AA.targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AB.targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AB.targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AC.targets.psms.csv exists, but will be overwritten.\n", + " warnings.warn(\n", + "/Users/sebastianpaez/git/mokapot_worktree/auto_pin_handling/mokapot/tabular_data/csv.py:102: UserWarning: CSV file joint_models/joint/scope2_FP97AC.targets.peptides.csv exists, but will be overwritten.\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# A dictionary to store the results:\n", "joint_results = {}\n", @@ -314,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -348,48 +415,48 @@ " \n", " \n", " \n", - " 3546\n", - " target_0_4697_2_-1\n", - " -.MAEAGK.V\n", - " -0.548790\n", - " 0.102058\n", - " 0.645097\n", - " sp|Q7Z4M0|RE114_HUMAN\n", - " \n", - " \n", - " 3979\n", + " 3995\n", " target_0_7282_2_-1\n", " -.MAGGMK.V\n", - " -0.677872\n", - " 0.191709\n", - " 0.875404\n", + " -0.659660\n", + " 0.193944\n", + " 0.860169\n", " sp|O14524|NEMP1_HUMAN\n", " \n", " \n", - " 5175\n", + " 5172\n", " target_0_12287_3_-1\n", " -.MALGLLIAVPLLLQAAPRGAAHYEMMGTCR.M\n", - " -1.396336\n", - " 0.374061\n", + " -1.397640\n", + " 0.372711\n", " 1.000000\n", " sp|Q7Z5L3|C1QL2_HUMAN\n", " \n", " \n", - " 5055\n", + " 5056\n", " target_0_12268_3_-1\n", " -.MATEN[0.98]GAVELGIQN[0.98]PSTDKAPK.G\n", - " -1.103717\n", - " 0.357722\n", + " -1.100226\n", + " 0.355547\n", " 1.000000\n", " sp|Q9H1R3|MYLK2_HUMAN\n", " \n", " \n", - " 3323\n", + " 3677\n", + " target_0_11417_2_-1\n", + " -.MCLLPR.G\n", + " -0.565965\n", + " 0.122316\n", + " 0.694290\n", + " sp|Q9BZD3|GCOM2_HUMAN\n", + " \n", + " \n", + " 3372\n", " target_0_3673_2_-1\n", " -.MDNQAER.E\n", - " -0.457317\n", - " 0.059549\n", - " 0.470527\n", + " -0.458577\n", + " 0.069037\n", + " 0.491961\n", " sp|Q9BWW8|APOL6_HUMAN\n", " \n", " \n", @@ -402,86 +469,86 @@ " ...\n", " \n", " \n", - " 452\n", + " 409\n", " target_0_3700_2_-1\n", " R.YYGGGSEGGR.A\n", - " 1.055641\n", - " 0.000522\n", - " 0.000062\n", + " 1.054732\n", + " 0.000514\n", + " 0.000087\n", " sp|P14866|HNRPL_HUMAN\n", " \n", " \n", - " 3368\n", + " 3423\n", " target_0_6172_3_-1\n", " R.YYGINDPVADK.L\n", - " -0.476968\n", - " 0.066489\n", - " 0.507022\n", + " -0.477437\n", + " 0.077372\n", + " 0.526640\n", " sp|Q9NW64|RBM22_HUMAN\n", " \n", " \n", - " 638\n", + " 589\n", " target_0_7942_2_-1\n", " R.YYPTEDVPR.K\n", - " 0.826321\n", - " 0.000522\n", - " 0.000256\n", + " 0.823093\n", + " 0.000514\n", + " 0.000349\n", " sp|Q02878|RL6_HUMAN\n", " \n", " \n", - " 4985\n", + " 4986\n", " target_0_3659_2_-1\n", " R.YYQVAR.D\n", - " -1.012155\n", - " 0.347634\n", + " -1.011639\n", + " 0.346231\n", " 1.000000\n", " sp|Q969U6|FBXW5_HUMAN\n", " \n", " \n", - " 1734\n", + " 1695\n", " target_0_9733_2_-1\n", " R.YYTVFDR.D\n", - " 0.204112\n", - " 0.000522\n", - " 0.011981\n", + " 0.204137\n", + " 0.000514\n", + " 0.014292\n", " sp|P07339|CATD_HUMAN\n", " \n", " \n", "\n", - "

5221 rows × 6 columns

\n", + "

5217 rows × 6 columns

\n", "" ], "text/plain": [ " PSMId peptide score \\\n", - "3546 target_0_4697_2_-1 -.MAEAGK.V -0.548790 \n", - "3979 target_0_7282_2_-1 -.MAGGMK.V -0.677872 \n", - "5175 target_0_12287_3_-1 -.MALGLLIAVPLLLQAAPRGAAHYEMMGTCR.M -1.396336 \n", - "5055 target_0_12268_3_-1 -.MATEN[0.98]GAVELGIQN[0.98]PSTDKAPK.G -1.103717 \n", - "3323 target_0_3673_2_-1 -.MDNQAER.E -0.457317 \n", + "3995 target_0_7282_2_-1 -.MAGGMK.V -0.659660 \n", + "5172 target_0_12287_3_-1 -.MALGLLIAVPLLLQAAPRGAAHYEMMGTCR.M -1.397640 \n", + "5056 target_0_12268_3_-1 -.MATEN[0.98]GAVELGIQN[0.98]PSTDKAPK.G -1.100226 \n", + "3677 target_0_11417_2_-1 -.MCLLPR.G -0.565965 \n", + "3372 target_0_3673_2_-1 -.MDNQAER.E -0.458577 \n", "... ... ... ... \n", - "452 target_0_3700_2_-1 R.YYGGGSEGGR.A 1.055641 \n", - "3368 target_0_6172_3_-1 R.YYGINDPVADK.L -0.476968 \n", - "638 target_0_7942_2_-1 R.YYPTEDVPR.K 0.826321 \n", - "4985 target_0_3659_2_-1 R.YYQVAR.D -1.012155 \n", - "1734 target_0_9733_2_-1 R.YYTVFDR.D 0.204112 \n", + "409 target_0_3700_2_-1 R.YYGGGSEGGR.A 1.054732 \n", + "3423 target_0_6172_3_-1 R.YYGINDPVADK.L -0.477437 \n", + "589 target_0_7942_2_-1 R.YYPTEDVPR.K 0.823093 \n", + "4986 target_0_3659_2_-1 R.YYQVAR.D -1.011639 \n", + "1695 target_0_9733_2_-1 R.YYTVFDR.D 0.204137 \n", "\n", " mokapot_qvalue posterior_error_prob proteinIds \n", - "3546 0.102058 0.645097 sp|Q7Z4M0|RE114_HUMAN \n", - "3979 0.191709 0.875404 sp|O14524|NEMP1_HUMAN \n", - "5175 0.374061 1.000000 sp|Q7Z5L3|C1QL2_HUMAN \n", - "5055 0.357722 1.000000 sp|Q9H1R3|MYLK2_HUMAN \n", - "3323 0.059549 0.470527 sp|Q9BWW8|APOL6_HUMAN \n", + "3995 0.193944 0.860169 sp|O14524|NEMP1_HUMAN \n", + "5172 0.372711 1.000000 sp|Q7Z5L3|C1QL2_HUMAN \n", + "5056 0.355547 1.000000 sp|Q9H1R3|MYLK2_HUMAN \n", + "3677 0.122316 0.694290 sp|Q9BZD3|GCOM2_HUMAN \n", + "3372 0.069037 0.491961 sp|Q9BWW8|APOL6_HUMAN \n", "... ... ... ... \n", - "452 0.000522 0.000062 sp|P14866|HNRPL_HUMAN \n", - "3368 0.066489 0.507022 sp|Q9NW64|RBM22_HUMAN \n", - "638 0.000522 0.000256 sp|Q02878|RL6_HUMAN \n", - "4985 0.347634 1.000000 sp|Q969U6|FBXW5_HUMAN \n", - "1734 0.000522 0.011981 sp|P07339|CATD_HUMAN \n", + "409 0.000514 0.000087 sp|P14866|HNRPL_HUMAN \n", + "3423 0.077372 0.526640 sp|Q9NW64|RBM22_HUMAN \n", + "589 0.000514 0.000349 sp|Q02878|RL6_HUMAN \n", + "4986 0.346231 1.000000 sp|Q969U6|FBXW5_HUMAN \n", + "1695 0.000514 0.014292 sp|P07339|CATD_HUMAN \n", "\n", - "[5221 rows x 6 columns]" + "[5217 rows x 6 columns]" ] }, - "execution_count": 34, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -492,12 +559,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -542,12 +609,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 409d98d83e137409df08ff1a966ad98b9b4a9cc0 Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Thu, 19 Dec 2024 14:56:51 -0600 Subject: [PATCH 11/12] chore,confidence: update docstrings --- mokapot/confidence.py | 134 ++++++++++++++++++++++++++---------------- 1 file changed, 84 insertions(+), 50 deletions(-) diff --git a/mokapot/confidence.py b/mokapot/confidence.py index 950aae6..371bbab 100644 --- a/mokapot/confidence.py +++ b/mokapot/confidence.py @@ -8,13 +8,18 @@ The following classes store the confidence estimates for a dataset based on the provided score. They provide utilities to access, save, and plot these estimates for the various relevant levels (i.e. PSMs, peptides, and proteins). -The :py:func:`Confidence` class is appropriate for most data-dependent -acquisition proteomics datasets. - -We recommend using the :py:func:`~mokapot.brew()` function to obtain these -confidence estimates, rather than initializing the classes below directly. - -TODO: update this docstring. +The :py:class:`Confidence` class is the primary interface for handling confidence +estimates in data-dependent acquisition proteomics datasets. + +The module provides: +- Confidence estimation at PSM, peptide, and protein levels +- Streaming processing for large datasets +- Visualization utilities for confidence estimates +- Export capabilities in various formats + +We recommend using the :py:func:`~mokapot.brew()` followed by the `assign_confidence` +function to obtain these confidence estimates, rather than initializing the +classes below directly. """ from __future__ import annotations @@ -184,7 +189,7 @@ def __repr__(self) -> str: def _assign_confidence( self, - levels: list[str], # why is this passed if its a property of self? + levels: list[str], level_path_map: dict[str, Path], out_writers_map: dict[str, Sequence[TabularDataWriter]], write_decoys: bool = False, @@ -195,19 +200,36 @@ def _assign_confidence( score_stats: OnlineStatistics | None = None, eval_fdr: float = 0.01, ): - """ - Assign confidence to PSMs and peptides. + """Assign confidence estimates to PSMs and peptides. + + This method processes the dataset to assign confidence estimates (q-values and PEPs) + at different levels (PSMs, peptides) using the specified algorithms. It can optionally + stream the confidence calculations for large datasets. Parameters ---------- - level_path_map : List(Path) - Files with unique psms and unique peptides. - levels : List(str) - the levels at which confidence estimation was performed - out_paths : List(Path) - The output files where the results will be written + levels : list[str] + The levels at which to compute confidence estimates (e.g., ['psms', 'peptides']). + level_path_map : dict[str, Path] + Mapping of confidence levels to their corresponding file paths for intermediate data. + out_writers_map : dict[str, Sequence[TabularDataWriter]] + Mapping of confidence levels to their output writers for results. write_decoys : bool, optional - Save decoys confidence estimates as well? + Whether to include decoy results in the output, by default False. + peps_error : bool, optional + Whether to raise an error if PEP calculation fails, by default False. + peps_algorithm : str, optional + Algorithm to use for posterior error probability calculation. + Currently supports "qvality" (default). + qvalue_algorithm : str, optional + Algorithm to use for q-value calculation. + Currently supports "tdc" (default). + stream_confidence : bool, optional + Whether to stream confidence calculations for large datasets, by default False. + score_stats : OnlineStatistics | None, optional + Pre-computed score statistics if streaming is enabled, by default None. + eval_fdr : float, optional + FDR threshold for evaluation metrics, by default 0.01. """ if stream_confidence: if score_stats is None: @@ -250,7 +272,10 @@ def _assign_confidence( level_path.unlink(missing_ok=True) def _write_protein_level_data( - self, level_paths: dict[str, Path], proteins: Proteins, rng + self, + level_paths: dict[str, Path], + proteins: Proteins, + rng: int | np.random.Generator, ): psms = TabularDataReader.from_path(level_paths["psms"]).read() proteins_df = picked_protein( @@ -346,51 +371,60 @@ def assign_confidence( append_to_output_file: bool = False, rng: int | np.random.Generator = 0, peps_error: bool = False, - peps_algorithm="qvality", # TODO make this an enum (2024-12-17) - qvalue_algorithm="tdc", # TODO make this an enum (2024-12-17) + peps_algorithm="qvality", + qvalue_algorithm="tdc", sqlite_path: Path | None = None, stream_confidence: bool = False, -) -> list[Confidence]: - """Assign confidence to PSMs peptides, and optionally, proteins. +): + """Assign confidence to PSMs, peptides, and optionally proteins. Parameters ---------- - max_workers - datasets : list[OnDiskPsmDataset] + datasets : list[PsmDataset] A collection of PSMs. - scores_list : list[numpy.ndarray] + scores_list : list[numpy.ndarray[float]] | None, optional The scores by which to rank the PSMs. Usually derived from - `mokapot.brew` - rng : int or np.random.Generator, optional - A seed or generator used for cross-validation split creation and to - break ties, or ``None`` to use the default random number generator - state. - eval_fdr : float - The FDR threshold at which to report and evaluate performance. If - `scores` is not :code:`None`, this parameter has no affect on the - analysis itself, but does affect logging messages and the FDR - threshold applied for some output formats, such as FlashLFQ. - dest_dir : Path or None, optional - The directory in which to save the files. :code:`None` will use the - current working directory. - prefixes : [str] or None + `mokapot.brew`, by default None. + max_workers : int, optional + Number of parallel workers to use for processing, by default 1. + eval_fdr : float, optional + The FDR threshold at which to report and evaluate performance, by default 0.01. + This affects logging messages and the FDR threshold applied for some output formats. + dest_dir : Path | None, optional + The directory in which to save the files. None will use the + current working directory, by default None. + file_root : str, optional + Base name prefix for output files, by default "". + prefixes : list[str | None] | None, optional The prefixes added to all output file names. - If None, a single concatenated file will be created. + If None, a single concatenated file will be created, by default None. write_decoys : bool, optional - Save decoys confidence estimates as well? - deduplication: bool - Are we performing deduplication on the psm level? - do_rollup: bool - do we apply rollup on peptides, modified peptides etc.? - proteins: Proteins, optional - collection of proteins - append_to_output_file: bool - do we append results to file ? - sqlite_path: Path to the sqlite database to write mokapot results + Save decoy confidence estimates as well?, by default False. + deduplication : bool, optional + Whether to perform deduplication on the PSM level, by default True. + do_rollup : bool, optional + Whether to apply rollup on peptides, modified peptides etc., by default True. + proteins : Proteins | None, optional + Collection of proteins for protein inference, by default None. + append_to_output_file : bool, optional + Whether to append results to existing file, by default False. + rng : int | np.random.Generator, optional + Random number generator or seed for reproducibility, by default 0. + peps_error : bool, optional + Whether to raise error on PEP calculation failure, by default False. + peps_algorithm : {'qvality', 'qvality_bin', 'kde_nnls', 'hist_nnls'}, optional + Algorithm for posterior error probability calculation, by default "qvality". + qvalue_algorithm : {'tdc', 'hist'}, optional + Algorithm for q-value calculation, by default "tdc". + sqlite_path : Path | None, optional + Path to the SQLite database to write mokapot results, by default None. + stream_confidence : bool, optional + Whether to stream confidence calculations for large datasets, by default False. Returns ------- list[Confidence] + A list of Confidence objects containing the confidence estimates for each dataset. """ # Note: I am really not a big fan of how large this function is ... From 100ec5852c1d6a898d31e122edfb14006148ea5f Mon Sep 17 00:00:00 2001 From: "J. Sebastian Paez" Date: Thu, 19 Dec 2024 14:59:26 -0600 Subject: [PATCH 12/12] chore,qvalue: removed commented out code --- mokapot/qvalues.py | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/mokapot/qvalues.py b/mokapot/qvalues.py index 0eac457..2d22c58 100644 --- a/mokapot/qvalues.py +++ b/mokapot/qvalues.py @@ -141,35 +141,7 @@ def tdc( unique_metric = np.flip(unique_metric) indices = np.flip(indices) - # import time - - # t0 = time.time() qvals = _fdr2qvalue(fdr, num_total, indices) - # et = (time.time() - t0) * 1000 - # print(f"Base Time: {et}") - # t0 = time.time() - # qvals_np = np.minimum.accumulate(fdr) - # et = (time.time() - t0) * 1000 - # print(f"Numpy Time: {et}") - - # CARE = False - # if CARE and not np.allclose(qvals, qvals_np): - # rmse = np.sqrt(np.mean((qvals - qvals_np) ** 2)) - # print(f"RMSE: {rmse}") - # from matplotlib import pyplot as plt - - # diff_window = (qvals > 0.6) & (qvals < 0.75) - # print(f"Diff Qvals: {qvals[diff_window]}") - # print(f"Diff Qvals_np: {qvals[diff_window]}") - # print(f"Diff Qvals_fdr: {qvals[diff_window]}") - - # plt.scatter(x=qvals, y=qvals_np, alpha=0.3) - # plt.xlabel("Qvals") - # plt.ylabel("Qvals Numpy") - # plt.show() - # # if rmse > 1e-3: - # # raise RuntimeError("Numpy implementation is not close.") - qvals = np.flip(qvals) qvals = qvals[np.argsort(srt_idx)]