From a5304ff5c632c5308324a1f9766665e79ae06ec8 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Wed, 11 Mar 2026 13:33:21 -0400 Subject: [PATCH 01/26] Rename reaction_template_builder package --- .vscode/settings.json | 5 +- .../detectors/functional_groups_detector.py | 2 +- AutoREACTER/detectors/reaction_detector.py | 48 ++- .../__init__.py | 0 .../build_reaction_system.py} | 288 ++++++------------ .../lunar_client/__init__.py | 0 .../lunar_client/config.py | 1 + .../lunar_client/locate_lunar.py | 0 .../lunar_client/lunar_api_wrapper.py | 0 .../lunar_client/molecule_3d_preparation.py | 0 .../molecule_template_preparation.py | 0 .../reaction_processor}/__init__.py | 0 .../reaction_processor/atom_mapping.py} | 0 .../fragment_comparison.py} | 0 .../reaction_processor/prepare_reactions.py | 78 +++++ .../reaction_processor/utils.py} | 0 .../reaction_processor}/walker.py | 0 .../lunar_client/config.py | 5 - 18 files changed, 194 insertions(+), 233 deletions(-) rename AutoREACTER/{reaction_template_builder => reaction_preparation}/__init__.py (100%) rename AutoREACTER/{reaction_template_builder/run_reaction_template_pipeline.py => reaction_preparation/build_reaction_system.py} (66%) rename AutoREACTER/{reaction_template_builder => reaction_preparation}/lunar_client/__init__.py (100%) create mode 100644 AutoREACTER/reaction_preparation/lunar_client/config.py rename AutoREACTER/{reaction_template_builder => reaction_preparation}/lunar_client/locate_lunar.py (100%) rename AutoREACTER/{reaction_template_builder => reaction_preparation}/lunar_client/lunar_api_wrapper.py (100%) rename AutoREACTER/{reaction_template_builder => reaction_preparation}/lunar_client/molecule_3d_preparation.py (100%) rename AutoREACTER/{reaction_template_builder => reaction_preparation}/lunar_client/molecule_template_preparation.py (100%) rename AutoREACTER/{reaction_template_builder/reaction_template_pipeline => reaction_preparation/reaction_processor}/__init__.py (100%) rename AutoREACTER/{reaction_template_builder/reaction_template_pipeline/map_reactant_atoms.py => reaction_preparation/reaction_processor/atom_mapping.py} (100%) rename AutoREACTER/{reaction_template_builder/reaction_template_pipeline/compare_rdkit_fragments.py => reaction_preparation/reaction_processor/fragment_comparison.py} (100%) create mode 100644 AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py rename AutoREACTER/{reaction_template_builder/reaction_template_pipeline/util.py => reaction_preparation/reaction_processor/utils.py} (100%) rename AutoREACTER/{reaction_template_builder/reaction_template_pipeline => reaction_preparation/reaction_processor}/walker.py (100%) delete mode 100644 AutoREACTER/reaction_template_builder/lunar_client/config.py diff --git a/.vscode/settings.json b/.vscode/settings.json index 2c67ab7..4b5a294 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,4 @@ { - "python-envs.defaultEnvManager": "ms-python.python:system", - "python-envs.defaultPackageManager": "ms-python.python:pip", - "python-envs.pythonProjects": [] + "python-envs.defaultEnvManager": "ms-python.python:conda", + "python-envs.defaultPackageManager": "ms-python.python:conda" } \ No newline at end of file diff --git a/AutoREACTER/detectors/functional_groups_detector.py b/AutoREACTER/detectors/functional_groups_detector.py index 1f612ac..f35f1e2 100644 --- a/AutoREACTER/detectors/functional_groups_detector.py +++ b/AutoREACTER/detectors/functional_groups_detector.py @@ -139,7 +139,7 @@ class MonomerEntry: # TODO: Add more functional groups as needed from literature/user requirements. -@dataclass(slots=True, frozen=True) +@dataclass(slots=True) class FunctionalGroupInfo: """ Immutable dataclass storing information about a detected functional group. diff --git a/AutoREACTER/detectors/reaction_detector.py b/AutoREACTER/detectors/reaction_detector.py index 4ffbb72..713ab31 100644 --- a/AutoREACTER/detectors/reaction_detector.py +++ b/AutoREACTER/detectors/reaction_detector.py @@ -118,35 +118,27 @@ def _matching_fgs(self, monomer_entry: MonomerRole, target_group_name: str) -> L return [fg for fg in monomer_entry.functionalities if fg.fg_name == target_group_name] def _seen_pair_key( - self, - reaction_name: str, - monomer_role_1: MonomerRole, - fg_1: FunctionalGroupInfo, - monomer_role_2: Optional[MonomerRole] = None, - fg_2: Optional[FunctionalGroupInfo] = None, - ) -> Tuple: - """ - Generates a unique, order-independent key for a reaction pair to avoid duplicates. - - Args: - reaction_name: Name of the reaction. - monomer_role_1: First monomer. - fg_1: First functional group. - monomer_role_2: Second monomer (optional). - fg_2: Second functional group (optional). - - Returns: - A tuple representing the unique state of this reaction instance. - """ + self, + reaction_name: str, + monomer_role_1: MonomerRole, + fg_1: FunctionalGroupInfo, + monomer_role_2: Optional[MonomerRole] = None, + fg_2: Optional[FunctionalGroupInfo] = None, + ) -> Tuple: + if monomer_role_2 is None or fg_2 is None: - return (reaction_name, monomer_role_1, fg_1) - - # Sort reactants by memory ID to ensure (A, B) and (B, A) produce the same key - ordered = tuple(sorted( - [(monomer_role_1, fg_1), (monomer_role_2, fg_2)], - key=lambda x: (id(x[0]), id(x[1])) - )) - return (reaction_name, ordered[0], ordered[1]) + return ( + reaction_name, + monomer_role_1.smiles, + fg_1.fg_name + ) + + pair1 = (monomer_role_1.smiles, fg_1.fg_name) + pair2 = (monomer_role_2.smiles, fg_2.fg_name) + + ordered = tuple(sorted([pair1, pair2])) + + return (reaction_name, ordered) def reaction_detector(self, monomer_roles: List[MonomerRole]) -> List[ReactionInstance]: """ diff --git a/AutoREACTER/reaction_template_builder/__init__.py b/AutoREACTER/reaction_preparation/__init__.py similarity index 100% rename from AutoREACTER/reaction_template_builder/__init__.py rename to AutoREACTER/reaction_preparation/__init__.py diff --git a/AutoREACTER/reaction_template_builder/run_reaction_template_pipeline.py b/AutoREACTER/reaction_preparation/build_reaction_system.py similarity index 66% rename from AutoREACTER/reaction_template_builder/run_reaction_template_pipeline.py rename to AutoREACTER/reaction_preparation/build_reaction_system.py index 7c8e4ac..3ebc26b 100644 --- a/AutoREACTER/reaction_template_builder/run_reaction_template_pipeline.py +++ b/AutoREACTER/reaction_preparation/build_reaction_system.py @@ -24,7 +24,7 @@ """ -from typing import Literal + # --- preferred: package-relative imports; fallback: absolute imports for script/notebook --- try: # Case 1 (correct when imported as part of the package) @@ -54,204 +54,69 @@ from lunar_client.lunar_api_wrapper import lunar_workflow from lunar_client.molecule_template_preparation import molecule_template_preparation +from AutoREACTER.detectors.reaction_detector import ReactionInstance, ReactionTemplate +from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupInfo, MonomerRole +from AutoREACTER.input_parser import SimulationSetup, MonomerEntry # standard libs / third-party import pandas as pd from pathlib import Path import os +from dataclasses import dataclass, field +from typing import List, Any, Optional, Dict +from rdkit import Chem -def is_continuous(d): - """ - Checks if the integer keys of a dictionary form a continuous sequence starting from 1. - - This is used to verify if reaction IDs are sequential after potential - filtering or deduplication steps. - - Args: - d (dict): The dictionary to check, where keys are expected to be integers. - Returns: - bool: True if keys are exactly [1, 2, ..., len(d)], False otherwise. - """ - keys = sorted(d.keys()) - if not keys: - return True - # Compare sorted keys against a generated range of the same length - return keys == list(range(1, len(keys) + 1)) - - -def save_grid_image(mols, cache, key=None): - from pathlib import Path - from rdkit.Chem import Draw - import base64 - """ - TODO: Add full grid set of reactant1 + reactant2 → product image grid to ipynb or cache/ "grid_images". - With Template atoms highlighted in one color and Edge atoms highlighted in another color. - With Edge atoms hightlighted in a different color if possible. - This will be useful for debugging and for users to visually inspect the detected reactions and templates. - Note: If you want to use the SVG output instead of PNG, you can set useSVG=True in Draw.MolsToGridImage and handle the SVG data accordingly. +@dataclass (slots=True) +class ReactionMetadata: """ - out_dir = Path(cache) / "grid_images" - out_dir.mkdir(parents=True, exist_ok=True) - - out_path = out_dir / (f"reaction_grid_{key}.png" if key is not None else "reaction_grid.png") - - # Ask RDKit for a raster image (PNG-like) - img = Draw.MolsToGridImage(mols, useSVG=False) - - # Case 1: PIL.Image.Image (has .save) - if hasattr(img, "save"): - img.save(str(out_path)) - return out_path - - # Case 2: IPython/RDKit display object (often has .data) - data = getattr(img, "data", None) - if data is None: - raise TypeError(f"Unexpected image type {type(img)}; cannot save.") - - # data can be bytes OR base64 string depending on wrapper - if isinstance(data, bytes): - png_bytes = data - elif isinstance(data, str): - # try base64 decode; if it fails, treat as raw text - try: - png_bytes = base64.b64decode(data) - except Exception: - png_bytes = data.encode("utf-8") - else: - raise TypeError(f"Unexpected img.data type {type(data)}; cannot save.") - - with open(out_path, "wb") as f: - f.write(png_bytes) - - return out_path - - -def add_dict_as_new_columns(df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): - """ - Adds dictionary keys and values as new columns to an existing DataFrame. - - This is specifically used to map reactant indices to product indices - within the reaction template. - - Args: - df_existing (pd.DataFrame): The DataFrame to modify. - data_dict (dict): Dictionary where keys and values will become column data. - titles (list): List of two strings for the new column names. - - Returns: - pd.DataFrame: The modified DataFrame with new columns added. - """ - # Convert dict keys and values to Series to ensure alignment with the DataFrame - # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers - df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") - df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") - - return df_existing - - -def molecule_dict_csv_path_dict_rearrange(molecule_dict_csv_path_dict): - """ - Rearranges the reaction dictionary keys to be continuous and renames - associated CSV files on the filesystem to match the new keys. - - This ensures that if reaction #2 is deleted, reaction #3 becomes the new #2, - maintaining a clean, gapless sequence for downstream processing. - - Args: - molecule_dict_csv_path_dict (dict): Dictionary containing reaction metadata - and 'csv_path' entries. - - Returns: - dict: A new dictionary with normalized continuous keys (1 to N) and updated file paths. + A dataclass to hold all relevant metadata and file paths for a single reaction instance. + Attributes: + - reaction_id: Unique identifier for the reaction. + - reactant_combined_mol: RDKit molecule object representing the combined reactants. + - product_combined_mol: RDKit molecule object representing the combined products. + - reaction_smarts: Optional SMARTS string representing the reaction. + - reactant_smarts: Optional SMARTS string for the reactants. + - product_smiles: Optional SMILES string for the products. + - csv_path: Path to the CSV file containing processing reaction data. + - mol_3d_path: Optional path to the generated 3D molecule file. + - reaction_dataframe: Optional pandas DataFrame holding detailed reaction mapping and analysis data. + - reactant_to_product_mapping: Dictionary mapping reactant atom indices to product atom indices. + - template_reactant_to_product_mapping: Dictionary mapping reactant atom indices to product atom indices specifically for the reaction template. + - edge_atoms: List of atom indices that are considered 'edge atoms' connecting the reaction template to the rest of the molecule. + - delete_atom: Boolean flag indicating whether an atom is deleted in the reaction (e.g., for polycondensation). + - delete_atom_idx: Optional index of the atom that is deleted in the reaction, if applicable. + - activity_stats: Boolean flag indicating whether to calculate and include activity statistics for the reaction. """ - # Skip if already continuous to save processing time - if is_continuous(molecule_dict_csv_path_dict): - return molecule_dict_csv_path_dict - - print("Rearranging molecule_dict_csv_path_dict keys to be continuous...") - new_dict = {} - - # Sort keys to ensure we process them in the original numerical order - sorted_old_keys = sorted(molecule_dict_csv_path_dict.keys()) + reaction_id: int + reactant_combined_mol: Chem.Mol + product_combined_mol: Chem.Mol + reaction_smarts: Optional[str] = None + reactant_smarts: Optional[str] = None + product_smiles: Optional[str] = None + csv_path: Path = None + mol_3d_path: Optional[Path] = None + reaction_dataframe: Optional[pd.DataFrame] = None + reactant_to_product_mapping: Dict[int, int] + template_reactant_to_product_mapping: Dict[int, int] + edge_atoms: List[int] + delete_atom: bool = True + delete_atom_idx: Optional[int] = None + activity_stats: bool = True - for new_key_idx, old_key in enumerate(sorted_old_keys): - new_key = new_key_idx + 1 # Start new keys from 1 - reaction_data = molecule_dict_csv_path_dict[old_key] - csv_save_path = reaction_data.get("csv_path") - - if new_key != old_key: - # Construct the new filename based on the new index (e.g., reaction_2.csv) - new_csv_save_path = os.path.join( - os.path.dirname(csv_save_path), - f"reaction_{new_key}.csv" - ) - - # Check if destination exists to avoid crashing or accidental overwrites - if os.path.exists(new_csv_save_path): - os.remove(new_csv_save_path) - - # Rename the physical file on the disk to match the new key - os.rename(csv_save_path, new_csv_save_path) - - # Update the path in the metadata dictionary - reaction_data["csv_path"] = new_csv_save_path - - new_dict[new_key] = reaction_data - - return new_dict - -def add_column_safe(df, list_data, column_name): + +@dataclass (slots=True) +class PipelineOutput: """ - Safely adds a list as a new column to a DataFrame, handling potential - length mismatches by using Series alignment. - - Args: - df (pd.DataFrame): Target DataFrame. - list_data (list): Data to be added to the column. - column_name (str): Name of the new column. - - Returns: - pd.DataFrame: Modified DataFrame with the new column. + Final structured output of the ReactionTemplatePipeline. + Attributes: + - template_files: Dictionary mapping reaction identifiers to their corresponding molecule template file paths. + - all_reactions: Optional list of ReactionMetadata instances containing detailed information about each processed reaction """ - # Creating a Series from the list ensures it starts from the top (index 0) - # and fills missing rows with NaN if the list is shorter than the DataFrame - df[column_name] = pd.Series(list_data).astype("Int64") - return df - - -def extract_unique_references(detected_reactions: dict) -> list[str]: - """Collect reference URLs from detected_reactions[*]["reference"], dedupe, keep order.""" - seen = set() - refs: list[str] = [] - - for rxn in detected_reactions.values(): - ref = rxn.get("reference") or {} - - # single URL fields - for v in ref.values(): - if isinstance(v, str): - if v not in seen: - seen.add(v) - refs.append(v) - - # list-of-URLs fields - elif isinstance(v, (list, tuple)): - for u in v: - if isinstance(u, str) and u not in seen: - seen.add(u) - refs.append(u) - - # (optional) nested dict handling, if you ever add that later - elif isinstance(v, dict): - for u in v.values(): - if isinstance(u, str) and u not in seen: - seen.add(u) - refs.append(u) - return refs - + template_files: Dict[str, Path] + all_reactions: Optional[List[ReactionMetadata]] = None # The main class encapsulating the reaction template pipeline class ReactionTemplatePipeline: @@ -277,7 +142,46 @@ def __init__(self, detected_reactions_dict: dict, cache: str, non_monomer_molecu self.non_monomer_molecules_to_retain = non_monomer_molecules_to_retain self.formatted_dict, self.molecule_template_files, self.molecule_images = self.execute_pipeline(self.detected_reactions_dict, self.non_monomer_molecules_to_retain, self.cache) + def _add_column_safe(self, df, list_data, column_name): + """ + Safely adds a list as a new column to a DataFrame, handling potential + length mismatches by using Series alignment. + + Args: + df (pd.DataFrame): Target DataFrame. + list_data (list): Data to be added to the column. + column_name (str): Name of the new column. + Returns: + pd.DataFrame: Modified DataFrame with the new column. + """ + # Creating a Series from the list ensures it starts from the top (index 0) + # and fills missing rows with NaN if the list is shorter than the DataFrame + df[column_name] = pd.Series(list_data).astype("Int64") + return df + + def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): + """ + Adds dictionary keys and values as new columns to an existing DataFrame. + + This is specifically used to map reactant indices to product indices + within the reaction template. + + Args: + df_existing (pd.DataFrame): The DataFrame to modify. + data_dict (dict): Dictionary where keys and values will become column data. + titles (list): List of two strings for the new column names. + + Returns: + pd.DataFrame: The modified DataFrame with new columns added. + """ + # Convert dict keys and values to Series to ensure alignment with the DataFrame + # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers + df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") + df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + + return df_existing + def run_reaction_template_pipeline(self, detected_reactions, cache): """ Main execution pipeline for mapping reactions, identifying templates, @@ -324,14 +228,14 @@ def run_reaction_template_pipeline(self, detected_reactions, cache): # is_duplicate, processed_dict = compare_rdkit_fragments(...) # Update the dataframe with specific template mapping indices - reaction_dataframe = add_dict_as_new_columns( + reaction_dataframe = self._add_dict_as_new_columns( reaction_dataframe, template_mapped_dict, titles = ["template_reactant_idx", "template_product_idx"] ) # Append edge atoms information (crucial for building polymer chains) - reaction_dataframe = add_column_safe( + reaction_dataframe = self._add_column_safe( reaction_dataframe, edge_atoms, "edge_atoms" @@ -406,19 +310,11 @@ def execute_pipeline(self, detected_reactions, non_monomer_molecules_to_retain, print(f"Molecule Template File for {name}: {path}") # Extract and save unique references to a text file for user reference - references = extract_unique_references(detected_reactions) - - # Print and save references to a text file - print("\nReferences used in detected reactions:") - for ref in references: - print(ref) with open(Path(cache) / "molecule_template_files.txt", "w") as f: for name, path in molecule_template_files.items(): f.write(f"{name}: {path}\n") - f.write("\nReferences:\n") - for ref in references: - f.write(f"{ref}\n") + return formatted_dict, molecule_template_files, molecule_images # TODO: If duplicates were found and skipped, re-index the dictionary and files to be continuous diff --git a/AutoREACTER/reaction_template_builder/lunar_client/__init__.py b/AutoREACTER/reaction_preparation/lunar_client/__init__.py similarity index 100% rename from AutoREACTER/reaction_template_builder/lunar_client/__init__.py rename to AutoREACTER/reaction_preparation/lunar_client/__init__.py diff --git a/AutoREACTER/reaction_preparation/lunar_client/config.py b/AutoREACTER/reaction_preparation/lunar_client/config.py new file mode 100644 index 0000000..adfc586 --- /dev/null +++ b/AutoREACTER/reaction_preparation/lunar_client/config.py @@ -0,0 +1 @@ +LUNAR_ROOT_DIR = '/mnt/c/Users/Janitha/OneDrive - stevens.edu/research_code_projects/LUNAR' diff --git a/AutoREACTER/reaction_template_builder/lunar_client/locate_lunar.py b/AutoREACTER/reaction_preparation/lunar_client/locate_lunar.py similarity index 100% rename from AutoREACTER/reaction_template_builder/lunar_client/locate_lunar.py rename to AutoREACTER/reaction_preparation/lunar_client/locate_lunar.py diff --git a/AutoREACTER/reaction_template_builder/lunar_client/lunar_api_wrapper.py b/AutoREACTER/reaction_preparation/lunar_client/lunar_api_wrapper.py similarity index 100% rename from AutoREACTER/reaction_template_builder/lunar_client/lunar_api_wrapper.py rename to AutoREACTER/reaction_preparation/lunar_client/lunar_api_wrapper.py diff --git a/AutoREACTER/reaction_template_builder/lunar_client/molecule_3d_preparation.py b/AutoREACTER/reaction_preparation/lunar_client/molecule_3d_preparation.py similarity index 100% rename from AutoREACTER/reaction_template_builder/lunar_client/molecule_3d_preparation.py rename to AutoREACTER/reaction_preparation/lunar_client/molecule_3d_preparation.py diff --git a/AutoREACTER/reaction_template_builder/lunar_client/molecule_template_preparation.py b/AutoREACTER/reaction_preparation/lunar_client/molecule_template_preparation.py similarity index 100% rename from AutoREACTER/reaction_template_builder/lunar_client/molecule_template_preparation.py rename to AutoREACTER/reaction_preparation/lunar_client/molecule_template_preparation.py diff --git a/AutoREACTER/reaction_template_builder/reaction_template_pipeline/__init__.py b/AutoREACTER/reaction_preparation/reaction_processor/__init__.py similarity index 100% rename from AutoREACTER/reaction_template_builder/reaction_template_pipeline/__init__.py rename to AutoREACTER/reaction_preparation/reaction_processor/__init__.py diff --git a/AutoREACTER/reaction_template_builder/reaction_template_pipeline/map_reactant_atoms.py b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py similarity index 100% rename from AutoREACTER/reaction_template_builder/reaction_template_pipeline/map_reactant_atoms.py rename to AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py diff --git a/AutoREACTER/reaction_template_builder/reaction_template_pipeline/compare_rdkit_fragments.py b/AutoREACTER/reaction_preparation/reaction_processor/fragment_comparison.py similarity index 100% rename from AutoREACTER/reaction_template_builder/reaction_template_pipeline/compare_rdkit_fragments.py rename to AutoREACTER/reaction_preparation/reaction_processor/fragment_comparison.py diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py new file mode 100644 index 0000000..9bf062c --- /dev/null +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -0,0 +1,78 @@ + +from dataclasses import dataclass +from pathlib import Path +from typing import Dict, List, Optional +import pandas as pd +from rdkit import Chem + +from AutoREACTER.detectors.reaction_detector import ReactionInstance, ReactionTemplate +from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupInfo, MonomerRole + +@dataclass (slots=True) +class ReactionMetadata: + reaction_id: int + reactant_combined_mol: Chem.Mol + product_combined_mol: Chem.Mol + reaction_smarts: Optional[str] = None + reactant_smarts: Optional[str] = None + product_smiles: Optional[str] = None + csv_path: Path = None + mol_3d_path: Optional[Path] = None + reaction_dataframe: Optional[pd.DataFrame] = None + reactant_to_product_mapping: Dict[int, int] + template_reactant_to_product_mapping: Dict[int, int] + edge_atoms: List[int] + delete_atom: bool = True + delete_atom_idx: Optional[int] = None + activity_stats: bool = True + +class PrepareReactions: + def __init__(self, reaction_templates: List[ReactionInstance]): + self.reaction_templates = reaction_templates + + def _add_column_safe(self, df, list_data, column_name): + """ + Safely adds a list as a new column to a DataFrame, handling potential + length mismatches by using Series alignment. + + Args: + df (pd.DataFrame): Target DataFrame. + list_data (list): Data to be added to the column. + column_name (str): Name of the new column. + + Returns: + pd.DataFrame: Modified DataFrame with the new column. + """ + # Creating a Series from the list ensures it starts from the top (index 0) + # and fills missing rows with NaN if the list is shorter than the DataFrame + df[column_name] = pd.Series(list_data).astype("Int64") + return df + + def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): + """ + Adds dictionary keys and values as new columns to an existing DataFrame. + + This is specifically used to map reactant indices to product indices + within the reaction template. + + Args: + df_existing (pd.DataFrame): The DataFrame to modify. + data_dict (dict): Dictionary where keys and values will become column data. + titles (list): List of two strings for the new column names. + + Returns: + pd.DataFrame: The modified DataFrame with new columns added. + """ + # Convert dict keys and values to Series to ensure alignment with the DataFrame + # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers + df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") + df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + + return df_existing + + def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionMetadata]: + for reaction in reactions: + # Placeholder for the actual preparation logic + # This is where you would implement the logic to process each reaction, + # generate the combined mols, create the DataFrame, and populate the metadata. + pass diff --git a/AutoREACTER/reaction_template_builder/reaction_template_pipeline/util.py b/AutoREACTER/reaction_preparation/reaction_processor/utils.py similarity index 100% rename from AutoREACTER/reaction_template_builder/reaction_template_pipeline/util.py rename to AutoREACTER/reaction_preparation/reaction_processor/utils.py diff --git a/AutoREACTER/reaction_template_builder/reaction_template_pipeline/walker.py b/AutoREACTER/reaction_preparation/reaction_processor/walker.py similarity index 100% rename from AutoREACTER/reaction_template_builder/reaction_template_pipeline/walker.py rename to AutoREACTER/reaction_preparation/reaction_processor/walker.py diff --git a/AutoREACTER/reaction_template_builder/lunar_client/config.py b/AutoREACTER/reaction_template_builder/lunar_client/config.py deleted file mode 100644 index 50954f3..0000000 --- a/AutoREACTER/reaction_template_builder/lunar_client/config.py +++ /dev/null @@ -1,5 +0,0 @@ -import os - -# Root directory for the LUNAR installation. -# Configure via the LUNAR_ROOT_DIR environment variable; defaults to None if unset. -LUNAR_ROOT_DIR = os.environ.get("LUNAR_ROOT_DIR") or None From b289ea8d9e35c7e8006a0af3a94de31d75decf39 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:08:52 -0400 Subject: [PATCH 02/26] Implement reaction mapping pipeline --- .../reaction_processor/prepare_reactions.py | 415 +++++++++++++++++- 1 file changed, 392 insertions(+), 23 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 9bf062c..152d0e3 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -1,27 +1,38 @@ from dataclasses import dataclass +import os from pathlib import Path from typing import Dict, List, Optional import pandas as pd from rdkit import Chem +from rdkit.Chem import AllChem +from rdkit.Chem import rdChemReactions, rdmolops +import itertools from AutoREACTER.detectors.reaction_detector import ReactionInstance, ReactionTemplate from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupInfo, MonomerRole +from AutoREACTER.reaction_preparation.reaction_processor.atom_mapping import smart_mapping +from AutoREACTER.reaction_preparation.reaction_processor.utils import compare_products -@dataclass (slots=True) +class MappingError(Exception): + """Custom exception for errors in atom mapping.""" + pass + +@dataclass(slots=True) class ReactionMetadata: reaction_id: int reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol + reactant_to_product_mapping: Dict[int, int] + template_reactant_to_product_mapping: Dict[int, int] + edge_atoms: List[int] + reaction_smarts: Optional[str] = None reactant_smarts: Optional[str] = None product_smiles: Optional[str] = None - csv_path: Path = None + csv_path: Optional[Path] = None mol_3d_path: Optional[Path] = None reaction_dataframe: Optional[pd.DataFrame] = None - reactant_to_product_mapping: Dict[int, int] - template_reactant_to_product_mapping: Dict[int, int] - edge_atoms: List[int] delete_atom: bool = True delete_atom_idx: Optional[int] = None activity_stats: bool = True @@ -49,30 +60,388 @@ def _add_column_safe(self, df, list_data, column_name): return df def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): + # Convert dict keys and values to Series to ensure alignment with the DataFrame + # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers + df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") + df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + + return df_existing + + def _reaction_tuples(self, same_reactants, mol_reactant_1, mol_reactant_2): + + if same_reactants: + return [[mol_reactant_1, mol_reactant_1]] + + return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] + + def _is_number_in_set(self, set_of_tuples, reactant): + """ + Find a tuple in the set that contains atom indices matching specific atom map numbers. + + This function searches for atoms in the reactant molecule that have atom map numbers + 101 or 102, then checks if those atom indices exist in any tuple within the provided set. + + Args: + set_of_tuples (set of tuples): Set of atom index tuples to search through + reactant (Chem.Mol): RDKit molecule object to search for mapped atoms + + Returns: + tuple: The first tuple found containing a matching atom index + + Raises: + MappingError: If no matching atom is found in the provided set of tuples + + Example: + >>> matches = {(0, 1, 2), (3, 4, 5)} + >>> result = self._is_number_in_set(matches, reactant_mol) + """ + for atom in reactant.GetAtoms(): + # Check for specific atom map numbers (101 or 102) + if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: + x = atom.GetIdx() + for t in set_of_tuples: + if x in t: + print(f"Found matching atom index {x} in tuple {t}") + return t + raise ValueError("No matching atom found in the provided set of tuples") + + def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): """ - Adds dictionary keys and values as new columns to an existing DataFrame. + Create RDKit molecule objects from SMILES strings with explicit hydrogens. + + Args: + reactant_smiles_1 (str): SMILES string for first reactant + reactant_smiles_2 (str): SMILES string for second reactant + + Returns: + tuple: (mol_reactant_1, mol_reactant_2) - Both molecules with explicit hydrogens + + Example: + >>> mol1, mol2 = self._build_reactants("CCO", "CC=O") + """ + mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) + mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens + mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) + mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens + return mol_reactant_1, mol_reactant_2 - This is specifically used to map reactant indices to product indices - within the reaction template. + def _prepare_paths(self, cache): + csv_cache = Path(cache) / "atom_mapping_btw_reactants_products_in_csv" + csv_cache.mkdir(parents=True, exist_ok=True) + return csv_cache + + def _build_reaction(self, rxn_smarts): + rxn = AllChem.ReactionFromSmarts(rxn_smarts) + if rxn is None: + raise ValueError(f"Invalid reaction SMARTS: {rxn_smarts}") + return rxn + def _is_consecutive(self, num_list): + """ + Check if a list of numbers forms a consecutive sequence without gaps. + Args: - df_existing (pd.DataFrame): The DataFrame to modify. - data_dict (dict): Dictionary where keys and values will become column data. - titles (list): List of two strings for the new column names. - + num_list (list): List of integers to check + Returns: - pd.DataFrame: The modified DataFrame with new columns added. + bool: True if the numbers are consecutive, False otherwise + + Examples: + >>> is_consecutive([1, 2, 3, 4]) # Returns True + >>> is_consecutive([1, 3, 4]) # Returns False + >>> is_consecutive([]) # Returns False """ - # Convert dict keys and values to Series to ensure alignment with the DataFrame - # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers - df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") - df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + if not num_list: + return False + + # Check for consecutive sequence: unique numbers and max-min+1 equals length + return (len(set(num_list)) == len(num_list) and + max(num_list) - min(num_list) + 1 == len(num_list)) + - return df_existing + def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, + molecule_and_csv_path_dict=None, delete_atoms=False): + """ + Process chemical reactions, map atoms between reactants and products, and save data. + + This is the main processing function that: + 1. Runs reactions on reactant pairs + 2. Maps atoms between reactants and products + 3. Validates mapping consistency + 4. Saves mapping data to CSV files + 5. Identifies reaction features (first shell, initiators, byproducts) + + Args: + rxn (Chem.rdChemReactions.ChemicalReaction): RDKit reaction object + csv_cache (Path): Directory path for CSV output files + reaction_tuple (list): List of reactant pairs to process + key (str or int, optional): Identifier for the reaction set + molecule_and_csv_path_dict (dict, optional): Dictionary to store results + delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion + + Returns: + mols, output, molecule_and_csv_path_dict + - mols: List of reactant and product molecules for visualization + - molecule_and_csv_path_dict: Dictionary containing all processed data + + Raises: + ValueError: If mapping validation fails at any step + + Note: + This function performs extensive validation including: + - Atom count consistency between reactants and products + - Consecutive indexing requirements + - Initiator count validation (must be exactly 2) + """ + if molecule_and_csv_path_dict is None: + molecule_and_csv_path_dict = {} + + total_products = 0 + mols = [] + + # Process each reactant pair in the reaction tuple + for j, pair in enumerate(reaction_tuple): + r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) + products = rxn.RunReactants((r1, r2)) + if not products: + continue # Skip if no products are generated + + # Get substructure matches for each reactant against reaction templates + matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) + matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) + + # Process each product set generated by the reaction + for product_set in products: + # Clean up any existing DataFrame + if "df" in locals(): + del df + + + # Initialize data structures + df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) + first_shell = [] # Atoms in first coordination shell + initiator_idxs = [] # Initiator atom indices + mapping_dict = {} # Additional mapping dictionary + + # Apply atom mapping from reaction properties + num_total_atoms = 0 + for i, product in enumerate(product_set): + if i > 0: + num_total_atoms += product_set[i - 1].GetNumAtoms() + for atom in product.GetAtoms(): + if atom.HasProp("react_idx"): + r_idx = atom.GetIntProp("react_idx") + a_idx = atom.GetIntProp("react_atom_idx") + r = (r1, r2)[r_idx] + r_atom = r.GetAtomWithIdx(a_idx) + map_num = atom.GetIdx() + 1 + num_total_atoms + 100 + r_atom.SetAtomMapNum(map_num) + atom.SetAtomMapNum(map_num) + + # Combine reactants and products for easier processing + reactant_combined = Chem.CombineMols(r1, r2) + product_combined = Chem.CombineMols(*product_set) + + # Create mapping between reactant and product atoms based on map numbers + for r_atom in reactant_combined.GetAtoms(): + for p_atom in product_combined.GetAtoms(): + if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): + new_row = pd.DataFrame([{"reactant_idx": r_atom.GetIdx(), + "product_idx": p_atom.GetIdx()}]) + df = pd.concat([df, new_row], ignore_index=True) + break + + # Validate mapping completeness and consistency + num_reactant_atoms = reactant_combined.GetNumAtoms() + num_product_atoms = product_combined.GetNumAtoms() + reactant_mapped = df["reactant_idx"].notna().sum() + product_mapped = df["product_idx"].notna().sum() + + # Validation 1: Mapped atom counts must match between columns + if reactant_mapped != product_mapped: + raise MappingError( + "Mismatch in mapped atom counts between columns: " + f"reactant_idx mapped={reactant_mapped}, product_idx mapped={product_mapped}" + ) + + # Validation 2: All reactant atoms must be mapped + if reactant_mapped != num_reactant_atoms: + df.to_csv(csv_cache / f"debug_mapping_{key}_{total_products}.csv", index=False) + raise MappingError( + "Mapping does not cover all reactant atoms: " + f"reactant atoms={num_reactant_atoms}, mapped={reactant_mapped}" + ) + + # Validation 3: All product atoms must be mapped + if product_mapped != num_product_atoms: + raise MappingError( + "Mapping does not cover all product atoms: " + f"product atoms={num_product_atoms}, mapped={product_mapped}" + ) + + # Validation 4: Mapping indices must be consecutive + if (self._is_consecutive(df["reactant_idx"].tolist()) is False or + self._is_consecutive(df["product_idx"].tolist()) is False): + raise MappingError( + "Mapping indices are not consecutive: " + f"reactant indices={df['reactant_idx'].tolist()}, " + f"product indices={df['product_idx'].tolist()}" + ) + + # Apply smart mapping to both reactants + try: + sub_set1 = self._is_number_in_set(matches_1, r1) + except ValueError: + sub_set1 = () + smart_mapping( + reactant=r1, + smarts_template=rxn.GetReactants()[0], + match_tuple=sub_set1 if sub_set1 else (), + ) + + try: + sub_set2 = self._is_number_in_set(matches_2, r2) + except ValueError: + sub_set2 = () + smart_mapping( + reactant=r2, + smarts_template=rxn.GetReactants()[1], + match_tuple=sub_set2 if sub_set2 else (), + ) + + # Recombine reactants after mapping + reactant_combined = Chem.CombineMols(r1, r2) + + # Identify first shell atoms and initiators + for atom in reactant_combined.GetAtoms(): + if 0 < map_num <= 99: + first_shell.append(atom.GetIdx()) + + if 0 < map_num <= 2: + initiator_idxs.append(atom.GetIdx()) + + # Identify byproduct atoms if deletion is requested + byproduct_product_idxs = [] + byproduct_reactant_idxs = [] + + if delete_atoms: + frags = rdmolops.GetMolFrags(product_combined, asMols=True) + smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) + + # 1) get byproduct atom indices in PRODUCT space + for atom in smallest_mol.GetAtoms(): + byproduct_map_number = atom.GetAtomMapNum() + for p_atom in product_combined.GetAtoms(): + if p_atom.GetAtomMapNum() == byproduct_map_number: + byproduct_product_idxs.append(p_atom.GetIdx()) + break + + # 2) convert PRODUCT indices -> REACTANT indices using df mapping + byproduct_reactant_idxs = ( + df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] + .astype(int) + .tolist() + ) + + # if you want the column to store REACTANT indices now: + byproduct_indexs = byproduct_reactant_idxs + + # Add any additional mappings from mapping_dict + for r_idx, p_idx in mapping_dict.items(): + new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) + df = pd.concat([df, new_row], ignore_index=True) + + # Create comprehensive DataFrame with all analysis columns + first_shell_column = pd.Series(first_shell, name="first_shell") + initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") + + # Validation: Must have exactly 2 initiators + if len(initiator_idxs) != 2: + raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") + + by_product_indexs_column = pd.Series(byproduct_indexs, name="byproduct_indices") + + # Combine all data into final DataFrame + df_combined = pd.concat([df, first_shell_column, initiator_idxs_column, + by_product_indexs_column], axis=1).astype(pd.Int64Dtype()) + + # Check for duplicate products + if not compare_products(molecule_and_csv_path_dict, product_combined): + continue + + # Update counters and store results + total_products += 1 + mols.append(reactant_combined) + mols.append(product_combined) + + # Organize results in the output dictionary + for i in itertools.count(1): + if i not in molecule_and_csv_path_dict: # Check if i IS a key + sub_dict = molecule_and_csv_path_dict[i] = {} # Initialize if not found + dict_key = i + break + + # Save to CSV file + df_combined.to_csv(csv_cache / f"reaction_{dict_key}.csv", index=False) + print(f"Saved reaction {dict_key} to CSV") + + sub_dict["reactant"] = reactant_combined + sub_dict["product"] = product_combined + sub_dict["csv_path"] = csv_cache / f"reaction_{dict_key}.csv" + sub_dict["delete_atoms"] = delete_atoms + sub_dict["reaction_dataframe"] = df_combined + + + return mols, molecule_and_csv_path_dict - def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionMetadata]: + def prepare_reactions(self, reactions: List[ReactionInstance], cache: str) -> List[ReactionMetadata]: + + csv_cache = self._prepare_paths(cache) + metadata_list = [] + for reaction in reactions: - # Placeholder for the actual preparation logic - # This is where you would implement the logic to process each reaction, - # generate the combined mols, create the DataFrame, and populate the metadata. - pass + + rxn = self._build_reaction(reaction.reaction_smarts) + + mol_r1, mol_r2 = self._build_reactants( + reaction.reactant_smiles_1, + reaction.reactant_smiles_2 + ) + + reaction_tuple = self._reaction_tuples( + reaction.same_reactants, + mol_r1, + mol_r2 + ) + + mols, result_dict = self._process_reactions( + rxn, + csv_cache, + reaction_tuple, + key=reaction.reaction_id + ) + + for rid, data in result_dict.items(): + + df = data["reaction_dataframe"] + + mapping = dict(zip( + df["reactant_idx"].dropna(), + df["product_idx"].dropna() + )) + + metadata = ReactionMetadata( + reaction_id=rid, + reactant_combined_mol=data["reactant"], + product_combined_mol=data["product"], + reactant_to_product_mapping=mapping, + template_reactant_to_product_mapping={}, + edge_atoms=[], + reaction_smarts=reaction.reaction_smarts, + csv_path=data["csv_path"], + reaction_dataframe=df + ) + + metadata_list.append(metadata) + + return metadata_list From 11cc7ffb1c1fdf4f85000ede337b7660397291b8 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Wed, 11 Mar 2026 14:38:45 -0400 Subject: [PATCH 03/26] Integrate walker, add template mapping & image grid --- .../reaction_processor/prepare_reactions.py | 122 ++++++++++++++---- 1 file changed, 99 insertions(+), 23 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 152d0e3..3adf61c 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -1,18 +1,19 @@ from dataclasses import dataclass -import os from pathlib import Path from typing import Dict, List, Optional import pandas as pd from rdkit import Chem -from rdkit.Chem import AllChem -from rdkit.Chem import rdChemReactions, rdmolops +from rdkit.Chem import AllChem, Draw, rdChemReactions +from PIL.Image import Image import itertools +import pandas as pd from AutoREACTER.detectors.reaction_detector import ReactionInstance, ReactionTemplate from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupInfo, MonomerRole from AutoREACTER.reaction_preparation.reaction_processor.atom_mapping import smart_mapping from AutoREACTER.reaction_preparation.reaction_processor.utils import compare_products +from AutoREACTER.reaction_preparation.reaction_processor.walker import reaction_atom_walker class MappingError(Exception): """Custom exception for errors in atom mapping.""" @@ -89,7 +90,7 @@ def _is_number_in_set(self, set_of_tuples, reactant): tuple: The first tuple found containing a matching atom index Raises: - MappingError: If no matching atom is found in the provided set of tuples + ValueError: If no matching atom is found in the provided set of tuples Example: >>> matches = {(0, 1, 2), (3, 4, 5)} @@ -180,7 +181,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion Returns: - mols, output, molecule_and_csv_path_dict + mols, molecule_and_csv_path_dict: - mols: List of reactant and product molecules for visualization - molecule_and_csv_path_dict: Dictionary containing all processed data @@ -212,16 +213,11 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # Process each product set generated by the reaction for product_set in products: - # Clean up any existing DataFrame - if "df" in locals(): - del df - - + # Initialize data structures df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) first_shell = [] # Atoms in first coordination shell initiator_idxs = [] # Initiator atom indices - mapping_dict = {} # Additional mapping dictionary # Apply atom mapping from reaction properties num_total_atoms = 0 @@ -314,12 +310,14 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # Identify first shell atoms and initiators for atom in reactant_combined.GetAtoms(): + map_num = atom.GetAtomMapNum() + idx = atom.GetIdx() if 0 < map_num <= 99: - first_shell.append(atom.GetIdx()) + first_shell.append(idx) if 0 < map_num <= 2: - initiator_idxs.append(atom.GetIdx()) - + initiator_idxs.append(idx) + # Identify byproduct atoms if deletion is requested byproduct_product_idxs = [] byproduct_reactant_idxs = [] @@ -346,11 +344,6 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # if you want the column to store REACTANT indices now: byproduct_indexs = byproduct_reactant_idxs - # Add any additional mappings from mapping_dict - for r_idx, p_idx in mapping_dict.items(): - new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) - df = pd.concat([df, new_row], ignore_index=True) - # Create comprehensive DataFrame with all analysis columns first_shell_column = pd.Series(first_shell, name="first_shell") initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") @@ -425,18 +418,48 @@ def prepare_reactions(self, reactions: List[ReactionInstance], cache: str) -> Li df = data["reaction_dataframe"] - mapping = dict(zip( + reactant_mol = data["reactant"] + + # FULL atom mapping + fully_mapped_dict = dict(zip( df["reactant_idx"].dropna(), df["product_idx"].dropna() )) + # first shell atoms + first_shell = df["first_shell"].dropna().astype(int).tolist() + + # WALKER + template_mapped_dict, edge_atoms = reaction_atom_walker( + reactant_mol, + first_shell, + fully_mapped_dict + ) + + # update dataframe + df = self._add_dict_as_new_columns( + df, + template_mapped_dict, + titles=["template_reactant_idx", "template_product_idx"] + ) + + df = self._add_column_safe( + df, + edge_atoms, + "edge_atoms" + ) + + # store updated dataframe + data["reaction_dataframe"] = df.copy() + + # build metadata metadata = ReactionMetadata( reaction_id=rid, reactant_combined_mol=data["reactant"], product_combined_mol=data["product"], - reactant_to_product_mapping=mapping, - template_reactant_to_product_mapping={}, - edge_atoms=[], + reactant_to_product_mapping=fully_mapped_dict, + template_reactant_to_product_mapping=template_mapped_dict, + edge_atoms=edge_atoms, reaction_smarts=reaction.reaction_smarts, csv_path=data["csv_path"], reaction_dataframe=df @@ -445,3 +468,56 @@ def prepare_reactions(self, reactions: List[ReactionInstance], cache: str) -> Li metadata_list.append(metadata) return metadata_list + + + + def reaction_templates_highligted_image_grid( + self, + metadata_list: List[ReactionMetadata], + highlight_type: str = "template" + ) -> Image: + """ + Create a grid image highlighting atoms in reactant molecules. + + highlight_type options: + "template" + "edge" + "initiators" + """ + + mols = [] + highlight_lists = [] + + for metadata in metadata_list: + + reactant = metadata.reactant_combined_mol + product = metadata.product_combined_mol + df = metadata.reaction_dataframe + + if highlight_type == "template": + atoms = list(metadata.template_reactant_to_product_mapping.keys()) + + elif highlight_type == "edge": + atoms = metadata.edge_atoms + + elif highlight_type == "initiators": + atoms = df["initiators"].dropna().astype(int).tolist() + + else: + atoms = [] + + mols.extend([reactant, product]) + highlight_lists.append(atoms) + highlight_lists.append([]) # don't highlight product + + img = Draw.MolsToGridImage( + mols, + molsPerRow=2, + highlightAtomLists=highlight_lists, + subImgSize=(400, 400), + useSVG=False + ) + + return img + + From 972b3cad68eb0955da6d9e0fba870ad501e818b4 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Wed, 11 Mar 2026 19:15:17 -0400 Subject: [PATCH 04/26] Update prepare_reactions.py --- .../reaction_processor/prepare_reactions.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 3adf61c..04d3a2d 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -4,7 +4,8 @@ from typing import Dict, List, Optional import pandas as pd from rdkit import Chem -from rdkit.Chem import AllChem, Draw, rdChemReactions +from rdkit.Chem import AllChem, Draw, rdChemReactions, rdmolops +from rdkit.Chem.rdchem import Mol from PIL.Image import Image import itertools import pandas as pd @@ -39,8 +40,8 @@ class ReactionMetadata: activity_stats: bool = True class PrepareReactions: - def __init__(self, reaction_templates: List[ReactionInstance]): - self.reaction_templates = reaction_templates + def __init__(self, cache: Path): + self.cache = self._prepare_paths(cache) def _add_column_safe(self, df, list_data, column_name): """ @@ -387,9 +388,9 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, return mols, molecule_and_csv_path_dict - def prepare_reactions(self, reactions: List[ReactionInstance], cache: str) -> List[ReactionMetadata]: + def prepare_reactions(self, reactions: List[ReactionInstance],) -> List[ReactionMetadata]: - csv_cache = self._prepare_paths(cache) + csv_cache = self._prepare_paths(self.cache) metadata_list = [] for reaction in reactions: From 2cbae0fcb47f836b822d727f9e498dbc2c7f70f6 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Wed, 11 Mar 2026 19:15:52 -0400 Subject: [PATCH 05/26] Update example_1.ipynb --- examples/example_1.ipynb | 384 +++++++++++++++++++++++++++++++-------- 1 file changed, 310 insertions(+), 74 deletions(-) diff --git a/examples/example_1.ipynb b/examples/example_1.ipynb index 69c0c6c..f58ca2d 100644 --- a/examples/example_1.ipynb +++ b/examples/example_1.ipynb @@ -12,17 +12,34 @@ "- `Initialization()` sets up the AutoREACTER runtime environment.\n", "- `InputParser()` prepares the parser for validating and normalizing user input files.\n", "- `GetCacheDir()` retrieves the staging cache directory used for intermediate data.\n", - "- `RunDirectoryManager.make_dated_run_dir()` creates a timestamped run directory to store outputs for this session.\n", - "\n", - "This ensures each run is isolated and reproducible." + "- `RunDirectoryManager.make_dated_run_dir()` creates a timestamped run directory to store outputs for this session." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2dccf25a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All required modules are successfully imported.\n", + " \n", + " .o. . ooooooooo. oooooooooooo .o. .oooooo. ooooooooooooo oooooooooooo ooooooooo. \n", + " .888. .o8 `888 `Y88. `888' `8 .888. d8P' `Y8b 8' 888 `8 `888' `8 `888 `Y88. \n", + " .8\"888. oooo oooo .o888oo .ooooo. 888 .d88' 888 .8\"888. 888 888 888 888 .d88' \n", + " .8' `888. `888 `888 888 d88' `88b 888ooo88P' 888oooo8 .8' `888. 888 888 888oooo8 888ooo88P' \n", + " .88ooo8888. 888 888 888 888 888 888`88b. 888 \" .88ooo8888. 888 888 888 \" 888`88b. \n", + " .8' `888. 888 888 888 . 888 888 888 `88b. 888 o .8' `888. `88b ooo 888 888 o 888 `88b. \n", + "o88o o8888o `V88V\"V8P' \"888\" `Y8bod8P' o888o o888o o888ooooood8 o88o o8888o `Y8bood8P' o888o o888ooooood8 o888o o888o \n", + "\n", + "AutoREACTER version: v0.2-beta.0\n", + "Cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache\n" + ] + } + ], "source": [ "from AutoREACTER.initialization import Initialization\n", "from AutoREACTER.input_parser import InputParser\n", @@ -30,7 +47,8 @@ "from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupsDetector\n", "from AutoREACTER.detectors.reaction_detector import ReactionDetector\n", "from AutoREACTER.detectors.non_monomer_detector import NonReactantsDetector\n", - "from AutoREACTER.reaction_template_builder.run_reaction_template_pipeline import ReactionTemplatePipeline\n", + "from AutoREACTER.reaction_preparation.reaction_processor.prepare_reactions import PrepareReactions\n", + "# from AutoREACTER.reaction_template_builder.run_reaction_template_pipeline import ReactionTemplatePipeline\n", "from rdkit import Chem\n", "from rdkit.Chem import Draw\n", "import json\n", @@ -41,6 +59,7 @@ "dated_cache_dir = RunDirectoryManager.make_dated_run_dir(cache_dir, chdir_to=\"none\")\n", "# #future use\n", "# RunDirectoryManager.copy_into_run(cache_dir, dated_cache_dir)\n", + "print(f\"Cache directory: {cache_dir}\")\n", "\n", "\n" ] @@ -52,21 +71,20 @@ "source": [ "### Cache Cleanup (Optional)\n", "\n", - "This cell can be used to clean up cached data generated by previous runs.\n", - "\n", - "- `RetentionCleanup.run()` removes cached directories from the AutoREACTER cache base directory.\n", - "- Useful for freeing disk space or resetting the cache state.\n", - "\n", - "Uncomment and run only if you want to remove cached run data." + "This cell can be used to clean up cached data generated by previous runs.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "67a1b385", "metadata": {}, "outputs": [], "source": [ + "\n", + "# `RetentionCleanup.run()` removes cached directories from the AutoREACTER cache base directory.\n", + "# Useful for freeing disk space or resetting the cache state.\n", + "\n", "# RetentionCleanup.run(GetCacheDir().cache_base_dir)" ] }, @@ -75,29 +93,57 @@ "id": "b1dd989a", "metadata": {}, "source": [ - "### Load, Validate, and Visualize Monomers\n", + "### Load and Validate Monomers\n", "\n", "This cell loads the example input file, validates it using the `InputParser`, and visualizes the monomers.\n", - "\n", - "- The JSON input file is loaded into `input_data`.\n", - "- `validate_inputs()` checks the schema and normalizes the data.\n", - "- `molecule_representation_of_initial_molecules()` extracts RDKit molecule objects.\n", - "- `Draw.MolsToGridImage()` displays the monomers in a grid with their labels.\n", - "\n", - "This provides a quick visual check of the input molecules before running further analysis." + "\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "32ab0cba", "metadata": {}, "outputs": [], "source": [ + "\n", + "# validate_inputs() checks the schema and normalizes the data.\n", + "# molecule_representation_of_initial_molecules() extracts RDKit molecule objects.\n", + "# Draw.MolsToGridImage() displays the monomers in a grid with their labels.\n", + "\n", "with open(\"example_1_inputs_count_mode.json\", \"r\") as f:\n", " input_data = json.load(f)\n", "\n", - "validated_inputs = input_parser.validate_inputs(input_data)\n", + "validated_inputs = input_parser.validate_inputs(input_data)\n" + ] + }, + { + "cell_type": "markdown", + "id": "a48c7aee", + "metadata": {}, + "source": [ + "### Visualize Monomers (Optional)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "63c6e279", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "initial_molecules = input_parser.initial_molecules_image_grid(validated_inputs)\n", "initial_molecules" ] @@ -114,10 +160,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "3bcaf515", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Default cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache\n" + ] + } + ], "source": [ "default_cache_dir = GetCacheDir().cache_base_dir\n", "print(f\"Default cache directory: {default_cache_dir}\")" @@ -130,20 +184,32 @@ "source": [ "### Functional Group Detection\n", "\n", - "This cell runs the functional group detection step.\n", - "\n", - "- `FunctionalGroupsDetector()` initializes the detector.\n", - "- `functional_groups_detector()` analyzes the validated monomers.\n", - "- It identifies functional groups present in each molecule and generates corresponding visualization images." + "This cell runs the functional group detection step.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "04b6e642", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: hydroxy_acid_halide\n", + "Note: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl - Hydroxy acid halides are highly reactive and less commonly used monomers for polyesterification compared to hydroxy carboxylic acids.\n", + "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: diol\n", + "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: di_carboxylic_acid_halide\n", + "Nc1cccc(N)c1 has functionality: di_amine\n" + ] + } + ], "source": [ + "# FunctionalGroupsDetector() initializes the detector.\n", + "# functional_groups_detector() analyzes the validated monomers.\n", + "# It identifies functional groups present in each molecule and generates corresponding visualization images.\n", + "\n", "# Run the detector only after the inputs have been validated, as it consumes validated_inputs.monomers to execute the detection workflow.\n", "functional_groups_detector = FunctionalGroupsDetector()\n", "functional_groups, functional_groups_imgs = \\\n", @@ -157,21 +223,33 @@ "id": "76ad6db0", "metadata": {}, "source": [ - "### Functional Group Visualization\n", - "\n", - "This cell visualizes the detected functional groups on the molecules.\n", + "### Functional Group Visualization (Optional)\n", "\n", - "- `molecules_to_visualization()` highlights the functional groups identified in the previous step.\n", - "- The resulting image shows each molecule with the detected functional groups marked." + "This cell visualizes the detected functional groups on the molecules." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "e295e3b3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdwAAAH0CAIAAACo53h7AAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1hUZ9rH8XsaICCoKBGsWAB7AVsssWBiEks0okYjphiMKWo2ibLvZlddUyTJJuqmrNhLij1RY0nQ2AtSBAvYUAQsIF0pM8PM+8coQUADChwh38+11+V45jln7okj6/nN89yPymw2CwAAAAAAACqXWukCAAAAAAAA/ooIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABRAKAMAAAAAAKAAQhkAAAAAAAAFEMoAAAAAAAAogFAGAAAAAABAAYQyAAAAAAAACiCUAQAAAAAAUAChDAAAAAAAgAIIZQAAAAAAABSgVboAoMrS6+XKFbl5U0TE0VHq1xedTumaAAAAAABVBqEMUHaXL8vu3ZKQIFqtmM0iIiqVGI3i5ib9+4uLi9L1AQAAAACqAJXZcksJoDQMBvn5Zzl7VgyGkgfodNKhgzz9tKhZGwgAAAAAuB9CGaDU9HpZulRSUsRotBwwm803srPVKpWTre0fw3Q6adBAXnxRNBpl6gQAAAAAVAWEMkCprV4tcXFiMIhKFXH16px9+369cOGWXi8itWxsnnV3/9cTT7g7OYmI6HTSpo0MG6ZwwQAAAACARxihDFA6J07I1q2i14vITzExY9av16rVEzp08HJ1zTeZDsXHf3fihI1Wu3Xs2D5NmoiI6HQydqw0baps1QAAAACARxahDFAKZrN8+aVkZYlIYmZm66+/ttFq97/yyu15MSIicig+3mflylo2NmfeequmtbWIiIuL+PsrVTIAAAAA4BFHL1KgFBITJS/P8vDb0NDMvLyPBwwonMiIyOONGr3/+ONXs7JWRUXdPpScLGlplVwpAAAAAKCqIJQBSiE2tqC5728XLqhVqpGtWxcfNaZtW8uA279Xq+XSpUqqEAAAAABQ1RDKAKVw9aqYTJaH51NTXWvWdLSxKT7Ko25djVp9LjX19u/1eklKqrQaAQAAAABVC6EMUAq5uQUPb+r1dlZWJY5Sq1S2Ol3WnYVOIiLZ2RVdGgAAAACgiiKUAUqh0LwYeyurm3p9iaPyTaZsg8HB0uW32IkAAAAAABRGKAOUwmOPifr2XxZ3J6crmZkZhebOFDibkpJvMnnUrXv79zqdODtXWo0AAAAAgKqFUAYoBTc30WotDwc2b24W2RAdXXzUmlOnROTJ5s3/ONS0aWWUBwAAAACogghlgFJo3Fh0OsvDSV5eNa2tP9i9+1J6euEhEVev/ufQIdeaNce2a3f7UK1acve22QAAAAAAFFCZzWalawCqgvBw2bFDDAYRWXvq1IsbN9rpdK97e3dt0CDfbN4fF7c4PFylUm0dO7avZXaMTie+vtKypbJVAwAAAAAeWYQyQOmYzbJsmVy5Ivn5InI4Pv5fv/++59Ilo8kkIjZa7VMtWnzUv38bZ2cxm0WnkxYtZPRopYsGAAAAADy6CGWAUsvJkUWLJD1d7vytyTYYEjIz1SpVIwcH6ztNZ0Srlbp15ZVXClY8AQAAAABQHKEMUBbp6e8/++zRxMTZffv2c3MrYYBOJ+7u8txzBY2BAQAAAAAoEfeNQFlkZ4ckJu6PizPdnWY+vmRJntG4ccKEJn5+UmJYAwAAAADA3QhlgLJITb2QliYizWrXLjhmNpuPX7uWYzDU7t2bRAYAAAAAUEqEMkAZ5F6/fjUrS6fRNHJ0LDiYmJWVYzA429k5NGyoYG0oN3l5EhcnKSliMIi1tdSvLw0bikajdFkAAAAAqhtCGaAMYmNiTGZzM0dHrVpdcPBCaqqINK9TRwpNn0GVlJkpv/4qMTGi1YrBICaTaDSi1YrZLF27Su/eYmWldIkAAAAAqg9CGaAMLpw7J5b8pZDYtDQRaV67ttx9HFXMiROyZYuYTJKfb9n4XET+eHz0qEREyLhx4uKiYI0AAAAAqhP1nw8BcMeFuDix5C+FD1pCmXr1xNZWmbLw8EJDZcsWMRj+iGOKMBhSkpOTv/pKEhIqtzIAAAAA1RYzZYBSMxovXL0qxWbK3F6+1KiRqFTKFIaHdPmy/PqrGAyW3+WbTCeSkq7fvGmr07V1dq5do4bl+JOrViVnZ1+uWVPeekvs7ZUrFwAAAEA1QSgDlFp6+u38pcSZMs2aKVMVHpLJJOvXWxKZfJNp7oEDXxw+nJqTY3lSp9GMb9/+y0GDHKytb483GmXrVhkzRql6AQAAAFQbhDJAqaWm/tHTt5DbBz08lKkKD+nECcnLszyc8NNP30VFta5X79OBA9s4O2fm5a0/fXpJeLhZZOmwYbfH5+dLbKzcuCF16ypWMwAAAIBqgVAGKC1TSkpcRoZKxK1WrYKD6bm5qTk5tjqds5ubgrXhwR09Knq9iPwUE/NdVJSXq+vel16yu7PL0pPNmz/n6dmrceO7TsnPl4gIGTiw8osFAAAAUJ3Q6BcorfizZ/OMxvo1a9oV2he5YO6MyslJudLwoAwGuX7d8jAoLExEvnjqKbu7971+pmXLP9YuWZhMEhNTWSUCAAAAqLYIZYDSunD2rNyroUzt2nL3cVQNN26ITiciZrP5UHy8jVbbu8ikmHtJTxezuWJrAwAAAFDdEcoApRV78aLcq6GMk5M4OipTFh5Gdrbl1yy9PiM3t5Gjo6qUW2ipVJZFTwAAAADwwAhlgNIxmy8kJsq9Zsq4uoqav01V0J0IJs9oFJE6d3a//nNMkwEAAADw0LiNBEonM/NCSorca6YMXX6rKHt7y68O1tYqkfTc3NKeqFLJ3a1nAAAAAKCsCGWA0klLu52/3D1TJtYyU6ZlS2WqwkNychKjUUSstdpmdepcSE3NvLM99p+fWMqFTgAAAABwD4QyQOmkpt7OXwrNlMkzGhOzsrRqdWMPD+Uqw0PQaKRhQ8vDp1u0MJpMKyMjS3VW69YVWxgAAACAvwBCGaBUUuLi0nNzHayt69raFhy8lJ6ebzI1dnTU1aunYG14KD16iJWVmM3v9OhhZ2X1j1279ly6VPj5cykpRafPqFTSqVNl1ggAAACgWtIqXQBQNVw4c0aKN5QpmDvDfthVl7u7ODpKcnKz2rVXDh8+dsOG/suX93Vz61i/fq7RGHX9+qHLl78ZPPh1b+/b47Vaad9eHBwULRoAAABAdcBMGaBULly4IMW3XiroMkMoU3WpVOLra3k4olWrE5MnT+7SJenWrZWRkb9euGCt0czq12+4p6eItHV27li/vtjaylNPKVoxAAAAgGqCmTJAqVy4fFlEmpW4H3b9+mzEU7Xd2YNJRFo6OX397LMljDGbV4wYITY2MmECf9wAAAAAygUzZYBSyMm5kJQk99gPu1mTJspUhfKSmlrwMCQxcer27ZvPnCk6xtpa6tWTSZPk7s8AAAAAADywv8ZMmfx8uXVLDAbR60WnE51ObG1Fp1O6LFQdaWm3J8WUOFOmeXNlqkJ5SUsreHg4Pn7B0aNGk2lowY5aarXUqiW9e0uHDmyDDQAAAKAcVdNQJidHYmPl0iVJSJC0NNHrRasVlUrUajGbxWSS/HzRaKRWLXF1laZNpVkz2nbiflJTb7ePKTRLwmw2X0pPF5Fmnp6KFYZyUWimjCVou2ud2lNPSdeulV8UAAAAgGqveoUyRqOcPCkhIZKUJFqt6PViNouImM1iMBQdbDJJcrIkJ0t0tJhM4uAg3t7SsaPUqFH5heMRl3Pt2tWsLJ1G06hQeJeYlZVjMDjb2dVs0EDB2lAOCs2UKZ6+iatr5VcEAAAA4K+guoQy+fly+LDs3y8iotffPlLg/isOLONTU+X33+X336VzZ+nbV2xsKq5YVDmx0dFmkaa1amnUf7Rh+uPunSYjVV2xmTJ3rVNjay0AAAAAFaNahDJXr8qaNZKTY4lX9sXFLQ4PP5aYmJ6bW8vGxtvV9TUvrz6FWrF+c+zYqsjIRUOHtnV2LnyZuOTkMevXD2/TZnpkpAwfLu7ulf1G8Ki6cP683KuhDPthVwN3ZsqY7ixJcyv4M7WyEjs7peoCAAAAUL1V/VDm1Cn5+eeC1Unv//rr54cO1bKxGdSihWvNmleysraePbs6KupvPXr856mnLGPi0tOPJCRk5eUVuVKO0XgkIaH9Y49Jbq6sXy+9e0vv3pX6XvBoys+/EBsrxbZeirWEMvXqcdNetRmNkpVleZiQmZlnNNa3t7cv2PSaxA0AAABAhanioUxsbOFEZllExOeHDvVt2nTD6NF17rSGScnOHr5mzReHD7euV+/Vzp1Le2WDQfbvF2trGnz+1Z06Jb/8EmvZD7vITBnL8qWGDZUpDOXl/g1lWJsGAAAAoMKo/3zIIysvT9atK0hk8k2m2Xv32ltZrfH1rVOoWa+Tre1aX187K6t/792bbzKV4foGg/z2m6SklG/VqDLMZtm8WTZvlpyc2yuV7r4/v33QykoSE5WpEOWChjIAAAAAFFKVQ5mQkMLdfKOuX49LTx/i4eFcbC1JfXv7Ie7ulzMyIq9fL9tLmEyye/fDV4oqaetWOXnS0qjo9gSKEmfKODrKypWSlKRIjSgHzJQBAAAAoJCqvHzpxInCG12fSk4WkQ6PPVbi2M4uLj+ePHkqKamzi4vlyLErV25a9l26Iz4zs+hpJpOcPStm85/s34TqJzq64ANmMpvjMjJUhZu/iqTn5qbm5NhbWTnb2YleL99/L2+/LRqNchXjQTFTBgAAAIBCqnIoc3eGkpGbKyK17rGVteV4Wm5uwZGp27eX6lXMZsnLY4fsvxaTSbZtK4j84jMy8oxG15o1bXW6giGWKRXNatdWWQK7nBwJDZVu3ZQoFw+n0EyZ2OLr1AhlAAAAAFSYqhzK6HRSaAelGjqdiOQajSWOtRwvfFO9/Lnn2t89reZSevqINWuKnmk2S6Gz8Jdw7lzhSVj3ayhTcFCvl4MHCWWqpOKhTEEQo1aLo6MiRQEAAAD4K6jKoUzjxnL69B+/c3SUO/dUxVluoZsUur9yd3LqdGcpk0WNEsOX2rVZk/KXc+pU4bzvPg1lmhU+mJcnKSni5FRJRaJcmM2Snm55mJqTk5aTY29lVa+gL5Wjo6ircuMtAAAAAI+2qny/0aNH4TksXRs0sNFqd5w/bzabiww0mc3bzp2z0Wq7lXX3Yisr6dnz4StFlWE2y9mzEhNT+FjhSTHBFy4k37olJTYfUamkrJ2kobjMzIJ+4ZagrQVdfgEAAABUlqo8U6ZhQ2nVSk6fFqNRRBysrce1b78kPPyrkJC3715F8lVIyLmUFH8vLwdr6zJcX6MRJyfp2LF8q8YjKitLoqIkJESK9Xu23KsfvHy5xocf5hqNVhrNN88+W8I2PSaTZGdXYsUoD8W7/NJQBgAAAEBlqcqhjIgMHSppaXL1qiWXCfTx+f3ixWk7dpxNSXmxfXuXmjWv3by5KjLym2PHmtep84mPTxmurNGIvb28+CL7LlVzZrNcvChhYRITIyZT8eePX7u259IlEdlx/rzliD4//7XNmx1r1JDiM2W0Vfwv1F9Q8f2wC/+ZMlMGAAAAQEWq4veQGo1MmCCbNsm5c6LXO9naHnz11be3bfvm2LGvQkIsQ9Qq1fOtW//36afr1KhR2svqdOLsLOPGSelPQZVz65YcPy5hYVJSH6I8o3HzmTNBYWHBsbGWI53q1+/RqNHMvn2f+e67sCtX0nNyVCqVk63tH+eo1VKrVuXUjnLDTBkAAAAAylEV78BSJUVHy9atYjSKXi8iybduHbtyJTMvz8Hauour6x9tO0VE5PrNm8nZ2c1r1y7S2Vefn382I6OOra3rc89J167Mkam2rl6VsDCJjJSS9uo6n5q6ODx8SXj4jexsEXGwth7Ttu1bXbu2K7RX16aYmAmbNmXl5XnWrbth9OjW9eqJiGi1Mn06e3VVMevWFfQLf2LZsn1xcb/5+fk0a3b72cmTxdlZsdoAAAAAVHdVfKZMgVatxN1dIiLkwAHJyclMT+9Yv75rzZoljn3M3v4xe/u7DqlUYmVlpVa39fGRbt2kTK1nUFXk5UlkpISGSnJy8SfzTabfL12af+TIL2fPWnJKL1dXfy+vce3a2VlZFRk83NOz9WuvjVy79mRSUvfFi5cOGzayTRtp0YJEpuopPlOm8OwYpj4BAAAAqEjVJZQREY1GvL3F21uuXn1r2LAdx45tHjduSNu2IiIGQ9F2ISqV6HSiUonRKHZ24uEhrVtLkybMjqmeLFNjoqLEYCjhyayslZGR3xw7djkjQ0RstNohHh5Tu3Xr2bjxfS7pUbfu4YkTJ27evObkyVFr177do8fnEycSyVQ9dxav5RqNV7OydBpNI0fH20/Z20uxPA4AAAAAylE1CmUKuLhcSE8XkeYzZoiTk6SkSEaGZGZKbq6YzaJSibW12NuLo6M4OYmzM/Niqi2jUc6elbAwudMXpjCT2bz74sWgsLBN0dFGk0lEPOrWfbljx9e8vErZfsjeyurHkSP7u7m9vW3bgsOHj7/wwo8//uji4lLO7wIVJztb8vIsD2PT0kxmczNHR61afftZGsoAAAAAqGDVMJTJz8+Pi4tTqVRNmzcXW1txdVW6IjwQg0GSkuTmTdFopE6dsu2Dk5IiERESHi45OcWfTM/NXXH8+IKjR2PT0kTESqPxbdPG38trgJubqsSpUpYs7x78e/Ro3bXr6G+/3bdvX8eOHX/44Yf+/fuXoVQoqPjWS4U/Zmy9BAAAAKCCVcNQJj4+Xq/XN2jQwLbwzjioQhIS5PffJS5OtFpRqcRsFpNJtFrx8pLHH7/fllj5+XLmzL2mxohI2JUrQWFhq6KicgwGEWng4DCxc+c3unRxvrsV9G3W1tKypSQmyq1blgbSRanVotFI9+69+vY9PmnS2LFjg4ODn3rqqQ8//HD69Okl5zt4pNy/oQwzZQAAAABUsGoYyly4cEFEmjdvrnQhKDujUbZskejo281f8vP/eMpgkCNH5Ngxee458fQsemJWlkRFSUiIZGYWv2pmXt6PJ09+c+xY5LVrIqJWqXyaNfP38hrRqpWmYK1KYS4u4uUl7duLTidmsxw/LgcOSGamaLVSsFtZfr64u0u/flK3rojUq1dvx44dc+bMmTNnTkBAwJEjR5YvX+5Y0J0EjyZmygAAAABQVLUNZZoVbGqLqsJgkKVLJSWlxHa8IiJGoxiNsnGjPPmkeHuLiJjNcvGihIVJTEzRXs4iInI6OXlhaOjSiIiber2I1Le3n9Cx4+ve3k1L3FVHqxV3d/HyksIfHpVKOnWSTp0kM1OuX5ebN0Wrldq1pX590d7110ej0cyaNcvLy8vPz++nn37q2rXrhg0b2lpaTVc12dnZs2fPzs3NnTlzZp1qnE0wUwYAAACAoqptKMNMmapn7Vq5cUMMhoIGLhm5ublGYz07O/WdI99FRb3366/fxcb2nzZNMjIkNFTS04tfKc9o3HzmTFBYWPCddUxerq5TunV7oW1bnUZTwks7OUmnTtK58/3WRjk4iIPDn76JIUOGhISEjBw5MioqqkePHosXLx49evSfnvXouHLlyjfffDN37tz8/HwRWbRo0bZt2/r27at0XRXj/jNlCGUAAAAAVDBCGTwaoqLk8mUxGkWlSszM/PfevT/FxCTduiUi9lZWw1u1+njAgIYODtkGw7WbN3Nzc2XDhhIvcy4lZUlExJLw8BvZ2SLiaGMzuk2bt7t1a+vsXMJojUY8PMTLS9zcynE39JYtWx49evTNN99cunTpmDFjdu/e/d///tfq0d5c2WQy7dy589tvv922bZsljrG2ts7Pz8/JyRkyZMgPP/wwePBgpWusAHdCGZPZHJeRoRJxK5hCZWUlJXYaAgAAAIDyQyiDR4DZLL/9ZmmmG3PjRr/ly6/dvDmwefOnmje30WrDr15dHRW1KzY2cvLke10g32Tadu7cgqNHd8XGWpq+eLm6+nt5jWvXzq7ENKRWLencWTp3rqAbbxsbmyVLlnTr1u3tt98OCgqKiIhYt25dkyZNKuK1HlJSUtKyZcuCgoJiY2NFxMrKasSIEaNHjx4xYsTVq1dHjBhx9OjRoUOHTp8+/aOPPtKUOM+oKsrLkz17JCvL8ruEzMw8o9GlZs0/Pi1MkwEAAABQ8aphKGO5tySUqUpiYy19ZMxm84sbN167efPrZ599o0uXgudf8/KKvHatbknbaV3JyloVGfn1sWPxGRkiYqPV+rZp80737p1cXEp4IZVK3NzEy0s8PaXEFr/lyt/f38vLa+TIkceOHevSpcv333/v4+NT0S9aemFhYUFBQatWrcrJyRGRhg0bvvrqq2+88YbznVlFrq6uhw8fXrBgwfvvvx8YGHj06NEffvihfv36ilZdHuLi5McfxWgsOHB77VLhIEavF5OpEj4kwJ8wGCQxUa5ckcRESUmRW7ckL0/y82/vSafRSI0a4uAg9euLi4s0bGhpPY7qLytLEhLk2jW5elXS02/vEmgy3f5gaLW3PxiPPSb160uDBlKvXjlOCAUAAOWouoUyycnJmZmZDg4OTk5OSteCUouOtkyT2RcXF3blyoBmzQonMiLSvWHD7g0bFj5iMpt3X7wYFBa2KTraaDKJiEfdui937Pial1edEvvC2NlJx47i7S0ltvitMF5eXqGhoePGjdu5c+egQYM++OCDf/3rX2pFb/UzMzN//PHHr7/+OioqSkTUarWPj4+/v/+IESOKT4RRqVRTp07t1KnTmDFj9uzZ4+3tvW7duh49eihReDk5d07WrSvSTPp2l9/CDWUyMuSHH2TsWG5joIysLDl5Uk6ckKQk0enEYLhrNzoRMZtv9z7Py5P0dLl8WSzzvFQqadFCOnSQ5s1JFasbs1ni4+XECTlzRnJyRKMRvf6PPQELWD4YubmSliZxcbc/GGazuLlJ+/bi7i46XeXXDgAA7qW6hTKWtUstWrRQuhCURXy85Z+Vv1+6JCIjW7f+0zOCwsImb90qItZa7ag2bSZ36dKrceOSh7q4SLdu0ratKLT0xsnJafv27Z9++un//d//zZ49Ozw8fOXKlbUqNxuysEyN+e67727duiUi9evXnzBhwuTJk/90XVWfPn2OHz/+wgsv7N69u0+fPh9++OGMGTMqpeTylpoq69cX396rhJkyJpPExUlwsAwcWJkFAhIfL3v2yOXLolLd/qwWiWMsiseFev3tB6dOyfnzIiLdukn37vfrX46qQq+XsDA5dEj0ejEYxGy+ncqV8lyLs2clLk5MJmnXTnr1YpEmAACPiOoZyrB2qYq5dcvya2xamhRutnpvo9u0+TokZHyHDi937FivxL4w1tbStq107SoltvitXCqVasaMGe3atRs/fvyWLVu6dOmyYcOG9u3bV86r5+bmbtmyJSgoKDg42HKkZ8+eU6dOfe6553Sl/r7U2dl5586dH3zwwaeffhoQEBAZGblo0SK7KtcKd9OmEjdct8yUqWltfddRg0FCQqRjR6lXr3Kqw19dcrJs2SLXr9++634YeXkiIocPy+HD0rOn9OqlVCqNh2UyydGjsmePmM13/fh6sEl8lg9GZKRERYmnpzz1lNjbl0+dAADgQVW3UIaGMlXSnduPW3q9iDxWin8j1q5R48Qbb5T8nIuLeHlJ+/aP2gztZ555JiIiwtfXNyQkpFu3bl999dWrr75aoa949uzZpUuXLl68OCUlRUQcHR1Hjx49ZcqUNm3a/Om5kZGRjRo1qlNoRY9Wq507d26PHj0mTJjwww8/REREbNiwoXUppjU9KhITJSmpxHvdMzduiMgHu3Y1dnQc0arVH0/k58uePeLrW2k14i/KbJa9e8hxMvkAACAASURBVLcuXXomKWmyt7ft3T+7LqalbYyO7tOkSZcGDe51gV8vXIi4erVj/fpPFZ4oajAcio/fv2/fuO7dG/r7i6trxb0DVIhr164vXrz8wAGdyJRu3bSF1qPd0uu/Cglp6+z8rLu7iCwMDdVpNK906lTkAgcvXz6SkPBCu3auNWv+cdQy9yo6Ws6ckUGDpHPnSngrAADgXqrbgnNmylRJNjaWX+2trEQku6S5DH9Oq5XWreWVV8TfX7y8HrVExqJx48Z79+719/fPzc2dOHGin5+fpclu+dLr9evWrRs4cKCnp2dgYGBKSoqXl9fChQuvXLmycOHC0iQy169ff/bZZzt27Hj06NEiTw0bNiwkJKRt27YxMTHdu3dft25duddfUSIj7zXbPy4jQ0RuGQwj16wJCA7ON5luP2E2y9mzJS8eAcpLXp4sXy6HDq0IC3tv584sy1yGQk4nJ7/366+7L168zzV+jokJCA72XbcuMTOz8PHdFy8G7Nx5KT5eli+XiIjyLx4VJzxcli69kpAQsHPnuzt3/vfun8Y39fqA4OB1p09bfjt7796P9+8vfo1t58699+uvllmoReXni8EgO3bI2rX8lAMAQEGEMngE3NnQx9Jp9XRyctlOd3ISHx/529/E11caNSr36sqXjY3NwoULV6xYYWtru2rVql69el28771WmSQmJgYGBjZv3nzUqFHBwcH29vb+/v7h4eGhoaH+/v62JW1fVSKDwdCgQYP4+Pi+ffsuXry4yLPu7u6HDx8eM2ZMVlbWqFGjJk2aZHiwHK2SXbwoBWlLIedTUzNyc600mnmDBmk1msADB3xWrrx+8+btpzUauXatUuvEX0purixeLFeulLiwrqyyDYZ3du4s+TmDQbZvl0OHHv5VUBn27ZMdOwo+FRq1euaePQl3J27lw2CQ8+dl+fJy+QQCAIAHQCiDR4Cnp1hbi0i/pk1FZM3Jk6U9sXVrGT9e3nxTevasWs0s/fz8Dhw40KxZs/Dw8C5duuy8131U6ZhMpuDg4FGjRjVt2jQgICAhIcHT03Pu3LlxcXELFy7sVGxC+59q2LDhwYMHZ8yYkZub+9prr/n5+WVnZxceYG9v/8MPPyxcuNDKyiooKGjAgAFXr159mLdQGbKyih+LS0/327hRRDRq9dTu3YP9/Fxq1txz6ZJ3UNDh+PjbgzIyKrNM/IWYTLJqlaSllbZj65/x69Bh3alTW8+eLflpg0H27JHS/4CFUsLC5MCBwinJ2Hbtco3Gqdu3V8jLGQxy7Zr8+OPDdjICAAAPpFqFMtnZ2deuXbO2tm5w74X3eBR5eFimMPRq3Njb1TU4NjYoLKzIkJsF+0dYqNXSrp34+kqzZlV00+JOnTpFREQMHz48JSXl6aefDggIMJU0j+P+rl+/HhgY2KJFi4EDB65bt06j0fj6+v7222/R0dEzZsyo/RCba1g6yKxevdrOzm7VqlU9e/a0JJ6F+fv7Hzx4sEmTJvv37+/QocOuXbse+OUqw93/ecOuXHlt8+YWCxYcTkgQkb5Nm4pInyZNjr/+en83t4TMzD7LlgUeOCAmU4nza4BysHu3JCeX48qR6T17PmZvP3X79nsuAjUYZPNmSU8vr1dE+bt+XXbuLDJvpWWdOq97e2+Mjr5n4vaQjEZJSJADByrk4gAA4L6qVSgTGxtrNpubNm2qYZuJqsXKSnr0EJ1OpVKtHD78MXv7SVu2PPvdd1+HhHx/4sSH+/Z1W7TouR9/vOsUjUYGDFCo3HLj4OCwYcOGuXPnqtXqwMDAIUOGpKamlvLcsLCwSZMmWabGXLx4sUWLFnPnzo2Pj1+7dq2Pj095VThu3LjQ0NDWrVsfP368c+fOGzduLDLA29s7NDR04MCBycnJgwYNCgwMND+y37XWqCEit/T6JeHh3kFB3kFBi8PDjSaTk63tjJ49fxozxjLK2c5u5/jxM3r1yjeZAoKDx/34462YGL5ARvlLS5OjR8t3zYijtfXHAwbEpqV9tG/fPQcZjbJ1azm+qOJyc3OVLqFcbdpU4syp2X371rW1ffOXX24V+YqivOj1sn8/EwMBAKh81Wr3Jcs3+c2aNVO6EJRd794SFSUZGa3q1Tv22msz9+z5KSZm27lzImKl0bSuV2+oh4eIqFUqrVqt1mrliSfE0VHposuBZbfsrl27vvDCC9u2bevUqdO6deu6du16r/EZGRlr1qz56quvTpw4ISJqtdrHx8ff33/EiBEVlEV6enoeOXLklVdeWb9+/ciRI6dPn/7RRx8Vfq26detu3759zpw5c+bMCQgIOHTo0IoVK2qVYl/zSnZGpVoWHLwoLCw1J0dE7Kyssg0Gs9ncrUGD6b16WRV6R1q1eq6PT/eGDV/66afvT5wInzx5Q0JC6zfeECsr5cpHtbNvX4mTsFosWKC6e/afsSxztV7q2HFxePjnhw6Na9++dYm7uZvNEhcnN25I3bplrPiRc+3ateeffz48PLxFixabNm1qUXjnqSrq4kVJSysxBa5do8bHAwb4b9kyZ9++uSUl77GpqQ6ffFLkYF6ZVsbl58u+fTJkSFkqBgAAD6sahjI0lKmStFrx85OgIMnLa+TouHTYsEVDhiRnZ5vMZhd7+4JblFc7d361Wzdxd5fHH1e23vLVr1+/0NBQX1/fI0eO9OnTJzAwcOrUqUXGhIWFBQUFfffdd7du3RIRFxcXPz+/yZMnN2nSpKLLq1mz5tq1axcsWPD+++8HBgYePXr0xx9/fOyxxwoGaDSaWbNmeXt7+/n5bd68uVu3buvXr2/Xrl1FF1Yaer3+559/DgoK2rVrl2UWj5erq7+X14vt2x9NSHhhw4Zt5851/N//1o8a1fXuZY/PeXqGvPba82vWnExK6h4QsOTECd9PPhFnZ4XeB6oXk0lOnSoxlHm1c2e7uzePO5+auvbUqVJeWK1SffXMM10XLXrjl1/2vPTSPV89MrJKTzY0mUzLli1744039Hq9iJw8ebJVq1YLFizw9/ev2lNlQ0Pl3hNhXu3ceWlExBeHD/t16OBUrI1arRo1Jnt7Fzm4Ny7u4OXLpX11k0lOnpTBg6voomAAAKqoarV8iVCmaqtdW/z9pVYty27WGrW6vr29a82ad31prNNJ587y/PPV75+MDRs23LNnz5QpU/Ly8qZNm1bQWzc3N3fdunW9evXy9vYOCgrKzs728fFZu3ZtXFzc3LlzKyGRsVCpVFOnTg0ODnZxcdmzZ4+3t/fhw4eLjBk8eHBISEj79u3Pnj3brVu3ZcuWVU5t95KYmDhr1qxGjRr9sRdV9+4Rr78e6u/v7+Vlq9P1c3ML9ffv3rBhfEZGn2XL5h85UuQK7k5OhydOHN22bVZe3uilS6cOH26IjFTkvaC6SUq61w+xv/fq9dGAAYX/59ehQ5mu3dnFZbK3995Ll9bdK8oxmeTcubKW/OgICQnp2bPnxIkT9Xp9zZo133nnnTp16hiNxjfeeKNt27Y7duxQusCHcN/N+NQq1cIhQ8xm85SSOv7WqVGjyCfnowEDnijr/0eoVHL9etlOAQAAD4dQBo+S2rXlzTeld2+xthZrayn4wtPKSrRacXGRF1+UQYOqXyJjYW1tPX/+/JUrV1p2y+7atetLL71Uv379UaNGHTx4sG7duu+9997Zs2d/++03X19f3d3fpVeOPn36HD9+vH///gkJCZYZPUUGtGjR4ujRoxMnTszJyXnllVcmTZqkr6D2B/dWsBdVkyZNZs+enZSU1KpVq9t7US1f3vHuTdMbOjjseemlKd265RmN03bs8Nu0qUiHVHsrqx9Hjlw4ZIhOo1lw6NCAYcOurlxZjp1Z8ReVllahP8c+7N+/vr399N9+K7x6xVD4c1sRmytXvMTERD8/v+7dux85cqRBgwYrVqzIyMj44osvUlJSNm/e3KxZs5iYmKeffnrIkCGxsbFKF1t2JpMU6o9jKOnnTPvHHpvcpcuu2NiK6vgrImlpFXVlAABQEkIZPGI0GundW6ZPlzFjpH9/6d5devWSQYPkjTfE318aN1a6vgo3fvz40NBQDw+P8+fPW245vLy8Fi5cGBcX99lnnyneNMHZ2Xnnzp0zZszIz88PCAgYN26cZTlVARsbm0WLFq1YsaJGjRpBQUE9e/a8dOlS5dR27dq1wMDA5s2bW/ai0mq1lr2oTp8+fXsvKg8P6dxZ7s6zrLXa+U8/vXrECDsrq1WRkT2XLLlQrN2yv5fXgVdeaVKr1v64uI5vvLE7IKDEDbaB0iqnPbDvxdHG5rMnn7yUnr40IsJy5HxqauMvv5x/5MjtDjVVLVjMzs4ODAz09PRctWqVjY3NjBkzYmJi/Pz8CqZSDhkyJDo6et68eQ4ODlu3bm3VqtXUqVMzq1b2lJ9vierMZvPKyEi3+fOjSpq0Mqdfv/r29v/6/feKKqOCP5wAAKCI6hPK5OfnX758WaVSubm5KV0LHppaLU2byuOPy1NPyYAB0qmTPMTuzlVOq1atFi5cmJeX5+LiEhkZGRoa6u/vb2trq3Rdt1l2y960aZOjo+P333/v7e19+vTpImP8/PwOHDjg5uYWGhrapUuXX3/9tUJLCgsL8/Pza9y4cUBAwKVLlyx7USUkJJSwF9VTT0mXLlJsntG49u1D/f1b1at3/Nq1zgsXboqOLjKgS4MGx157bWDz5km3bj31xReBY8aYi+0RDpSWre0Dz5QxmkyLw8MnbNo0Zfv2sCtX7jXsxfbt+7m5XbmTHq44fvzazZvTduzwWrjw94sXxdr6wV5dEVu2bGnTpk1AQMDNmzcHDx58+vTpuXPn2tvbFxlmZWU1derUmJgYf39/o9G4YMECT0/PoKAgU1XZ1V6rFZEDly97BwVN2LQpMTNzxfHjxUdZErcrD5QLp+XkfLx/v9+mTf+3a9c9r2Bn9wBXBgAAD6z6hDKXL1/W6/Wurq41inW/A6qc69evi0j37t3bt2+vdC0lGzZsWEhISNu2bWNiYrp3775u3boiAzp37nzs2LFBgwbduHHjmWeemTVrVrnfGmVkZAQFBbVr187b23vVqlUmk8nHx2fz5s1nz56dMWNG3RI3l1GpZOBAeeEFqV1brKwK3xh71q17dNKkka1bZ+blPb9mTUBwcP7dBdezs9s+btzMvn1NZnPAtm3DBw/O+OUXdsvGg3jssQeejzB+48bvoqKebtnyMTu7XkuXRl67dq+RXz3zjO7OItA5/ftvfuGFZrVrR12/3n/FiiGrV1eJBT7h4eF9+vQZOnTopUuXOnfuvG/fvi1btjRt2vQ+p7i4uCxcuNDSd+bq1auTJk3q2rXrgQMHKqvkB5d45YrfL7/0Wbo0/OrVBg4OK4YP//zJJ0sc+WL79v3L/v1TjsHQY8mS2LS0oR4eV7Oyui9enJWXV3SQ0SiFmrgDAIBKoJk1a5bSNZSPsLCwVatWderU6eWXX1a6FuBhbd68edeuXc8+++yT9/hH+aPAycnJz8/v4sWL4eHh69evT01N9fHxKbz1ia2t7bhx42rUqLFr1649e/aEh4c//fTT5RKbhoWFzZ49+6WXXtq4cWNSUpKLi8ubb765evXqt99+28PDQ/WncxBq15auXaVxY7EUo9VKzZrStKl1r16+L75Y+/LlXefP74uL2xcX93SLFvaFdsJWq1R9mzbt7OKy/fz5yGvXNu7c2U+lcvbysnzFDZSWlZVERUlOTuFjKpHWzs79mja1unv/IJVIHVvbfk2bNnZ0FBFHa+uA3r07ubj0adLkUHx8Rl5ePzc3g8nUtFYtn2bNrAt9FOvZ2TWtVcu9bt3+bm61bGw86tad3KVLXVvbQ/HxJxIS/ve//924caNnz57Wj+SsmZSUlL///e/+/v6XLl1ycnL65JNPFi1adP84pjBXV9eXX365TZs2ISEh0dHRy5cvP3XqVNeuXWvVqlWRVT+gnJycL774YtSoUaEXL9bQ6d59/PG1vr5dGjRQqVRmEZ1G08/Nze3u6aLdGza0s7Lq06RJmztbwj3eqFG3hg2LXFmlUrnVrt23aVNHGxuziLuT07uPP966Xr0h7u4f79/fpUGDFnXq3HVC3brSs2dFvlcAAFCUylxdvuYNCgqaNGnSyy+/vHTpUqVrAR7WxIkTlyxZ8s0330yePFnpWv5cUFDQ22+/rdfre/fuvWbNGhcXlyIDdu/e/cILLyQlJTVu3Hj9+vVdunR5sBfKzc1du3btvHnzIiIiREStVvfv39/f33/48OHacoxFMjP3ffTRmG+/vZqV1dDBYa2vb4+72wOLyPnU1OfXrIm6ft3eymrR2LFj5s7l62WUTUSE7Nhxn/2PS2PYDz94u7r+84knynTWVb1+VlLS4qVLTSaTi4vLrFmzJk6cqFY/KjNnDQbDN998M3PmzIyMDJ1ON3ny5H//+9+Ojo7FR169evUf//jHuHHjBtx7e+/s7OxPP/00MDAwNzfX1tb2/fffnzFjxiM1o3bLli1Tpkyx9N4a/PTT/23dumnNmhX9omaz2fmzz9b4+v4x48ZsFmtrGTxY2rWr6FcHAACFPSr/CHt4dPlFdVLi5/nrr79evXq1ZavsR4q/v//BgwebNGmyf//+jh077tq1q8iA/v37h4aGduvW7fLly3369Fm8eHFZX+LMmTMBAQENGjSYMGFCRERErVq1pkyZcu7cOcteVOWZyIiIg0OfTz4JXbSoZ+PGCZmZfZYtCyy29qFFnTpHX3vt1c6db+r1LyxfPmnIEH1ISHnWgGqvQwd5uEZRiZmZuy9eHOLhUbbTrKxcnntu4aJFRRb4HDx48GGKKS/BwcEdO3acNm1aRkaGj4/P8ePH58+fXzyRycvLCwwM9PDwWLZs2YwZM+5zQVtb21mzZp07d278+PE5OTmzZ892d3dfuXLlo/CNVAmLs7Zta/rMM6LTVfS6yK1nz+o0mm4NGvxxSK0WBwdp27ZCXxcAABRHKAM8ikr8PAcEBIwfP77yN5kuDW9v79DQ0IEDByYlJQ0aNCgwMLDIPU+jRo327t07ZcqU3Nzc1157zc/PL+futRsl0uv169atGzhwYKtWrQIDA1NTUy17UV25cmX+/PnNmjWrqPejVruOHr3n559n9OmTbzIFBAeP27Dh1t3/5W202sVDh64YPryGThd07FjP4cPjgoLYuASlpVaLr2/xntOldFOv91237nVv747165fhNI1G6tUTb28R8fLy2r9//9q1axs3bhwWFta7d+9Ro0bFxcU9WD0P78yZM88+++zAgQNPnz7t4eHxyy+//Pbbb61bty4+sqDvb1ZWlo+Pz6pVq/704g0bNly5cuXvv//eoUOHhISECRMm9OvX73hJbXQrR0pKytSpU7t27bp//34nJ6d58+aFhIT07t1bROSJJ6RWLbl7CVv5Op+a+vrWrV8984xdobWZotXKqFEVulM7AAAoUfVZvtSpU6fjx4+HhIQ88MoI4BGRl5dna2urVquzs7N1d+7Zrl275uLi4uTkdOPGDWXLu4/8/Pw5c+bMmTPHZDINGzZs+fLlxTs4rF69etKkSdnZ2Z06dVq/fv29gpULFy4sWrRo6dKlycnJIuLg4DBmzJg33nijQ4cOFf42Crtx46d//OOllSszcnM969bdMHp063r1igwJv3p15Nq1F9PS6trafu/vP3DmTHkk+1bgURQZKb/8IgZDmU5KyMx8fs2aTi4u3z777J93UCqgVou9vUyaVGSGjuILfNLS0gIDA7/88ku9Xl+7du0ZM2a88847VoXzgjtiYmL+9re/bd++XUQ8PDy+/PLLp59+ukyvZTKZVq9ePX369OvXr6vV6nHjxn322WePVeLaw1ItzsrKkoULJTu7IubLHIqPH7N+/ay+fV/p1OmPozqdPP+8lHXWFQAAKA/VJ5RxdHTMzMxMSUmpU6RrHVDVxMTEtGrVqlmzZhcKbbp88ODBXr16de3a9ejRowrWVhpbt2718/NLS0tzd3dfv359u2IdCo4fPz5y5MgLFy7UqVNn9erVhW+rTCbT7t27g4KCNm7cmJ+fLyKtW7f29/d/9dVXi++AW0n0+jPffjvy449PJiXVtLZeMnSob5s2RYakZGeP27hx5/nzGrX6g/79//XNN+qWLRUpFlVPeLhs3176OVb74uLGbtjwdteuM3r1KsOraLViby8vvywODiU+n5CQ8H//93+rV682m80NGzb86KOPxo8fX4bE54FYIpL33nsvOTnZEpF8/vnnznc61xaWlpY2a9asb775xmg01q5de+bMmW+++eYDr1tMT0+fO3fuvHnz8vLyatWqFRAQMG3atEpoeBwcHDx16tTTp0+LiI+Pz/z580ucCiQikpEhy5bJrVvlO/kuKCxs1p49K557bmDhaZg6nYwYIZ6e5fhCAACg9KpJKJOcnOzs7Ozo6Jienq50LcDD2rZtm2Ua/6+//lpwcOXKlRMmTHjhhRe+//57BWsrpfPnzz///PNRUVE1atT45ptvXnrppSIDMjMzX3nllQ0bNqhUqunTp3/88cdJSUkrVqz49ttvLQsorK2thw4d6u/v7+Pjo8AbKMJsvrl378S3315z8qRK5O1u3T5/8knd3esLzGbzpwcP/t+uXSazebC7+8rAwNrDhrEWAKVy4YKsWydGo+Tn33+gIT+/xkcfFd6s3adZs9/8/P7k+jqdNGwoo0aJjc39B+7Zs2fatGmRkZEi8sQTT8ybN69jx46legtl9/vvv0+bNi0qKkpE+vXrN2/evPbt2xcfZjQaly5d+sEHHyQnJ2u12ldeeeXDDz+sV2zC2gM4e/bsu+++u3XrVhFp2bLlRx995Ovr+/CXLdGZM2f+9re/bdu2TUQ8PDy++OKLZ5555k/Oyc2V9eslPv4hu0EXOHD5cu+7d0KY2b//rGeekbFjpVh3dgAAUGmqSShz5MiRHj16dO7cOSwsTOlagIf13//+d8qUKa+//vq3335bcHDmzJn//ve/P/jggzlz5ihYW+nl5ua+9dZbS5YsERF/f////ve/RdYjmM3muXPn/vOf/8zPz2/SpEliYqLRaBQRDw+P119/fcKECbXv3gJWeZcvB7377tubNunz8/s0afLjyJEuxTZJ2Xbu3PiNG1NzclrUqbPh/ffbT50qj9I+L3h03bwpmzfLpUtlXcr0J7RaUavlySelc+dSRoSW2Svvv/9+UlJSBS3wiY+P/8c//mHpBdOoUaMPP/zQ7x650u7du6dNm3bixAkR6d+//7x584rPvHtIwcHB06ZNO3XqlIj4+PjMmzevTbGpcA+j9IuzSnb8uOzYISZTOX8w1GrRaKRDBxk4UEpfDAAAqADVpNEvXX5RnZT4ebYcrMDWtuXNxsZm8eLFK1asqFGjRlBQUM+ePYv0EFWpVH//+9937drl4OBgNpvNZvPgwYN/++236OjoadOmPXKJjIg0buy/fPnuv//dtWbNfXFxHf/3v90XLxYZ8kzLlsdff71rgwbnU1O7/fOfi19+WRITFSkWVYy9vYwdK+PGiYuL6HTlMMdKpxOdTry8ZNo08fIq/QXVarWfn9+ZM2dmzJih0+lWrVrl6ekZGBiYl5f3sCWJ3Lp1a9asWe7u7qtWrbKzs5s5c+bZs2dLTGTOnz8/atSoAQMGnDhxokWLFmvXrt21a1e5JzIi4uPjExERMW/evFq1agUHB3fq1GnSpEnl0rrLZDKtXLnSw8MjMDDQaDSOHz8+JiZmxowZZUhkRKRjR3nnHenRQ6ysyic90WpFqxV3d/H3l2efJZEBAEBx1WSmzL///e+ZM2cGBAR88sknStcCPKwhQ4Zs3bp148aNw4cPLzjYo0ePI0eO7N27t0+fPgrW9gDCw8NHjhx58eLFunXrfvfdd08++WSRAZa3tmHDhhEjRihSYdmYTMmbNo2dPj04NlarVn/Yv//0nj2LtN7INRrf3rZtcXi4iEzq0uWrefO0Xl5y/rwkJEha2u0dcJo0kaZNWd+EEly5IocPy5kzolaLXl+2bq+W1uB2dtK1q3Tq9Kfrle6v8AIfd3f3//znP4MHD36wS5nN5lWrVs2YMePatWsqlWrkyJH/+c9/GjVqVHzkrVu3PvvsM0vjYTs7u/feey8gIMDm4d5IaaSmps6ePfvrr7/Oz8+vU6fOv/71r7feekvzoLsglXJxVhkYDHLypISESHKyaDRlXtOk0YhGIzqddO4sXl5SbJdxAACglCofymRlZf3www8zZ85MS0sbMWJElWi3Adxf69ato6OjIyMjC/8j3tnZOTk5OSEhoUGDBgrW9mBSUlLGjRu3c+dOjUazYsWKcePGFX7WxcXl2rVrly9fLvEO7dGUf/r0nClT5uzebTKbh3l6rnjuOcdiN42rIiNf37r1OU/P755/XlQq0en+uI9Sq0WnE7Va+vUTb2+iGZQgP18uXZJz5yQ2VlJTRaMRlUpMJjGbbzd/Valu32mrVGIwiE4nLi7i7i7u7lKuDe8ffoHPsWPHpk6devjwYRHp0qXLvHnzHn/88eLDigQ3L7744qefflq/THt+P7To6Oh33nln586dItKqVasvv/zyqaeeKtMVSr846wHdvCkXLsi5c3L5sty6dXuFWn6+5OeLpdmQZWmSSiVqtRgMotVK/frSsqW0aCGVuM8UAAAopSocykRFRf3vf/9bvXp1VlaWiFhZWen1+rFjxwYFBdnZ2SldHfCAzGaznZ1dTk5OZmZmzTstS27evFmzZk0bG5tbt26p1VVy1aHZbP7000/nz59/7NixwrlSdna2vb29lZVVdnZ2FXtrKSlb/vlPv2XL0nNz3Z2cNowe3bbYrjFR16+3qFPH9s6+5iXQ6aRePRk3rsguxcBdzGZJS5O0NMnKkpwcKWj0q9OJnZ04OoqTU4V2L7Js5Dxr1qz09HTLRs6zZ88uvuF9cVeuXAkICLBs6uTq5l9N4AAAIABJREFU6jpz5syJEyeW+Dc9JCRk2rRpBcHN/Pnze/ToUf7vpHS2bNkyderUixcvisjgwYPnz59fmqWjCszxMRolJUUyMuTmTcnJ+eO4lZXY2YmDg9Spw88WAAAecVUvlMnLy9u8eXNQUFBwcLDliJeXl7+/f+3atV977bWMjAxPT8/169eXb6M+oNIkJCQ0atTI2dn5+vXrBQePHz/eqVOn1q1bW76srroyMzMd7t6R98SJE+3bt/f09IyOjlaqqgen158LChr54YdR16/bW1ktGjp0TNu29xqbbTAcjo+/kpWl02g8nJw61K+vtkyQ0WikZk2ZNOkhV5oAFa1MC3xycnIWLFjw0UcfZWVl1ahRY8qUKf/4xz9qFuuNLSKJiYl///vfLcFNgwYNPv7440rYjftP6fX6b7/99p///GdWVpaVldXrr7/+4Ycflli/iJjN5vXr17/77rvx8fGWxVmff/5548aNK7lmAABQFVWl76XPnz8fEBDQqFGjUaNGBQcHOzg4+Pv7R0ZGhoaG+vv7+/r6hoSEtG3bNiYmpkePHmvXrlW6XuBB3KfLbzVoZV0kkZGq/tasrFq+9dbRTZte6dz5pl7/wvr1k7Zs0Rfb1TjfZPrX7787f/aZz8qVfps2vbB+feeFC5vPn/9zTIyISH6+3Lwp69YpUD9QFnXq1Jk/f35oaGifPn1SU1OnTZvWrl07y0qfIrZs2dKmTZuAgICsrKzBgwefOnVq7ty5xRONnJycwMBAT0/PVatW2djYzJgxIzo62s/PT/FERkSsrKymTp0aExPj7+9vNBoXLFjg6ekZFBRkKrQfucWxY8d69eo1atSo+Pj4Ll26HDhwYO3atSQyAACglKpAKGMymYKDg0eNGmXZACI5OdnLy2vhwoWJiYkLFy4s3HTD3d398OHDY8aMycrKGj169KRJkwzlu4UkUPGqdyhTXDV4azY9eizZsmXhqFHWWm1QWFjPJUvi0tMLD3j555/n7N3btUGDnePHJ7777oWpUxcPHWowmUasWfPDiRMiIkajJCTImTPKvAGgLDp27Lh3797Nmze7ublFR0cPGjRoyJAhF+/sRBYREfHEE08MHTr04sWLlpFbtmxxc3Mrfp0tW7a0bt06ICDg5s2b9wlulOXq6rpw4cIjR448/vjjV65cmTRpUrdu3Q4dOmR51nKke/fuhw4dKjxS2ZoBAEDV8kiHMlevXg0MDGzWrNnAgQPXrVun0+l8fX1/++03y9QYe3v74qfY29v/8P/s3Xtc1HX6//9rhuEgIKB4RDlp4llRQDRPpZBmonkAtQTLNbBPm/hp/QaftVZr63eDrW2VtgOkbkplopWpqQWRBzwD4llQAUVRUQREjsPM/P6YYk3QFIE34OP+h8nMa97vayhMnrxe17V2bXR0tJmZWUxMzNixY3Nzcxu/cqDOag0pMjMzaz7YMrSAUEZExMEheNWqXYsXO9raJufm/r/4+OpnNqWnxx458nSPHvGBgU917+7QunW3Nm3+NHjwnrlz7SwsXv7hh8LychGRykpJTFSsfuAB+fn5nT59etmyZa1bt96yZUuvXr1CQkJefvllLy+vXbt2tW3bdtmyZcY9NTVfe/jw4VGjRk2aNCk7O3vQoEH3CG6aiNv3vyQnJ48YMWLatGn/93//Z9w7o9FoFixYYNxT08waYwEAgCagKf7twWAwGLfGODs7h4eHnz9/3s3NLSIi4uLFi3FxcT4+Pn94heDg4D179jg7O+/evdvd3f3nn39uhLKBevFo7pS5nyaaTZ2V1ZAlS1JXrw4cOPDDp5+ufjg6OVlE3vP1Nfn9d2vOdnavDRtWVF7+62YZEblxQ4qKGrFi4KHcccBnxYoVn376qVqtXrBgwblz50JDQ2u2m8nPzw8NDfXy8tq9e7e9vf2yZcsOHTpUa3DT1KhUKn9//5MnTy5ZssTc3Pzbb7/95z//aTycdfr06eXLlze1PT4AAKC5aFqhTGFhYUxMTL9+/YxbY4x/B4qPjz99+nRYWJi9vf39X8rT0zM5OdnX1/fatWvjx4+PjIxsdi2N8Wh6NEOZFvLWVKp2kyeviYvreFvrnD05OV1sbPrWGMwkIk/36GFc8OvHJiZS/XugmTAe29myZYter2/VqtWxY8eWL19eczCTVqtdvnx59+7do6Ki7h3cNGVWVlZLly49fvy4jY2NVqtdt25dE9/jAwAAmr6mEsqkpKSEhIR06dIlJCTk5MmTDg4OYWFh586dM26NqVvPv3bt2m3btm3JkiV6vT48PPzZZ58t/H2jB6AJqnlSSavV5uTkqNVqZ2dn5epqEFVVVRcuXFCpVC4uLkrXUn/c3OS3BLm4oqKovNzZ1rbWhS52diJy8ebNXz/Watkpg2bKy8tLRCwtLXv27Fnz2YSEBHd394ULFxYVFfn4+KSlpS1fvtz2Ll8XTV/37t2NqZO3t7fStQAAgGZPo+zti4uL165d+8knn6SlpYmIWq328fEJDg6eMmWKRlMPtZmYmCxdutTT0zMoKGjTpk1Dhgz55ptv+vfv//BXBhpCYWHhjRs3rK2tO9y2seL8+fNVVVXOzs7m5uYK1tYQLly4oNVqu3bt2qpVK6VrqVe/zWep0utFRHOXNhOmarWI/Hdak8EgVVWNUR7QWNLT0//yl7/88MMPIuLm5vbBBx8888wzShcFAADQhCi2U+bUqVOhoaEODg4hISFpaWkdO3YMCws7e/ZsfHy8v79/vSQy1SZOnHj48GEvL68zZ854e3v/5z//qceLN7Ly8vIVK1acPHlS6ULQIKobrNy+O6xFHfD5vRb71iwtjf+0MTc3UatvlJXVuup6aamI2FcHUiYm1S8EWoaEhIQffvjBzs4uIiLi2LFjzTGRuXjxYnp6emlpqdKFAACAlqmxQ5mKior169f7+vr26dMnKirq1q1bxvnW2dnZERERDXcw29nZedeuXfPmzSsrK5s7d25ISEhlZWUD3auBXL58eebMmdbW1i+99FL//v1ff/11pStC/btHQ5mW0Aq3hhYbynTtKiqViJio1X3bt8/Iz79V2x84ybm5IjKwU6dfPzYxkdpazwDNV0hIyNKlS8+cORMWFmZmZqZ0OXUxZ86cXr167du3T+lCAABAy9R4oczZs2fDw8O7du0aEBCQkJBgY2MTHBx89OhR43xrCwuLhi7AwsLis88+W716datWrWJiYoYPH56dnd3QN314er3+xx9/nDJliqOj47p163Q6nVqt1uv177333muvvaarPviAFoEuvy2Em5v89v3ns716Vep0n6el1VwVk5IiItN69/71Y71eunZtrBKBxqDRaJYsWdKuXTulCwEAAGiiGjyU0el0CQkJfn5+bm5ukZGR169fN26Nyc3NjY6Obvz2LkFBQUlJSa6ursnJyV5eXj/99FMjF3D/CgsLly9f7ubmNn78+I0bN5qYmEyfPv2DDz7QarXGE17/+te/xowZc+XKFaUrRb2pdVNMi00uWvBbc3auDmVe9fbuZG39159/jj93rvp5nV7/ZmJiQmbmtD59BnXuLCJiYiIDB0qzmkQDAAAA4CE1YKPfy5cvr1mz5uOPP75w4YKIWFhY+Pn5hYaGDh8+vOFuej8GDx586NCh2bNnb9++fcKECW+88cbf/vY39V06cSoiJSUlJiYmNja2rKxMRLp06TJ79uw///nPXX/7KXpcXFxSUtKMGTN27drl6em5bt06xT+rqBfslGkhVCp5+mn57jvRattZWm6cOXPiV1+Ni40d6ug4sGPH8qqqnefPZxUUjHBy+szP79eXmJjI6NGKFg0AAACgsdV/EqHX6xMSEgICApycnMLDwy9cuODm5hYREXHp0qW4uLgmkh3Y29tv3bo1IiLCYDC89dZbkyZNKigoULooKS4ujomJcXd39/T0jImJqaio8PHxiYuLMzbc6fr7cw0jRoxIS0sbO3bspUuXnnjiicjISKXKRj2qGVIYDIasrCxpoT1ljG+tBYYyItK7t7i5iampiHh37Xr6z39e8sQTGrV629mz+y5e7Nu+/eopU3a88EIbY5dfU1Px8xNra4VrBgAAANC4VAaDob6uVVhYuHr16qioqMzMTBExMzObPHlycHDw2LFjbx8l06QkJibOmjUrLy/Pyclpw4YNXl5eipRx8uTJ6OjoVatW3bp1S0Q6duz4wgsvzJ8/38XF5d4vrKqqeuedd95++22DwfDss89+/vnntra2jVExGkBFRYWlpaVarS4tLTU1NTU+ePnyZQcHB3t7++vXrytbXr27evVqp06d7OzsmkIk2iB0Olm7Vi5cEK32XstMTWXMGBk6tLHKAurf9evX27dv3yL/pBo7dmxiYmJCQsLYsWOrH3R2dr5w4UJ2drazs7OCtQEAgBag3o4vpaamPv744xUVFSLi6uoaHBw8d+7cDk1+ksiYMWOSk5P9/f0PHDgwatSoqKiol156qdHuXlFRsWnTppiYmISEBOMjHh4eCxYsmDVrVvX35Pem0WiWLl06ePDgOXPmbNy40dvbe8OGDf369WvIqtFQsrKy9Hq9i4vL7f/2W+wBHxFjevvYY48pXUiDMTGR55+XHTtk3z7R60WnE4NBbk+ozczExESmTpUW/EkAAAAAcHf1Fsq4u7t36dKlW7duwcHBU6dONWk+7SodHR137tz5+uuvR0VFBQcH7969Ozo6upXxTEGDOXPmzMqVK1euXGn8oaKtre2MGTNeffXVuuUpkyZNOnjw4LRp044dOzZs2LAVK1bMmDGjvktGg6s1fzEmFy0ylGnBedN/qVTy5JPi4SH79snx41JW9msr36oqsbcXT08ZNEjuL4EFAAAA0PLUWyijVquPHz/e0FlGAzE3N1++fLmXl1dISEhsbOzx48c3bNjQEC08dDrd1q1bo6Kifv75Z+PBMQ8Pj+Dg4Oeff97KyuphrtyjR4+DBw++8sorq1atmjlzZmJi4ocffmj22/wXNAt0+W2xbGxk3DgZN04qKqS0VFQqad2aQUsAAAAA6rPRbzNNZKrNnj1779693bt3P3z48ODBgzdu3FiPF8/NzY2MjHR1dZ00aVJCQoK5uXlgYGBKSkpycnJwcPBDJjJGFhYWK1eujI6ONjMzi4mJGTt2bG5u7sNfFo2m1k0xLTi5aMFv7a7MzaVNG7GzI5EBAAAAIA0xfalZGzhwYGpq6rRp04qKiqZOnRoeHq7T6R7mgtWzqJydncPDw3Nycnr27GmcRbVmzZrBgwfXV+XVgoOD9+7d6+LikpSU5O7uXt2tptnJycmZOXPmlClTMjIylK6lkbBTBgAAAAAeKYQyd7KxsVm/fv2yZctMTEwiIyN9fX2vXr1ah+vk5eVFRkb26NHD19d3/fr1arXa398/Pj7+1KlTYWFhbdu2rffKq3l4eBw6dOipp566du3a+PHjly5dqtfrG+529S41NXXOnDnOzs7r1q3buHFjnz59Vq5cqXRRjYFQBgAAAAAeKYQytVCpVKGhoQkJCZ06dfrll188PT33799//y9PSUkJCQlxcXEJDw/PzMzs2rXrkiVLLl68GBcX5+Pj0zjTwdu1a7d9+/aIiAiDwfDWW289++yzhYWFjXDfh1FaWvqf//zH29vbw8NjzZo1BoPBzs7O0tJSp9PNnz//448/VrrAhmUwGLKzs0XE1dW1+sHi4uJr165ZWFh07txZscoaxq1bt/Ly8szNzR0cHJSuBQAAAACUQShzV6NHj05OTn788ccvXrz4xBNPLF++/N7rb968GRMTM3DgQE9Pz5iYmIqKCh8fn7i4uOzs7KVLl7Zv375xyq6mUqnCwsI2bdrUpk2bzZs3Dxky5OjRo41cw33KyMgIDw93cnKaO3fuwYMHbW1tg4ODDx8+XFBQcP369RkzZlRVVb3yyiuzZ88uKSlRutiGcunSpbKyso4dO7Zu3br6QeNekm7dujVOlteYMjMzDQaDq6urWs2fQgAAAAAeUXw7dC9dunTZuXNnWFhYRUXFwoULAwMDaw0FjFtjHBwcQkJCjh492qlTp7CwsMzMzPj4eH9/f2Wngz/zzDNpaWleXl5nzpzx9vZetWqVgsXcobKycv369b6+vr169YqMjMzPz/fw8IiOjs7NzY2OjnZ3dxeRVq1aff311999952tre2XX37p6el58uRJpQtvEJxdAgAAAIBHDaHMH9BoNBEREV999ZW1tfUXX3zh5eV16tQp41Pl5eXGTMG4NaakpGT48OFxcXEXLlyIiIhwdnZWtvJqTk5Ou3bteumll8rLy//0pz+FhIRUVlYqW5JxFlX37t0DAgKqZ1GlpqYaZ1FZWlresf7ZZ589cOBAv379Tp8+PXTo0PXr1ytSdoMilAEAAACAR41G6QKah1mzZg0ePHjatGknTpwYOnToO++8c+nSpRUrVuTn54uIra3tjBkzFixY0LdvX6UrrZ2FhUVMTMyIESNefvnlmJiYlJSUDRs2uLi4NHIZer0+MTExJibmu+++q6qqEpFevXq98MILwcHBbdq0ufdre/bsuW/fvnnz5q1bt27GjBlJSUnvv/++qalpoxTeGKpPKtV8sEUmFy34rQEAAADAfSKUuV/GUGDu3LkbNmx48803i4qKRMTDwyM4OHj27Nk1N3c0QUFBQf37958+fXpKSoqnp+eXX345bty4xrn11atXP//88+jo6KysLBExNzefMmVKcHDw2LFj779birW19ddffz1mzJhXX301KioqLS3t66+/bjEdcNkpAwAAAACPGo4vPYDWrVvHxcUNHTq0qKjoiSeeSEtLu9txmyZr0KBBqampU6ZMyc/Pf/rpp8PDwxt6Wvbts6iysrK6d+8eERGRk5NT51lUwcHBiYmJDg4Ou3btcnd3T0xMbIiyG1+tIcWlS5ekxvaZloFQBgAAAAAIZR6MSqUyMzMTkTfeeGPgwIFKl1MXtra233zzTUREhFqtjoyM9PPzu3HjRr3fxTiLasCAAcaGO5WVlcZZVOnp6WFhYQ85i2r48OFpaWk+Pj55eXnjxo2LjIw0GAz1VblSag0pTp48mZOT0/KSi6qqqpycHLVa3fhn6AAAAACg6SCUeWAt4Cf8xmnZ8fHxHTt23Lp166BBgw4ePFhfF799FtWxY8c6d+7cELOo2rdvv3379iVLluj1+vDw8ClTphgPlDVThYWFBQUF1tbWHTp0uP1xlUrVtWtXjaalHTM8f/68Vqvt0qWLhYWF0rUAAAAAgGIIZR5MeXn55cuXTU1NHR0dla7lYT355JPJyclDhw69cOHCqFGjYmJiHuZqxllUI0aMMG6NKS0tNW6NOX/+fAPNojIxMVm6dOnGjRvt7Oy+//77IUOGHD9+vN7v0giys7MXLVqkUqmsrKzKy8uVLqcxtIBkEwAAAAAeHqHMg8nMzNTr9S4uLvW140NZXbt23bFjx4IFCyoqKkJCQoKCgkpLSx/0Iunp6eHh4V26dAkICNizZ4+dnV1wcPDx48eNW2MaekCSn5/foUOHBgwYkJGRMWzYsK+//rpBb1eP9Hp9QkJCQEBAjx49Vq5c2apVq6tXrz7++OOZmZlKl9bgCGUAAAAAQAhlHlTL+2bS3Nx8+fLlX3zxhZWVVWxs7PDhw+8zFKisrFy/fr2vr2/v3r0jIyNv3Ljh4eERHR196dKl6OjoPn36NHTl1R577LEDBw786U9/unXr1qxZs0JCQiorKxvt7nVw9erVyMjI7t27+/r6rl+/3sTExN/f/9///nefPn3S0tIGDRr07bffKl1jwzL+N9aSvo4AAAAAoA4IZR5MywtljJ5//vlDhw717t3bGAp8991391h86dKlpUuXOjo6BgQEJCQkWFtbBwcHHz58WMFZVBYWFitWrFi9enWrVq1iYmKGDx9+/vz5xi/jD6WkpAQFBTk6OoaHh2dnZz/22GPVs6hefPHF/fv3+/v737x5c/r06aGhoVVVVUrX21Ba6tcRAAAAADwQQpkHY/xmskWOKO7du/eBAwemT59+8+bNadOmhYeH63S62xdUH7dxdnZ+66238vLyevfuvWzZstzc3OjoaHd3d6UqrxYUFJSUlOTq6pqcnOzp6RkfH690Rb8qKiqKiYnp37+/p6dnbGysTqfz8fHZtGlTRkbG7bOoWrduvW7dumXLlmk0mqioKB8fnytXrihbeQMhlAEAAAAAIZR5UC37m8nWrVvHxcUZQ4HIyEgvL69Tp06JyPnz528/bqPRaPz9/ePj40+ePBkaGmptba104f81ePDgQ4cOjRs37vr1608//fTSpUv1er2C9RhnUXXp0iUkJOT48ePGWVRZWVnx8fF+fn4qleqO9SqVKjQ09Oeff+7cufPOnTs9PT337t2rSOUNKisrS1pouAkAAAAA949Q5sG07FBGfgsFfvzxx3bt2h0+fLh///4dO3Z0dXU1Hrdxc3P75z//mZubGxcX5+Pjo3SxtbO3t9+2bVtERITBYHjrrbcmT55cUFDQyDWUl5evWbPGw8PDOIuqrKzs9llUTk5O9375yJEj09LSxowZc+nSpdGjR0dGRjZO2fXr9OnT4eHhzzzzzB2PX716tbi4uG3btm3atFGkMAAAAABoIghlHoBerz9//rxKpXJ1dVW6lob15JNPbt++3cbGRqfT5eXlGQwGDw+PTZs2nT59+rXXXmvbtq3SBf4BlUoVFha2efPmtm3bbtmyZciQIUePHm2cW1fPopozZ05qaqpxFtWxY8cedBZVhw4dfvzxx7CwMJ1OFx4e/txzz5WUlDRo5fWloqLiyy+/HDlypLED9NatWzMyMm5f0OKTTQAAAAC4T4QyDyAnJ6eioqJTp05WVlZK19LgPDw8Ll++/OKLL06fPj01NTU5ObnW4zZN2YQJE9LS0oYMGXL27Flvb+8VK1Y03L3uNovK2HCnbrOoNBpNRETEd999Z2tru3btWk9PzxMnTtR75fXo3Llz4eHhjo6Os2fPTkpKsrGxCQ4OPnLkiJub2x3LhFAGAAAAAEQ0ShfQnDxq30xaWlquWrVK6SoeiqOj465du15//fWoqKiXXnpp165d0dHRrVq1qsdbXLx4ccWKFZ988kleXp6ItG7detasWf/zP/8zcODAern+5MmTDx48OG3atOPHjw8bNmzlypX+/v71cuX6otfrExMTY2Jivv32W2Nz6MGDB4eEhDz33HO19hvasmWLiCgypQsAAAAAmhR2yjyARy2UaRnMzc2XL1++Zs0aS0vL2NjYESNGGLvMPqTqWVQuLi41Z1HVVyJj5Obmtm/fvpkzZxYXFwcEBISEhGi12nq8fp1dvnw5MjKyW7dud3SATklJCQ4OvlsH6IMHD4qIwWBo3GIBAAAAoMkhlHkAmZmZQijTPAUGBu7Zs6d79+6pqaleXl7bt2+v86WuXLnS+LOorK2t165dGx0dbWZmFhMTM3bs2MuXLzfEje6HwWCoHo4eHh5+/vz5Hj16REREXLp06d4doOPj43v27JmdnS0inp6ejVcxAAAAADRJhDIPgJ0yzZq7u3tqaurUqVPz8/MnTJgQHh7+oNOyk5KSAgICnJycjLOojEnExYsXG20WVXBw8J49e5ydnXfv3j1w4MCff/65EW56u8LCwpiYmH79+hkDKb1eP3HixPj4+PT09LCwMHt7+1pfdevWrejo6EGDBj311FPGpr8DBgyYOXNm49YOAAAAAE0OocwDIJRp7mxsbDZs2BAREaFWqyMjI319fY2NYO6tqKjImESMHDmyZhLRrl27Rqi8mqenZ3Jysq+v77Vr18aPHx8ZGdk454BSUlJCQkK6dOkSEhJy8uRJBweHsLCwrKyszZs3+/j43K0DtHEqtpOT0/z589PS0tq0aTNp0qQdO3YcOXKk6c/wAgAAAICGRqPfB8DxpRbAOC3b29t75syZiYmJnp6e69ev9/b2rnVxSkpKTEzMF198UVpaKiIODg6BgYGvvPKKo6Nj41b9O+3atdu2bdvf//73v//97+Hh4Xv37l29erWdnV1D3Ku4uHjt2rWffPJJWlqaiKjVah8fn+Dg4ClTpmg0d/3To6KiYtOmTTExMT///LMxM/Lw8AgODg4MDKzfLssAAAAA0KwRytyv/Pz8wsJCGxubRt4ZgYbwxBNPJCcnBwQE7Nu3b/To0ZGRkaGhodXPGpOITz/99PDhw3LfSURjMjExWbp0qaenZ1BQ0KZNm7y9vTds2NC/f/96vMWpU6dWr14dExNTUFAgIh07dnzhhRdCQkJcXV3v8apz58599tlnq1atunbtmojY2NjMnDnzlVdeGTBgQD3WBqAZKS4ubt26tdJVAAAANFFN4jvMZoGzSy1M165dd+3a9cYbb0RGRi5cuPCTTz7Zs2dPUlJSfHz8V199ZUwi2rRpExgYGBoa2q1bN6XrrcXEiRMPHjw4ffr0I0eOeHt7f/TRRy+++OJDXrN6k0tCQoLxEeMml6CgIAsLi7u9quZUbOOr7jYVG8Aj4uzZs4MGDZo7d+4777zTTKOZMWPGdOjQoVOnTkoXAgAAWiZCmftFKNPyaDSaiIiI/v37z5kzJz09vUOHDtWtf0eNGjV//vxp06aZmZkpW+S9PfbYY/v373/11VdXrFgxd+7c/fv3f/jhh3Wr+ezZsytWrFi5cuX169flt00uf/7zn++9Aefy5ctr1qz55JNPzp8/LyLm5uZTp04NDg5unM7HAJq4zZs3l5SUREVFffvttxEREc8999zdWlA1WYsXL1a6BAAA0JLR6Pd+GUOZprljAg/j+eef//bbb83MzPR6vUql8vDwOHLkyM6dO2fNmtXEExkjCwuLzz77bPXq1a1atYqJiRk+fLhx5vR90ul0CQkJfn5+bm5ukZGR169f9/DwiI6Ozs3NjY6OvlsiU3Mqtpub2/1MxQbQIt26dav619v97//+74GrqX/uAAAgAElEQVQDB4YNG3bx4sXZs2d7e3vv3btXiQLr2Y0bN6p/BQAAeBiEMveLnTIt2KRJk3Jzcz/77LMrV64kJyc3xwYoQUFBSUlJrq6uycnJXl5eP/300x++5PLly5GRkd26dfP19d2yZYu5ubm/v39SUlJycnJwcLCVlVWtr7pjKrZKpfL394+Pjz99+vQ9pmIDaNkqKyurf72Dl5fXnj174uLiHB0dDx06NGLEiICAgAsXLjR6jfWprKys+lcAAICHQShzvwhlWjZ7e/t58+Z16NBB6ULqbvDgwYcOHRo/fvz169cnTJiwdOnS6tNYNe3evdvR0TE8PPzChQt9+vSJioq6cuVKXFzc8OHD7/aSWqdinzt3zrg1ptkdSQBQj8zNzUXEYDC4uLikpKTc8awxvT116tSSJUvMzc3Xr1/fp0+fpUuXlpeXK1HsQzlz5ky/fv2MzbPuFl4DAADcP5VxYC3+UJcuXXJzc7OyslxcXJSuBbgrg8Hwj3/8469//ater3/mmWdiY2PbtGlTc5lWq3Vzc/Py8goODh47duw9IpWaU7HHjBnTpGZRAVBcVVXVc889t379ehGxsrL661//+tprr9XaHTwnJ2fx4sWxsbEi4ujo+M477wQFBTV2uXVSWVkZFRX19ttvFxcXi8jEiRM3bNhgTKMAAADqjFDmvpSVlVlZWWk0mrKyMhMTE6XLAf5AYmLirFmz8vLynJycNmzY4OXlVXNNZWXlvZvm1G0qNoBH1t69excvXrxjxw4R6dq167vvvhsYGFhr5vvLL78sXLjw6NGjIvLkk08uW7asiZ8bTUhICA0NPXnypIi4u7u/++67EyZMULooAADQEhDK3JcTJ07069evR48eGRkZStcC3JecnBx/f/8DBw5YWFh8+OGH8+bNu88X1m0qNgAY7dixY+HChUeOHBGRJ554YtmyZQMHDqy5TK/Xf/HFF4sWLbp27ZparX7++efff//9JniGND09/bXXXtu6dauIuLm5ffDBB88884zSRQEAgJaDnjL3hYYyaHYcHR137ty5YMGC8vLyl156KSgo6A97Up49ezY8PLxr164BAQEJCQk2NjbBwcFHjx41tv4lkQFwP5544onU1NTVq1d36NBhx44dgwcPDgoKysvLu2OZWq0OCgpKT08PCwvTaDSxsbG9evWKjIystVuwIgoKCsLDwwcMGLB161Y7O7uIiIhjx46RyAAAgPpFKHNfCGXQHJmbmy9fvjw2NtbS0jI2Nnb48OGZmZk1l9VtKjYA3M3tgYupqWlsbGzPnj0jIyMrKiruWNmmTZuIiIijR49OmDDh9hBEkbKr6fX6NWvWGEOiqqqqwMBA43u595FPAACAOiCUuS/Gb2UJZdAczZ49e8+ePd27dz98+LCXl9e2bduqn6rbVGwAuB/G3SVHjx6dOHFiYWGhMXDZsmVLzZU9e/b84Ycf4uPj+/Tpk56e/swzz/j6+hobuDS+X375ZdCgQXPmzMnLy3vyyScPHz68Zs2aJniuCgAAtAyEMveFnTJo1tzd3VNTU6dNm3bjxo1nnnkmLCzsp59+CggIcHJyMk7FdnNzi4iIuHjx4r2nYgPAg3Jzc9u8eXN8fHzfvn0zMjL8/Px8fX1PnDhRc6WPj09aWtqyZctsbW0TEhLc3d1DQ0OLiooardScnJygoKAxY8YcPXrU0dFx9erViYmJTbwDMQAAaO5o9HtfevbsmZGRcfz48b59+ypdC1BHBoMhIiLizTff1Ov1xi98MzOzqVOnzp8/f/To0UpXB6CF02q1H3/88ZIlS4qKikxNTV9++eW33nrLzs6u5sr8/Py33377o48+0ul09vb2b7755p///OcGHX1YUlLy3nvvRUZGlpeXW1lZLVq0KDw8nEZaAACgERDK/DG9Xm9paVlZWXnr1i1LS0ulywEeSnR09CuvvNK6deuwsLC5c+eyJx9AY7o9cGnbtu3f/va3uwUuqampCxcu3L17t4gMHjx42bJlI0eOrPd6DAbDhg0bFi1adOHCBZVKNX369Pfff9/JyanebwQAAFArji/9sZycnIqKis6dO5PIoAWwt7fX6XSjR48ODw8nkQHQyOzt7ZcvX37o0KFRo0bduHFj4cKFnp6eu3btqrly8ODBu3bt2rRpk4uLS2pq6qhRo/z8/LKzs+uxmEOHDo0YMSIgIODChQuenp5JSUlxcXEkMgAAoDERyvwxGsqgJeG/ZwCKGzRo0M6dOzdt2uTq6pqWljZ69Gg/P7+srKyaK/38/E6ePBkREWFtbb1ly5Y+ffqEh4ffunXrIQvIzc0NCQkZOnTo3r17HRwcoqOjDxw48Pjjjz/kZQEAAB4UocwfO3f2rIh0s7eXAwdkxw7Zvl22b5effpJduyQlRc6elcJC4RQYmgljKNOtWzelCwHwqPPz8ztx4kRERETr1q23bNnSt2/f8PDw4uLiO5a1atUqLCzs9OnTgYGB5eXlkZGRvXr1WrNmTd3OX1dWVi5fvrxXr14xMTEajWbBggWnT58ODg5Wq/kbEQAAUAA9Ze4uN1dOnZL09PCvv47cvfttX983R4+Wqqr/LlCpxMRETExErxcR6dxZeveW3r3F1lapkoE/NHbs2MTExG3bto0fP17pWgBARCQ3Nzc8PPyLL74wGAwODg5LliyZN29erSnJwYMHQ0ND9+/fLyJDhgxZvnz50KFD7/9GmzdvDg0NNW7JmThxYlRUlKura329CwAAgDoglKlBq5WUFNm7VyoqRKcTne5mRcWZ/Pz2VlZOf5i2mJqKwSAdOsioUeLmJipVo1QMPAAXF5fz589nZGT06NFD6VoA4L8OHToUGhq6b98+EfHy8lq2bFmt54n0ev2qVaveeOONq1evqtXqkJCQjz/++A8vnpaWtnDhwp07d4pI7969//Wvf40bN67e3wIAAMCDYrPubQwGSUmRf/5TfvlFioulsvJqUdHO7Oy9OTki4tC69R3LLxQVnbp27XcPabVSVVWUmXnq00+L3n9fcnIarXbgflRWVl68eNHExMTZ2VnpWgDgd7y8vPbs2RMXF+fo6Fjdgjenxv9J1Wr1vHnzzp07t2TJElNTUysrq3tf9saNG6GhoZ6enjt37mzbtu2yZcuOHTtGIgMAAJoIdsr8prxcvv5acnNFqxWR43l5C7dvT8zMrP7s2FpYLPD2fnPUKNPfJneO/s9/dp0/r1+yRPX7HTGfp6W9uHHjqsmTXxwyRIYMkbFj2TKDJiIjI6Nnz54uLi61NtQEgKagpKTkvffei4yMLC8vt7KyWrRoUXh4uIWFRc2VZ86c6dChg+1d9rFqtdqPP/546dKlhYWFpqamL7744rvvvtuuXbsGLh8AAOABsFNGRERKSyU6Wi5eNCYyhy9fHr5y5b6cnP8bOTJp7ty0+fO/nTFjUKdOf9+5c+q6dfr7j7G0Wjl4UDZsoA0wmghGLwFo+qysrJYuXZqRkREYGFhSUvLWW2+5ubmtWbOm5soePXrcLZFJSEgYNGjQwoULCwsLfXx8Dh8+HB0dTSIDAACaGkIZEYNBYmPl5k3R6UTEYDDM2bixVKvdNnv2u2PHDndyGtip05TevX+eM2danz5bMjJWpqY+wMW1WjlzRn75paGKBx4EoQyA5sLR0XHNmjWJiYkDBgzIycmZM2fOmDFjjh49+ocvzMjI8PPz8/X1PXHiRI8ePTZv3hwfH9+3b99GqBkAAOBBEcqIpKTIjRvGREZEdp4/f+zq1Vn9+4/6fdMNtUr14dNPa9Tqfx88+GDX12pl3z65caO+6gXqLDMzUwhlADQfTz755OHDh1evXt2+fftffvll0KBBQUFBeXl5tS4uLCwMDw8fMGDAli1b7OzsIiIijh07NnHixEauGQAA4P4RyogkJUllZXXbl13nz4vIhNoG03Ru3drTweHY1asFZWUPdgu9Xg4ceOhCgYfFThkAzY5arQ4KCkpPTw8LC9NoNLGxsb169YqMjKysrKxeo9fr16xZ07Nnz8jISK1WGxgYePr06bCwMHNzcwUrBwAA+EMapQtQWnm53Lp1+wM5RUUi0q1Nm1qXd2/bdv/Fizk3b7Zp1cr4yKxvvrljTVZBwZ0v0+vl3Ll6qRd4GIQyAJqpNm3aREREvPjii6+99trWrVvDw8NXrlw5Z86cxYsXL1u2bMWKFSdOnBCR0aNHL1u2zN3dXel6AQAA7guhTLmo1dVnl0SkQqcTEbPfRizdwdzERETKtNrqR9KvX79jzY1a99FUVDx0rcBDMRgMxqFL3bp1U7oWAKiLnj17/vDDD99///2iRYvOnDnzxhtvvP3228YtMy4uLu+999706dOVrhEAAOABPPKhjLX17YmMiNiam4tIYXl5rcuNgUvb37bJiEhqSEitI7HvfOVdxkMAjeby5culpaXt27e3sbFRuhYAqLvJkydPmDAhICDg+++/NyYyY8eO3bx5c6vb/u8MAADQLDzyPWU0GnF0vP2Bfh06iEjalSu1Lk+7csXazMz1Loeb7srUVPr1q2uJQP3g7BKAFsPU1PS7775LS0tbvHhxcnJyQkICiQwAAGiOHvlQRkTGjhVT0+qPnu7Rw0StXnPkiN5guGNhYlZWdmHhhB49NOoH/LyZmMjgwQ9fKfAwCGUAtDADBgx45513PDw8lC4EAACgjghlRBwdxdOzOpdxsrV90d398OXLr8fH6/T66lWZBQUvbdpkZmLy15EjH+z6pqbi7y9mZvVYMlAHxlCGhjIAAAAA0EQ88j1ljHx9pbxcTpyQykoR+df48ecKCv65d++WjIzxjz3WtlWr09evf3/6dKVOt3Ly5IGdOj3AlU1NZdIk4dtgNAHslAEAAACAJoVQRkREVCqZNEkcHOSnn0SnszYz+ykw8PO0tC+PHv3q2LHiiopO1tYBffv+5fHHjR1njHq3b19WVXVHl18RaW9p6dWlS3sbG7G2lpkzpUuXxn0zQO0IZQAAAACgSVEZanROeaQVFcmPP8qZM6LXy21nlx6MqamoVDJsmIwYIRpiLzQV7dq1y8/Pz83N7dy5s9K1AAAAAAAIZWpVWCgHDsjRo1JVJTrdHTOz78rUVAwGsbUVLy9xdxdz8wauEngAN2/etLW1tbS0vHXrVs3tXQAAAACAxsc+jtrY2cm4cfLUU3L1qpw7J5mZkpcnJSWi0YhaLSqVqFS/7qPR6USvF1tbcXCQ7t2lWzextVW6eqAWZ8+eFZFu3bqRyAAAAABAE0Eoc3cqlXTqJJ06yfDhIiJ6vdy6JaWlotWKVivm5mJmJpaWYmWldKHAH6OhDAAAAAA0NYQy902tFhsbsbFRug6gLjIzM4VQBgAAAACaErXSBQBoDOyUAQAAAICmhlAGeCQQygAAAABAU0MoAzwSCGUAAAAAoKlhJDbQ8lVWVlpaWopIaWmpmZmZ0uUAAAAAAETYKQM8CrKzs3U6naOjI4kMAAAAADQdhDJAy8fZJQAAAABogghlgJaPUAYAAAAAmiBCGaDlI5QBAAAAgCaIUAZo+QhlAAAAAKAJIpQBWj5CGQAAAABogjRKFwCgwVRWyvXrhrKy7KwsEenWrZvSBQEAAAAA/otQBmhxDAZJT5ekJLlyRTSayzdvlpaVtbeysomJEQ8PGTpUWrVSukQAAAAAAKEM0MIUFcm6dZKfL5WVIiI63bkrV0Ske5s2UlIie/fK/v3i5yf9+ilcJwAAAAA88ghlgBbk2jVZtUoqKsRgqH7sXEGBiHRv21ZEpKpKRGTTJrlxQ0aNUqZIAAAAAICI0OgXaDnKyuTzz+9IZETk3I0bYtwpU02rlaQkOXq0kQsEAAAAANyOUAZoKbZsqZnIyG87ZRxtbX/3qFYrP/wgpaWNVh0AAAAA4A6EMkCLcOOGnDkjOl3NZ87m54tIZFKSccvMf+l0snt341QHAAAAAKiJUAZoEQ4fFr2+1mfOFhSIyNkbNzxjYjalp//3CZ1O0tJq7qwBAAAAADQOQhmgRTh1qtZtMhdv3iwoK1OrVP59+hSWlz+7dm3otm1V1fGNXi/5+Y1aJwAAAADgN4QyQHNmMEhGhsTG3i1b+f927xYRMxOTuICAaD8/jYlJ1IEDPmvWXLl1S0REpZI7zjQBAAAAABoLI7GB5qm4WI4elYMH5ebNWp6sqFh7/PiSX34xhi/9O3YUkWAPj97t2s3YsGFndrZnTEycv//jjz0mWm1jVw4AAAAAEBERlYGOEkAzYjBIVpakpMjp07U2kUm7cuXT5OQvjx69VVkpImqVamjXrl9Om+ZiZ2dckFdS8tw33/ycmalRq98ZMybsrbfk8ccb9S0AAAAAAESEUAZoNkpKJC1NkpOlsLDmkxVVVZvS02NSUhIyM6sfVKlUfx0x4u0xY9Qq1e2Lq/T6NxIT/5GUZBCZ1b//Z//6l9WYMfL7NQAAAACAhkYoAzR5ly9LSoocOSJVVTWfPHvjxorU1JWpqddLS0XExtx8Zr9+rwwZsu3MmcWJiTq9foyr69rp0ztYWd3xwu9Pn56zcWNReXmvdu02hIX1ffVVMTdvjLcDAAAAABARQhmg6aqokOPH5dAhuXq15pM6vf6X7Ozl+/f/kJFh/Br2cHAI9vB4vn9/KzMz45od2dkzN2y4euuWo63ten9/765d77hIRn7+9Li4Y1evtjY3X/HccwEREdKhQ8O+KQAAAADAbwhlgKYnN1eSk+X48Vq78OYWF8ceOfLxoUMXiopExEKj8evZM9Tbe7iTU83FF2/eDFi/fl9OjrlGE+njEzp06B0LyrTa//nhh8/T0kQkeMiQf0dHm7q7N8BbAgAAAADciVAGaDKqqiQjQ1JS5La+MNX0BkNiVlZMSsp3p05V6fUi0rNduxfd3V/y8GjbqtW9rqrXv5GYGJmUJCKBAwd+OnGipanpHWtiUlJe3bq1Uqcb6ez89dtvOzz/vJiY1N8bAwAAAADUglAGqCfFxZKeLhcuSEmJaDTSsaN07y5OTvfVQDc/Xw4fltRUKSur+WRhefnqtLSoAwcyCwpExMzEZHKvXsEeHmNdXVW1Xlylkhpf118dOxa8eXNJZaV7p04bAgK6t217x4Lk3NzpcXHnCwvbW1mtDQkZ+7e/ia3t/b1zAAAAAEBdEMoAD624WLZulbNnRaX674EjtVpMTcXMTJ5+Wnr3rv2FOp2kp99ta4yIpOTmxqSkxB49WqbVikgXG5t5gwf/j5dXza69IiLm5tKvn3h5SXq67N79u2JEROT09evT1q07ee2ajbn5qsmTp/Xpc8cFrpeWPvfNN/HnzmnU6nfGj389KkrVvfsDfSYAAAAAAPePUAZ4OJmZsm6d6HSi09W+wMxMevSQKVN+dyCouFiOHpWDB+XmzZqvuFlR8fXx4x8dPHj06lURUatUY1xdgz08pvbubaJW13KLzp3Fw0MGDJDqc0mlpZKWJsePS36+VFaKWi3W1tK9e7HB8KfFi9efOKESedXb+5/jxml+f0GdXv/3Xbv+vnOn3mCY1LPn6vfft3vmGaZlAwAAAEBDIJQBHkJmpnz9da3teKtlFRSkFxYOGz7cdt48EZGsLElJkdOnRa+vuTj18uXo5OSvjh27VVkpIp2sree4u8/39HSxs6vl0hqNuLnJ0KHi6Hj/JRuys6MWLvx/W7ZodbrRLi5fT5/eydr6jjVbMjKCvvuuoKysh739N6+/3n/BArGwuP9bAAAAAADuB6EMUFfFxfLvf0tlpfGjovLyX7KzMwsKDAaDi53dU927tzY3F5GIpKT/S0jYP3++9/Dhkp8vhYU1r1RRVbUpPT0mJSXht3NMHg4OC7y9Z/XrZ1prw117exk0SAYPlnu2+L1H5bvffXfGxx9fLi7uYmMT5+//eI1Y53xhof/69YcuXWplavqRv/+LH3wgHTvW5V4AAAAAgLsglAHqat06ycgwbnj55969b+3cWVxRUf1k21atPp040b9v319DmXnzvLt2rXmNM/n5Kw8fXpGaml9aKiK2FhYz+vZ91du7X4cOtdzRxER69hQPD3F1fdgjRXp93rffznr99cSsLI1a/c6YMWEjRtyxpLyq6tWtW1ekpopIsJfXh//+t9mQIQ91UwAAAADAbQhlgDopLJSPPpKqKhGJTEoKT0h4rG3bf/j6PunqamZisjcnZ9FPP92sqDj28ssfHjxYM5TR6fVbz5yJOnDg58xM41egh4NDsIfH8/37W5mZ1XI7Ozvx8JBBg6TWFr91VXXkyBuhof/YudMgMqt//8/8/Grefc2RI/O3bCnTaj0dHNb/7W8uf/qTaDT1WAMAAAAAPLIIZYA62bVLdu0Sne5ycbHLsmWtzc2Pvfxy59atq58vLC+vqKrqaG19x06Z3OLi2CNHPjp0KKeoSEQsNBr/vn3/d+jQQZ0713IXlUpcXcXDQ3r1klpb/D68/PzvFy+es3p1UXl5r3btNgQE9K2xSSf18uXpcXFZBQXtLC2/fOmlp5YulVp73AAAAAAAHgQ/8QbqJD3dOG4p7sSJSp3uz0OG3J7IiIhdjc64e3NyIpKStp45o9PrRaRfhw7zPT0DBw60MTev5fpWVuLuLp6eDR5/2NtPjoo62LfvtHfeOZ6XN2zlypWTJvn37Xv7ksGdOx966aXZ3367/ezZCR9++MaJE3/76CO1m1vDFgYAAAAALV3D/OwdaPFu3DD+81BurogMra1fzB0yCwo2p6ebqFT+ffvGBwUdffnlV4YMqSWR6dxZnn1WXntNfHwaaUOKmZnbq6/u27BhZv/+xRUVAevXh2zerP39hG97S8utzz8f4eNjMBjeSkiY5OdXsHGjsM8OAAAAAB4CO2WAOvltDPbVW7dExNnW9g9f4d+nT15JSeCAAe1r7Qtjbi79+smQIVJri9+GZz1y5NotW55ctOjVb7+NSUk5df36uunTb9/+o1KpwkaM8OrSZdaGDT9kZLi/8MKGv/zFa9GiOk6AAgAAAIBHHjtlgDr5rcOLzmAQEetau/P+nrlG89qwYbUkMp07y8SJ8pe/yMSJSiUyv3JyCv788z1vvulsZ7f7/PmBn376828juquNcXVNDg727tr1QlHRqLffXvHCC3LpkohIQYGcOCEHD0pKipw9K+XlCtQPAAAAAM0KO2WAOrGyksJCEbFv1UpE8kpKHO9js8zvaDTSp48MHSq1tvhViqWl55tvJru7P/eXv8SfOzf+iy/eGTPm9eHDVbdN4Ha0td3xwgsLtm37LCVl9f79L372mYmlpVRViVotOp2oVKJWS1WVODmJj484OCj4bgAAAACgKWOnDFAnvzWRGdCxo4jsu3jxAV5rby8+PvLaazJlStNKZIzU6naTJ2/btGmJj4/eYAhPSHj2668Lf7/zxUKjifHzi506Nc7f30SlkrIyqayUigqpqhKtVioqRKeTrCz5/HPZvl30eqXeCgAAAAA0ZYQyQJ306yfm5iIytXdvEfnk0KHK33fGrZ2FhQQGyiuvyPDhTbwVi0mfPkvXrft+/vw2rVptSk/3/uyzY1ev3rFm9oABnVu3/rXdr0pVVF5++vr1rIKC/34qtFpJTZW1a2kJDAAAAAA1EcoAddKjh2g0ItK3Q4fZAwacvHZt5oYN10pKqp9PvXx5R3b2715iZiZ+ftKtm9x2FKhJa9t2YlTUwX/9a2CnThn5+d4rVvzn8OFalqlUG0+fHvLZZ20iInr/+9/dli9vExERsH59Rn6+iIhWK+fPy08/NXLtAAAAAND00VMGqBO1WsaNk82bRav9dOLEwvLy706d+iEjY3DnzhYaTVZh4fnCwhFOTrvnzv11vUoltrbSu7eiRT84jeaxkJD9Awa8+uqrK1JS5n7//f6LFz+cMMHMxKR6SWRSUnhCQlcbm3fHju3boUOZVpuYlfV5Wlr8uXM/BQZ6dekiWq2kpMjAgdKpk4JvBQAAAACaGpWBYwVAna1bJ2fPSlWViMSfO/d9enpWQYFKpXK0senfseOMvn3tLS1/PHv221On/m/MGJewMLG3V7riurp4Mfq110K/+66iqmr2gAGxU6caHz546dKwFSv6duiw84UX2tx2IGtHdvZTsbFOtranXnnF1MREVCrp1k1mz1aoegAAAABoighlgIdQVSVffimXLolWW/sCg0HUajE1leefFyenxi2uvpWWpn7wQWBU1BdTpw76rT/xc998s/bYsR0vvDDaxeWO5a/88MPHhw6tDwiY3qePiIiJiSxaJBYWjVs0AAAAADRd9JQBHoJGI4GB4uUlGo2oa/tqMjcXe3t56aVmn8iIiKXl4MWLj33zzaDbplz/nJnZztJylLNzzeX+ffuKSGJW1q8fm5pKTk6jFAoAAAAAzQM9ZYCHo1aLr694eMiePXLqlGi1YmIier3odNK5swwbJn36NJvOvn9IpVKPHCmpqVJYKCIllZV5JSXDHB1Vtb1BN3t7EcksKPj146oquXGjEWsFAAAAgKaOUAaoD23bip+f+PlJSYmUlIiZmdjY1L53pgX4LYIp0WpFpJWm9j9GrExNReRWZeWvH+t0Uv17AAAAAAChDFDPrKzEykrpIhqYubnxnzbm5iJSfJeo5WZFhYjY/rZYTEzEzKwxygMAAACAZqKF/iQfQMP5bbK1hUbjbGd3+vr1Kr2+5qpjeXki0qd9+18/1mikXbvGKhEAAAAAmgFCGQAPqEeP6j0v47p3L66o2HrmTM1VXx07JiLjH3vs14+1WnF0bKwSAQAAAKAZIJQB8IDc3Kp/+7/DhplrNKHbtuUUFd2+5JuTJ9ceO+bdtesYV1cREZXq9igHAAAAACAiKoPBoHQNAJqbpCTZvVsqKkSl+jwtbd6mTdZmZi+6uw/s1KmksvLnrKyNp051tbVNnDPnsbZtRURMTSU4mONLAAAAAHA7QhkAD06vl5gYuX5ddDoR2ZeT886uXb9kZ5dptSLSydo6oG/fxWwNJ+gAAAsESURBVKNGdTD2PDYzk2HD5IknFK0YAAAAAJocQhkAdXLrlqxYIbduGXMZEdEbDNdLS1tpNK2rJy6JiKmp9OolU6ZUD9IGAAAAABgRygCoq7IyWb9eLl2SWqdiq1RiYiIjR8rIkSQyAAAAAFAToQyAh5ORITt2SF6emJqKcTa2SiU6nfTsKU8+Kfb2StcHAAAAAE0UoQyA+lBWJpcvS0mJmJiIra106iQmJkrXBAAAAABNGqEMAAAAAACAAtRKFwAAAAAAAPAoIpQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAAAAAAAAUQygAAAAAAACiAUAYAAAAAAEABhDIAAAAAAAAKIJQBAAAAAABQAKEMAAAAAACAAghlAAAAAAAAFEAoAwAAAAAAoABCGQAA8EgoKCgoLy9XugoAAID/IpQB8P+3d3+hVdZ/HMC/83jcZi52ZkFzynHMWbCDlLTYIBW6CQl245hjN94o26QNoYhdaNBN5GoDt4KCUBQt2LLwQkVk6oU0AnEW6CLlbFAtWdB2tjGtttXF6XfyZ3/4FfV7cr1eV8+f7/Pw+d49vJ/vH4DFb35+vqSkpLOzM+pCAAB+JpQBAAAAiIBQBgAAACACS6MuAADgZxMTE7du3Vq1atXY2Ni1a9dKS0urqqpCCN9+++2lS5fi8XgqlVq+fHkIYWFhYXR0dPXq1bOzs0NDQw899FBlZeXSpf/1bXPr1q2hoaG5ubmysrJo+gMA8NuEMgDAP0hvb++77767devWN954o7CwMJPJ1NfX7969u6mp6fbt29PT06tXrz579mxlZeXs7GxFRUVzc/OxY8disVgmk0kmk++///7GjRuzr3rzzTc7Ojqmp6dXrFgxNTUVbb8AAH7J9CUWgxs3bjzzzDNRVwHAX+PTTz8dHx8fGxubnJzs6up67733du3a9cEHH0xMTIyMjGQymZdffjnXuK+v7/Tp05OTk6OjowUFBfX19XNzcyGEEydOtLa2NjY2ZjKZTCbz9ddfR9chAIBfJ5RhMbh+/fq5c+eirgKAv8zBgwdXrlwZQqivrw8htLe319TUhBDWrFnzxBNPDA8P51q2trY++eSTIYRkMrl3796RkZGhoaEQQnd397p1615//fUVK1aEEBKJRCQdAQD4HaYvcc87fvz4+fPn5+fn+/v7QwipVKqsrOzMmTN1dXUjIyMDAwOxWGzr1q3JZHJ6evrkyZPj4+MbN27MfsHnXLlyZXBw8Pvvv6+tra2uro6oKwD8JBaLZQ8KCwtDCEuW/PwbqbCwcHx8PHdaXFycO06lUiGEdDpdXV39ySef1NXV3bXEDADAP4qRMtzzurq6jh8/Pj8/v3///v379w8ODn7++ecNDQ2tra21tbX9/f0vvfRSVVXVsWPHUqnUq6++evjw4U2bNu3bty/3hpaWlscee6y3t/fQoUM1NTXt7e0RdgeAP21mZib8J8GJxWIFBQVRVwQA8Hv8PuKe9+GHH3Z0dBw4cODSpUvZK1evXg0hjI6OptPpRCIxOTlZXl7e3Nx86tSpzZs3hxB27tzZ2dn54osvxuPxvr6+t95667XXXnvuuedCCGfOnInH4xF2B4A/7ezZs3l5eY8//ngIoaKi4uOPP87d+uKLL6KrCwDg1xkpw6LV0tKSXUGguLj4kUceqampySYyIYTa2trvvvtubGwshHDy5MnS0tI9e/Zkbz399NNPPfVUVDUD8EfdvHlzYmJiZmbmyJEjXV1d27dvLy8vDyFs3779o48+6unpmZ2dTafTO3bsiLpSAIC7CWX4V4jH4z/88MOdpyGE7PYc6XS6oqIit3gBAPeW7u7ukpKSoqKinTt3NjU1vf3229nr7e3tzz777PPPP3/fffetX7/+0Ucfffjhh6MtFQDgLqYv8W93//33f/XVV1FXAcBPXnjhhba2tlxW/sADD3zzzTfLly/PNTh69OjCwkLu9JVXXmlsbJyamiovL89utJS1dOnS3t7erq6uzz77rLS0dOXKlTMzM9b9BQD+UXyasBjE4/G5ubmFhYU7t+f4H6VSqYGBgS+//LKsrOzvqA2AP6SgoODOBXrz8vLu2s36zuQlhLBkyZJkMvlbb1u2bFl2S6ZfPggAEDnTl1gMNmzYMDc319nZOTAwMDw8/IeebW1tzc/Pr6urO3Xq1OXLl48cOfLOO+/8TXUCAABAjlCGxWDbtm1tbW2dnZ0NDQ0XL16MxWKJRGLZsmW5BkVFRXf+IM3Pz08kEtlhNWvXrr1w4cKDDz7Y2Ni4ZcuWnp6e7FozAAAA8LfKu3P1UwAAAAD+P4yUAQAAAIiAUAYAAAAgAkIZAAAAgAgIZQAAAAAiIJQBAAAAiIBQBgAAACACQhkAAACACAhlAAAAACIglAEAAACIgFAGAAAAIAJCGQAAAIAICGUAAAAAIiCUAQAAAIiAUAYAAAAgAkIZAAAAgAgIZQAAAAAiIJQBAAAAiIBQBgAAACACQhkAAACACAhlAAAAACIglAEAAACIgFAGAAAAIAJCGQAAAIAICGUAAAAAIvAjEJpS1imyqfIAAAGoelRYdHJka2l0UEtMIHJka2l0IDIwMjUuMDkuNQAAeJx7v2/tPQYgEABiJgYIkIDiBkY2hgQgzcgMoZkZOSB8Rux8JiactIMGSD0LnGaA0BwQmkmQQQFkDptDBojLzEglddwMjAyMTED3A6UYmFkZWNkY2NgZ2DkYODgZOLkymLi4Fbh5NJi4eRm4+BL4+DOY+AUUBAQ1mASEGPiFE4RFMphERBVExTSYRMUZRDgTnBiBhrJxigjz83GJawE5jAywELu54/cBG5kSKxDH2uv8gZstgvYgNt/ZEwdm1zM7gNinIlYeuBS5eR+I/f3q+gP2wq/3g9jhVyoPLM2OswOxSz/qHrg5zRgsnq+xar+MDSdYfZio8L7UA21g8fPh8+3fFf4Ai7f47LT3V2gA2/VHqs3OYOdXMPv827d2f39Fgu3dbTxhv7voWrB4fbOpg8WRE2C2weYGh3VhahD1imsdHM7PBrMdhC87VN+cAXbPn3mbHVjZdMHmsOeUODxXCgO74VSftEPs1s0Qd07hcxD5aXEAxA4qj3JoOVoMZp+6E2bP4R0LZosBAIB5cTxFb7DCAAACO3pUWHRNT0wgcmRraXQgMjAyNS4wOS41AAB4nH1UW24bMQz89yl0gQh8U/yM46AoithA6/YOBfrZ+6OkgnRlVOjuitBjRC41Q51aPV8vX37+bn8fupxOrcF/vohoPxgATm+tOu38+unztb3cn88fMy+379f7t0ZSH9T7iH2+394+ZrC9tCfvw4xRG/R0HIzvnXyOrVRA6+I+sNbVhjBvgNxuBSRXSEfUQcVMNkApj9opCMZoT9BZgUI3SC2X2iVkWLQn7INNaYe08sk9gHXUOqGn9w3QC0jd0YdRBXdApV3io5DYmYI1CoksgDufUchcFza22gNKLrZBYpLUsJNkQl57ZGgOdkicSBE3GdkpfsbWZRGUCRtGngz2wHDceiyCMqKJgzbuAhr70EnQr0oDydQjfbISZZwNVDM4FS2omMASx9gdERZB0oFweMU0CTfYAYugpByB3euokkjbhh6ZjnUNw5pOOQ3lbTpR6Wg3TKV7/q0DS+xcUrHDfWBkLRQ7mVce1g6JM2/hPEOooxLg8K1PmkiiLB8o5Y0Agi2y+ElakDXrK8U8YARvo0+C6vdy3Qoq6kXqv9DX6+Wh7N8vgvPtejkugnrpKPccND6KuoZylC5m06M+a2hHEWI2P0oNs42jnjBbHEWD1dbSkDKISwngNLRoncogL6LGOSOLemXu0kWkUgZtUSNO44vsqAyORV84Z2IRktQuWgUjZQgXYWAZokUANA0vROOckYVQmVsfeFtZqvHHVZ/90x9L1Cm6QtHQJgAAASd6VFh0U01JTEVTIHJka2l0IDIwMjUuMDkuNQAAeJxNkElqxUAMRK+SpT+0heYBk5UPkEN4myP8w0fqZBGDQf2QVKq67+Prtf/+HnqO+/jsx/fr+V/SX/nxPs6AdBdaCIhYQoyxrtNBI3KoearIRhyGshjQ1L2JARdjrRNBDLlsMy3NWCdBihs3EigUq97FFIzZiCEo0mcykIypGYFwyWYkijR9Xar4QGrV1l8XAesWQNC0rgephtuibaHW1UpOxUOKKmiIugbaElC00q1H7JbdI8ZzAc/FNEPjudcoIFNLIbhWtOM2RygzMk4aOFj5pMSVJjodTkLeIQXK7BBIqt+MervGyKj0CWNJUWoT5gm7Y8lCniElMVkdXWKWzP0pJeiD1CLW6/0DWgVkFDZhKC8AAACnelRYdHJka2l0UEtMMSByZGtpdCAyMDI1LjA5LjUAAHice79v7T0GIBAAYiYGCOCA4gZGNocMIM3MjMzQADFYcAuwM4AZjExwBjcDYwYTI1MCE3MGEzNLAgtrBhMLmwITuwIrQ4ITI1ANGwMrCzMTo3gWkM3IAHMF51tWNQaGD/tBnIduy4D0BCT2ATsQu9d87lKguD1U3B4mDmHD1Ks5INSoHYCxxQBSniT90cLaYQAAAOZ6VFh0TU9MMSByZGtpdCAyMDI1LjA5LjUAAHicjZLNCoMwDMfvfYq8gCX9su1RrYwxrLC5vcPue3+WbGj1oJhYSOKvMfmjALZ7ur0/sJhOQgDgwRNjhJdBRDEAB9D2l2uGbmraudKNzzw9IJAj+5ZspnGYKwo6QIk/g0rJ4B1HS2m5qgmk9zpGNIEjpXdIsyFRmr2WlsGlfNDREXimYb3mjkb0kEFLFwP6+ujDgbjqDNjntJH1L3Q75lSEtnR0kdPSMUUzy6cow+7K/pRAXdZUlPqyjKK7ocxsmVhPtp6D8/lXoVh8AWFHeNE/3tWsAAAAYnpUWHRTTUlMRVMxIHJka2l0IDIwMjUuMDkuNQAAeJzzSzZMBgINP81kQ4UaDSM9U0sLAwsdQz1DI1Mda0M9I0tLAxMdAz1jcySuLlTaAMSyAMnookvpomnVRTPZAMrQrAEAOwobHsNdexoAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "# molecules_to_visualization() highlights the functional groups identified in the previous step.\n", + "# The resulting image shows each molecule with the detected functional groups marked.\n", + "\n", "img = functional_groups_detector.functional_group_highlighted_molecules_image_grid(functional_groups_imgs)\n", "img\n" ] @@ -183,23 +261,53 @@ "source": [ "### Reaction Detection\n", "\n", - "This cell identifies possible reactions between the detected functional groups.\n", - "\n", - "- `ReactionDetector()` initializes the reaction detection module.\n", - "- `reaction_detector()` analyzes the detected functional groups and generates possible reaction instances.\n", - "- `create_reaction_image_grid()` visualizes the detected reactions in a grid format." + "This cell identifies possible reactions between the detected functional groups.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "76817cd8", "metadata": {}, "outputs": [], "source": [ + "\n", + "# ReactionDetector() initializes the reaction detection module.\n", + "# reaction_detector() analyzes the detected functional groups and generates possible reaction instances.\n", + "# create_reaction_image_grid() visualizes the detected reactions in a grid format.\n", + "\n", "reaction_detector = ReactionDetector()\n", - "reaction_instances = reaction_detector.reaction_detector(functional_groups)\n", - "print(f\"Number of reaction instances detected: {len(reaction_instances)}\")\n", + "reaction_instances = reaction_detector.reaction_detector(functional_groups)\n" + ] + }, + { + "cell_type": "markdown", + "id": "0149d1d3", + "metadata": {}, + "source": [ + "### Reaction visualization (Optional)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b443f92e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "img = reaction_detector.available_reaction_image_grid(reaction_instances)\n", "img" ] @@ -211,22 +319,57 @@ "source": [ "### Reaction Selection\n", "\n", - "This cell filters and selects the relevant reactions from the detected reaction instances.\n", - "\n", - "- `reaction_selection()` processes the detected reactions.\n", - "- It removes invalid or redundant reaction candidates." + "This cell filters and selects the relevant reactions from the detected reaction instances.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "26d581e2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Detected Reactions:\n", + "1. Diol and Di-Acid Halide Polycondensation(Polyesterification)\n", + " Monomer 1: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (diol)\n", + " Monomer 2: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (di_carboxylic_acid_halide)\n", + "\n", + "2. Di-Amine and Di-Carboxylic Acid Halide Polycondensation (Polyamidation)\n", + " Monomer 1: Nc1cccc(N)c1 (di_amine)\n", + " Monomer 2: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (di_carboxylic_acid_halide)\n", + "\n", + "Selected 2 reactions.\n" + ] + } + ], "source": [ + "# reaction_selection() processes the detected reactions.\n", + "# It removes user selected reactions from the list of detected reactions and returns the final set of reactions to be used for template generation.\n", + "\n", "selected_reactions = reaction_detector.reaction_selection(reaction_instances)" ] }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ee4e5c22", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ReactionInstance(reaction_name='Diol and Di-Acid Halide Polycondensation(Polyesterification)', reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[O,S;X2;H1;!$([O,S]C=*):2]-[H:5]>>[CX3:1](=[O:3])-[O,S;X2;!$([O,S]C=*):2].[Cl,Br,I:4]-[H:5]', delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], 'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734.1', 'https://pubs.acs.org/doi/10.1021/ed073pA312']}, monomer_1=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_1=FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), monomer_2=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_2=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None)), ReactionInstance(reaction_name='Di-Amine and Di-Carboxylic Acid Halide Polycondensation (Polyamidation)', reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[N;H2,H1;!$(NC=*):2][H:5]>>[CX3:1](=[O:3])[NX3;!$(NC=*):2].[Cl,Br,I:4]([H:5])', delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], 'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734']}, monomer_1=MonomerRole(smiles='Nc1cccc(N)c1', name='mpd', functionalities=(FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None),)), functional_group_1=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), monomer_2=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_2=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))]\n" + ] + } + ], + "source": [ + "print(selected_reactions)" + ] + }, { "cell_type": "markdown", "id": "09b1cb36", @@ -235,23 +378,63 @@ "### Non-Reactant (Non-Monomer) Detection\n", "\n", "This cell identifies molecules that do **not participate in any detected reactions**.\n", - "\n", - "- `NonReactantsDetector()` initializes the detector.\n", - "- `non_monomer_detector()` to determine which molecules are non-reactive.\n", - "- `non_reactants_to_visualization()` grid to non reactive molecules\n", - "\n", - "If no non-reactant molecules are detected, this stage is **automatically skipped**, and the workflow continues without generating any visualization." + "\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "c811c031", "metadata": {}, "outputs": [], "source": [ + "# NonReactantsDetector() initializes the detector.\n", + "# non_monomer_detector() to determine which molecules are non-reactive.\n", + "\n", + "\n", "non_monomer_detector = NonReactantsDetector()\n", - "non_reactants_list = non_monomer_detector.non_monomer_detector(validated_inputs, selected_reactions)\n", + "non_reactants_list = non_monomer_detector.non_monomer_detector(validated_inputs, selected_reactions)\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e03f325", + "metadata": {}, + "source": [ + "### non_reactants_to_visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5040c430", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ID: 3, Name: ethanol, SMILES: CCO\n", + "ID: 4, Name: data_4, SMILES: CCN\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# `()` grid to non reactive molecules\n", + "\n", + "# If no non-reactant molecules are detected, this stage is **automatically skipped**, and the workflow continues without generating any visualization.\n", + "\n", "img_non_reactants = non_monomer_detector.non_reactants_to_visualization(non_reactants_list)\n", "img_non_reactants" ] @@ -263,38 +446,83 @@ "source": [ "### Update Inputs After Non-Reactant Filtering\n", "\n", - "This cell updates the validated inputs after identifying non-reactive molecules.\n", - "\n", - "- `non_reactant_selection()` removes or marks molecules that do not participate in any reactions.\n", - "- The resulting `updated_inputs` contains the filtered set of monomers that will be used in the next stages of the workflow.\n", - "\n", - "If no non-reactants were detected in the previous step, the inputs remain unchanged." + "This cell updates the validated inputs after identifying non-reactive molecules.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "00d75b1a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Selection Guide for Non-Reactant Monomers:\n", + "- N: Discard all non-reactant monomers from the simulation.\n", + "- A: Retain all non-reactant monomers in the simulation.\n", + "- S: Select specific non-reactant monomers to retain. You will be prompted \n", + "to enter the IDs of the monomers you wish to keep, separated by commas.\n", + "Example: If you want to keep monomers with IDs 1 and 3, you would enter: 1,3\n", + " \n", + "The following monomers do not participate in any detected reactions:\n", + "ID: 3, Name: ethanol, SMILES: CCO\n", + "ID: 4, Name: data_4, SMILES: CCN\n" + ] + } + ], "source": [ + "# non_reactant_selection() removes or marks molecules that do not participate in any reactions.\n", + "# The resulting `updated_inputs` contains the filtered set of monomers that will be used in the next stages of the workflow.\n", + "# If no non-reactants were detected in the previous step, the inputs remain unchanged.\n", + "\n", "updated_inputs = non_monomer_detector.non_reactant_selection(validated_inputs, non_reactants_list)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "d62efe2a", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'ReactionInstance' object has no attribute 'reactant_smiles_1'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m prepare_reactions = PrepareReactions(cache_dir)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m prepared_reactions = \u001b[43mprepare_reactions\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprepare_reactions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mselected_reactions\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/mnt/c/Users/Janitha/Documents/AutoREACTER/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py:401\u001b[39m, in \u001b[36mPrepareReactions.prepare_reactions\u001b[39m\u001b[34m(self, reactions)\u001b[39m\n\u001b[32m 396\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m reaction \u001b[38;5;129;01min\u001b[39;00m reactions:\n\u001b[32m 398\u001b[39m rxn = \u001b[38;5;28mself\u001b[39m._build_reaction(reaction.reaction_smarts)\n\u001b[32m 400\u001b[39m mol_r1, mol_r2 = \u001b[38;5;28mself\u001b[39m._build_reactants(\n\u001b[32m--> \u001b[39m\u001b[32m401\u001b[39m \u001b[43mreaction\u001b[49m\u001b[43m.\u001b[49m\u001b[43mreactant_smiles_1\u001b[49m,\n\u001b[32m 402\u001b[39m reaction.reactant_smiles_2\n\u001b[32m 403\u001b[39m )\n\u001b[32m 405\u001b[39m reaction_tuple = \u001b[38;5;28mself\u001b[39m._reaction_tuples(\n\u001b[32m 406\u001b[39m reaction.same_reactants,\n\u001b[32m 407\u001b[39m mol_r1,\n\u001b[32m 408\u001b[39m mol_r2\n\u001b[32m 409\u001b[39m )\n\u001b[32m 411\u001b[39m mols, result_dict = \u001b[38;5;28mself\u001b[39m._process_reactions(\n\u001b[32m 412\u001b[39m rxn,\n\u001b[32m 413\u001b[39m csv_cache,\n\u001b[32m 414\u001b[39m reaction_tuple,\n\u001b[32m 415\u001b[39m key=reaction.reaction_id\n\u001b[32m 416\u001b[39m )\n", + "\u001b[31mAttributeError\u001b[39m: 'ReactionInstance' object has no attribute 'reactant_smiles_1'" + ] + } + ], + "source": [ + "prepare_reactions = PrepareReactions(cache_dir)\n", + "prepared_reactions = prepare_reactions.prepare_reactions(selected_reactions,)" + ] }, { "cell_type": "code", "execution_count": null, "id": "6603c504", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'AutoREACTER.reaction_template_builder'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# execute_pipeline may live in the same module as ReactionTemplatePipeline; import if needed.\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mAutoREACTER\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mreaction_template_builder\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mrun_reaction_template_pipeline\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m execute_pipeline\n\u001b[32m 4\u001b[39m execute_pipeline(\n\u001b[32m 5\u001b[39m detected_reactions=detected_reactions,\n\u001b[32m 6\u001b[39m retain_smiles=non_monomers,\n\u001b[32m 7\u001b[39m cache=cache_dir,\n\u001b[32m 8\u001b[39m )\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'AutoREACTER.reaction_template_builder'" + ] + } + ], "source": [ "%%capture captured_output\n", "# execute_pipeline may live in the same module as ReactionTemplatePipeline; import if needed.\n", @@ -312,7 +540,15 @@ "execution_count": null, "id": "52d28045", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output written to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/output.txt\n" + ] + } + ], "source": [ "from pathlib import Path\n", "\n", From b7dd6e50b8948b8226d2b07a585b083431fd83e9 Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Thu, 12 Mar 2026 00:21:15 -0400 Subject: [PATCH 06/26] Fix utils imports, SMILES parsing and reactant names --- AutoREACTER/detectors/reactions_library.py | 6 +++--- .../reaction_processor/atom_mapping.py | 8 ++++---- .../reaction_processor/prepare_reactions.py | 16 ++++++++++++---- 3 files changed, 19 insertions(+), 11 deletions(-) diff --git a/AutoREACTER/detectors/reactions_library.py b/AutoREACTER/detectors/reactions_library.py index f0abc47..cd970c7 100644 --- a/AutoREACTER/detectors/reactions_library.py +++ b/AutoREACTER/detectors/reactions_library.py @@ -51,8 +51,8 @@ def __init__(self): }, "Hydroxy Acid Halides Hydroxy Acid Halides Polycondensation(Polyesterification)": { "same_reactants": False, - "reactant_1": "hydroxy_acid_halides_monomer", - "reactant_2": "hydroxy_acid_halides_monomer", + "reactant_1": "hydroxy_acid_halide", + "reactant_2": "hydroxy_acid_halide", "product": "polyester_chain", "delete_atom": True, "reaction": "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[Cl,Br,I:4]>>[OX2:1]-[CX3:2](=[O:5]).[Cl,Br,I:4]-[H:3]", @@ -62,7 +62,7 @@ def __init__(self): }, "Hydroxy Acid Halides Polycondensation(Polyesterification)": { "same_reactants": True, - "reactant_1": "hydroxy_acid_halides_monomer", + "reactant_1": "hydroxy_acid_halide", "product": "polyester_chain", "delete_atom": True, "reaction": "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[Cl,Br,I:4]>>[OX2:1]-[CX3:2](=[O:5]).[Cl,Br,I:4]-[H:3]", diff --git a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py index c13dad4..b3496bf 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py @@ -26,23 +26,23 @@ import itertools try: # Case 1: correct when reaction_template_pipeline is a proper package - from .util import compare_products + from .utils import compare_products except (ImportError, ModuleNotFoundError): try: # Case 2: fully-qualified import under your installed namespace - from reaction_lammps_mupt.reaction_template_builder.reaction_template_pipeline.util import ( + from reaction_lammps_mupt.reaction_template_builder.reaction_template_pipeline.utils import ( compare_products, ) except (ImportError, ModuleNotFoundError): try: # Case 3: if reaction_template_pipeline is installed as a top-level package - from reaction_template_pipeline.util import compare_products + from reaction_template_pipeline.utils import compare_products except (ImportError, ModuleNotFoundError): # Case 4: running as a loose script from the same directory - from util import compare_products + from utils import compare_products def is_number_in_set(set_of_tuples, reactant): diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 04d3a2d..d414910 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -20,6 +20,10 @@ class MappingError(Exception): """Custom exception for errors in atom mapping.""" pass +class SMARTSParsingError(Exception): + """Custom exception for errors in parsing reaction SMARTS.""" + pass + @dataclass(slots=True) class ReactionMetadata: reaction_id: int @@ -103,7 +107,6 @@ def _is_number_in_set(self, set_of_tuples, reactant): x = atom.GetIdx() for t in set_of_tuples: if x in t: - print(f"Found matching atom index {x} in tuple {t}") return t raise ValueError("No matching atom found in the provided set of tuples") @@ -122,8 +125,13 @@ def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): >>> mol1, mol2 = self._build_reactants("CCO", "CC=O") """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) + mol = Chem.MolFromSmiles(reactant_smiles_1) + if mol is None: + raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_1}") mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) + if mol_reactant_2 is None: + raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_2}") mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens return mol_reactant_1, mol_reactant_2 @@ -135,7 +143,7 @@ def _prepare_paths(self, cache): def _build_reaction(self, rxn_smarts): rxn = AllChem.ReactionFromSmarts(rxn_smarts) if rxn is None: - raise ValueError(f"Invalid reaction SMARTS: {rxn_smarts}") + raise SMARTSParsingError(f"Invalid reaction SMARTS: {rxn_smarts}") return rxn def _is_consecutive(self, num_list): @@ -398,8 +406,8 @@ def prepare_reactions(self, reactions: List[ReactionInstance],) -> List[Reaction rxn = self._build_reaction(reaction.reaction_smarts) mol_r1, mol_r2 = self._build_reactants( - reaction.reactant_smiles_1, - reaction.reactant_smiles_2 + reaction.monomer_1.smiles, + reaction.monomer_2.smiles ) reaction_tuple = self._reaction_tuples( From c4a192d6f1dfc54373fa8d7cdcb2c7c5ea6cb03d Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Thu, 12 Mar 2026 02:42:49 -0400 Subject: [PATCH 07/26] Refactor reaction preparation and clean debug logs Major refactor and cleanup across the reaction preparation pipeline: --- .../reaction_processor/atom_mapping.py | 1 - .../reaction_processor/prepare_reactions.py | 214 +++++++++++------- .../reaction_processor/utils.py | 3 +- .../reaction_processor/walker.py | 3 +- 4 files changed, 131 insertions(+), 90 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py index b3496bf..ad0ab48 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py @@ -72,7 +72,6 @@ def is_number_in_set(set_of_tuples, reactant): x = atom.GetIdx() for t in set_of_tuples: if x in t: - print(f"Found matching atom index {x} in tuple {t}") return t raise ValueError("No matching atom found in the provided set of tuples.") diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index d414910..cf9926e 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -2,16 +2,12 @@ from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Optional -import pandas as pd from rdkit import Chem -from rdkit.Chem import AllChem, Draw, rdChemReactions, rdmolops -from rdkit.Chem.rdchem import Mol +from rdkit.Chem import AllChem, Draw, rdmolops from PIL.Image import Image -import itertools import pandas as pd -from AutoREACTER.detectors.reaction_detector import ReactionInstance, ReactionTemplate -from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupInfo, MonomerRole +from AutoREACTER.detectors.reaction_detector import ReactionInstance from AutoREACTER.reaction_preparation.reaction_processor.atom_mapping import smart_mapping from AutoREACTER.reaction_preparation.reaction_processor.utils import compare_products from AutoREACTER.reaction_preparation.reaction_processor.walker import reaction_atom_walker @@ -33,6 +29,10 @@ class ReactionMetadata: template_reactant_to_product_mapping: Dict[int, int] edge_atoms: List[int] + first_shell: Optional[List[int]] = None + initiators: Optional[List[int]] = None + byproduct_indices: Optional[List[int]] = None + reaction_smarts: Optional[str] = None reactant_smarts: Optional[str] = None product_smiles: Optional[str] = None @@ -45,7 +45,8 @@ class ReactionMetadata: class PrepareReactions: def __init__(self, cache: Path): - self.cache = self._prepare_paths(cache) + self.cache = Path(cache) + self.csv_cache = self._prepare_paths(self.cache) def _add_column_safe(self, df, list_data, column_name): """ @@ -103,7 +104,7 @@ def _is_number_in_set(self, set_of_tuples, reactant): """ for atom in reactant.GetAtoms(): # Check for specific atom map numbers (101 or 102) - if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: + if atom.GetAtomMapNum() >= 100: x = atom.GetIdx() for t in set_of_tuples: if x in t: @@ -125,14 +126,15 @@ def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): >>> mol1, mol2 = self._build_reactants("CCO", "CC=O") """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) - mol = Chem.MolFromSmiles(reactant_smiles_1) - if mol is None: + if mol_reactant_1 is None: raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_1}") - mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens + mol_reactant_1 = Chem.AddHs(mol_reactant_1) + mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) if mol_reactant_2 is None: raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_2}") - mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens + mol_reactant_2 = Chem.AddHs(mol_reactant_2) + return mol_reactant_1, mol_reactant_2 def _prepare_paths(self, cache): @@ -170,7 +172,7 @@ def _is_consecutive(self, num_list): def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, - molecule_and_csv_path_dict=None, delete_atoms=False): + molecule_and_csv_path_dict=None, delete_atom=False): """ Process chemical reactions, map atoms between reactants and products, and save data. @@ -187,11 +189,10 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, reaction_tuple (list): List of reactant pairs to process key (str or int, optional): Identifier for the reaction set molecule_and_csv_path_dict (dict, optional): Dictionary to store results - delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion + delete_atom (bool, optional): Whether to identify byproduct atoms for deletion Returns: - mols, molecule_and_csv_path_dict: - - mols: List of reactant and product molecules for visualization + molecule_and_csv_path_dict: - molecule_and_csv_path_dict: Dictionary containing all processed data Raises: @@ -207,14 +208,13 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, molecule_and_csv_path_dict = {} total_products = 0 - mols = [] # Process each reactant pair in the reaction tuple for j, pair in enumerate(reaction_tuple): r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) products = rxn.RunReactants((r1, r2)) if not products: - continue # Skip if no products are generated + continue # Get substructure matches for each reactant against reaction templates matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) @@ -222,11 +222,14 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # Process each product set generated by the reaction for product_set in products: + if "df" in locals(): + del df # Initialize data structures df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - first_shell = [] # Atoms in first coordination shell - initiator_idxs = [] # Initiator atom indices + first_shell = [] + initiator_idxs = [] + mapping_dict = {} # Apply atom mapping from reaction properties num_total_atoms = 0 @@ -246,13 +249,17 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # Combine reactants and products for easier processing reactant_combined = Chem.CombineMols(r1, r2) product_combined = Chem.CombineMols(*product_set) + if not compare_products(molecule_and_csv_path_dict, product_combined): + continue # Create mapping between reactant and product atoms based on map numbers for r_atom in reactant_combined.GetAtoms(): for p_atom in product_combined.GetAtoms(): if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): - new_row = pd.DataFrame([{"reactant_idx": r_atom.GetIdx(), - "product_idx": p_atom.GetIdx()}]) + new_row = pd.DataFrame([{ + "reactant_idx": r_atom.GetIdx(), + "product_idx": p_atom.GetIdx() + }]) df = pd.concat([df, new_row], ignore_index=True) break @@ -285,7 +292,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, ) # Validation 4: Mapping indices must be consecutive - if (self._is_consecutive(df["reactant_idx"].tolist()) is False or + if (self._is_consecutive(df["reactant_idx"].tolist()) is False or self._is_consecutive(df["product_idx"].tolist()) is False): raise MappingError( "Mapping indices are not consecutive: " @@ -303,7 +310,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, smarts_template=rxn.GetReactants()[0], match_tuple=sub_set1 if sub_set1 else (), ) - + try: sub_set2 = self._is_number_in_set(matches_2, r2) except ValueError: @@ -316,22 +323,19 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # Recombine reactants after mapping reactant_combined = Chem.CombineMols(r1, r2) - + # Identify first shell atoms and initiators for atom in reactant_combined.GetAtoms(): - map_num = atom.GetAtomMapNum() - idx = atom.GetIdx() - if 0 < map_num <= 99: - first_shell.append(idx) + if atom.GetAtomMapNum() <= 99: + first_shell.append(atom.GetIdx()) + if atom.GetAtomMapNum() in [1, 2]: + initiator_idxs.append(atom.GetIdx()) - if 0 < map_num <= 2: - initiator_idxs.append(idx) - # Identify byproduct atoms if deletion is requested byproduct_product_idxs = [] byproduct_reactant_idxs = [] - if delete_atoms: + if delete_atom: frags = rdmolops.GetMolFrags(product_combined, asMols=True) smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) @@ -353,115 +357,120 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, # if you want the column to store REACTANT indices now: byproduct_indexs = byproduct_reactant_idxs + # Add any additional mappings from mapping_dict + for r_idx, p_idx in mapping_dict.items(): + new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) + df = pd.concat([df, new_row], ignore_index=True) + # Create comprehensive DataFrame with all analysis columns first_shell_column = pd.Series(first_shell, name="first_shell") initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") - + # Validation: Must have exactly 2 initiators if len(initiator_idxs) != 2: raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") - + by_product_indexs_column = pd.Series(byproduct_indexs, name="byproduct_indices") - + # Combine all data into final DataFrame - df_combined = pd.concat([df, first_shell_column, initiator_idxs_column, - by_product_indexs_column], axis=1).astype(pd.Int64Dtype()) - - # Check for duplicate products - if not compare_products(molecule_and_csv_path_dict, product_combined): - continue + df_combined = pd.concat( + [df, first_shell_column, initiator_idxs_column, by_product_indexs_column], + axis=1 + ).astype(pd.Int64Dtype()) # Update counters and store results total_products += 1 - mols.append(reactant_combined) - mols.append(product_combined) # Organize results in the output dictionary - for i in itertools.count(1): - if i not in molecule_and_csv_path_dict: # Check if i IS a key - sub_dict = molecule_and_csv_path_dict[i] = {} # Initialize if not found - dict_key = i - break + local_id = len(molecule_and_csv_path_dict) + 1 + dict_key = f"{key}_{local_id}" + + sub_dict = molecule_and_csv_path_dict.setdefault(local_id, {}) # Save to CSV file - df_combined.to_csv(csv_cache / f"reaction_{dict_key}.csv", index=False) + csv_file = csv_cache / f"reaction_{dict_key}.csv" + df_combined.to_csv(csv_file, index=False) print(f"Saved reaction {dict_key} to CSV") sub_dict["reactant"] = reactant_combined sub_dict["product"] = product_combined - sub_dict["csv_path"] = csv_cache / f"reaction_{dict_key}.csv" - sub_dict["delete_atoms"] = delete_atoms + sub_dict["csv_path"] = csv_file + sub_dict["delete_atom"] = delete_atom sub_dict["reaction_dataframe"] = df_combined - - return mols, molecule_and_csv_path_dict + return molecule_and_csv_path_dict - def prepare_reactions(self, reactions: List[ReactionInstance],) -> List[ReactionMetadata]: + def _extract_reactant_info(self, reaction: ReactionInstance) -> tuple[str, str, bool]: + if reaction.monomer_1 is None: + raise ValueError(f"Reaction {reaction.reaction_name} has no monomer_1") - csv_cache = self._prepare_paths(self.cache) - metadata_list = [] + smiles_1 = reaction.monomer_1.smiles - for reaction in reactions: + if reaction.monomer_2 is None: + return smiles_1, smiles_1, True + + smiles_2 = reaction.monomer_2.smiles + return smiles_1, smiles_2, False + + def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionMetadata]: + csv_cache = self.csv_cache + metadata_list = [] + for rxn_idx, reaction in enumerate(reactions, start=1): rxn = self._build_reaction(reaction.reaction_smarts) + reactant_smiles_1, reactant_smiles_2, same_reactants = \ + self._extract_reactant_info(reaction) + mol_r1, mol_r2 = self._build_reactants( - reaction.monomer_1.smiles, - reaction.monomer_2.smiles + reactant_smiles_1, + reactant_smiles_2 ) reaction_tuple = self._reaction_tuples( - reaction.same_reactants, + same_reactants, mol_r1, mol_r2 ) - mols, result_dict = self._process_reactions( - rxn, - csv_cache, - reaction_tuple, - key=reaction.reaction_id - ) - for rid, data in result_dict.items(): + result_dict = self._process_reactions( + rxn, + csv_cache, + reaction_tuple, + key=rxn_idx, + delete_atom=reaction.delete_atom + ) - df = data["reaction_dataframe"] + for rid, data in result_dict.items(): + df = data["reaction_dataframe"] reactant_mol = data["reactant"] - # FULL atom mapping + mapping_df = df.dropna(subset=["reactant_idx", "product_idx"]) + fully_mapped_dict = dict(zip( - df["reactant_idx"].dropna(), - df["product_idx"].dropna() + mapping_df["reactant_idx"].astype(int), + mapping_df["product_idx"].astype(int) )) - # first shell atoms first_shell = df["first_shell"].dropna().astype(int).tolist() - # WALKER template_mapped_dict, edge_atoms = reaction_atom_walker( reactant_mol, first_shell, fully_mapped_dict ) - # update dataframe df = self._add_dict_as_new_columns( df, template_mapped_dict, titles=["template_reactant_idx", "template_product_idx"] ) - df = self._add_column_safe( - df, - edge_atoms, - "edge_atoms" - ) - - # store updated dataframe + df = self._add_column_safe(df, edge_atoms, "edge_atoms") data["reaction_dataframe"] = df.copy() - # build metadata metadata = ReactionMetadata( reaction_id=rid, reactant_combined_mol=data["reactant"], @@ -469,9 +478,12 @@ def prepare_reactions(self, reactions: List[ReactionInstance],) -> List[Reaction reactant_to_product_mapping=fully_mapped_dict, template_reactant_to_product_mapping=template_mapped_dict, edge_atoms=edge_atoms, + initiators=df["initiators"].dropna().astype(int).tolist(), + byproduct_indices=df["byproduct_indices"].dropna().astype(int).tolist(), reaction_smarts=reaction.reaction_smarts, csv_path=data["csv_path"], - reaction_dataframe=df + reaction_dataframe=df, + delete_atom=data.get("delete_atom", True), ) metadata_list.append(metadata) @@ -480,11 +492,11 @@ def prepare_reactions(self, reactions: List[ReactionInstance],) -> List[Reaction - def reaction_templates_highligted_image_grid( + def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], highlight_type: str = "template" - ) -> Image: + ) -> Image: """ Create a grid image highlighting atoms in reactant molecules. @@ -492,37 +504,65 @@ def reaction_templates_highligted_image_grid( "template" "edge" "initiators" + "delete" """ mols = [] highlight_lists = [] + highlight_colors = [] for metadata in metadata_list: reactant = metadata.reactant_combined_mol product = metadata.product_combined_mol + for atom in reactant.GetAtoms(): + atom.SetAtomMapNum(0) + for atom in product.GetAtoms(): + atom.SetAtomMapNum(0) df = metadata.reaction_dataframe + atoms = [] + color_map = {} + if highlight_type == "template": atoms = list(metadata.template_reactant_to_product_mapping.keys()) + for a in atoms: + color_map[a] = (0.2, 0.6, 1.0) # blue elif highlight_type == "edge": atoms = metadata.edge_atoms + for a in atoms: + color_map[a] = (1.0, 0.4, 0.0) # orange elif highlight_type == "initiators": atoms = df["initiators"].dropna().astype(int).tolist() + for a in atoms: + color_map[a] = (0.0, 0.8, 0.2) # green + + elif highlight_type == "delete": + if not metadata.delete_atom: + atoms = [] + else: + atoms = metadata.byproduct_indices + for a in atoms: + color_map[a] = (1.0, 0.0, 0.0) # red else: atoms = [] mols.extend([reactant, product]) + highlight_lists.append(atoms) - highlight_lists.append([]) # don't highlight product + highlight_lists.append([]) + + highlight_colors.append(color_map) + highlight_colors.append({}) img = Draw.MolsToGridImage( mols, molsPerRow=2, highlightAtomLists=highlight_lists, + highlightAtomColors=highlight_colors, subImgSize=(400, 400), useSVG=False ) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/utils.py b/AutoREACTER/reaction_preparation/reaction_processor/utils.py index 3ad4257..9922b22 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/utils.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/utils.py @@ -39,7 +39,8 @@ def compare_products(reactions_dict, _prod2): # Perform string comparison to detect duplicates if smi1 == smi2: - print("DUPLICATE PRODUCT FOUND") + # Debug print to indicate a duplicate was found (can be commented out in production) + # print("DUPLICATE PRODUCT FOUND") return False # No duplicates found after checking all entries diff --git a/AutoREACTER/reaction_preparation/reaction_processor/walker.py b/AutoREACTER/reaction_preparation/reaction_processor/walker.py index 36d939c..b6d7c97 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/walker.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/walker.py @@ -105,7 +105,8 @@ def product_atom_walker(template_indexes, MAP_dict): """ template_mapped_dict = {} for i in template_indexes: - print(f"Mapping reactant atom index {i}") + # debug print to trace which reactant atom index is being processed + # print(f"Mapping reactant atom index {i}") # Check if the reactant atom index exists in our mapping dictionary atom = MAP_dict.get(i) if atom is not None: From 933c70036429e2f1721b46f116f2af16d86f516d Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Thu, 12 Mar 2026 02:47:53 -0400 Subject: [PATCH 08/26] Refactor prepare_reactions: typing & validations --- .../reaction_processor/prepare_reactions.py | 399 +++++++++++------- 1 file changed, 248 insertions(+), 151 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index cf9926e..f6ab72d 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -1,3 +1,11 @@ +""" +Module for preparing chemical reactions for analysis, including atom mapping between reactants and products, +reaction metadata extraction, and visualization utilities using RDKit. + +This module processes reaction SMARTS, applies atom mappings, identifies key reaction features (e.g., first shell, +initiators, byproducts), and generates metadata and visualizations for downstream tasks like reaction prediction +or mechanistic analysis. +""" from dataclasses import dataclass from pathlib import Path @@ -12,16 +20,40 @@ from AutoREACTER.reaction_preparation.reaction_processor.utils import compare_products from AutoREACTER.reaction_preparation.reaction_processor.walker import reaction_atom_walker + class MappingError(Exception): - """Custom exception for errors in atom mapping.""" - pass + """Custom exception raised when atom mapping between reactants and products fails or is inconsistent.""" + class SMARTSParsingError(Exception): - """Custom exception for errors in parsing reaction SMARTS.""" - pass + """Custom exception raised when parsing SMILES or reaction SMARTS fails.""" + @dataclass(slots=True) class ReactionMetadata: + """ + Dataclass holding comprehensive metadata for a processed reaction instance. + + Attributes: + reaction_id: Unique identifier for the reaction instance. + reactant_combined_mol: RDKit Mol object combining all reactant molecules. + product_combined_mol: RDKit Mol object combining all product molecules. + reactant_to_product_mapping: Dictionary mapping reactant atom indices to product atom indices. + template_reactant_to_product_mapping: Dictionary mapping template-matched reactant atoms to products. + edge_atoms: List of atom indices on the 'edge' of the reaction (e.g., involved in changes). + first_shell: List of atoms in the first coordination shell around reaction centers (optional). + initiators: List of initiator atom indices (typically 2 per reaction). + byproduct_indices: List of byproduct atom indices (optional). + reaction_smarts: Original reaction SMARTS string (optional). + reactant_smarts: Reactant SMARTS string (optional). + product_smiles: Product SMILES string (optional). + csv_path: Path to CSV file storing reaction mapping data (optional). + mol_3d_path: Path to 3D molecule file (optional). + reaction_dataframe: Pandas DataFrame with detailed atom mapping and features. + delete_atom: Flag indicating if byproduct atoms should be deleted. + delete_atom_idx: Specific index of atom to delete (optional). + activity_stats: Flag for including activity statistics (optional). + """ reaction_id: int reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol @@ -42,88 +74,116 @@ class ReactionMetadata: delete_atom: bool = True delete_atom_idx: Optional[int] = None activity_stats: bool = True - + + class PrepareReactions: + """ + Class for preparing reaction instances by processing SMILES/SMARTS, performing atom mapping, + extracting reaction features, and generating metadata and visualizations. + """ + def __init__(self, cache: Path): + """ + Initialize the reaction preparer with a cache directory for storing CSV outputs. + + Args: + cache: Path to the base cache directory for storing processed reaction data. + """ self.cache = Path(cache) self.csv_cache = self._prepare_paths(self.cache) - def _add_column_safe(self, df, list_data, column_name): + def _add_column_safe(self, df: pd.DataFrame, list_data: List, column_name: str) -> pd.DataFrame: """ - Safely adds a list as a new column to a DataFrame, handling potential - length mismatches by using Series alignment. + Safely add a new integer column to a DataFrame, handling NaN values with nullable Int64 dtype. Args: - df (pd.DataFrame): Target DataFrame. - list_data (list): Data to be added to the column. - column_name (str): Name of the new column. + df: Input DataFrame. + list_data: List of data to add as a new column. + column_name: Name of the new column. Returns: - pd.DataFrame: Modified DataFrame with the new column. + DataFrame with the new column added. """ - # Creating a Series from the list ensures it starts from the top (index 0) - # and fills missing rows with NaN if the list is shorter than the DataFrame df[column_name] = pd.Series(list_data).astype("Int64") return df - - def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): - # Convert dict keys and values to Series to ensure alignment with the DataFrame - # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers + + def _add_dict_as_new_columns( + self, + df_existing: pd.DataFrame, + data_dict: Dict[int, int], + titles: List[str] = ["template_reactant_idx", "template_product_idx"] + ) -> pd.DataFrame: + """ + Add two new columns from a dictionary keys and values, using nullable Int64 dtype. + + Args: + df_existing: Input DataFrame. + data_dict: Dictionary where keys go to titles[0] and values to titles[1]. + titles: List of two column names for keys and values. + + Returns: + DataFrame with the two new columns added. + """ df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") - return df_existing - - def _reaction_tuples(self, same_reactants, mol_reactant_1, mol_reactant_2): - + + def _reaction_tuples( + self, + same_reactants: bool, + mol_reactant_1: Chem.Mol, + mol_reactant_2: Chem.Mol + ) -> List[List[Chem.Mol]]: + """ + Generate reactant pairs for reaction processing, handling homo-polymerization (same reactants). + + Args: + same_reactants: If True, use the same molecule twice (homo-polymerization). + mol_reactant_1: First reactant molecule. + mol_reactant_2: Second reactant molecule. + + Returns: + List of reactant pairs [[r1, r2], ...]. + """ if same_reactants: return [[mol_reactant_1, mol_reactant_1]] - return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] - - def _is_number_in_set(self, set_of_tuples, reactant): + + def _is_number_in_set(self, set_of_tuples: List[tuple], reactant: Chem.Mol) -> tuple: """ - Find a tuple in the set that contains atom indices matching specific atom map numbers. - - This function searches for atoms in the reactant molecule that have atom map numbers - 101 or 102, then checks if those atom indices exist in any tuple within the provided set. - + Find the substructure match tuple containing an atom with map number >= 100. + Args: - set_of_tuples (set of tuples): Set of atom index tuples to search through - reactant (Chem.Mol): RDKit molecule object to search for mapped atoms - + set_of_tuples: List of match tuples from GetSubstructMatches. + reactant: RDKit Mol of the reactant. + Returns: - tuple: The first tuple found containing a matching atom index - + The matching tuple. + Raises: - ValueError: If no matching atom is found in the provided set of tuples - - Example: - >>> matches = {(0, 1, 2), (3, 4, 5)} - >>> result = self._is_number_in_set(matches, reactant_mol) + ValueError: If no matching atom/tuple found. """ for atom in reactant.GetAtoms(): - # Check for specific atom map numbers (101 or 102) if atom.GetAtomMapNum() >= 100: x = atom.GetIdx() for t in set_of_tuples: if x in t: return t raise ValueError("No matching atom found in the provided set of tuples") - - def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): + + def _build_reactants(self, reactant_smiles_1: str, reactant_smiles_2: str) -> tuple[Chem.Mol, Chem.Mol]: """ - Create RDKit molecule objects from SMILES strings with explicit hydrogens. - + Parse SMILES strings into RDKit Mol objects, add hydrogens, and validate. + Args: - reactant_smiles_1 (str): SMILES string for first reactant - reactant_smiles_2 (str): SMILES string for second reactant - + reactant_smiles_1: SMILES for first reactant. + reactant_smiles_2: SMILES for second reactant. + Returns: - tuple: (mol_reactant_1, mol_reactant_2) - Both molecules with explicit hydrogens - - Example: - >>> mol1, mol2 = self._build_reactants("CCO", "CC=O") + Tuple of (mol_reactant_1, mol_reactant_2). + + Raises: + SMARTSParsingError: If SMILES parsing fails. """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) if mol_reactant_1 is None: @@ -137,76 +197,86 @@ def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): return mol_reactant_1, mol_reactant_2 - def _prepare_paths(self, cache): + def _prepare_paths(self, cache: Path) -> Path: + """ + Create the CSV cache directory for storing atom mapping data. + + Args: + cache: Base cache Path. + + Returns: + Path to the CSV cache subdirectory. + """ csv_cache = Path(cache) / "atom_mapping_btw_reactants_products_in_csv" csv_cache.mkdir(parents=True, exist_ok=True) return csv_cache - - def _build_reaction(self, rxn_smarts): + + def _build_reaction(self, rxn_smarts: str) -> AllChem.ChemicalReaction: + """ + Parse reaction SMARTS into an RDKit ChemicalReaction object. + + Args: + rxn_smarts: Reaction SMARTS string. + + Returns: + RDKit ChemicalReaction object. + + Raises: + SMARTSParsingError: If parsing fails. + """ rxn = AllChem.ReactionFromSmarts(rxn_smarts) if rxn is None: raise SMARTSParsingError(f"Invalid reaction SMARTS: {rxn_smarts}") return rxn - def _is_consecutive(self, num_list): + def _is_consecutive(self, num_list: List[int]) -> bool: """ - Check if a list of numbers forms a consecutive sequence without gaps. - + Check if a list of numbers is consecutive without duplicates or gaps. + Args: - num_list (list): List of integers to check - + num_list: List of integers. + Returns: - bool: True if the numbers are consecutive, False otherwise - - Examples: - >>> is_consecutive([1, 2, 3, 4]) # Returns True - >>> is_consecutive([1, 3, 4]) # Returns False - >>> is_consecutive([]) # Returns False + True if consecutive and unique. """ if not num_list: return False - - # Check for consecutive sequence: unique numbers and max-min+1 equals length - return (len(set(num_list)) == len(num_list) and + return (len(set(num_list)) == len(num_list) and max(num_list) - min(num_list) + 1 == len(num_list)) - - def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, - molecule_and_csv_path_dict=None, delete_atom=False): + def _process_reactions( + self, + rxn: AllChem.ChemicalReaction, + csv_cache: Path, + reaction_tuple: List[List[Chem.Mol]], + key: Optional[str] = None, + molecule_and_csv_path_dict: Optional[Dict] = None, + delete_atom: bool = False + ) -> Dict: """ Process chemical reactions, map atoms between reactants and products, and save data. - - This is the main processing function that: - 1. Runs reactions on reactant pairs - 2. Maps atoms between reactants and products - 3. Validates mapping consistency - 4. Saves mapping data to CSV files - 5. Identifies reaction features (first shell, initiators, byproducts) - + + This is the core processing function that: + 1. Runs reactions on reactant pairs using RDKit.RunReactants. + 2. Applies atom mapping from reaction properties and validates consistency. + 3. Identifies reaction centers, first shell, initiators, and byproducts. + 4. Saves detailed mapping DataFrames to CSV files. + 5. Stores results in a dictionary keyed by local reaction IDs. + Args: - rxn (Chem.rdChemReactions.ChemicalReaction): RDKit reaction object - csv_cache (Path): Directory path for CSV output files - reaction_tuple (list): List of reactant pairs to process - key (str or int, optional): Identifier for the reaction set - molecule_and_csv_path_dict (dict, optional): Dictionary to store results - delete_atom (bool, optional): Whether to identify byproduct atoms for deletion - + rxn: RDKit ChemicalReaction object. + csv_cache: Directory to save CSV files. + reaction_tuple: List of reactant pairs to process. + key: Identifier for the reaction set (e.g., reaction index). + molecule_and_csv_path_dict: Dictionary to store results (updated in-place). + delete_atom: If True, identify and mark byproduct atoms for deletion. + Returns: - molecule_and_csv_path_dict: - - molecule_and_csv_path_dict: Dictionary containing all processed data - - Raises: - ValueError: If mapping validation fails at any step - - Note: - This function performs extensive validation including: - - Atom count consistency between reactants and products - - Consecutive indexing requirements - - Initiator count validation (must be exactly 2) + Dictionary of processed reaction data, including mols, DataFrames, and paths. """ if molecule_and_csv_path_dict is None: molecule_and_csv_path_dict = {} - + total_products = 0 # Process each reactant pair in the reaction tuple @@ -215,7 +285,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, products = rxn.RunReactants((r1, r2)) if not products: continue - + # Get substructure matches for each reactant against reaction templates matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) @@ -225,13 +295,13 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, if "df" in locals(): del df - # Initialize data structures + # Initialize data structures for mapping df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) first_shell = [] initiator_idxs = [] mapping_dict = {} - # Apply atom mapping from reaction properties + # Apply atom mapping from reaction properties (react_idx and react_atom_idx props) num_total_atoms = 0 for i, product in enumerate(product_set): if i > 0: @@ -246,13 +316,13 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, r_atom.SetAtomMapNum(map_num) atom.SetAtomMapNum(map_num) - # Combine reactants and products for easier processing + # Combine reactants and products for unified processing reactant_combined = Chem.CombineMols(r1, r2) product_combined = Chem.CombineMols(*product_set) if not compare_products(molecule_and_csv_path_dict, product_combined): continue - # Create mapping between reactant and product atoms based on map numbers + # Build mapping DataFrame based on shared atom map numbers for r_atom in reactant_combined.GetAtoms(): for p_atom in product_combined.GetAtoms(): if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): @@ -276,7 +346,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, f"reactant_idx mapped={reactant_mapped}, product_idx mapped={product_mapped}" ) - # Validation 2: All reactant atoms must be mapped + # Validation 2: All reactant atoms must be mapped (debug CSV if fails) if reactant_mapped != num_reactant_atoms: df.to_csv(csv_cache / f"debug_mapping_{key}_{total_products}.csv", index=False) raise MappingError( @@ -291,16 +361,16 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, f"product atoms={num_product_atoms}, mapped={product_mapped}" ) - # Validation 4: Mapping indices must be consecutive - if (self._is_consecutive(df["reactant_idx"].tolist()) is False or - self._is_consecutive(df["product_idx"].tolist()) is False): + # Validation 4: Mapping indices must be consecutive (no gaps/duplicates) + if (not self._is_consecutive(df["reactant_idx"].tolist()) or + not self._is_consecutive(df["product_idx"].tolist())): raise MappingError( "Mapping indices are not consecutive: " f"reactant indices={df['reactant_idx'].tolist()}, " f"product indices={df['product_idx'].tolist()}" ) - # Apply smart mapping to both reactants + # Apply smart atom mapping to reactants using reaction templates try: sub_set1 = self._is_number_in_set(matches_1, r1) except ValueError: @@ -321,17 +391,17 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, match_tuple=sub_set2 if sub_set2 else (), ) - # Recombine reactants after mapping + # Recombine reactants after smart mapping reactant_combined = Chem.CombineMols(r1, r2) - # Identify first shell atoms and initiators + # Identify first shell atoms (map num <=99) and initiators (map num 1 or 2) for atom in reactant_combined.GetAtoms(): if atom.GetAtomMapNum() <= 99: first_shell.append(atom.GetIdx()) if atom.GetAtomMapNum() in [1, 2]: initiator_idxs.append(atom.GetIdx()) - # Identify byproduct atoms if deletion is requested + # Identify byproduct atoms if deletion is enabled byproduct_product_idxs = [] byproduct_reactant_idxs = [] @@ -339,7 +409,7 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, frags = rdmolops.GetMolFrags(product_combined, asMols=True) smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) - # 1) get byproduct atom indices in PRODUCT space + # Map byproduct atoms from smallest fragment back to product_combined indices for atom in smallest_mol.GetAtoms(): byproduct_map_number = atom.GetAtomMapNum() for p_atom in product_combined.GetAtoms(): @@ -347,47 +417,44 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, byproduct_product_idxs.append(p_atom.GetIdx()) break - # 2) convert PRODUCT indices -> REACTANT indices using df mapping + # Convert product byproduct indices to reactant indices using df byproduct_reactant_idxs = ( df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] .astype(int) .tolist() ) - # if you want the column to store REACTANT indices now: - byproduct_indexs = byproduct_reactant_idxs + byproduct_indexs = byproduct_reactant_idxs # Store reactant indices - # Add any additional mappings from mapping_dict + # Append any additional manual mappings for r_idx, p_idx in mapping_dict.items(): new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) df = pd.concat([df, new_row], ignore_index=True) - # Create comprehensive DataFrame with all analysis columns + # Create columns for first_shell, initiators, and byproducts first_shell_column = pd.Series(first_shell, name="first_shell") initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") - # Validation: Must have exactly 2 initiators + # Validation: Exactly 2 initiators expected if len(initiator_idxs) != 2: raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") by_product_indexs_column = pd.Series(byproduct_indexs, name="byproduct_indices") - # Combine all data into final DataFrame + # Combine into final DataFrame with nullable integer dtype df_combined = pd.concat( [df, first_shell_column, initiator_idxs_column, by_product_indexs_column], axis=1 ).astype(pd.Int64Dtype()) - # Update counters and store results + # Update counters and store in output dict total_products += 1 - - # Organize results in the output dictionary local_id = len(molecule_and_csv_path_dict) + 1 dict_key = f"{key}_{local_id}" sub_dict = molecule_and_csv_path_dict.setdefault(local_id, {}) - # Save to CSV file + # Save DataFrame to CSV csv_file = csv_cache / f"reaction_{dict_key}.csv" df_combined.to_csv(csv_file, index=False) print(f"Saved reaction {dict_key} to CSV") @@ -399,8 +466,20 @@ def _process_reactions(self, rxn, csv_cache, reaction_tuple, key=None, sub_dict["reaction_dataframe"] = df_combined return molecule_and_csv_path_dict - + def _extract_reactant_info(self, reaction: ReactionInstance) -> tuple[str, str, bool]: + """ + Extract SMILES for reactants from a ReactionInstance, handling homo- vs. co-polymerization. + + Args: + reaction: ReactionInstance with monomer_1 and optional monomer_2. + + Returns: + Tuple of (smiles_1, smiles_2, same_reactants_flag). + + Raises: + ValueError: If monomer_1 is missing. + """ if reaction.monomer_1 is None: raise ValueError(f"Reaction {reaction.reaction_name} has no monomer_1") @@ -411,8 +490,24 @@ def _extract_reactant_info(self, reaction: ReactionInstance) -> tuple[str, str, smiles_2 = reaction.monomer_2.smiles return smiles_1, smiles_2, False - + def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionMetadata]: + """ + Main public method to process a list of ReactionInstances into ReactionMetadata. + + For each reaction: + 1. Builds reaction object and reactant mols. + 2. Processes pairs via _process_reactions. + 3. Extracts mappings, edge atoms via reaction_atom_walker. + 4. Builds and augments DataFrames. + 5. Constructs ReactionMetadata objects. + + Args: + reactions: List of ReactionInstance objects. + + Returns: + List of ReactionMetadata objects. + """ csv_cache = self.csv_cache metadata_list = [] @@ -433,22 +528,20 @@ def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionM mol_r2 ) - result_dict = self._process_reactions( - rxn, - csv_cache, - reaction_tuple, - key=rxn_idx, - delete_atom=reaction.delete_atom - ) - + rxn, + csv_cache, + reaction_tuple, + key=rxn_idx, + delete_atom=reaction.delete_atom + ) for rid, data in result_dict.items(): df = data["reaction_dataframe"] reactant_mol = data["reactant"] + # Extract core reactant-to-product mapping (drop NaNs) mapping_df = df.dropna(subset=["reactant_idx", "product_idx"]) - fully_mapped_dict = dict(zip( mapping_df["reactant_idx"].astype(int), mapping_df["product_idx"].astype(int) @@ -456,12 +549,14 @@ def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionM first_shell = df["first_shell"].dropna().astype(int).tolist() + # Walk the reaction graph to get template mappings and edge atoms template_mapped_dict, edge_atoms = reaction_atom_walker( reactant_mol, first_shell, fully_mapped_dict ) + # Augment DataFrame with template mappings and edge atoms df = self._add_dict_as_new_columns( df, template_mapped_dict, @@ -471,6 +566,7 @@ def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionM df = self._add_column_safe(df, edge_atoms, "edge_atoms") data["reaction_dataframe"] = df.copy() + # Build metadata object metadata = ReactionMetadata( reaction_id=rid, reactant_combined_mol=data["reactant"], @@ -489,32 +585,36 @@ def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionM metadata_list.append(metadata) return metadata_list - - def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], highlight_type: str = "template" - ) -> Image: + ) -> Image: """ - Create a grid image highlighting atoms in reactant molecules. + Generate a grid image of reactant-product pairs with highlighted atoms. - highlight_type options: - "template" - "edge" - "initiators" - "delete" - """ + Clears atom maps before drawing. Supports multiple highlight types. + Args: + metadata_list: List of ReactionMetadata. + highlight_type: Type of atoms to highlight: + - "template": Template-matched atoms (blue). + - "edge": Edge atoms (orange). + - "initiators": Initiator atoms (green). + - "delete": Byproduct atoms if delete_atom=True (red). + + Returns: + PIL Image of the grid. + """ mols = [] highlight_lists = [] highlight_colors = [] for metadata in metadata_list: - reactant = metadata.reactant_combined_mol product = metadata.product_combined_mol + # Clear atom maps for clean visualization for atom in reactant.GetAtoms(): atom.SetAtomMapNum(0) for atom in product.GetAtoms(): @@ -551,13 +651,12 @@ def reaction_templates_highlighted_image_grid( atoms = [] mols.extend([reactant, product]) - highlight_lists.append(atoms) - highlight_lists.append([]) - + highlight_lists.append([]) # No highlights on products highlight_colors.append(color_map) highlight_colors.append({}) + # Draw grid: 2 columns (reactant | product) img = Draw.MolsToGridImage( mols, molsPerRow=2, @@ -568,5 +667,3 @@ def reaction_templates_highlighted_image_grid( ) return img - - From 5b081aad0978772d2c82012fd83bf0d104ebcd74 Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Thu, 12 Mar 2026 02:48:51 -0400 Subject: [PATCH 09/26] Update example_1.ipynb --- examples/example_1.ipynb | 241 +++++++-------------------------------- 1 file changed, 40 insertions(+), 201 deletions(-) diff --git a/examples/example_1.ipynb b/examples/example_1.ipynb index f58ca2d..e59d05f 100644 --- a/examples/example_1.ipynb +++ b/examples/example_1.ipynb @@ -17,29 +17,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "2dccf25a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All required modules are successfully imported.\n", - " \n", - " .o. . ooooooooo. oooooooooooo .o. .oooooo. ooooooooooooo oooooooooooo ooooooooo. \n", - " .888. .o8 `888 `Y88. `888' `8 .888. d8P' `Y8b 8' 888 `8 `888' `8 `888 `Y88. \n", - " .8\"888. oooo oooo .o888oo .ooooo. 888 .d88' 888 .8\"888. 888 888 888 888 .d88' \n", - " .8' `888. `888 `888 888 d88' `88b 888ooo88P' 888oooo8 .8' `888. 888 888 888oooo8 888ooo88P' \n", - " .88ooo8888. 888 888 888 888 888 888`88b. 888 \" .88ooo8888. 888 888 888 \" 888`88b. \n", - " .8' `888. 888 888 888 . 888 888 888 `88b. 888 o .8' `888. `88b ooo 888 888 o 888 `88b. \n", - "o88o o8888o `V88V\"V8P' \"888\" `Y8bod8P' o888o o888o o888ooooood8 o88o o8888o `Y8bood8P' o888o o888ooooood8 o888o o888o \n", - "\n", - "AutoREACTER version: v0.2-beta.0\n", - "Cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache\n" - ] - } - ], + "outputs": [], "source": [ "from AutoREACTER.initialization import Initialization\n", "from AutoREACTER.input_parser import InputParser\n", @@ -76,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "67a1b385", "metadata": {}, "outputs": [], @@ -101,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "32ab0cba", "metadata": {}, "outputs": [], @@ -127,22 +108,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "63c6e279", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "initial_molecules = input_parser.initial_molecules_image_grid(validated_inputs)\n", "initial_molecules" @@ -160,18 +129,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "3bcaf515", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Default cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache\n" - ] - } - ], + "outputs": [], "source": [ "default_cache_dir = GetCacheDir().cache_base_dir\n", "print(f\"Default cache directory: {default_cache_dir}\")" @@ -189,22 +150,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "04b6e642", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: hydroxy_acid_halide\n", - "Note: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl - Hydroxy acid halides are highly reactive and less commonly used monomers for polyesterification compared to hydroxy carboxylic acids.\n", - "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: diol\n", - "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl has functionality: di_carboxylic_acid_halide\n", - "Nc1cccc(N)c1 has functionality: di_amine\n" - ] - } - ], + "outputs": [], "source": [ "# FunctionalGroupsDetector() initializes the detector.\n", "# functional_groups_detector() analyzes the validated monomers.\n", @@ -230,22 +179,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "e295e3b3", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# molecules_to_visualization() highlights the functional groups identified in the previous step.\n", "# The resulting image shows each molecule with the detected functional groups marked.\n", @@ -266,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "76817cd8", "metadata": {}, "outputs": [], @@ -290,23 +227,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "b443f92e", "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "img = reaction_detector.available_reaction_image_grid(reaction_instances)\n", "img" @@ -324,27 +248,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "26d581e2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Detected Reactions:\n", - "1. Diol and Di-Acid Halide Polycondensation(Polyesterification)\n", - " Monomer 1: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (diol)\n", - " Monomer 2: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (di_carboxylic_acid_halide)\n", - "\n", - "2. Di-Amine and Di-Carboxylic Acid Halide Polycondensation (Polyamidation)\n", - " Monomer 1: Nc1cccc(N)c1 (di_amine)\n", - " Monomer 2: CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl (di_carboxylic_acid_halide)\n", - "\n", - "Selected 2 reactions.\n" - ] - } - ], + "outputs": [], "source": [ "# reaction_selection() processes the detected reactions.\n", "# It removes user selected reactions from the list of detected reactions and returns the final set of reactions to be used for template generation.\n", @@ -354,18 +261,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "ee4e5c22", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ReactionInstance(reaction_name='Diol and Di-Acid Halide Polycondensation(Polyesterification)', reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[O,S;X2;H1;!$([O,S]C=*):2]-[H:5]>>[CX3:1](=[O:3])-[O,S;X2;!$([O,S]C=*):2].[Cl,Br,I:4]-[H:5]', delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], 'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734.1', 'https://pubs.acs.org/doi/10.1021/ed073pA312']}, monomer_1=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_1=FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), monomer_2=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_2=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None)), ReactionInstance(reaction_name='Di-Amine and Di-Carboxylic Acid Halide Polycondensation (Polyamidation)', reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[N;H2,H1;!$(NC=*):2][H:5]>>[CX3:1](=[O:3])[NX3;!$(NC=*):2].[Cl,Br,I:4]([H:5])', delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], 'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734']}, monomer_1=MonomerRole(smiles='Nc1cccc(N)c1', name='mpd', functionalities=(FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None),)), functional_group_1=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), monomer_2=MonomerRole(smiles='CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_different', fg_name='hydroxy_acid_halide', fg_smarts_1='[OX2H1;!$(OC=*):1]', fg_count_1=2, fg_smarts_2='[CX3:2](=[O])[Cl,Br,I]', fg_count_2=3), FunctionalGroupInfo(functionality_type='di_identical', fg_name='diol', fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))), functional_group_2=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))]\n" - ] - } - ], + "outputs": [], "source": [ "print(selected_reactions)" ] @@ -383,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "c811c031", "metadata": {}, "outputs": [], @@ -406,30 +305,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "5040c430", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ID: 3, Name: ethanol, SMILES: CCO\n", - "ID: 4, Name: data_4, SMILES: CCN\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# `()` grid to non reactive molecules\n", "\n", @@ -451,28 +330,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "00d75b1a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Selection Guide for Non-Reactant Monomers:\n", - "- N: Discard all non-reactant monomers from the simulation.\n", - "- A: Retain all non-reactant monomers in the simulation.\n", - "- S: Select specific non-reactant monomers to retain. You will be prompted \n", - "to enter the IDs of the monomers you wish to keep, separated by commas.\n", - "Example: If you want to keep monomers with IDs 1 and 3, you would enter: 1,3\n", - " \n", - "The following monomers do not participate in any detected reactions:\n", - "ID: 3, Name: ethanol, SMILES: CCO\n", - "ID: 4, Name: data_4, SMILES: CCN\n" - ] - } - ], + "outputs": [], "source": [ "# non_reactant_selection() removes or marks molecules that do not participate in any reactions.\n", "# The resulting `updated_inputs` contains the filtered set of monomers that will be used in the next stages of the workflow.\n", @@ -483,26 +344,24 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "d62efe2a", "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'ReactionInstance' object has no attribute 'reactant_smiles_1'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m prepare_reactions = PrepareReactions(cache_dir)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m prepared_reactions = \u001b[43mprepare_reactions\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprepare_reactions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mselected_reactions\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m/mnt/c/Users/Janitha/Documents/AutoREACTER/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py:401\u001b[39m, in \u001b[36mPrepareReactions.prepare_reactions\u001b[39m\u001b[34m(self, reactions)\u001b[39m\n\u001b[32m 396\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m reaction \u001b[38;5;129;01min\u001b[39;00m reactions:\n\u001b[32m 398\u001b[39m rxn = \u001b[38;5;28mself\u001b[39m._build_reaction(reaction.reaction_smarts)\n\u001b[32m 400\u001b[39m mol_r1, mol_r2 = \u001b[38;5;28mself\u001b[39m._build_reactants(\n\u001b[32m--> \u001b[39m\u001b[32m401\u001b[39m \u001b[43mreaction\u001b[49m\u001b[43m.\u001b[49m\u001b[43mreactant_smiles_1\u001b[49m,\n\u001b[32m 402\u001b[39m reaction.reactant_smiles_2\n\u001b[32m 403\u001b[39m )\n\u001b[32m 405\u001b[39m reaction_tuple = \u001b[38;5;28mself\u001b[39m._reaction_tuples(\n\u001b[32m 406\u001b[39m reaction.same_reactants,\n\u001b[32m 407\u001b[39m mol_r1,\n\u001b[32m 408\u001b[39m mol_r2\n\u001b[32m 409\u001b[39m )\n\u001b[32m 411\u001b[39m mols, result_dict = \u001b[38;5;28mself\u001b[39m._process_reactions(\n\u001b[32m 412\u001b[39m rxn,\n\u001b[32m 413\u001b[39m csv_cache,\n\u001b[32m 414\u001b[39m reaction_tuple,\n\u001b[32m 415\u001b[39m key=reaction.reaction_id\n\u001b[32m 416\u001b[39m )\n", - "\u001b[31mAttributeError\u001b[39m: 'ReactionInstance' object has no attribute 'reactant_smiles_1'" - ] - } - ], + "outputs": [], "source": [ "prepare_reactions = PrepareReactions(cache_dir)\n", - "prepared_reactions = prepare_reactions.prepare_reactions(selected_reactions,)" + "prepared_reactions = prepare_reactions.prepare_reactions(selected_reactions)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7c134e5", + "metadata": {}, + "outputs": [], + "source": [ + "img = prepare_reactions.reaction_templates_highlighted_image_grid(prepared_reactions)\n", + "img" ] }, { @@ -510,19 +369,7 @@ "execution_count": null, "id": "6603c504", "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'AutoREACTER.reaction_template_builder'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# execute_pipeline may live in the same module as ReactionTemplatePipeline; import if needed.\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mAutoREACTER\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mreaction_template_builder\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mrun_reaction_template_pipeline\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m execute_pipeline\n\u001b[32m 4\u001b[39m execute_pipeline(\n\u001b[32m 5\u001b[39m detected_reactions=detected_reactions,\n\u001b[32m 6\u001b[39m retain_smiles=non_monomers,\n\u001b[32m 7\u001b[39m cache=cache_dir,\n\u001b[32m 8\u001b[39m )\n", - "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'AutoREACTER.reaction_template_builder'" - ] - } - ], + "outputs": [], "source": [ "%%capture captured_output\n", "# execute_pipeline may live in the same module as ReactionTemplatePipeline; import if needed.\n", @@ -540,15 +387,7 @@ "execution_count": null, "id": "52d28045", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output written to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/output.txt\n" - ] - } - ], + "outputs": [], "source": [ "from pathlib import Path\n", "\n", From c01db2cb15879fde22b8b3be4a5ecbc71a385c21 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 15:12:28 -0400 Subject: [PATCH 10/26] Refactor reaction preparation pipeline Rework PrepareReactions to a more modular pipeline and improve mapping/data handling. - Added csv_path to ReactionMetadata and made template_reactant_to_product_mapping/edge_atoms optional. - Introduced run_reaction_template_pipeline, process_reaction_instances and _process_reaction_products to split responsibilities (mapping, template detection, CSV output). - Replaced/renamed several helpers: _prepare_paths now uses self.cache, added _is_consecutive, _smart_mapping, _build_reactants, _build_reaction, _add_dict_as_new_columns and a safer _add_column_safe. - Improved atom-mapping validation (consecutive indices, full coverage), byproduct detection, initiator checks, and CSV persistence for each processed reaction. - Hardened DataFrame column additions with nullable Int64 dtypes and handled potential None values in template/edge fields. - Updated reaction_templates_highlighted_image_grid to tolerate missing fields and use RWMol for visualization. still a broken code --- .../reaction_processor/prepare_reactions.py | 1034 ++++++++++------- 1 file changed, 587 insertions(+), 447 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index f6ab72d..2c45b8f 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -10,6 +10,9 @@ from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Optional +import itertools +import os + from rdkit import Chem from rdkit.Chem import AllChem, Draw, rdmolops from PIL.Image import Image @@ -58,8 +61,9 @@ class ReactionMetadata: reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol reactant_to_product_mapping: Dict[int, int] - template_reactant_to_product_mapping: Dict[int, int] - edge_atoms: List[int] + csv_path: Path + template_reactant_to_product_mapping: Optional[Dict[int, int]] = None + edge_atoms: Optional[List[int]] = None first_shell: Optional[List[int]] = None initiators: Optional[List[int]] = None @@ -75,7 +79,6 @@ class ReactionMetadata: delete_atom_idx: Optional[int] = None activity_stats: bool = True - class PrepareReactions: """ Class for preparing reaction instances by processing SMILES/SMARTS, performing atom mapping, @@ -90,506 +93,647 @@ def __init__(self, cache: Path): cache: Path to the base cache directory for storing processed reaction data. """ self.cache = Path(cache) - self.csv_cache = self._prepare_paths(self.cache) + self.csv_cache = self._prepare_paths() - def _add_column_safe(self, df: pd.DataFrame, list_data: List, column_name: str) -> pd.DataFrame: + def run_reaction_template_pipeline(self, detected_reactions_dict, cache): """ - Safely add a new integer column to a DataFrame, handling NaN values with nullable Int64 dtype. + Main execution pipeline for mapping reactions, identifying templates, + and saving results to CSV. + + Steps: + 1. Maps atoms between reactants and products. + 2. Uses an atom walker to identify the 'reaction center' (template). + 3. Identifies 'edge atoms' that connect the template to the rest of the molecule. + 4. Updates reaction dataframes with mapping indices and saves them. Args: - df: Input DataFrame. - list_data: List of data to add as a new column. - column_name: Name of the new column. + detected_reactions_dict (dict): Raw dictionary of detected reactions. + cache (str): Path to the cache directory for processing. Returns: - DataFrame with the new column added. + tuple: (updated_molecule_dict, formatted_summary_dict) """ - df[column_name] = pd.Series(list_data).astype("Int64") - return df - - def _add_dict_as_new_columns( - self, - df_existing: pd.DataFrame, - data_dict: Dict[int, int], - titles: List[str] = ["template_reactant_idx", "template_product_idx"] - ) -> pd.DataFrame: + # Initial processing: atom mapping and basic dictionary formatting + reactions_metadata = self.process_reaction_instances(detected_reactions_dict, cache) + + + # Iterate through each detected reaction to perform template analysis + for reaction in reactions_metadata: + combined_reactant_molecule_object = reaction.reactant_combined_mol + combined_product_molecule_object = reaction.product_combined_mol + reaction_dataframe = reaction.reaction_dataframe + csv_save_path = reaction.csv_path + + # Create a mapping dictionary {reactant_idx: product_idx} from the dataframe + fully_mapped_dict = reaction_dataframe.set_index("reactant_idx")["product_idx"].to_dict() + + # Extract the 'first shell' (atoms directly involved in bond changes) + first_shell = reaction_dataframe["first_shell"].dropna().tolist() + + # Perform atom walking to determine the reaction template and boundary (edge) atoms + template_mapped_dict, edge_atoms = reaction_atom_walker( + combined_reactant_molecule_object, + first_shell, + fully_mapped_dict + ) + + # Note: Duplicate checking logic is currently commented out but available for future use + # is_duplicate, processed_dict = compare_rdkit_fragments(...) + + # Update the dataframe with specific template mapping indices + reaction_dataframe = self._add_dict_as_new_columns( + reaction_dataframe, + template_mapped_dict, + titles = ["template_reactant_idx", "template_product_idx"] + ) + + # Append edge atoms information (crucial for building polymer chains) + reaction_dataframe = self._add_column_safe( + reaction_dataframe, + edge_atoms, + "edge_atoms" + ) + + # Store the updated dataframe back in the reaction object + # Using .copy() to avoid SettingWithCopyWarning in pandas + reaction["reaction_dataframe"] = reaction_dataframe.copy() + + # Persist the processed reaction data to a CSV file + reaction_dataframe.to_csv(csv_save_path, index=False) + + # For debugging: print the final molecule dictionary with CSV paths + # print("Formatted Detected Reactions Summary:") + # print(molecule_dict_csv_path_dict) + return + + + def process_reaction_instances(self, detected_reactions: list[ReactionInstance], cache : Path) -> list[ReactionInstance]: """ - Add two new columns from a dictionary keys and values, using nullable Int64 dtype. - + Process a dictionary of detected reactions and generate mapping data. + + This is a high-level function that processes multiple reactions defined in + a dictionary structure, handling all steps from SMILES to final CSV output. + Args: - df_existing: Input DataFrame. - data_dict: Dictionary where keys go to titles[0] and values to titles[1]. - titles: List of two column names for keys and values. - + detected_reactions (list[ReactionInstance]): List of detected reaction instances + cache (Path): Base cache directory for output files + Returns: - DataFrame with the two new columns added. + tuple: (molecule_and_csv_path_dict, detected_reactions) + - molecule_and_csv_path_dict: Dictionary with all processed reaction data + - detected_reactions: The original input dictionary (unchanged) + + Example: + >>> reactions_dict = { + ... 1: {"reaction": "[C:1]=[O:2]>>[C:1]-[O:2]", + ... "monomer_1": {"smiles": "CCO"}, ...} + ... } + >>> results, original = process_reaction_instances(reactions_dict, "/path/to/cache") """ - df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") - df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") - return df_existing - - def _reaction_tuples( - self, - same_reactants: bool, - mol_reactant_1: Chem.Mol, - mol_reactant_2: Chem.Mol - ) -> List[List[Chem.Mol]]: """ - Generate reactant pairs for reaction processing, handling homo-polymerization (same reactants). +[ReactionInstance +(reaction_name='Diol and Di-Acid Halide Polycondensation(Polyesterification)', +reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[O,S;X2;H1;!$([O,S]C=*):2]-[H:5]>>[CX3:1](=[O:3])-[O,S;X2;!$([O,S]C=*):2].[Cl,Br,I:4]-[H:5]', +delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], +'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734.1', 'https://pubs.acs.org/doi/10.1021/ed073pA312']}, +monomer_1= + MonomerRole(smiles='OC[C@H]1OC(O)[C@H](O)[C@@H](O)[C@@H]1O', + name='data_4', + functionalities= + (FunctionalGroupInfo(functionality_type='di_identical', + fg_name='diol', + fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', + fg_count_1=5, + fg_smarts_2=None, + fg_count_2=None),)), + functional_group_1= + FunctionalGroupInfo(functionality_type='di_identical', + fg_name='diol', + fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', + fg_count_1=5, + fg_smarts_2=None, + fg_count_2=None), +monomer_2 + =MonomerRole( + smiles='O=C(Cl)c1c(Cl)c(C(=O)Cl)c(I)c(C(=O)Cl)c1Br', + name='tmc', + functionalities=( + FunctionalGroupInfo + (functionality_type='di_identical', + fg_name='di_carboxylic_acid_halide', + fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', + fg_count_1=3, fg_smarts_2=None, fg_count_2=None),)), + functional_group_2= + FunctionalGroupInfo(functionality_type='di_identical', + fg_name='di_carboxylic_acid_halide', + fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', + fg_count_1=3, fg_smarts_2=None, fg_count_2=None)), +""" + csv_cache = self.csv_cache - Args: - same_reactants: If True, use the same molecule twice (homo-polymerization). - mol_reactant_1: First reactant molecule. - mol_reactant_2: Second reactant molecule. + # Process each reaction in the detected reactions class + for reaction in detected_reactions: + rxn_smarts = reaction.reaction_smarts + reactant_smiles_1 = reaction.monomer_1.smiles + same_reactants = reaction.same_reactants + + # Handle same vs different reactants + if same_reactants: + reactant_smiles_2 = reactant_smiles_1 + else: + reactant_smiles_2 = reaction.monomer_2.smiles + + delete_atoms = reaction.delete_atom + # Build reaction and reactants + rxn = self._build_reaction(rxn_smarts) + mol_reactant_1, mol_reactant_2 = self._build_reactants(reactant_smiles_1, reactant_smiles_2) + reaction_tuple = self._build_reaction_tuple(same_reactants, mol_reactant_1, mol_reactant_2) + + # Process the reaction + reaction_metadata = self._process_reaction_products( + rxn, + csv_cache, + reaction_tuple, + delete_atoms=delete_atoms, + ) + + return reaction_metadata + + def _process_reaction_products(self, + rxn: Chem.rdChemReactions.ChemicalReaction, + csv_cache: Path, + reaction_tuple: list, + delete_atoms: bool = True, + reaction_metadata: list[ReactionMetadata] = None + ) -> list[ReactionMetadata]: + """ + Process chemical reactions, map atoms between reactants and products, and save data. + + This is the main processing function that: + 1. Runs reactions on reactant pairs + 2. Maps atoms between reactants and products + 3. Validates mapping consistency + 4. Saves mapping data to CSV files + 5. Identifies reaction features (first shell, initiators, byproducts) + + Args: + rxn (Chem.rdChemReactions.ChemicalReaction): RDKit reaction object + csv_cache (Path): Directory path for CSV output files + reaction_tuple (list): List of reactant pairs to process + key (str or int, optional): Identifier for the reaction set + molecule_and_csv_path_dict (dict, optional): Dictionary to store results + delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion + Returns: - List of reactant pairs [[r1, r2], ...]. + tuple: (mols, output, molecule_and_csv_path_dict) + - mols: List of reactant and product molecules for visualization + - output: String output (currently empty, reserved for future use) + - molecule_and_csv_path_dict: Dictionary containing all processed data + + Raises: + ValueError: If mapping validation fails at any step + + Note: + This function performs extensive validation including: + - Atom count consistency between reactants and products + - Consecutive indexing requirements + - Initiator count validation (must be exactly 2) """ - if same_reactants: - return [[mol_reactant_1, mol_reactant_1]] - return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] + if reaction_metadata is None: + reaction_metadata = [] - def _is_number_in_set(self, set_of_tuples: List[tuple], reactant: Chem.Mol) -> tuple: - """ - Find the substructure match tuple containing an atom with map number >= 100. + # Process each reactant pair in the reaction tuple + for j, pair in enumerate(reaction_tuple): + r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) + products = rxn.RunReactants((r1, r2)) + + # Get substructure matches for each reactant against reaction templates + matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) + matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) - Args: - set_of_tuples: List of match tuples from GetSubstructMatches. - reactant: RDKit Mol of the reactant. + # Process each product set generated by the reaction + # Process each product set generated by the reaction + for product_set in products: + # loop over ALL match combinations + for match1 in matches_1 if matches_1 else [()]: + for match2 in matches_2 if matches_2 else [()]: + + # IMPORTANT: copy reactants for each combination + r1_copy = Chem.Mol(r1) + r2_copy = Chem.Mol(r2) + + # Clean up any existing DataFrame + if "df" in locals(): + del df + + df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) + first_shell = [] + initiator_idxs = [] + mapping_dict = {} + + + # Apply atom mapping from reaction properties + num_total_atoms = 0 + for i, product in enumerate(product_set): + if i > 0: + num_total_atoms += product_set[i - 1].GetNumAtoms() + for atom in product.GetAtoms(): + if atom.HasProp("react_idx"): + r_idx = atom.GetIntProp("react_idx") + a_idx = atom.GetIntProp("react_atom_idx") + r = (r1_copy, r2_copy)[r_idx] + r_atom = r.GetAtomWithIdx(a_idx) + map_num = atom.GetIdx() + num_total_atoms + 101 + r_atom.SetAtomMapNum(map_num) + atom.SetAtomMapNum(map_num) + + # Combine reactants and products + reactant_combined = Chem.CombineMols(r1_copy, r2_copy) + product_combined = Chem.CombineMols(*product_set) + + # Create mapping dictionary and dataframe of reactant to product atom indices + for r_atom in reactant_combined.GetAtoms(): + for p_atom in product_combined.GetAtoms(): + if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): + r_atom_idx = r_atom.GetIdx() + p_atom_idx = p_atom.GetIdx() + mapping_dict[r_atom_idx] = p_atom_idx + new_row = pd.DataFrame([{ + "reactant_idx": r_atom_idx, + "product_idx": p_atom_idx + }]) + df = pd.concat([df, new_row], ignore_index=True) + break + + num_reactant_atoms = reactant_combined.GetNumAtoms() + num_product_atoms = product_combined.GetNumAtoms() + reactant_mapped = df["reactant_idx"].notna().sum() + product_mapped = df["product_idx"].notna().sum() + + if reactant_mapped != product_mapped: + raise ValueError("Mismatch in mapped atom counts") + + if reactant_mapped != num_reactant_atoms: + raise ValueError("Not all reactant atoms mapped") + + if product_mapped != num_product_atoms: + raise ValueError("Not all product atoms mapped") + + if (not self._is_consecutive(df["reactant_idx"].tolist()) or + not self._is_consecutive(df["product_idx"].tolist())): + raise ValueError("Non-consecutive indices") + + # Identify first shell + initiators + for atom in reactant_combined.GetAtoms(): + if atom.GetAtomMapNum() <= 99: + first_shell.append(atom.GetIdx()) + if atom.GetAtomMapNum() in [1, 2]: + initiator_idxs.append(atom.GetIdx()) + + if len(initiator_idxs) != 2: + raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") + + """ + This step enforces SMARTS-based atom mapping onto the reactants using selected substructure matches. + It assigns atom map numbers from the SMARTS template to corresponding atoms in the reactants, ensuring + consistent labeling of reaction centers. + + For each reactant, one matching substructure is selected and used to apply mapping. This helps standardize + atom indices so that downstream processes, such as the atom walker, can identify reaction templates and edge atoms. + """ + # Apply SMARTS-based mapping for THIS combination + self._smart_mapping( + reactant=r1_copy, + smarts_template=rxn.GetReactants()[0], + match_tuple=match1 if match1 else (), + ) + + self._smart_mapping( + reactant=r2_copy, + smarts_template=rxn.GetReactants()[1], + match_tuple=match2 if match2 else (), + ) + + # Byproduct detection + byproduct_product_idxs = [] + byproduct_reactant_idxs = [] + + if delete_atoms: + frags = rdmolops.GetMolFrags(product_combined, asMols=True) + smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) + + for atom in smallest_mol.GetAtoms(): + map_num = atom.GetAtomMapNum() + for p_atom in product_combined.GetAtoms(): + if p_atom.GetAtomMapNum() == map_num: + byproduct_product_idxs.append(p_atom.GetIdx()) + break + + byproduct_reactant_idxs = ( + df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] + .astype(int) + .tolist() + ) + + byproduct_indexs = byproduct_reactant_idxs + + # Build dataframe + df_combined = pd.concat([ + df, + pd.Series(first_shell, name="first_shell"), + pd.Series(initiator_idxs, name="initiators"), + pd.Series(byproduct_indexs, name="byproduct_indices") + ], axis=1).astype(pd.Int64Dtype()) + + + total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 + + df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) + reaction_metadata.append( + ReactionMetadata( + reaction_id=total_products, + reactant_combined_mol=reactant_combined, + product_combined_mol=product_combined, + reactant_to_product_mapping=mapping_dict, + csv_path= csv_cache / f"reaction_{total_products}.csv", + first_shell=first_shell, + initiators=initiator_idxs, + byproduct_indices=byproduct_indexs, + reaction_dataframe=df_combined + ) + ) + + return reaction_metadata + + def _is_consecutive(self, num_list): + """ + Check if a list of numbers forms a consecutive sequence without gaps. + + Args: + num_list (list): List of integers to check + Returns: - The matching tuple. + bool: True if the numbers are consecutive, False otherwise + + Examples: + >>> is_consecutive([1, 2, 3, 4]) # Returns True + >>> is_consecutive([1, 3, 4]) # Returns False + >>> is_consecutive([]) # Returns False + """ + if not num_list: + return False + return ( + len(set(num_list)) == len(num_list) + and max(num_list) - min(num_list) + 1 == len(num_list) + ) + + def _is_number_in_set(self, set_of_tuples, reactant): + """ + Find a tuple in the set that contains atom indices matching specific atom map numbers. + + This function searches for atoms in the reactant molecule that have atom map numbers + 101 or 102, then checks if those atom indices exist in any tuple within the provided set. + + Args: + set_of_tuples (set of tuples): Set of atom index tuples to search through + reactant (Chem.Mol): RDKit molecule object to search for mapped atoms + + Returns: + tuple: The first tuple found containing a matching atom index + Raises: - ValueError: If no matching atom/tuple found. + ValueError: If no matching atom is found in the provided set of tuples + + Example: + >>> matches = {(0, 1, 2), (3, 4, 5)} + >>> result = self._is_number_in_set(matches, reactant_mol) """ for atom in reactant.GetAtoms(): - if atom.GetAtomMapNum() >= 100: + # Check for specific atom map numbers (101 or 102) + if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: x = atom.GetIdx() for t in set_of_tuples: if x in t: + print(f"Found matching atom index {x} in tuple {t}") return t - raise ValueError("No matching atom found in the provided set of tuples") - - def _build_reactants(self, reactant_smiles_1: str, reactant_smiles_2: str) -> tuple[Chem.Mol, Chem.Mol]: + raise ValueError("No matching atom found in the provided set of tuples.") + + def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): """ - Parse SMILES strings into RDKit Mol objects, add hydrogens, and validate. - - Args: - reactant_smiles_1: SMILES for first reactant. - reactant_smiles_2: SMILES for second reactant. + Generate reactant pair orderings for reaction processing. - Returns: - Tuple of (mol_reactant_1, mol_reactant_2). - - Raises: - SMARTSParsingError: If SMILES parsing fails. + - For same reactants: only one unique ordering [A, A]. + - For different reactants: return both [A, B] and [B, A] to avoid relying + on reactant ordering and to support order-dependent reaction definitions. """ - mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) - if mol_reactant_1 is None: - raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_1}") - mol_reactant_1 = Chem.AddHs(mol_reactant_1) - - mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) - if mol_reactant_2 is None: - raise SMARTSParsingError(f"Invalid SMILES: {reactant_smiles_2}") - mol_reactant_2 = Chem.AddHs(mol_reactant_2) + if same_reactants: + return [[mol_reactant_1, mol_reactant_1]] - return mol_reactant_1, mol_reactant_2 + return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] + - def _prepare_paths(self, cache: Path) -> Path: + def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): """ - Create the CSV cache directory for storing atom mapping data. + Adds dictionary keys and values as new columns to an existing DataFrame. + + This is specifically used to map reactant indices to product indices + within the reaction template. Args: - cache: Base cache Path. + df_existing (pd.DataFrame): The DataFrame to modify. + data_dict (dict): Dictionary where keys and values will become column data. + titles (list): List of two strings for the new column names. Returns: - Path to the CSV cache subdirectory. + pd.DataFrame: The modified DataFrame with new columns added. """ - csv_cache = Path(cache) / "atom_mapping_btw_reactants_products_in_csv" - csv_cache.mkdir(parents=True, exist_ok=True) - return csv_cache + # Convert dict keys and values to Series to ensure alignment with the DataFrame + # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers + df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") + df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + + return df_existing - def _build_reaction(self, rxn_smarts: str) -> AllChem.ChemicalReaction: + + def _add_column_safe(self, df, list_data, column_name): """ - Parse reaction SMARTS into an RDKit ChemicalReaction object. + Safely adds a list as a new column to a DataFrame, handling potential + length mismatches by using Series alignment. Args: - rxn_smarts: Reaction SMARTS string. + df (pd.DataFrame): Target DataFrame. + list_data (list): Data to be added to the column. + column_name (str): Name of the new column. Returns: - RDKit ChemicalReaction object. - - Raises: - SMARTSParsingError: If parsing fails. + pd.DataFrame: Modified DataFrame with the new column. """ - rxn = AllChem.ReactionFromSmarts(rxn_smarts) - if rxn is None: - raise SMARTSParsingError(f"Invalid reaction SMARTS: {rxn_smarts}") - return rxn + # Creating a Series from the list ensures it starts from the top (index 0) + # and fills missing rows with NaN if the list is shorter than the DataFrame + df[column_name] = pd.Series(list_data).astype("Int64") + return df + + def _extract_unique_references(self, metadata_list: List[ReactionMetadata]) -> list[str]: + """Collect reference URLs from detected_reactions[*]["reference"], dedupe, keep order.""" + seen = set() + refs: list[str] = [] - def _is_consecutive(self, num_list: List[int]) -> bool: + for metadata in metadata_list: + ref = metadata.reference or {} + + # single URL fields + for v in ref.values(): + if isinstance(v, str): + if v not in seen: + seen.add(v) + refs.append(v) + + # list-of-URLs fields + elif isinstance(v, (list, tuple)): + for u in v: + if isinstance(u, str) and u not in seen: + seen.add(u) + refs.append(u) + + # (optional) nested dict handling, if you ever add that later + elif isinstance(v, dict): + for u in v.values(): + if isinstance(u, str) and u not in seen: + seen.add(u) + refs.append(u) + + return refs + + def _prepare_paths(self): """ - Check if a list of numbers is consecutive without duplicates or gaps. - + Create and prepare directory structure for CSV output files. + Args: - num_list: List of integers. - + cache (str or Path): Base cache directory path + Returns: - True if consecutive and unique. + Path: Path object pointing to the CSV cache directory + + Example: + >>> csv_dir = prepare_paths("/path/to/cache") + >>> print(csv_dir) # /path/to/cache/csv """ - if not num_list: - return False - return (len(set(num_list)) == len(num_list) and - max(num_list) - min(num_list) + 1 == len(num_list)) + csv_cache = Path(self.cache) / "reactant_product_mapping" + os.makedirs(csv_cache, exist_ok=True) + return csv_cache - def _process_reactions( - self, - rxn: AllChem.ChemicalReaction, - csv_cache: Path, - reaction_tuple: List[List[Chem.Mol]], - key: Optional[str] = None, - molecule_and_csv_path_dict: Optional[Dict] = None, - delete_atom: bool = False - ) -> Dict: + def _build_reaction(self, rxn_smarts): """ - Process chemical reactions, map atoms between reactants and products, and save data. - - This is the core processing function that: - 1. Runs reactions on reactant pairs using RDKit.RunReactants. - 2. Applies atom mapping from reaction properties and validates consistency. - 3. Identifies reaction centers, first shell, initiators, and byproducts. - 4. Saves detailed mapping DataFrames to CSV files. - 5. Stores results in a dictionary keyed by local reaction IDs. - + Create an RDKit reaction object from SMARTS string. + Args: - rxn: RDKit ChemicalReaction object. - csv_cache: Directory to save CSV files. - reaction_tuple: List of reactant pairs to process. - key: Identifier for the reaction set (e.g., reaction index). - molecule_and_csv_path_dict: Dictionary to store results (updated in-place). - delete_atom: If True, identify and mark byproduct atoms for deletion. - + rxn_smarts (str): Reaction SMARTS string + Returns: - Dictionary of processed reaction data, including mols, DataFrames, and paths. + Chem.rdChemReactions.ChemicalReaction: RDKit reaction object + + Example: + >>> rxn = build_reaction("[C:1]=[O:2]>>[C:1]-[O:2]") """ - if molecule_and_csv_path_dict is None: - molecule_and_csv_path_dict = {} + return AllChem.ReactionFromSmarts(rxn_smarts) - total_products = 0 - # Process each reactant pair in the reaction tuple - for j, pair in enumerate(reaction_tuple): - r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) - products = rxn.RunReactants((r1, r2)) - if not products: - continue - - # Get substructure matches for each reactant against reaction templates - matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) - matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) - - # Process each product set generated by the reaction - for product_set in products: - if "df" in locals(): - del df - - # Initialize data structures for mapping - df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - first_shell = [] - initiator_idxs = [] - mapping_dict = {} - - # Apply atom mapping from reaction properties (react_idx and react_atom_idx props) - num_total_atoms = 0 - for i, product in enumerate(product_set): - if i > 0: - num_total_atoms += product_set[i - 1].GetNumAtoms() - for atom in product.GetAtoms(): - if atom.HasProp("react_idx"): - r_idx = atom.GetIntProp("react_idx") - a_idx = atom.GetIntProp("react_atom_idx") - r = (r1, r2)[r_idx] - r_atom = r.GetAtomWithIdx(a_idx) - map_num = atom.GetIdx() + 1 + num_total_atoms + 100 - r_atom.SetAtomMapNum(map_num) - atom.SetAtomMapNum(map_num) - - # Combine reactants and products for unified processing - reactant_combined = Chem.CombineMols(r1, r2) - product_combined = Chem.CombineMols(*product_set) - if not compare_products(molecule_and_csv_path_dict, product_combined): - continue - - # Build mapping DataFrame based on shared atom map numbers - for r_atom in reactant_combined.GetAtoms(): - for p_atom in product_combined.GetAtoms(): - if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): - new_row = pd.DataFrame([{ - "reactant_idx": r_atom.GetIdx(), - "product_idx": p_atom.GetIdx() - }]) - df = pd.concat([df, new_row], ignore_index=True) - break - - # Validate mapping completeness and consistency - num_reactant_atoms = reactant_combined.GetNumAtoms() - num_product_atoms = product_combined.GetNumAtoms() - reactant_mapped = df["reactant_idx"].notna().sum() - product_mapped = df["product_idx"].notna().sum() - - # Validation 1: Mapped atom counts must match between columns - if reactant_mapped != product_mapped: - raise MappingError( - "Mismatch in mapped atom counts between columns: " - f"reactant_idx mapped={reactant_mapped}, product_idx mapped={product_mapped}" - ) - - # Validation 2: All reactant atoms must be mapped (debug CSV if fails) - if reactant_mapped != num_reactant_atoms: - df.to_csv(csv_cache / f"debug_mapping_{key}_{total_products}.csv", index=False) - raise MappingError( - "Mapping does not cover all reactant atoms: " - f"reactant atoms={num_reactant_atoms}, mapped={reactant_mapped}" - ) - - # Validation 3: All product atoms must be mapped - if product_mapped != num_product_atoms: - raise MappingError( - "Mapping does not cover all product atoms: " - f"product atoms={num_product_atoms}, mapped={product_mapped}" - ) - - # Validation 4: Mapping indices must be consecutive (no gaps/duplicates) - if (not self._is_consecutive(df["reactant_idx"].tolist()) or - not self._is_consecutive(df["product_idx"].tolist())): - raise MappingError( - "Mapping indices are not consecutive: " - f"reactant indices={df['reactant_idx'].tolist()}, " - f"product indices={df['product_idx'].tolist()}" - ) - - # Apply smart atom mapping to reactants using reaction templates - try: - sub_set1 = self._is_number_in_set(matches_1, r1) - except ValueError: - sub_set1 = () - smart_mapping( - reactant=r1, - smarts_template=rxn.GetReactants()[0], - match_tuple=sub_set1 if sub_set1 else (), - ) - - try: - sub_set2 = self._is_number_in_set(matches_2, r2) - except ValueError: - sub_set2 = () - smart_mapping( - reactant=r2, - smarts_template=rxn.GetReactants()[1], - match_tuple=sub_set2 if sub_set2 else (), - ) - - # Recombine reactants after smart mapping - reactant_combined = Chem.CombineMols(r1, r2) - - # Identify first shell atoms (map num <=99) and initiators (map num 1 or 2) - for atom in reactant_combined.GetAtoms(): - if atom.GetAtomMapNum() <= 99: - first_shell.append(atom.GetIdx()) - if atom.GetAtomMapNum() in [1, 2]: - initiator_idxs.append(atom.GetIdx()) - - # Identify byproduct atoms if deletion is enabled - byproduct_product_idxs = [] - byproduct_reactant_idxs = [] - - if delete_atom: - frags = rdmolops.GetMolFrags(product_combined, asMols=True) - smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) - - # Map byproduct atoms from smallest fragment back to product_combined indices - for atom in smallest_mol.GetAtoms(): - byproduct_map_number = atom.GetAtomMapNum() - for p_atom in product_combined.GetAtoms(): - if p_atom.GetAtomMapNum() == byproduct_map_number: - byproduct_product_idxs.append(p_atom.GetIdx()) - break - - # Convert product byproduct indices to reactant indices using df - byproduct_reactant_idxs = ( - df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] - .astype(int) - .tolist() - ) - - byproduct_indexs = byproduct_reactant_idxs # Store reactant indices - - # Append any additional manual mappings - for r_idx, p_idx in mapping_dict.items(): - new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) - df = pd.concat([df, new_row], ignore_index=True) - - # Create columns for first_shell, initiators, and byproducts - first_shell_column = pd.Series(first_shell, name="first_shell") - initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") - - # Validation: Exactly 2 initiators expected - if len(initiator_idxs) != 2: - raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") - - by_product_indexs_column = pd.Series(byproduct_indexs, name="byproduct_indices") - - # Combine into final DataFrame with nullable integer dtype - df_combined = pd.concat( - [df, first_shell_column, initiator_idxs_column, by_product_indexs_column], - axis=1 - ).astype(pd.Int64Dtype()) - - # Update counters and store in output dict - total_products += 1 - local_id = len(molecule_and_csv_path_dict) + 1 - dict_key = f"{key}_{local_id}" - - sub_dict = molecule_and_csv_path_dict.setdefault(local_id, {}) - - # Save DataFrame to CSV - csv_file = csv_cache / f"reaction_{dict_key}.csv" - df_combined.to_csv(csv_file, index=False) - print(f"Saved reaction {dict_key} to CSV") - - sub_dict["reactant"] = reactant_combined - sub_dict["product"] = product_combined - sub_dict["csv_path"] = csv_file - sub_dict["delete_atom"] = delete_atom - sub_dict["reaction_dataframe"] = df_combined - - return molecule_and_csv_path_dict - - def _extract_reactant_info(self, reaction: ReactionInstance) -> tuple[str, str, bool]: + def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): """ - Extract SMILES for reactants from a ReactionInstance, handling homo- vs. co-polymerization. - + Create RDKit molecule objects from SMILES strings with explicit hydrogens. + Args: - reaction: ReactionInstance with monomer_1 and optional monomer_2. - + reactant_smiles_1 (str): SMILES string for first reactant + reactant_smiles_2 (str): SMILES string for second reactant + Returns: - Tuple of (smiles_1, smiles_2, same_reactants_flag). + tuple: (mol_reactant_1, mol_reactant_2) - Both molecules with explicit hydrogens + + Example: + >>> mol1, mol2 = build_reactants("CCO", "CC=O") + """ + mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) + mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens + mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) + mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens + return mol_reactant_1, mol_reactant_2 + def _is_initiator_in_set(self, set_of_tuples, reactant): + """ + Find a tuple in the set that contains atom indices matching specific atom map numbers. + + This function searches for atoms in the reactant molecule that have atom map numbers + 101 or 102, then checks if those atom indices exist in any tuple within the provided set. + + Args: + set_of_tuples (set of tuples): Set of atom index tuples to search through + reactant (Chem.Mol): RDKit molecule object to search for mapped atoms + + Returns: + tuple: The first tuple found containing a matching atom index + Raises: - ValueError: If monomer_1 is missing. + ValueError: If no matching atom is found in the provided set of tuples + + Example: + >>> matches = {(0, 1, 2), (3, 4, 5)} + >>> result = is_initiator_in_set(matches, reactant_mol) """ - if reaction.monomer_1 is None: - raise ValueError(f"Reaction {reaction.reaction_name} has no monomer_1") - - smiles_1 = reaction.monomer_1.smiles - - if reaction.monomer_2 is None: - return smiles_1, smiles_1, True - - smiles_2 = reaction.monomer_2.smiles - return smiles_1, smiles_2, False + for atom in reactant.GetAtoms(): + # Check for specific atom map numbers (101 or 102) + if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: + x = atom.GetIdx() + for t in set_of_tuples: + if x in t: + print(f"Found matching atom index {x} in tuple {t}") + return t + raise ValueError("No matching atom found in the provided set of tuples.") + - def prepare_reactions(self, reactions: List[ReactionInstance]) -> List[ReactionMetadata]: + def _smart_mapping(self, reactant, smarts_template, match_tuple): """ - Main public method to process a list of ReactionInstances into ReactionMetadata. - - For each reaction: - 1. Builds reaction object and reactant mols. - 2. Processes pairs via _process_reactions. - 3. Extracts mappings, edge atoms via reaction_atom_walker. - 4. Builds and augments DataFrames. - 5. Constructs ReactionMetadata objects. - + Apply atom mapping from SMARTS template to reactant molecule based on match indices. + + This function transfers atom map numbers from a SMARTS template to corresponding + atoms in the reactant molecule using the provided match tuple that maps SMARTS + atom indices to reactant atom indices. + Args: - reactions: List of ReactionInstance objects. - + reactant (Chem.Mol): The reactant molecule to apply mapping to + smarts_template (Chem.Mol): SMARTS pattern molecule with atom map numbers + match_tuple (tuple): Tuple mapping SMARTS atom indices to reactant atom indices + Returns: - List of ReactionMetadata objects. + None: Modifies the reactant molecule in-place by setting atom map numbers + + Note: + Only atoms with non-zero map numbers in the SMARTS template are processed. + The function does nothing if match_tuple is empty. """ - csv_cache = self.csv_cache - metadata_list = [] - - for rxn_idx, reaction in enumerate(reactions, start=1): - rxn = self._build_reaction(reaction.reaction_smarts) - - reactant_smiles_1, reactant_smiles_2, same_reactants = \ - self._extract_reactant_info(reaction) - - mol_r1, mol_r2 = self._build_reactants( - reactant_smiles_1, - reactant_smiles_2 - ) - - reaction_tuple = self._reaction_tuples( - same_reactants, - mol_r1, - mol_r2 - ) - - result_dict = self._process_reactions( - rxn, - csv_cache, - reaction_tuple, - key=rxn_idx, - delete_atom=reaction.delete_atom - ) - - for rid, data in result_dict.items(): - df = data["reaction_dataframe"] - reactant_mol = data["reactant"] - - # Extract core reactant-to-product mapping (drop NaNs) - mapping_df = df.dropna(subset=["reactant_idx", "product_idx"]) - fully_mapped_dict = dict(zip( - mapping_df["reactant_idx"].astype(int), - mapping_df["product_idx"].astype(int) - )) - - first_shell = df["first_shell"].dropna().astype(int).tolist() - - # Walk the reaction graph to get template mappings and edge atoms - template_mapped_dict, edge_atoms = reaction_atom_walker( - reactant_mol, - first_shell, - fully_mapped_dict - ) - - # Augment DataFrame with template mappings and edge atoms - df = self._add_dict_as_new_columns( - df, - template_mapped_dict, - titles=["template_reactant_idx", "template_product_idx"] - ) - - df = self._add_column_safe(df, edge_atoms, "edge_atoms") - data["reaction_dataframe"] = df.copy() - - # Build metadata object - metadata = ReactionMetadata( - reaction_id=rid, - reactant_combined_mol=data["reactant"], - product_combined_mol=data["product"], - reactant_to_product_mapping=fully_mapped_dict, - template_reactant_to_product_mapping=template_mapped_dict, - edge_atoms=edge_atoms, - initiators=df["initiators"].dropna().astype(int).tolist(), - byproduct_indices=df["byproduct_indices"].dropna().astype(int).tolist(), - reaction_smarts=reaction.reaction_smarts, - csv_path=data["csv_path"], - reaction_dataframe=df, - delete_atom=data.get("delete_atom", True), - ) - - metadata_list.append(metadata) - - return metadata_list + if not match_tuple: + return + + # Create mapping from SMARTS atom indices to their map numbers + SMARTS_index_to_Map_Number = {} + for smarts_atom in smarts_template.GetAtoms(): + map_num = smarts_atom.GetAtomMapNum() + if map_num != 0: # Only process atoms with explicit mapping + SMARTS_index_to_Map_Number[smarts_atom.GetIdx()] = map_num + + # Apply mapping to corresponding atoms in reactant + for smarts_pos, map_num in SMARTS_index_to_Map_Number.items(): + if smarts_pos < len(match_tuple): + atom_index_in_mol = match_tuple[smarts_pos] + atom = reactant.GetAtomWithIdx(atom_index_in_mol) + atom.SetAtomMapNum(map_num) def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], - highlight_type: str = "template" + highlight_type: str = "template", ) -> Image: """ Generate a grid image of reactant-product pairs with highlighted atoms. @@ -612,17 +756,18 @@ def reaction_templates_highlighted_image_grid( highlight_colors = [] for metadata in metadata_list: - reactant = metadata.reactant_combined_mol - product = metadata.product_combined_mol + reactant = Chem.RWMol(metadata.reactant_combined_mol) + product = Chem.RWMol(metadata.product_combined_mol) + # Clear atom maps for clean visualization for atom in reactant.GetAtoms(): atom.SetAtomMapNum(0) for atom in product.GetAtoms(): atom.SetAtomMapNum(0) - df = metadata.reaction_dataframe - atoms = [] - color_map = {} + df = metadata.reaction_dataframe + atoms: List[int] = [] + color_map: Dict[int, tuple] = {} if highlight_type == "template": atoms = list(metadata.template_reactant_to_product_mapping.keys()) @@ -630,40 +775,35 @@ def reaction_templates_highlighted_image_grid( color_map[a] = (0.2, 0.6, 1.0) # blue elif highlight_type == "edge": - atoms = metadata.edge_atoms + atoms = metadata.edge_atoms or [] for a in atoms: color_map[a] = (1.0, 0.4, 0.0) # orange elif highlight_type == "initiators": - atoms = df["initiators"].dropna().astype(int).tolist() + atoms = df["initiators"].dropna().astype(int).tolist() if df is not None else [] for a in atoms: color_map[a] = (0.0, 0.8, 0.2) # green elif highlight_type == "delete": - if not metadata.delete_atom: - atoms = [] - else: + if metadata.delete_atom and metadata.byproduct_indices: atoms = metadata.byproduct_indices for a in atoms: color_map[a] = (1.0, 0.0, 0.0) # red - else: - atoms = [] - mols.extend([reactant, product]) highlight_lists.append(atoms) - highlight_lists.append([]) # No highlights on products + highlight_lists.append([]) # no highlights on products highlight_colors.append(color_map) highlight_colors.append({}) - # Draw grid: 2 columns (reactant | product) img = Draw.MolsToGridImage( mols, molsPerRow=2, highlightAtomLists=highlight_lists, highlightAtomColors=highlight_colors, subImgSize=(400, 400), - useSVG=False + useSVG=False, ) - return img + + From 6a5b6728fdc7af24189157d890d34013db8f4570 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 15:44:45 -0400 Subject: [PATCH 11/26] Refactor ReactionMetadata fields and callers --- .../reaction_processor/prepare_reactions.py | 45 ++++++++++--------- 1 file changed, 24 insertions(+), 21 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 2c45b8f..046dd76 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -61,7 +61,6 @@ class ReactionMetadata: reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol reactant_to_product_mapping: Dict[int, int] - csv_path: Path template_reactant_to_product_mapping: Optional[Dict[int, int]] = None edge_atoms: Optional[List[int]] = None @@ -251,12 +250,13 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance], reaction_tuple = self._build_reaction_tuple(same_reactants, mol_reactant_1, mol_reactant_2) # Process the reaction - reaction_metadata = self._process_reaction_products( - rxn, - csv_cache, - reaction_tuple, - delete_atoms=delete_atoms, - ) + reaction_metadata = self._process_reaction_products( + rxn, + csv_cache, + reaction_tuple, + delete_atoms, + reaction_metadata = [] + ) return reaction_metadata @@ -447,22 +447,24 @@ def _process_reaction_products(self, pd.Series(byproduct_indexs, name="byproduct_indices") ], axis=1).astype(pd.Int64Dtype()) - total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) reaction_metadata.append( ReactionMetadata( - reaction_id=total_products, - reactant_combined_mol=reactant_combined, - product_combined_mol=product_combined, - reactant_to_product_mapping=mapping_dict, - csv_path= csv_cache / f"reaction_{total_products}.csv", - first_shell=first_shell, - initiators=initiator_idxs, - byproduct_indices=byproduct_indexs, - reaction_dataframe=df_combined - ) + reaction_id = total_products, + reactant_combined_mol = reactant_combined, + product_combined_mol = product_combined, + reactant_to_product_mapping = mapping_dict, + first_shell = first_shell, + initiators = initiator_idxs, + byproduct_indices = byproduct_indexs, + csv_path = csv_cache / f"reaction_{total_products}.csv", + reaction_dataframe = df_combined, + delete_atom = delete_atoms, + delete_atom_idx = byproduct_indexs[0] if byproduct_indexs else None, + activity_stats = True + ) ) return reaction_metadata @@ -576,12 +578,13 @@ def _add_column_safe(self, df, list_data, column_name): df[column_name] = pd.Series(list_data).astype("Int64") return df - def _extract_unique_references(self, metadata_list: List[ReactionMetadata]) -> list[str]: + def _extract_unique_references(self, detected_reactions: List[ReactionInstance]) -> list[str]: """Collect reference URLs from detected_reactions[*]["reference"], dedupe, keep order.""" + seen = set() refs: list[str] = [] - for metadata in metadata_list: + for metadata in detected_reactions: ref = metadata.reference or {} # single URL fields @@ -770,7 +773,7 @@ def reaction_templates_highlighted_image_grid( color_map: Dict[int, tuple] = {} if highlight_type == "template": - atoms = list(metadata.template_reactant_to_product_mapping.keys()) + atoms = list((metadata.template_reactant_to_product_mapping or {}).keys()) for a in atoms: color_map[a] = (0.2, 0.6, 1.0) # blue From 302c3dd90558eddcbf8f3e2f819e895bb1b7a32e Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 15:57:11 -0400 Subject: [PATCH 12/26] Refactor reaction processing and validation Refactor reaction preparation flow --- .../reaction_processor/prepare_reactions.py | 144 +++++++----------- 1 file changed, 55 insertions(+), 89 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 046dd76..193426a 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -155,7 +155,7 @@ def run_reaction_template_pipeline(self, detected_reactions_dict, cache): # Store the updated dataframe back in the reaction object # Using .copy() to avoid SettingWithCopyWarning in pandas - reaction["reaction_dataframe"] = reaction_dataframe.copy() + reaction.reaction_dataframe = reaction_dataframe.copy() # Persist the processed reaction data to a CSV file reaction_dataframe.to_csv(csv_save_path, index=False) @@ -189,46 +189,8 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance], ... } >>> results, original = process_reaction_instances(reactions_dict, "/path/to/cache") """ - """ -[ReactionInstance -(reaction_name='Diol and Di-Acid Halide Polycondensation(Polyesterification)', -reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[O,S;X2;H1;!$([O,S]C=*):2]-[H:5]>>[CX3:1](=[O:3])-[O,S;X2;!$([O,S]C=*):2].[Cl,Br,I:4]-[H:5]', -delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], -'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734.1', 'https://pubs.acs.org/doi/10.1021/ed073pA312']}, -monomer_1= - MonomerRole(smiles='OC[C@H]1OC(O)[C@H](O)[C@@H](O)[C@@H]1O', - name='data_4', - functionalities= - (FunctionalGroupInfo(functionality_type='di_identical', - fg_name='diol', - fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', - fg_count_1=5, - fg_smarts_2=None, - fg_count_2=None),)), - functional_group_1= - FunctionalGroupInfo(functionality_type='di_identical', - fg_name='diol', - fg_smarts_1='[O,S;X2;H1;!$([O,S]C=*):3]', - fg_count_1=5, - fg_smarts_2=None, - fg_count_2=None), -monomer_2 - =MonomerRole( - smiles='O=C(Cl)c1c(Cl)c(C(=O)Cl)c(I)c(C(=O)Cl)c1Br', - name='tmc', - functionalities=( - FunctionalGroupInfo - (functionality_type='di_identical', - fg_name='di_carboxylic_acid_halide', - fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', - fg_count_1=3, fg_smarts_2=None, fg_count_2=None),)), - functional_group_2= - FunctionalGroupInfo(functionality_type='di_identical', - fg_name='di_carboxylic_acid_halide', - fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', - fg_count_1=3, fg_smarts_2=None, fg_count_2=None)), -""" csv_cache = self.csv_cache + all_metadata = [] # Process each reaction in the detected reactions class for reaction in detected_reactions: @@ -257,15 +219,15 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance], delete_atoms, reaction_metadata = [] ) + all_metadata.extend(reaction_metadata) - return reaction_metadata + return all_metadata def _process_reaction_products(self, rxn: Chem.rdChemReactions.ChemicalReaction, csv_cache: Path, reaction_tuple: list, - delete_atoms: bool = True, - reaction_metadata: list[ReactionMetadata] = None + delete_atoms: bool = True ) -> list[ReactionMetadata]: """ Process chemical reactions, map atoms between reactants and products, and save data. @@ -300,22 +262,22 @@ def _process_reaction_products(self, - Consecutive indexing requirements - Initiator count validation (must be exactly 2) """ - if reaction_metadata is None: - reaction_metadata = [] - + reaction_metadata = [] + # Process each reactant pair in the reaction tuple - for j, pair in enumerate(reaction_tuple): + for pair in reaction_tuple: r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) products = rxn.RunReactants((r1, r2)) + if not products: + continue # Skip if no products are generated + # Get substructure matches for each reactant against reaction templates matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) - - # Process each product set generated by the reaction + # Process each product set generated by the reaction for product_set in products: - # loop over ALL match combinations for match1 in matches_1 if matches_1 else [()]: for match2 in matches_2 if matches_2 else [()]: @@ -367,23 +329,8 @@ def _process_reaction_products(self, df = pd.concat([df, new_row], ignore_index=True) break - num_reactant_atoms = reactant_combined.GetNumAtoms() - num_product_atoms = product_combined.GetNumAtoms() - reactant_mapped = df["reactant_idx"].notna().sum() - product_mapped = df["product_idx"].notna().sum() - - if reactant_mapped != product_mapped: - raise ValueError("Mismatch in mapped atom counts") - - if reactant_mapped != num_reactant_atoms: - raise ValueError("Not all reactant atoms mapped") - - if product_mapped != num_product_atoms: - raise ValueError("Not all product atoms mapped") - - if (not self._is_consecutive(df["reactant_idx"].tolist()) or - not self._is_consecutive(df["product_idx"].tolist())): - raise ValueError("Non-consecutive indices") + if not self._validate_mapping(df, reactant_combined, product_combined): + raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") # Identify first shell + initiators for atom in reactant_combined.GetAtoms(): @@ -417,34 +364,17 @@ def _process_reaction_products(self, ) # Byproduct detection - byproduct_product_idxs = [] byproduct_reactant_idxs = [] if delete_atoms: - frags = rdmolops.GetMolFrags(product_combined, asMols=True) - smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) - - for atom in smallest_mol.GetAtoms(): - map_num = atom.GetAtomMapNum() - for p_atom in product_combined.GetAtoms(): - if p_atom.GetAtomMapNum() == map_num: - byproduct_product_idxs.append(p_atom.GetIdx()) - break - - byproduct_reactant_idxs = ( - df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] - .astype(int) - .tolist() - ) - - byproduct_indexs = byproduct_reactant_idxs + byproduct_reactant_idxs = self._detect_byproducts(product_combined, df, delete_atoms) # Build dataframe df_combined = pd.concat([ df, pd.Series(first_shell, name="first_shell"), pd.Series(initiator_idxs, name="initiators"), - pd.Series(byproduct_indexs, name="byproduct_indices") + pd.Series(byproduct_reactant_idxs, name="byproduct_indices") ], axis=1).astype(pd.Int64Dtype()) total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 @@ -458,18 +388,54 @@ def _process_reaction_products(self, reactant_to_product_mapping = mapping_dict, first_shell = first_shell, initiators = initiator_idxs, - byproduct_indices = byproduct_indexs, + byproduct_indices = byproduct_reactant_idxs, csv_path = csv_cache / f"reaction_{total_products}.csv", reaction_dataframe = df_combined, delete_atom = delete_atoms, - delete_atom_idx = byproduct_indexs[0] if byproduct_indexs else None, + delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, activity_stats = True ) ) return reaction_metadata - def _is_consecutive(self, num_list): + def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: + if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): + return False + if df["reactant_idx"].notna().sum() != reactant.GetNumAtoms(): + return False + if df["product_idx"].notna().sum() != product.GetNumAtoms(): + return False + if not self._is_consecutive(df["reactant_idx"].tolist()): + return False + if not self._is_consecutive(df["product_idx"].tolist()): + return False + return True + + + def _detect_byproducts(self, product_combined: Chem.Mol, df: pd.DataFrame, delete_atoms: bool) -> list[int]: + if not delete_atoms: + return [] + + frags = rdmolops.GetMolFrags(product_combined, asMols=True) + smallest = min(frags, key=lambda m: m.GetNumAtoms()) + + product_idxs = [] + for atom in smallest.GetAtoms(): + map_num = atom.GetAtomMapNum() + for p_atom in product_combined.GetAtoms(): + if p_atom.GetAtomMapNum() == map_num: + product_idxs.append(p_atom.GetIdx()) + break + + return ( + df.loc[df["product_idx"].isin(product_idxs), "reactant_idx"] + .astype(int) + .tolist() + ) + + + def _is_consecutive(self, num_list: list[int]) -> bool: """ Check if a list of numbers forms a consecutive sequence without gaps. From 9d559769e6e16d2628dff467f81c22e7dfaa1c3b Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 16:02:29 -0400 Subject: [PATCH 13/26] Use mapping dict to detect byproducts --- .../reaction_processor/prepare_reactions.py | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 193426a..ecd41d1 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -7,6 +7,9 @@ or mechanistic analysis. """ +# WARNING: +# When modifying this file for dataframe or any other indexing varibales use idx, do not use index or indicies or similar. + from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Optional @@ -367,14 +370,14 @@ def _process_reaction_products(self, byproduct_reactant_idxs = [] if delete_atoms: - byproduct_reactant_idxs = self._detect_byproducts(product_combined, df, delete_atoms) + byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) # Build dataframe df_combined = pd.concat([ df, pd.Series(first_shell, name="first_shell"), pd.Series(initiator_idxs, name="initiators"), - pd.Series(byproduct_reactant_idxs, name="byproduct_indices") + pd.Series(byproduct_reactant_idxs, name="byproduct_idx") ], axis=1).astype(pd.Int64Dtype()) total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 @@ -413,27 +416,24 @@ def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem. return True - def _detect_byproducts(self, product_combined: Chem.Mol, df: pd.DataFrame, delete_atoms: bool) -> list[int]: + def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, int], delete_atoms: bool) -> list[int]: if not delete_atoms: return [] frags = rdmolops.GetMolFrags(product_combined, asMols=True) smallest = min(frags, key=lambda m: m.GetNumAtoms()) - product_idxs = [] - for atom in smallest.GetAtoms(): - map_num = atom.GetAtomMapNum() - for p_atom in product_combined.GetAtoms(): - if p_atom.GetAtomMapNum() == map_num: - product_idxs.append(p_atom.GetIdx()) - break + byproduct = [] - return ( - df.loc[df["product_idx"].isin(product_idxs), "reactant_idx"] - .astype(int) - .tolist() - ) + # reverse mapping: product_idx → reactant_idx + reverse_map = {v: k for k, v in mapping_dict.items()} + + for atom in smallest.GetAtoms(): + p_idx = atom.GetIdx() + if p_idx in reverse_map: + byproduct.append(reverse_map[p_idx]) + return byproduct def _is_consecutive(self, num_list: list[int]) -> bool: """ From 4bcf2771c45ba6979d1aa1bd60195c11d662e859 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 18:10:56 -0400 Subject: [PATCH 14/26] Refactor reaction processor and utils --- .../reaction_processor/atom_mapping.py | 747 +----------------- .../reaction_processor/prepare_reactions.py | 185 +---- .../reaction_processor/utils.py | 200 +++-- 3 files changed, 163 insertions(+), 969 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py index ad0ab48..cbcaa99 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/atom_mapping.py @@ -1,713 +1,36 @@ -""" -Reaction Mapping and Analysis Module - -This module provides tools for processing chemical reactions, mapping atoms between -reactants and products, and generating comprehensive analysis data for polymer chemistry. -It uses RDKit for molecular operations and pandas for data management. - -Key features: -- Atom mapping between reactants and products -- Reaction validation and consistency checking -- CSV export of mapping data -- Visualization of reaction grids -- Support for polymerization reactions - -Author: Janitha Mahanthe -Date: 1/21/2026 -Version: 0.1.0 -# TODO: Return mols with mapped atoms for visualization for each reaction with highlighting -""" - -from rdkit import Chem -from rdkit.Chem import AllChem, rdmolops -import pandas as pd -from pathlib import Path -import os -import itertools -try: - # Case 1: correct when reaction_template_pipeline is a proper package - from .utils import compare_products - -except (ImportError, ModuleNotFoundError): - try: - # Case 2: fully-qualified import under your installed namespace - from reaction_lammps_mupt.reaction_template_builder.reaction_template_pipeline.utils import ( - compare_products, - ) - - except (ImportError, ModuleNotFoundError): - try: - # Case 3: if reaction_template_pipeline is installed as a top-level package - from reaction_template_pipeline.utils import compare_products - - except (ImportError, ModuleNotFoundError): - # Case 4: running as a loose script from the same directory - from utils import compare_products - - -def is_number_in_set(set_of_tuples, reactant): - """ - Find a tuple in the set that contains atom indices matching specific atom map numbers. - - This function searches for atoms in the reactant molecule that have atom map numbers - 101 or 102, then checks if those atom indices exist in any tuple within the provided set. - - Args: - set_of_tuples (set of tuples): Set of atom index tuples to search through - reactant (Chem.Mol): RDKit molecule object to search for mapped atoms - - Returns: - tuple: The first tuple found containing a matching atom index - - Raises: - ValueError: If no matching atom is found in the provided set of tuples - - Example: - >>> matches = {(0, 1, 2), (3, 4, 5)} - >>> result = is_number_in_set(matches, reactant_mol) - """ - for atom in reactant.GetAtoms(): - # Check for specific atom map numbers (101 or 102) - if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: - x = atom.GetIdx() - for t in set_of_tuples: - if x in t: - return t - raise ValueError("No matching atom found in the provided set of tuples.") - - def smart_mapping(reactant, smarts_template, match_tuple): - """ - Apply atom mapping from SMARTS template to reactant molecule based on match indices. - - This function transfers atom map numbers from a SMARTS template to corresponding - atoms in the reactant molecule using the provided match tuple that maps SMARTS - atom indices to reactant atom indices. - - Args: - reactant (Chem.Mol): The reactant molecule to apply mapping to - smarts_template (Chem.Mol): SMARTS pattern molecule with atom map numbers - match_tuple (tuple): Tuple mapping SMARTS atom indices to reactant atom indices - - Returns: - None: Modifies the reactant molecule in-place by setting atom map numbers - - Note: - Only atoms with non-zero map numbers in the SMARTS template are processed. - The function does nothing if match_tuple is empty. - """ - if not match_tuple: - return - - # Create mapping from SMARTS atom indices to their map numbers - SMARTS_index_to_Map_Number = {} - for smarts_atom in smarts_template.GetAtoms(): - map_num = smarts_atom.GetAtomMapNum() - if map_num != 0: # Only process atoms with explicit mapping - SMARTS_index_to_Map_Number[smarts_atom.GetIdx()] = map_num - - # Apply mapping to corresponding atoms in reactant - for smarts_pos, map_num in SMARTS_index_to_Map_Number.items(): - if smarts_pos < len(match_tuple): - atom_index_in_mol = match_tuple[smarts_pos] - atom = reactant.GetAtomWithIdx(atom_index_in_mol) - atom.SetAtomMapNum(map_num) - - -def is_consecutive(num_list): - """ - Check if a list of numbers forms a consecutive sequence without gaps. - - Args: - num_list (list): List of integers to check - - Returns: - bool: True if the numbers are consecutive, False otherwise - - Examples: - >>> is_consecutive([1, 2, 3, 4]) # Returns True - >>> is_consecutive([1, 3, 4]) # Returns False - >>> is_consecutive([]) # Returns False - """ - if not num_list: - return False - - # Check for consecutive sequence: unique numbers and max-min+1 equals length - return (len(set(num_list)) == len(num_list) and - max(num_list) - min(num_list) + 1 == len(num_list)) - - -def prepare_paths(cache): - """ - Create and prepare directory structure for CSV output files. - - Args: - cache (str or Path): Base cache directory path - - Returns: - Path: Path object pointing to the CSV cache directory - - Example: - >>> csv_dir = prepare_paths("/path/to/cache") - >>> print(csv_dir) # /path/to/cache/csv - """ - csv_cache = Path(cache) / "csv" / "reactant_product_mapping" - os.makedirs(csv_cache, exist_ok=True) - return csv_cache - - -def build_reaction(rxn_smarts): - """ - Create an RDKit reaction object from SMARTS string. - - Args: - rxn_smarts (str): Reaction SMARTS string - - Returns: - Chem.rdChemReactions.ChemicalReaction: RDKit reaction object - - Example: - >>> rxn = build_reaction("[C:1]=[O:2]>>[C:1]-[O:2]") - """ - return AllChem.ReactionFromSmarts(rxn_smarts) - - -def build_reactants(reactant_smiles_1, reactant_smiles_2): - """ - Create RDKit molecule objects from SMILES strings with explicit hydrogens. - - Args: - reactant_smiles_1 (str): SMILES string for first reactant - reactant_smiles_2 (str): SMILES string for second reactant - - Returns: - tuple: (mol_reactant_1, mol_reactant_2) - Both molecules with explicit hydrogens - - Example: - >>> mol1, mol2 = build_reactants("CCO", "CC=O") - """ - mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) - mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens - mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) - mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens - return mol_reactant_1, mol_reactant_2 - - -def process_reactions(rxn, csv_cache, reaction_tuple, key=None, - molecule_and_csv_path_dict=None, delete_atoms=False): - """ - Process chemical reactions, map atoms between reactants and products, and save data. - - This is the main processing function that: - 1. Runs reactions on reactant pairs - 2. Maps atoms between reactants and products - 3. Validates mapping consistency - 4. Saves mapping data to CSV files - 5. Identifies reaction features (first shell, initiators, byproducts) - - Args: - rxn (Chem.rdChemReactions.ChemicalReaction): RDKit reaction object - csv_cache (Path): Directory path for CSV output files - reaction_tuple (list): List of reactant pairs to process - key (str or int, optional): Identifier for the reaction set - molecule_and_csv_path_dict (dict, optional): Dictionary to store results - delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion - - Returns: - tuple: (mols, output, molecule_and_csv_path_dict) - - mols: List of reactant and product molecules for visualization - - output: String output (currently empty, reserved for future use) - - molecule_and_csv_path_dict: Dictionary containing all processed data - - Raises: - ValueError: If mapping validation fails at any step - - Note: - This function performs extensive validation including: - - Atom count consistency between reactants and products - - Consecutive indexing requirements - - Initiator count validation (must be exactly 2) - """ - if molecule_and_csv_path_dict is None: - molecule_and_csv_path_dict = {} - - total_products = 0 - mols = [] - - # Process each reactant pair in the reaction tuple - for j, pair in enumerate(reaction_tuple): - r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) - products = rxn.RunReactants((r1, r2)) - - # Get substructure matches for each reactant against reaction templates - matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) - matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) - - # Process each product set generated by the reaction - for product_set in products: - # Clean up any existing DataFrame - if "df" in locals(): - del df - - - # Initialize data structures - df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - first_shell = [] # Atoms in first coordination shell - initiator_idxs = [] # Initiator atom indices - mapping_dict = {} # Additional mapping dictionary - - # Apply atom mapping from reaction properties - num_total_atoms = 0 - for i, product in enumerate(product_set): - if i > 0: - num_total_atoms += product_set[i - 1].GetNumAtoms() - for atom in product.GetAtoms(): - if atom.HasProp("react_idx"): - r_idx = atom.GetIntProp("react_idx") - a_idx = atom.GetIntProp("react_atom_idx") - r = (r1, r2)[r_idx] - r_atom = r.GetAtomWithIdx(a_idx) - map_num = atom.GetIdx() + 1 + num_total_atoms + 100 - r_atom.SetAtomMapNum(map_num) - atom.SetAtomMapNum(map_num) - - # Combine reactants and products for easier processing - reactant_combined = Chem.CombineMols(r1, r2) - product_combined = Chem.CombineMols(*product_set) - - # Create mapping between reactant and product atoms based on map numbers - for r_atom in reactant_combined.GetAtoms(): - for p_atom in product_combined.GetAtoms(): - if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): - new_row = pd.DataFrame([{"reactant_idx": r_atom.GetIdx(), - "product_idx": p_atom.GetIdx()}]) - df = pd.concat([df, new_row], ignore_index=True) - break - - # Validate mapping completeness and consistency - num_reactant_atoms = reactant_combined.GetNumAtoms() - num_product_atoms = product_combined.GetNumAtoms() - reactant_mapped = df["reactant_idx"].notna().sum() - product_mapped = df["product_idx"].notna().sum() - - # Validation 1: Mapped atom counts must match between columns - if reactant_mapped != product_mapped: - raise ValueError( - "Mismatch in mapped atom counts between columns: " - f"reactant_idx mapped={reactant_mapped}, product_idx mapped={product_mapped}" - ) - - # Validation 2: All reactant atoms must be mapped - if reactant_mapped != num_reactant_atoms: - df.to_csv(csv_cache / f"debug_mapping_{key}_{total_products}.csv", index=False) - raise ValueError( - "Mapping does not cover all reactant atoms: " - f"reactant atoms={num_reactant_atoms}, mapped={reactant_mapped}" - ) - - # Validation 3: All product atoms must be mapped - if product_mapped != num_product_atoms: - raise ValueError( - "Mapping does not cover all product atoms: " - f"product atoms={num_product_atoms}, mapped={product_mapped}" - ) - - # Validation 4: Mapping indices must be consecutive - if (is_consecutive(df["reactant_idx"].tolist()) is False or - is_consecutive(df["product_idx"].tolist()) is False): - raise ValueError( - "Mapping indices are not consecutive: " - f"reactant indices={df['reactant_idx'].tolist()}, " - f"product indices={df['product_idx'].tolist()}" - ) - - # Apply smart mapping to both reactants - try: - sub_set1 = is_number_in_set(matches_1, r1) - except ValueError: - sub_set1 = () - smart_mapping( - reactant=r1, - smarts_template=rxn.GetReactants()[0], - match_tuple=sub_set1 if sub_set1 else (), - ) - - try: - sub_set2 = is_number_in_set(matches_2, r2) - except ValueError: - sub_set2 = () - smart_mapping( - reactant=r2, - smarts_template=rxn.GetReactants()[1], - match_tuple=sub_set2 if sub_set2 else (), - ) - - # Recombine reactants after mapping - reactant_combined = Chem.CombineMols(r1, r2) - - # Identify first shell atoms and initiators - for atom in reactant_combined.GetAtoms(): - if atom.GetAtomMapNum() <= 99: - first_shell.append(atom.GetIdx()) - # we could get the initiators by their map numbers - if atom.GetAtomMapNum() in [1, 2]: - initiator_idxs.append(atom.GetIdx()) - - # Identify byproduct atoms if deletion is requested - byproduct_product_idxs = [] - byproduct_reactant_idxs = [] - - if delete_atoms: - frags = rdmolops.GetMolFrags(product_combined, asMols=True) - smallest_mol = min(frags, key=lambda m: m.GetNumAtoms()) - - # 1) get byproduct atom indices in PRODUCT space - for atom in smallest_mol.GetAtoms(): - byproduct_map_number = atom.GetAtomMapNum() - for p_atom in product_combined.GetAtoms(): - if p_atom.GetAtomMapNum() == byproduct_map_number: - byproduct_product_idxs.append(p_atom.GetIdx()) - break - - # 2) convert PRODUCT indices -> REACTANT indices using df mapping - byproduct_reactant_idxs = ( - df.loc[df["product_idx"].isin(byproduct_product_idxs), "reactant_idx"] - .astype(int) - .tolist() - ) - - # if you want the column to store REACTANT indices now: - byproduct_indexs = byproduct_reactant_idxs - - # Add any additional mappings from mapping_dict - for r_idx, p_idx in mapping_dict.items(): - new_row = pd.DataFrame([{"reactant_idx": r_idx, "product_idx": p_idx}]) - df = pd.concat([df, new_row], ignore_index=True) - - # Create comprehensive DataFrame with all analysis columns - first_shell_column = pd.Series(first_shell, name="first_shell") - initiator_idxs_column = pd.Series(initiator_idxs, name="initiators") - - # Validation: Must have exactly 2 initiators - if len(initiator_idxs) != 2: - raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") - - by_product_indexs_column = pd.Series(byproduct_indexs, name="byproduct_indices") - - # Combine all data into final DataFrame - df_combined = pd.concat([df, first_shell_column, initiator_idxs_column, - by_product_indexs_column], axis=1).astype(pd.Int64Dtype()) - - # Check for duplicate products - if not compare_products(molecule_and_csv_path_dict, product_combined): - continue - - # Update counters and store results - total_products += 1 - mols.append(reactant_combined) - mols.append(product_combined) - - # Organize results in the output dictionary - for i in itertools.count(1): - if i not in molecule_and_csv_path_dict: # Check if i IS a key - sub_dict = molecule_and_csv_path_dict[i] = {} # Initialize if not found - dict_key = i - break - - # Save to CSV file - df_combined.to_csv(csv_cache / f"reaction_{dict_key}.csv", index=False) - print(f"Saved reaction {dict_key} to CSV") - - sub_dict["reactant"] = reactant_combined - sub_dict["product"] = product_combined - sub_dict["csv_path"] = csv_cache / f"reaction_{dict_key}.csv" - sub_dict["delete_atoms"] = delete_atoms - sub_dict["reaction_dataframe"] = df_combined - - - return mols, molecule_and_csv_path_dict - - -def save_grid_image(mols, cache, key=None): - from pathlib import Path - from rdkit.Chem import Draw - import base64 - - out_dir = Path(cache) / "grid_images" - out_dir.mkdir(parents=True, exist_ok=True) - - out_path = out_dir / (f"reaction_grid_{key}.png" if key is not None else "reaction_grid.png") - - # Ask RDKit for a raster image (PNG-like) - img = Draw.MolsToGridImage(mols, useSVG=False, subImgSize=(900, 900)) - - # Case 1: PIL.Image.Image (has .save) - if hasattr(img, "save"): - img.save(str(out_path)) - return out_path - - # Case 2: IPython/RDKit display object (often has .data) - data = getattr(img, "data", None) - if data is None: - raise TypeError(f"Unexpected image type {type(img)}; cannot save.") - - # data can be bytes OR base64 string depending on wrapper - if isinstance(data, bytes): - png_bytes = data - elif isinstance(data, str): - # try base64 decode; if it fails, treat as raw text - try: - png_bytes = base64.b64decode(data) - except Exception: - png_bytes = data.encode("utf-8") - else: - raise TypeError(f"Unexpected img.data type {type(data)}; cannot save.") - - with open(out_path, "wb") as f: - f.write(png_bytes) - - return out_path - - - -def reaction_tuples(same_reactants, mol_reactant_1, mol_reactant_2): - """ - Generate reactant pair orderings for reaction processing. - - - For same reactants: only one unique ordering [A, A]. - - For different reactants: return both [A, B] and [B, A] to avoid relying - on reactant ordering and to support order-dependent reaction definitions. - """ - if same_reactants: - return [[mol_reactant_1, mol_reactant_1]] - - return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] - - -def process_reaction_dict(detected_reactions, cache): - """ - Process a dictionary of detected reactions and generate mapping data. - - This is a high-level function that processes multiple reactions defined in - a dictionary structure, handling all steps from SMILES to final CSV output. - - Args: - detected_reactions (dict): Dictionary containing reaction definitions - cache (str or Path): Base cache directory for output files - - Returns: - tuple: (molecule_and_csv_path_dict, detected_reactions) - - molecule_and_csv_path_dict: Dictionary with all processed reaction data - - detected_reactions: The original input dictionary (unchanged) - - Example: - >>> reactions_dict = { - ... 1: {"reaction": "[C:1]=[O:2]>>[C:1]-[O:2]", - ... "monomer_1": {"smiles": "CCO"}, ...} - ... } - >>> results, original = process_reaction_dict(reactions_dict, "/path/to/cache") - """ - molecule_and_csv_path_dict = {} - csv_cache = prepare_paths(cache) - molecule_images = [] - - # TODO: Add function to compare products if products are identicals drop the duplicates - - - # Process each reaction in the dictionary - for key in detected_reactions: - reaction_dict = detected_reactions[key] - rxn_smarts = reaction_dict["reaction"] - reactant_smiles_1 = reaction_dict["monomer_1"]["smiles"] - same_reactants = reaction_dict["same_reactants"] - - # Handle same vs different reactants - if same_reactants: - reactant_smiles_2 = reactant_smiles_1 - else: - reactant_smiles_2 = reaction_dict["monomer_2"]["smiles"] - - delete_atoms = reaction_dict.get("delete_atom", False) - - # Build reaction and reactants - rxn = build_reaction(rxn_smarts) - mol_reactant_1, mol_reactant_2 = build_reactants(reactant_smiles_1, reactant_smiles_2) - reaction_tuple = reaction_tuples(same_reactants, mol_reactant_1, mol_reactant_2) - - # Process the reaction - mols, molecule_and_csv_path_dict = process_reactions( - rxn, csv_cache, reaction_tuple, key, molecule_and_csv_path_dict, - delete_atoms=delete_atoms - ) - - # Save outputs - save_grid_image(mols, cache, key) - molecule_images.append(mols) - - return molecule_and_csv_path_dict, detected_reactions, molecule_images - - -def run_all(cache, rxn_smarts, reactant_smiles_1, reactant_smiles_2): - """ - Run a complete reaction processing pipeline for a single reaction. - - This is a convenience function that handles all steps for processing - a single reaction from SMILES strings to final outputs. - - Args: - cache (str or Path): Base cache directory for output files - rxn_smarts (str): Reaction SMARTS string - reactant_smiles_1 (str): SMILES string for first reactant - reactant_smiles_2 (str): SMILES string for second reactant - - Returns: - dict: Dictionary containing all processed reaction data - - Example: - >>> results = run_all("/path/to/cache", - ... "[C:1]=[O:2]>>[C:1]-[O:2]", - ... "CCO", "CC=O") - """ - molecule_and_csv_path_dict = {} - csv_cache = prepare_paths(cache) - - # Build reaction and reactants - rxn = build_reaction(rxn_smarts) - mol_reactant_1, mol_reactant_2 = build_reactants(reactant_smiles_1, reactant_smiles_2) - reaction_tuple = [[mol_reactant_1, mol_reactant_2]] - delete_atoms = True # Default to identifying byproducts - - # Process the reaction - mols, molecule_and_csv_path_dict = process_reactions( - rxn, csv_cache, reaction_tuple, None, molecule_and_csv_path_dict, delete_atoms - ) - - # Save outputs - save_grid_image(mols, cache, None) - - return molecule_and_csv_path_dict - - -if __name__ == "__main__": - """ - Main execution block with example reaction data. - - This demonstrates the usage of the module with example polyesterification - reactions between hydroxy carboxylic acids. - """ - - # Example reaction database for polyesterification reactions - detected_reactions = { - 1: { - "reaction_name": "Hydroxy Carboxylic Acid Polycondensation(Polyesterification)", - "same_reactants": True, - "reactant_1": "hydroxy_carboxylic_acid", - "product": "polyester_chain", - "delete_atom": True, - "reaction": "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[OX2H1:4]>>[OX2:1]-[CX3:2](=[O:5]).[O:4]-[H:3]", - "reference": { - "smarts": "https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329", - "reaction_and_mechanism": [ - "https://pubs.acs.org/doi/10.1021/ed048pA734.1", - "https://pubs.acs.org/doi/10.1021/ed073pA312", - ], - }, - "monomer_1": { - "smiles": "O=C(O)c1cc(O)c(Cl)c(C(=O)O)c1", - "functionality_type": "di_different", - "functional_group_name": "hydroxy_carboxylic_acid", - "functional_group_smarts_1": "[OX2H1;!$(OC=*):1]", - "functional_count_1": 1, - "functional_group_smarts_2": "[CX3:2](=[O])[OX2H1]", - "functional_count_2": 2, - }, - }, - 2: { - "reaction_name": "Hydroxy Carboxylic Acid Polycondensation(Polyesterification)", - "same_reactants": True, - "reactant_1": "hydroxy_carboxylic_acid", - "product": "polyester_chain", - "delete_atom": True, - "reaction": "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[OX2H1:4]>>[OX2:1]-[CX3:2](=[O:5]).[O:4]-[H:3]", - "reference": { - "smarts": "https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329", - "reaction_and_mechanism": [ - "https://pubs.acs.org/doi/10.1021/ed048pA734.1", - "https://pubs.acs.org/doi/10.1021/ed073pA312", - ], - }, - "monomer_1": { - "smiles": "O=C(O)CCCC(O)CCCO", - "functionality_type": "di_different", - "functional_group_name": "hydroxy_carboxylic_acid", - "functional_group_smarts_1": "[OX2H1;!$(OC=*):1]", - "functional_count_1": 2, - "functional_group_smarts_2": "[CX3:2](=[O])[OX2H1]", - "functional_count_2": 1, - }, - }, - 3: { - "reaction_name": "Hydroxy Carboxylic and Hydroxy Carboxylic Polycondensation(Polyesterification)", - "same_reactants": False, - "reactant_1": "hydroxy_carboxylic_acid", - "reactant_2": "hydroxy_carboxylic_acid", - "product": "polyester_chain", - "delete_atom": True, - "reaction": "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[OX2H1:4]>>[OX2:1]-[CX3:2](=[O:5]).[O:4]-[H:3]", - "reference": { - "smarts": "https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329", - "reaction_and_mechanism": [ - "https://pubs.acs.org/doi/10.1021/ed048pA734.1", - "https://pubs.acs.org/doi/10.1021/ed073pA312", - ], - }, - "monomer_1": { - "smiles": "O=C(O)c1cc(O)c(Cl)c(C(=O)O)c1", - "functionality_type": "di_different", - "functional_group_name": "hydroxy_carboxylic_acid", - "functional_group_smarts_1": "[OX2H1;!$(OC=*):1]", - "functional_count_1": 1, - "functional_group_smarts_2": "[CX3:2](=[O])[OX2H1]", - "functional_count_2": 2, - }, - "monomer_2": { - "smiles": "O=C(O)CCCC(O)CCCO", - "functionality_type": "di_different", - "functional_group_name": "hydroxy_carboxylic_acid", - "functional_group_smarts_1": "[OX2H1;!$(OC=*):1]", - "functional_count_1": 2, - "functional_group_smarts_2": "[CX3:2](=[O])[OX2H1]", - "functional_count_2": 1, - }, - }, - } - - # Configuration parameters - cache = "C:\\Users\\Janitha\\Documents\\GitHub\\reaction_lammps_mupt\\cache\\00_cache" - rxn_smarts = "[O;!$(OC=*):1]-[H:3].[CX3:2](=[O:5])[OX2H1:4]>>[OX2:1]-[CX3:2](=[O:5]).[O:4]-[H:3]" - reactant_smiles_1 = "O=C(O)c1cc(O)c(Cl)c(C(=O)O)c1" - reactant_smiles_2 = "O=C(O)CCCC(O)CCCO" - - # Execute the reaction processing pipeline - print("Starting reaction processing pipeline...") - - # Process a single reaction using run_all - # run_all(cache, rxn_smarts, reactant_smiles_1, reactant_smiles_2) - - # Process all reactions in the dictionary - molecule_dict_csv_path_dict, detected_reactions, molecule_images = process_reaction_dict(detected_reactions, cache) - - # Display results - import pprint - print("\n" + "="*80) - print("REACTION PROCESSING RESULTS") - print("="*80) - pprint.pprint(molecule_dict_csv_path_dict) - - print("\n" + "="*80) - print("SUMMARY") - print("="*80) - print(f"Total reactions processed: {len(molecule_dict_csv_path_dict)}") - - # Count total products across all reactions - print("\nProcessing complete! CSV files and images have been saved to the cache directory.") + """ + Apply atom mapping from SMARTS template to reactant molecule based on match indices. + + This function transfers atom map numbers from a SMARTS template to corresponding + atoms in the reactant molecule using the provided match tuple that maps SMARTS + atom indices to reactant atom indices. + + Args: + reactant (Chem.Mol): The reactant molecule to apply mapping to + smarts_template (Chem.Mol): SMARTS pattern molecule with atom map numbers + match_tuple (tuple): Tuple mapping SMARTS atom indices to reactant atom indices + + Returns: + None: Modifies the reactant molecule in-place by setting atom map numbers + + Note: + Only atoms with non-zero map numbers in the SMARTS template are processed. + The function does nothing if match_tuple is empty. + """ + if not match_tuple: + return + + # Create mapping from SMARTS atom indices to their map numbers + SMARTS_index_to_Map_Number = {} + for smarts_atom in smarts_template.GetAtoms(): + map_num = smarts_atom.GetAtomMapNum() + if map_num != 0: # Only process atoms with explicit mapping + SMARTS_index_to_Map_Number[smarts_atom.GetIdx()] = map_num + + # Apply mapping to corresponding atoms in reactant + for smarts_pos, map_num in SMARTS_index_to_Map_Number.items(): + if smarts_pos < len(match_tuple): + atom_index_in_mol = match_tuple[smarts_pos] + atom = reactant.GetAtomWithIdx(atom_index_in_mol) + atom.SetAtomMapNum(map_num) \ No newline at end of file diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index ecd41d1..48c62d1 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -23,10 +23,13 @@ from AutoREACTER.detectors.reaction_detector import ReactionInstance from AutoREACTER.reaction_preparation.reaction_processor.atom_mapping import smart_mapping -from AutoREACTER.reaction_preparation.reaction_processor.utils import compare_products +from AutoREACTER.reaction_preparation.reaction_processor.utils import ( + add_dict_as_new_columns, add_column_safe, compare_set, prepare_paths +) from AutoREACTER.reaction_preparation.reaction_processor.walker import reaction_atom_walker + class MappingError(Exception): """Custom exception raised when atom mapping between reactants and products fails or is inconsistent.""" @@ -95,9 +98,9 @@ def __init__(self, cache: Path): cache: Path to the base cache directory for storing processed reaction data. """ self.cache = Path(cache) - self.csv_cache = self._prepare_paths() + self.csv_cache = prepare_paths(self.cache, "csv_cache") - def run_reaction_template_pipeline(self, detected_reactions_dict, cache): + def prepare_reactions(self, reaction_instances: list[ReactionInstance]) -> list[ReactionMetadata]: """ Main execution pipeline for mapping reactions, identifying templates, and saving results to CSV. @@ -109,20 +112,23 @@ def run_reaction_template_pipeline(self, detected_reactions_dict, cache): 4. Updates reaction dataframes with mapping indices and saves them. Args: - detected_reactions_dict (dict): Raw dictionary of detected reactions. + reaction_instances (list[ReactionInstance]): List of reaction instances to process. cache (str): Path to the cache directory for processing. Returns: tuple: (updated_molecule_dict, formatted_summary_dict) """ # Initial processing: atom mapping and basic dictionary formatting - reactions_metadata = self.process_reaction_instances(detected_reactions_dict, cache) - + reactions_metadata = self.process_reaction_instances(reaction_instances) + + # Detect duplicates after processing all reactions to ensure comprehensive comparison + reaction_metadata = self._detect_duplicates(reactions_metadata) # Iterate through each detected reaction to perform template analysis for reaction in reactions_metadata: + if not reaction.activity_stats: + continue # Skip reactions marked as duplicates combined_reactant_molecule_object = reaction.reactant_combined_mol - combined_product_molecule_object = reaction.product_combined_mol reaction_dataframe = reaction.reaction_dataframe csv_save_path = reaction.csv_path @@ -138,19 +144,16 @@ def run_reaction_template_pipeline(self, detected_reactions_dict, cache): first_shell, fully_mapped_dict ) - - # Note: Duplicate checking logic is currently commented out but available for future use - # is_duplicate, processed_dict = compare_rdkit_fragments(...) # Update the dataframe with specific template mapping indices - reaction_dataframe = self._add_dict_as_new_columns( + reaction_dataframe = add_dict_as_new_columns( reaction_dataframe, template_mapped_dict, titles = ["template_reactant_idx", "template_product_idx"] ) # Append edge atoms information (crucial for building polymer chains) - reaction_dataframe = self._add_column_safe( + reaction_dataframe = add_column_safe( reaction_dataframe, edge_atoms, "edge_atoms" @@ -162,14 +165,25 @@ def run_reaction_template_pipeline(self, detected_reactions_dict, cache): # Persist the processed reaction data to a CSV file reaction_dataframe.to_csv(csv_save_path, index=False) + reaction.edge_atoms = edge_atoms + reaction.template_reactant_to_product_mapping = template_mapped_dict + + return reaction_metadata + + def _detect_duplicates(self, reaction_metadata_list: list[ReactionMetadata]) -> list[ReactionMetadata]: + unique_metadata: list[ReactionMetadata] = [] + for reaction in reaction_metadata_list: + reactants = reaction.reactant_combined_mol + products = reaction.product_combined_mol - # For debugging: print the final molecule dictionary with CSV paths - # print("Formatted Detected Reactions Summary:") - # print(molecule_dict_csv_path_dict) - return + if compare_set(unique_metadata, reactants, products): + unique_metadata.append(reaction) + else: + reaction.activity_stats = False # mark duplicate reactions with False for activity_stats + return unique_metadata - def process_reaction_instances(self, detected_reactions: list[ReactionInstance], cache : Path) -> list[ReactionInstance]: + def process_reaction_instances(self, detected_reactions: list[ReactionInstance]) -> list[ReactionMetadata]: """ Process a dictionary of detected reactions and generate mapping data. @@ -215,18 +229,17 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance], reaction_tuple = self._build_reaction_tuple(same_reactants, mol_reactant_1, mol_reactant_2) # Process the reaction - reaction_metadata = self._process_reaction_products( + reaction_metadata = self.process_reaction_products( rxn, csv_cache, reaction_tuple, delete_atoms, - reaction_metadata = [] ) all_metadata.extend(reaction_metadata) return all_metadata - def _process_reaction_products(self, + def process_reaction_products(self, rxn: Chem.rdChemReactions.ChemicalReaction, csv_cache: Path, reaction_tuple: list, @@ -354,13 +367,13 @@ def _process_reaction_products(self, atom indices so that downstream processes, such as the atom walker, can identify reaction templates and edge atoms. """ # Apply SMARTS-based mapping for THIS combination - self._smart_mapping( + smart_mapping( reactant=r1_copy, smarts_template=rxn.GetReactants()[0], match_tuple=match1 if match1 else (), ) - self._smart_mapping( + smart_mapping( reactant=r2_copy, smarts_template=rxn.GetReactants()[1], match_tuple=match2 if match2 else (), @@ -502,98 +515,7 @@ def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] - - def _add_dict_as_new_columns(self, df_existing, data_dict, titles=["template_reactant_idx", "template_product_idx"]): - """ - Adds dictionary keys and values as new columns to an existing DataFrame. - - This is specifically used to map reactant indices to product indices - within the reaction template. - - Args: - df_existing (pd.DataFrame): The DataFrame to modify. - data_dict (dict): Dictionary where keys and values will become column data. - titles (list): List of two strings for the new column names. - - Returns: - pd.DataFrame: The modified DataFrame with new columns added. - """ - # Convert dict keys and values to Series to ensure alignment with the DataFrame - # Use .astype("Int64") to allow for potential Null/NaN values while keeping integers - df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") - df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") - - return df_existing - - - def _add_column_safe(self, df, list_data, column_name): - """ - Safely adds a list as a new column to a DataFrame, handling potential - length mismatches by using Series alignment. - - Args: - df (pd.DataFrame): Target DataFrame. - list_data (list): Data to be added to the column. - column_name (str): Name of the new column. - - Returns: - pd.DataFrame: Modified DataFrame with the new column. - """ - # Creating a Series from the list ensures it starts from the top (index 0) - # and fills missing rows with NaN if the list is shorter than the DataFrame - df[column_name] = pd.Series(list_data).astype("Int64") - return df - def _extract_unique_references(self, detected_reactions: List[ReactionInstance]) -> list[str]: - """Collect reference URLs from detected_reactions[*]["reference"], dedupe, keep order.""" - - seen = set() - refs: list[str] = [] - - for metadata in detected_reactions: - ref = metadata.reference or {} - - # single URL fields - for v in ref.values(): - if isinstance(v, str): - if v not in seen: - seen.add(v) - refs.append(v) - - # list-of-URLs fields - elif isinstance(v, (list, tuple)): - for u in v: - if isinstance(u, str) and u not in seen: - seen.add(u) - refs.append(u) - - # (optional) nested dict handling, if you ever add that later - elif isinstance(v, dict): - for u in v.values(): - if isinstance(u, str) and u not in seen: - seen.add(u) - refs.append(u) - - return refs - - def _prepare_paths(self): - """ - Create and prepare directory structure for CSV output files. - - Args: - cache (str or Path): Base cache directory path - - Returns: - Path: Path object pointing to the CSV cache directory - - Example: - >>> csv_dir = prepare_paths("/path/to/cache") - >>> print(csv_dir) # /path/to/cache/csv - """ - csv_cache = Path(self.cache) / "reactant_product_mapping" - os.makedirs(csv_cache, exist_ok=True) - return csv_cache - def _build_reaction(self, rxn_smarts): """ Create an RDKit reaction object from SMARTS string. @@ -662,43 +584,6 @@ def _is_initiator_in_set(self, set_of_tuples, reactant): raise ValueError("No matching atom found in the provided set of tuples.") - def _smart_mapping(self, reactant, smarts_template, match_tuple): - """ - Apply atom mapping from SMARTS template to reactant molecule based on match indices. - - This function transfers atom map numbers from a SMARTS template to corresponding - atoms in the reactant molecule using the provided match tuple that maps SMARTS - atom indices to reactant atom indices. - - Args: - reactant (Chem.Mol): The reactant molecule to apply mapping to - smarts_template (Chem.Mol): SMARTS pattern molecule with atom map numbers - match_tuple (tuple): Tuple mapping SMARTS atom indices to reactant atom indices - - Returns: - None: Modifies the reactant molecule in-place by setting atom map numbers - - Note: - Only atoms with non-zero map numbers in the SMARTS template are processed. - The function does nothing if match_tuple is empty. - """ - if not match_tuple: - return - - # Create mapping from SMARTS atom indices to their map numbers - SMARTS_index_to_Map_Number = {} - for smarts_atom in smarts_template.GetAtoms(): - map_num = smarts_atom.GetAtomMapNum() - if map_num != 0: # Only process atoms with explicit mapping - SMARTS_index_to_Map_Number[smarts_atom.GetIdx()] = map_num - - # Apply mapping to corresponding atoms in reactant - for smarts_pos, map_num in SMARTS_index_to_Map_Number.items(): - if smarts_pos < len(match_tuple): - atom_index_in_mol = match_tuple[smarts_pos] - atom = reactant.GetAtomWithIdx(atom_index_in_mol) - atom.SetAtomMapNum(map_num) - def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], diff --git a/AutoREACTER/reaction_preparation/reaction_processor/utils.py b/AutoREACTER/reaction_preparation/reaction_processor/utils.py index 9922b22..b2a8401 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/utils.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/utils.py @@ -1,51 +1,105 @@ from rdkit import Chem +import pandas as pd +from typing import List +from pathlib import Path +import os -def compare_products(reactions_dict, _prod2): - """ - Compares a new product molecule against a collection of existing products - to identify duplicates, ignoring atom mapping. +from AutoREACTER.detectors.reaction_detector import ReactionInstance +def prepare_paths( cache, subdir): + """ + Create and prepare directory structure for CSV output files. + Args: - reactions_dict (dict): A dictionary where values are dictionaries - potentially containing a "product" RDKit molecule object. - _prod2 (rdkit.Chem.rdchem.Mol): The RDKit molecule object to check for duplicates. - + cache (str or Path): Base cache directory path + Returns: - bool: Returns False if a duplicate product is found, True otherwise. + Path: Path object pointing to the CSV cache directory + + Example: + >>> csv_dir = prepare_paths("/path/to/cache") + >>> print(csv_dir) # /path/to/cache/csv + """ + csv_cache = Path(cache) / subdir + os.makedirs(csv_cache, exist_ok=True) + return csv_cache + +def add_dict_as_new_columns(df_existing, data_dict, titles=("template_reactant_idx", "template_product_idx")): + df_existing[titles[0]] = pd.Series(list(data_dict.keys())).astype("Int64") + df_existing[titles[1]] = pd.Series(list(data_dict.values())).astype("Int64") + return df_existing + + +def add_column_safe(df, list_data, column_name): + df[column_name] = pd.Series(list_data).astype("Int64") + return df + + +def extract_unique_references(detected_reactions: List[ReactionInstance]) -> list[str]: + seen = set() + refs = [] + + for metadata in detected_reactions: + ref = metadata.reference or {} + + for v in ref.values(): + if isinstance(v, str): + if v not in seen: + seen.add(v) + refs.append(v) + + elif isinstance(v, (list, tuple)): + for u in v: + if isinstance(u, str) and u not in seen: + seen.add(u) + refs.append(u) + + elif isinstance(v, dict): + for u in v.values(): + if isinstance(u, str) and u not in seen: + seen.add(u) + refs.append(u) + + return refs + +def compare_set(reaction_metadata_list, _react2, _prod2): """ - # Create a copy of the input molecule to avoid modifying the original object + Compare reactant + product pair against existing reactions. + Ignores atom mapping. + + Returns False if duplicate pair found. + """ + + # normalize new pair + react2 = Chem.Mol(_react2) prod2 = Chem.Mol(_prod2) - - for key, dict_2 in reactions_dict.items(): - # Retrieve the product molecule from the nested dictionary - prod = dict_2.get("product") - - if prod is not None: - # Create a copy of the stored product for comparison - prod1 = Chem.Mol(prod) - - # Remove atom map numbers from both molecules. - # Atom maps are often used in reactions to track atoms but should be - # ignored when checking if two chemical structures are identical. - for atom in prod1.GetAtoms(): - atom.SetAtomMapNum(0) - for atom in prod2.GetAtoms(): - atom.SetAtomMapNum(0) - - # Convert both molecules to canonical SMILES strings. - # Canonicalization ensures that the same molecule always results in the same string. - smi1 = Chem.MolToSmiles(prod1, canonical=True) - smi2 = Chem.MolToSmiles(prod2, canonical=True) - - # Perform string comparison to detect duplicates - if smi1 == smi2: - # Debug print to indicate a duplicate was found (can be commented out in production) - # print("DUPLICATE PRODUCT FOUND") - return False - - # No duplicates found after checking all entries + + for atom in react2.GetAtoms(): + atom.SetAtomMapNum(0) + for atom in prod2.GetAtoms(): + atom.SetAtomMapNum(0) + + smi_r2 = Chem.MolToSmiles(react2, canonical=True) + smi_p2 = Chem.MolToSmiles(prod2, canonical=True) + + for metadata in reaction_metadata_list: + react1 = Chem.Mol(metadata.reactant_combined_mol) + prod1 = Chem.Mol(metadata.product_combined_mol) + + for atom in react1.GetAtoms(): + atom.SetAtomMapNum(0) + for atom in prod1.GetAtoms(): + atom.SetAtomMapNum(0) + + smi_r1 = Chem.MolToSmiles(react1, canonical=True) + smi_p1 = Chem.MolToSmiles(prod1, canonical=True) + + if smi_r1 == smi_r2 and smi_p1 == smi_p2: + return False + return True + def compare_rdkit_molecules_canonical(data_smiles_list, mol_smi_2): """ Compares two RDKit molecule SMILES strings to determine if they @@ -80,75 +134,7 @@ def compare_rdkit_molecules_canonical(data_smiles_list, mol_smi_2): data_smiles_list.append(mol_smi_2) return data_smiles_list, False -def format_detected_reactions_dict(detected_reactions, non_monomer_molecules_to_retain = None): - """ - Aggregates and formats information from a dictionary of detected reactions - into a single summary dictionary. - - This function compiles unique reaction names, SMARTS references, and - mechanism references into comma-separated strings. - - Args: - detected_reactions (dict): A dictionary containing reaction data, - where each value is a dictionary with keys - like "reaction_name" and "reference". - - Returns: - dict: A dictionary containing aggregated strings for: - - "reactions_names" - - "smart_references" - - "mechanism_references" - """ - reactions_names = [] - smart_references = [] - mechanism_references = [] - seen_reactions = set() - seen_smarts = set() - seen_mechanisms = set() - - formatted_dict = {} - data_smiles_list = [] - - for key, reaction in detected_reactions.items(): - # Deduplicate reaction names safely (no substring bugs) - reactions_name = reaction.get("reaction_name") - if reactions_name and reactions_name not in seen_reactions: - seen_reactions.add(reactions_name) - reactions_names.append(reactions_name) - - # Reference is optional; do not skip monomer processing if missing - reference = reaction.get("reference") or {} - smarts_ref = reference.get("smarts") - mech_refs = reference.get("reaction_and_mechanism") - - if smarts_ref and smarts_ref not in seen_smarts: - seen_smarts.add(smarts_ref) - smart_references.append(smarts_ref) - - if mech_refs: - mech_block = ", ".join(mech_refs) - if mech_block and mech_block not in seen_mechanisms: - seen_mechanisms.add(mech_block) - mechanism_references.append(mech_block) - - # Always process monomers (if present) - m1 = reaction.get("monomer_1") - m2 = reaction.get("monomer_2") - m1_smiles = m1.get("smiles") if isinstance(m1, dict) else None - m2_smiles = m2.get("smiles") if isinstance(m2, dict) else None - - if m1_smiles: - data_smiles_list, _ = compare_rdkit_molecules_canonical(data_smiles_list, m1_smiles) - if m2_smiles: - data_smiles_list, _ = compare_rdkit_molecules_canonical(data_smiles_list, m2_smiles) - - formatted_dict = { - "reactions_names": ", ".join(reactions_names), - "smart_references": ", ".join(smart_references), - "mechanism_references": ", ".join(mechanism_references), - } - return formatted_dict , data_smiles_list def prep_for_3d_molecule_generation(data_smiles_list, molecule_dict_csv_path_dict): molecule_dict = {} From dab774245d1fd0462b8698de88bf08e590ee52b9 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 24 Mar 2026 20:16:40 -0400 Subject: [PATCH 15/26] Move same_reactants to ReactionInstance --- AutoREACTER/detectors/reaction_detector.py | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) diff --git a/AutoREACTER/detectors/reaction_detector.py b/AutoREACTER/detectors/reaction_detector.py index 713ab31..5b16523 100644 --- a/AutoREACTER/detectors/reaction_detector.py +++ b/AutoREACTER/detectors/reaction_detector.py @@ -58,20 +58,8 @@ class EmptyReactionListError(Exception): This should be prevented by the reaction_selection method, but this error serves as a safeguard.""" pass -@dataclass(slots=True, frozen=True) -class ReactionTemplate: - """ - Defines a generic template for a polymerization reaction. - """ - reaction_name: str - reactant_1: str # functional group name - reactant_2: Optional[str] # functional group name or None - reaction_smarts: str - same_reactants: bool - delete_atom: bool - references: dict -@dataclass(slots=True, frozen=True) +@dataclass(slots=True) class ReactionInstance: """ Represents a specific instance of a reaction between identified monomers. @@ -90,6 +78,7 @@ class ReactionInstance: reaction_smarts: str delete_atom: bool references: dict + same_reactants: bool monomer_1: MonomerRole functional_group_1: FunctionalGroupInfo monomer_2: Optional[MonomerRole] = None @@ -172,6 +161,7 @@ def reaction_detector(self, monomer_roles: List[MonomerRole]) -> List[ReactionIn reaction_smarts=reaction_info["reaction"], delete_atom=reaction_info["delete_atom"], references=reaction_info["reference"], + same_reactants=same_reactants, monomer_1=monomer_role, functional_group_1=fg ) @@ -202,6 +192,7 @@ def reaction_detector(self, monomer_roles: List[MonomerRole]) -> List[ReactionIn reaction_smarts=reaction_info["reaction"], delete_atom=reaction_info["delete_atom"], references=reaction_info["reference"], + same_reactants=same_reactants, monomer_1=monomer_role_i, functional_group_1=fg_i, monomer_2=monomer_role_j, @@ -235,6 +226,7 @@ def reaction_detector(self, monomer_roles: List[MonomerRole]) -> List[ReactionIn reaction_smarts=reaction_info["reaction"], delete_atom=reaction_info["delete_atom"], references=reaction_info["reference"], + same_reactants=same_reactants, monomer_1=monomer_role, functional_group_1=fg_1, monomer_2=monomer_role, From 456473fbbe75c1a5ef6374ff01f43da0ca5a81ea Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 15:56:59 -0400 Subject: [PATCH 16/26] Refactor atom-mapping and add helpers Refactor reaction preparation to simplify and harden atom-mapping. Reactant copies are created once per product set and unique atom map numbers are assigned via _assign_atom_map_numbers (using isotope fields to persist IDs through RDKit reactions). --- .../reaction_processor/prepare_reactions.py | 256 +++++++++--------- 1 file changed, 135 insertions(+), 121 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 48c62d1..eedcee9 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -1,3 +1,4 @@ + """ Module for preparing chemical reactions for analysis, including atom mapping between reactants and products, reaction metadata extraction, and visualization utilities using RDKit. @@ -287,134 +288,149 @@ def process_reaction_products(self, if not products: continue # Skip if no products are generated - - # Get substructure matches for each reactant against reaction templates - matches_1 = r1.GetSubstructMatches(rxn.GetReactants()[0]) - matches_2 = r2.GetSubstructMatches(rxn.GetReactants()[1]) + self._assign_atom_map_numbers(r1, r2) # Assign unique map numbers to reactant atoms to track them through the reaction + # Process each product set generated by the reaction for product_set in products: # loop over ALL match combinations - for match1 in matches_1 if matches_1 else [()]: - for match2 in matches_2 if matches_2 else [()]: - - # IMPORTANT: copy reactants for each combination - r1_copy = Chem.Mol(r1) - r2_copy = Chem.Mol(r2) - - # Clean up any existing DataFrame - if "df" in locals(): - del df - - df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - first_shell = [] - initiator_idxs = [] - mapping_dict = {} - - - # Apply atom mapping from reaction properties - num_total_atoms = 0 - for i, product in enumerate(product_set): - if i > 0: - num_total_atoms += product_set[i - 1].GetNumAtoms() - for atom in product.GetAtoms(): - if atom.HasProp("react_idx"): - r_idx = atom.GetIntProp("react_idx") - a_idx = atom.GetIntProp("react_atom_idx") - r = (r1_copy, r2_copy)[r_idx] - r_atom = r.GetAtomWithIdx(a_idx) - map_num = atom.GetIdx() + num_total_atoms + 101 - r_atom.SetAtomMapNum(map_num) - atom.SetAtomMapNum(map_num) - - # Combine reactants and products - reactant_combined = Chem.CombineMols(r1_copy, r2_copy) - product_combined = Chem.CombineMols(*product_set) - - # Create mapping dictionary and dataframe of reactant to product atom indices - for r_atom in reactant_combined.GetAtoms(): - for p_atom in product_combined.GetAtoms(): - if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): - r_atom_idx = r_atom.GetIdx() - p_atom_idx = p_atom.GetIdx() - mapping_dict[r_atom_idx] = p_atom_idx - new_row = pd.DataFrame([{ - "reactant_idx": r_atom_idx, - "product_idx": p_atom_idx - }]) - df = pd.concat([df, new_row], ignore_index=True) - break - - if not self._validate_mapping(df, reactant_combined, product_combined): - raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") - - # Identify first shell + initiators - for atom in reactant_combined.GetAtoms(): - if atom.GetAtomMapNum() <= 99: - first_shell.append(atom.GetIdx()) - if atom.GetAtomMapNum() in [1, 2]: - initiator_idxs.append(atom.GetIdx()) - - if len(initiator_idxs) != 2: - raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") - - """ - This step enforces SMARTS-based atom mapping onto the reactants using selected substructure matches. - It assigns atom map numbers from the SMARTS template to corresponding atoms in the reactants, ensuring - consistent labeling of reaction centers. - - For each reactant, one matching substructure is selected and used to apply mapping. This helps standardize - atom indices so that downstream processes, such as the atom walker, can identify reaction templates and edge atoms. - """ - # Apply SMARTS-based mapping for THIS combination - smart_mapping( - reactant=r1_copy, - smarts_template=rxn.GetReactants()[0], - match_tuple=match1 if match1 else (), - ) - smart_mapping( - reactant=r2_copy, - smarts_template=rxn.GetReactants()[1], - match_tuple=match2 if match2 else (), - ) + # IMPORTANT: copy reactants for each combination + r1_copy = Chem.Mol(r1) + r2_copy = Chem.Mol(r2) + + + df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) + first_shell = [] + initiator_idxs = [] + mapping_dict = {} + - # Byproduct detection - byproduct_reactant_idxs = [] - - if delete_atoms: - byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) - - # Build dataframe - df_combined = pd.concat([ - df, - pd.Series(first_shell, name="first_shell"), - pd.Series(initiator_idxs, name="initiators"), - pd.Series(byproduct_reactant_idxs, name="byproduct_idx") - ], axis=1).astype(pd.Int64Dtype()) - - total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 - - df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) - reaction_metadata.append( - ReactionMetadata( - reaction_id = total_products, - reactant_combined_mol = reactant_combined, - product_combined_mol = product_combined, - reactant_to_product_mapping = mapping_dict, - first_shell = first_shell, - initiators = initiator_idxs, - byproduct_indices = byproduct_reactant_idxs, - csv_path = csv_cache / f"reaction_{total_products}.csv", - reaction_dataframe = df_combined, - delete_atom = delete_atoms, - delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, - activity_stats = True - ) + # Step 2: combine for reactant→product mapping + reactant_combined = Chem.CombineMols(r1_copy, r2_copy) + product_combined = Chem.CombineMols(*product_set) + + # Restore Atom Map Numbers from Isotopes in the products + """surviving_idx = atom.GetIsotope() + inside the atom's "Isotope" property because RDKit's + reaction engine wouldn't delete them there. + Here, we are opening up that safe box to retrieve the ID.""" + for atom in product_combined.GetAtoms(): + surviving_idx = atom.GetIsotope() + if surviving_idx != 0: + atom.SetAtomMapNum(surviving_idx) # Restore map number + atom.SetIsotope(0) # Clear isotope to restore normal chemistry + + for p_atom in product_combined.GetAtoms(): + p_map_num = p_atom.GetAtomMapNum() + for r_atom in reactant_combined.GetAtoms(): + if r_atom.GetAtomMapNum() == p_map_num: + mapping_dict[r_atom.GetIdx()] = p_atom.GetIdx() + df = pd.concat([df, pd.DataFrame([{"reactant_idx": r_atom.GetIdx(), "product_idx": p_atom.GetIdx()}])], ignore_index=True) + + self._reveal_template_map_numbers(product_combined) # Make map numbers visible for debugging and visualization + + # Validate the mapping to ensure consistency before proceeding + if not self._validate_mapping(df, reactant_combined, product_combined): + raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") + + + for p_atom in product_combined.GetAtoms(): + if p_atom.GetAtomMapNum() < 999: # Only print mapped atoms (those with our custom map numbers) + found_keys = [key for key, val in mapping_dict.items() if val == p_atom.GetIdx()] + if len(found_keys) > 1 or len(found_keys) == 0: + raise ValueError(f"Mapping error for product atom {p_atom.GetIdx()}: found keys {found_keys}") + first_shell.append(found_keys[0]) # Assuming one-to-one mapping, take the first key + if p_atom.GetAtomMapNum() in [1, 2] : + initiator_idxs.append(found_keys[0]) + """ + This step enforces SMARTS-based atom mapping onto the reactants using selected substructure matches. + It assigns atom map numbers from the SMARTS template to corresponding atoms in the reactants, ensuring + consistent labeling of reaction centers. + + For each reactant, one matching substructure is selected and used to apply mapping. This helps standardize + atom indices so that downstream processes, such as the atom walker, can identify reaction templates and edge atoms. + """ + + # Identify first shell + initiators + for atom in reactant_combined.GetAtoms(): + if atom.GetAtomMapNum() <= 999: # Only consider original reactant atoms, not template-mapped ones + first_shell.append(atom.GetIdx()) + if atom.GetAtomMapNum() in [1, 2]: + initiator_idxs.append(atom.GetIdx()) + + if len(initiator_idxs) != 2: + raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") + + # Byproduct detection + byproduct_reactant_idxs = [] + + if delete_atoms: + byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) + + # Build dataframe + df_combined = pd.concat([ + df, + pd.Series(first_shell, name="first_shell"), + pd.Series(initiator_idxs, name="initiators"), + pd.Series(byproduct_reactant_idxs, name="byproduct_idx") + ], axis=1).astype(pd.Int64Dtype()) + + total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 + + df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) + reaction_metadata.append( + ReactionMetadata( + reaction_id = total_products, + reactant_combined_mol = reactant_combined, + product_combined_mol = product_combined, + reactant_to_product_mapping = mapping_dict, + first_shell = first_shell, + initiators = initiator_idxs, + byproduct_indices = byproduct_reactant_idxs, + csv_path = csv_cache / f"reaction_{total_products}.csv", + reaction_dataframe = df_combined, + delete_atom = delete_atoms, + delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, + activity_stats = True ) + ) return reaction_metadata + def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: + '''Make map numbers assigned to products of reaction visible for display''' + for atom in mol.GetAtoms(): + if atom.HasProp('old_mapno'): # RDKit sets certain "magic" properties post-reaction, including map numbers and reactant atom indices + map_num = atom.GetIntProp('old_mapno') + atom.SetAtomMapNum(map_num) + + def _assign_atom_map_numbers(self, r1_copy: Chem.Mol, r2_copy: Chem.Mol) -> None: + for atom in r1_copy.GetAtoms(): + idx = 1001 + atom.GetIdx() + atom.SetAtomMapNum(idx) + atom.SetIsotope(idx) # The isotope is what will survive the reaction! + + for atom in r2_copy.GetAtoms(): + idx = 2001 + atom.GetIdx() + atom.SetAtomMapNum(idx) + atom.SetIsotope(idx) # The isotope is what will survive the reaction! + + def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol, mapping_dict: dict[int, int], df: pd.DataFrame) -> tuple[pd.DataFrame, dict[int, int]]: + for r_atom in reactant_combined.GetAtoms(): + for p_atom in product_combined.GetAtoms(): + if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): + r_atom_idx = r_atom.GetIdx() + p_atom_idx = p_atom.GetIdx() + mapping_dict[r_atom_idx] = p_atom_idx + new_row = pd.DataFrame([{ + "reactant_idx": r_atom_idx, + "product_idx": p_atom_idx + }]) + df = pd.concat([df, new_row], ignore_index=True) + break + return df, mapping_dict + def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): return False @@ -658,6 +674,4 @@ def reaction_templates_highlighted_image_grid( subImgSize=(400, 400), useSVG=False, ) - return img - - + return img \ No newline at end of file From f671ca08003b7898fc20e27e382a51f6be83c0fe Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:01:59 -0400 Subject: [PATCH 17/26] Sync atom map numbers and clear isotopes Ensure reactant atoms receive the same atom map numbers as their mapped product atoms for correct visualization. Add a new _clear_isotopes(mol1, mol2) helper and call it before saving CSVs to reset isotopes used as temporary custom IDs and restore normal chemistry. Simplify total_products computation and rename parameters in _assign_atom_map_numbers for clarity. --- .../reaction_processor/prepare_reactions.py | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index eedcee9..be4fe9d 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -334,12 +334,13 @@ def process_reaction_products(self, if not self._validate_mapping(df, reactant_combined, product_combined): raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") - for p_atom in product_combined.GetAtoms(): if p_atom.GetAtomMapNum() < 999: # Only print mapped atoms (those with our custom map numbers) found_keys = [key for key, val in mapping_dict.items() if val == p_atom.GetIdx()] if len(found_keys) > 1 or len(found_keys) == 0: raise ValueError(f"Mapping error for product atom {p_atom.GetIdx()}: found keys {found_keys}") + atom = reactant_combined.GetAtomWithIdx(found_keys[0]) + atom.SetAtomMapNum(p_atom.GetAtomMapNum()) # Ensure reactant atom has the same map number for visualization first_shell.append(found_keys[0]) # Assuming one-to-one mapping, take the first key if p_atom.GetAtomMapNum() in [1, 2] : initiator_idxs.append(found_keys[0]) @@ -376,7 +377,9 @@ def process_reaction_products(self, pd.Series(byproduct_reactant_idxs, name="byproduct_idx") ], axis=1).astype(pd.Int64Dtype()) - total_products = len(reaction_metadata) + 1 if reaction_metadata else 1 + total_products = len(reaction_metadata) + 1 + + self._clear_isotopes(reactant_combined, product_combined) # Clear isotopes to restore normal chemistry before saving df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) reaction_metadata.append( @@ -398,6 +401,13 @@ def process_reaction_products(self, return reaction_metadata + def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: + '''Clear isotopes from a molecule to restore normal chemistry after using isotopes to store custom IDs''' + for atom in mol_1.GetAtoms(): + atom.SetIsotope(0) + for atom in mol_2.GetAtoms(): + atom.SetIsotope(0) + def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: '''Make map numbers assigned to products of reaction visible for display''' for atom in mol.GetAtoms(): @@ -405,13 +415,13 @@ def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: map_num = atom.GetIntProp('old_mapno') atom.SetAtomMapNum(map_num) - def _assign_atom_map_numbers(self, r1_copy: Chem.Mol, r2_copy: Chem.Mol) -> None: - for atom in r1_copy.GetAtoms(): + def _assign_atom_map_numbers(self, r1: Chem.Mol, r2: Chem.Mol) -> None: + for atom in r1.GetAtoms(): idx = 1001 + atom.GetIdx() atom.SetAtomMapNum(idx) atom.SetIsotope(idx) # The isotope is what will survive the reaction! - for atom in r2_copy.GetAtoms(): + for atom in r2.GetAtoms(): idx = 2001 + atom.GetIdx() atom.SetAtomMapNum(idx) atom.SetIsotope(idx) # The isotope is what will survive the reaction! From efbfbb79387d3a665f561d564af06a9815e7359c Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:21:13 -0400 Subject: [PATCH 18/26] Refactor reaction mapping and helper functions Restructure PrepareReactions by extracting and consolidating atom-mapping logic into helper methods (_reassign_atom_map_numbers_by_isotope, _build_atom_index_mapping, _assign_first_shell_and_initiators). --- .../reaction_processor/prepare_reactions.py | 406 +++++------------- 1 file changed, 103 insertions(+), 303 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index be4fe9d..cd43c16 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -23,7 +23,6 @@ import pandas as pd from AutoREACTER.detectors.reaction_detector import ReactionInstance -from AutoREACTER.reaction_preparation.reaction_processor.atom_mapping import smart_mapping from AutoREACTER.reaction_preparation.reaction_processor.utils import ( add_dict_as_new_columns, add_column_safe, compare_set, prepare_paths ) @@ -41,29 +40,6 @@ class SMARTSParsingError(Exception): @dataclass(slots=True) class ReactionMetadata: - """ - Dataclass holding comprehensive metadata for a processed reaction instance. - - Attributes: - reaction_id: Unique identifier for the reaction instance. - reactant_combined_mol: RDKit Mol object combining all reactant molecules. - product_combined_mol: RDKit Mol object combining all product molecules. - reactant_to_product_mapping: Dictionary mapping reactant atom indices to product atom indices. - template_reactant_to_product_mapping: Dictionary mapping template-matched reactant atoms to products. - edge_atoms: List of atom indices on the 'edge' of the reaction (e.g., involved in changes). - first_shell: List of atoms in the first coordination shell around reaction centers (optional). - initiators: List of initiator atom indices (typically 2 per reaction). - byproduct_indices: List of byproduct atom indices (optional). - reaction_smarts: Original reaction SMARTS string (optional). - reactant_smarts: Reactant SMARTS string (optional). - product_smiles: Product SMILES string (optional). - csv_path: Path to CSV file storing reaction mapping data (optional). - mol_3d_path: Path to 3D molecule file (optional). - reaction_dataframe: Pandas DataFrame with detailed atom mapping and features. - delete_atom: Flag indicating if byproduct atoms should be deleted. - delete_atom_idx: Specific index of atom to delete (optional). - activity_stats: Flag for including activity statistics (optional). - """ reaction_id: int reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol @@ -102,23 +78,6 @@ def __init__(self, cache: Path): self.csv_cache = prepare_paths(self.cache, "csv_cache") def prepare_reactions(self, reaction_instances: list[ReactionInstance]) -> list[ReactionMetadata]: - """ - Main execution pipeline for mapping reactions, identifying templates, - and saving results to CSV. - - Steps: - 1. Maps atoms between reactants and products. - 2. Uses an atom walker to identify the 'reaction center' (template). - 3. Identifies 'edge atoms' that connect the template to the rest of the molecule. - 4. Updates reaction dataframes with mapping indices and saves them. - - Args: - reaction_instances (list[ReactionInstance]): List of reaction instances to process. - cache (str): Path to the cache directory for processing. - - Returns: - tuple: (updated_molecule_dict, formatted_summary_dict) - """ # Initial processing: atom mapping and basic dictionary formatting reactions_metadata = self.process_reaction_instances(reaction_instances) @@ -185,30 +144,8 @@ def _detect_duplicates(self, reaction_metadata_list: list[ReactionMetadata]) -> return unique_metadata def process_reaction_instances(self, detected_reactions: list[ReactionInstance]) -> list[ReactionMetadata]: - """ - Process a dictionary of detected reactions and generate mapping data. - - This is a high-level function that processes multiple reactions defined in - a dictionary structure, handling all steps from SMILES to final CSV output. - - Args: - detected_reactions (list[ReactionInstance]): List of detected reaction instances - cache (Path): Base cache directory for output files - - Returns: - tuple: (molecule_and_csv_path_dict, detected_reactions) - - molecule_and_csv_path_dict: Dictionary with all processed reaction data - - detected_reactions: The original input dictionary (unchanged) - - Example: - >>> reactions_dict = { - ... 1: {"reaction": "[C:1]=[O:2]>>[C:1]-[O:2]", - ... "monomer_1": {"smiles": "CCO"}, ...} - ... } - >>> results, original = process_reaction_instances(reactions_dict, "/path/to/cache") - """ csv_cache = self.csv_cache - all_metadata = [] + reaction_metadata = [] # Process each reaction in the detected reactions class for reaction in detected_reactions: @@ -234,52 +171,19 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance]) rxn, csv_cache, reaction_tuple, - delete_atoms, + delete_atoms, + reaction_metadata ) - all_metadata.extend(reaction_metadata) - return all_metadata + return reaction_metadata def process_reaction_products(self, rxn: Chem.rdChemReactions.ChemicalReaction, csv_cache: Path, reaction_tuple: list, - delete_atoms: bool = True + delete_atoms: bool = True, + reaction_metadata: Optional[list[ReactionMetadata]] = None ) -> list[ReactionMetadata]: - """ - Process chemical reactions, map atoms between reactants and products, and save data. - - This is the main processing function that: - 1. Runs reactions on reactant pairs - 2. Maps atoms between reactants and products - 3. Validates mapping consistency - 4. Saves mapping data to CSV files - 5. Identifies reaction features (first shell, initiators, byproducts) - - Args: - rxn (Chem.rdChemReactions.ChemicalReaction): RDKit reaction object - csv_cache (Path): Directory path for CSV output files - reaction_tuple (list): List of reactant pairs to process - key (str or int, optional): Identifier for the reaction set - molecule_and_csv_path_dict (dict, optional): Dictionary to store results - delete_atoms (bool, optional): Whether to identify byproduct atoms for deletion - - Returns: - tuple: (mols, output, molecule_and_csv_path_dict) - - mols: List of reactant and product molecules for visualization - - output: String output (currently empty, reserved for future use) - - molecule_and_csv_path_dict: Dictionary containing all processed data - - Raises: - ValueError: If mapping validation fails at any step - - Note: - This function performs extensive validation including: - - Atom count consistency between reactants and products - - Consecutive indexing requirements - - Initiator count validation (must be exactly 2) - """ - reaction_metadata = [] # Process each reactant pair in the reaction tuple for pair in reaction_tuple: @@ -301,73 +205,28 @@ def process_reaction_products(self, df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - first_shell = [] - initiator_idxs = [] - mapping_dict = {} - # Step 2: combine for reactant→product mapping reactant_combined = Chem.CombineMols(r1_copy, r2_copy) product_combined = Chem.CombineMols(*product_set) # Restore Atom Map Numbers from Isotopes in the products - """surviving_idx = atom.GetIsotope() - inside the atom's "Isotope" property because RDKit's - reaction engine wouldn't delete them there. - Here, we are opening up that safe box to retrieve the ID.""" - for atom in product_combined.GetAtoms(): - surviving_idx = atom.GetIsotope() - if surviving_idx != 0: - atom.SetAtomMapNum(surviving_idx) # Restore map number - atom.SetIsotope(0) # Clear isotope to restore normal chemistry + self._reassign_atom_map_numbers_by_isotope(product_combined) - for p_atom in product_combined.GetAtoms(): - p_map_num = p_atom.GetAtomMapNum() - for r_atom in reactant_combined.GetAtoms(): - if r_atom.GetAtomMapNum() == p_map_num: - mapping_dict[r_atom.GetIdx()] = p_atom.GetIdx() - df = pd.concat([df, pd.DataFrame([{"reactant_idx": r_atom.GetIdx(), "product_idx": p_atom.GetIdx()}])], ignore_index=True) - + mapping_dict, df = self._build_atom_index_mapping(reactant_combined, product_combined) # Build mapping dictionary and dataframe of reactant to product atom indices based on map numbers + self._reveal_template_map_numbers(product_combined) # Make map numbers visible for debugging and visualization # Validate the mapping to ensure consistency before proceeding if not self._validate_mapping(df, reactant_combined, product_combined): raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") - for p_atom in product_combined.GetAtoms(): - if p_atom.GetAtomMapNum() < 999: # Only print mapped atoms (those with our custom map numbers) - found_keys = [key for key, val in mapping_dict.items() if val == p_atom.GetIdx()] - if len(found_keys) > 1 or len(found_keys) == 0: - raise ValueError(f"Mapping error for product atom {p_atom.GetIdx()}: found keys {found_keys}") - atom = reactant_combined.GetAtomWithIdx(found_keys[0]) - atom.SetAtomMapNum(p_atom.GetAtomMapNum()) # Ensure reactant atom has the same map number for visualization - first_shell.append(found_keys[0]) # Assuming one-to-one mapping, take the first key - if p_atom.GetAtomMapNum() in [1, 2] : - initiator_idxs.append(found_keys[0]) - """ - This step enforces SMARTS-based atom mapping onto the reactants using selected substructure matches. - It assigns atom map numbers from the SMARTS template to corresponding atoms in the reactants, ensuring - consistent labeling of reaction centers. - - For each reactant, one matching substructure is selected and used to apply mapping. This helps standardize - atom indices so that downstream processes, such as the atom walker, can identify reaction templates and edge atoms. - """ - - # Identify first shell + initiators - for atom in reactant_combined.GetAtoms(): - if atom.GetAtomMapNum() <= 999: # Only consider original reactant atoms, not template-mapped ones - first_shell.append(atom.GetIdx()) - if atom.GetAtomMapNum() in [1, 2]: - initiator_idxs.append(atom.GetIdx()) - - if len(initiator_idxs) != 2: - raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") - - # Byproduct detection - byproduct_reactant_idxs = [] - - if delete_atoms: - byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) + first_shell, initiator_idxs = self._assign_first_shell_and_initiators(reactant_combined, + product_combined, + mapping_dict) + + + byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) # Build dataframe df_combined = pd.concat([ @@ -382,25 +241,93 @@ def process_reaction_products(self, self._clear_isotopes(reactant_combined, product_combined) # Clear isotopes to restore normal chemistry before saving df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) + reaction_metadata.append( - ReactionMetadata( - reaction_id = total_products, - reactant_combined_mol = reactant_combined, - product_combined_mol = product_combined, - reactant_to_product_mapping = mapping_dict, - first_shell = first_shell, - initiators = initiator_idxs, - byproduct_indices = byproduct_reactant_idxs, - csv_path = csv_cache / f"reaction_{total_products}.csv", - reaction_dataframe = df_combined, - delete_atom = delete_atoms, - delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, - activity_stats = True - ) - ) + ReactionMetadata( + reaction_id = total_products, + reactant_combined_mol = reactant_combined, + product_combined_mol = product_combined, + reactant_to_product_mapping = mapping_dict, + first_shell = first_shell, + initiators = initiator_idxs, + byproduct_indices = byproduct_reactant_idxs, + csv_path = csv_cache / f"reaction_{total_products}.csv", + reaction_dataframe = df_combined, + delete_atom = delete_atoms, + delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, + activity_stats = True + ) + ) return reaction_metadata + def _assign_first_shell_and_initiators(self, reactant_combined, product_combined, mapping_dict): + first_shell = [] + initiator_idxs = [] + reversed_mapping_dict = {} + for react_idx, prod_idx in mapping_dict.items(): + reversed_mapping_dict[prod_idx] = react_idx + + + for p_atom in product_combined.GetAtoms(): + if p_atom.GetAtomMapNum() < 999: + + p_idx = p_atom.GetIdx() + + if p_idx not in reversed_mapping_dict: + raise ValueError(f"Mapping error: product atom {p_idx} not found in mapping_dict") + + r_idx = reversed_mapping_dict[p_idx] + + atom = reactant_combined.GetAtomWithIdx(r_idx) + atom.SetAtomMapNum(p_atom.GetAtomMapNum()) + + first_shell.append(r_idx) + + if p_atom.GetAtomMapNum() in [1, 2]: + initiator_idxs.append(r_idx) + if len(initiator_idxs) != 2: + raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") + + return first_shell, initiator_idxs + + def _reassign_atom_map_numbers_by_isotope(self, mol: Chem.Mol) -> None: + """ + surviving_idx = atom.GetIsotope() inside the atom's "Isotope" property because + RDKit's reaction engine wouldn't delete them there. Here, we are opening up that + safe box to retrieve the ID.""" + for atom in mol.GetAtoms(): + surviving_idx = atom.GetIsotope() + if surviving_idx != 0: + atom.SetAtomMapNum(surviving_idx) # Restore map number + atom.SetIsotope(0) # Clear isotope to restore normal chemistry + + def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol) -> tuple[dict[int, int], pd.DataFrame]: + mapping_dict = {} + # Pre-index product atoms by map number (avoids nested loop) + product_map = { + atom.GetAtomMapNum(): atom.GetIdx() + for atom in product_combined.GetAtoms() + if atom.GetAtomMapNum() != 0 + } + rows = [] + for r_atom in reactant_combined.GetAtoms(): + r_map_num = r_atom.GetAtomMapNum() + + if r_map_num != 0 and r_map_num in product_map: + r_idx = r_atom.GetIdx() + p_idx = product_map[r_map_num] + + mapping_dict[r_idx] = p_idx + rows.append({ + "reactant_idx": r_idx, + "product_idx": p_idx + }) + + df = pd.DataFrame(rows) + + return mapping_dict, df + def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: '''Clear isotopes from a molecule to restore normal chemistry after using isotopes to store custom IDs''' for atom in mol_1.GetAtoms(): @@ -426,21 +353,6 @@ def _assign_atom_map_numbers(self, r1: Chem.Mol, r2: Chem.Mol) -> None: atom.SetAtomMapNum(idx) atom.SetIsotope(idx) # The isotope is what will survive the reaction! - def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol, mapping_dict: dict[int, int], df: pd.DataFrame) -> tuple[pd.DataFrame, dict[int, int]]: - for r_atom in reactant_combined.GetAtoms(): - for p_atom in product_combined.GetAtoms(): - if r_atom.GetAtomMapNum() == p_atom.GetAtomMapNum(): - r_atom_idx = r_atom.GetIdx() - p_atom_idx = p_atom.GetIdx() - mapping_dict[r_atom_idx] = p_atom_idx - new_row = pd.DataFrame([{ - "reactant_idx": r_atom_idx, - "product_idx": p_atom_idx - }]) - df = pd.concat([df, new_row], ignore_index=True) - break - return df, mapping_dict - def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): return False @@ -465,30 +377,18 @@ def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, byproduct = [] # reverse mapping: product_idx → reactant_idx - reverse_map = {v: k for k, v in mapping_dict.items()} + reversed_mapping_dict = {} + for react_idx, prod_idx in mapping_dict.items(): + reversed_mapping_dict[prod_idx] = react_idx for atom in smallest.GetAtoms(): p_idx = atom.GetIdx() - if p_idx in reverse_map: - byproduct.append(reverse_map[p_idx]) + if p_idx in reversed_mapping_dict: + byproduct.append(reversed_mapping_dict[p_idx]) return byproduct def _is_consecutive(self, num_list: list[int]) -> bool: - """ - Check if a list of numbers forms a consecutive sequence without gaps. - - Args: - num_list (list): List of integers to check - - Returns: - bool: True if the numbers are consecutive, False otherwise - - Examples: - >>> is_consecutive([1, 2, 3, 4]) # Returns True - >>> is_consecutive([1, 3, 4]) # Returns False - >>> is_consecutive([]) # Returns False - """ if not num_list: return False @@ -497,45 +397,7 @@ def _is_consecutive(self, num_list: list[int]) -> bool: and max(num_list) - min(num_list) + 1 == len(num_list) ) - def _is_number_in_set(self, set_of_tuples, reactant): - """ - Find a tuple in the set that contains atom indices matching specific atom map numbers. - - This function searches for atoms in the reactant molecule that have atom map numbers - 101 or 102, then checks if those atom indices exist in any tuple within the provided set. - - Args: - set_of_tuples (set of tuples): Set of atom index tuples to search through - reactant (Chem.Mol): RDKit molecule object to search for mapped atoms - - Returns: - tuple: The first tuple found containing a matching atom index - - Raises: - ValueError: If no matching atom is found in the provided set of tuples - - Example: - >>> matches = {(0, 1, 2), (3, 4, 5)} - >>> result = self._is_number_in_set(matches, reactant_mol) - """ - for atom in reactant.GetAtoms(): - # Check for specific atom map numbers (101 or 102) - if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: - x = atom.GetIdx() - for t in set_of_tuples: - if x in t: - print(f"Found matching atom index {x} in tuple {t}") - return t - raise ValueError("No matching atom found in the provided set of tuples.") - def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): - """ - Generate reactant pair orderings for reaction processing. - - - For same reactants: only one unique ordering [A, A]. - - For different reactants: return both [A, B] and [B, A] to avoid relying - on reactant ordering and to support order-dependent reaction definitions. - """ if same_reactants: return [[mol_reactant_1, mol_reactant_1]] @@ -543,35 +405,9 @@ def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): def _build_reaction(self, rxn_smarts): - """ - Create an RDKit reaction object from SMARTS string. - - Args: - rxn_smarts (str): Reaction SMARTS string - - Returns: - Chem.rdChemReactions.ChemicalReaction: RDKit reaction object - - Example: - >>> rxn = build_reaction("[C:1]=[O:2]>>[C:1]-[O:2]") - """ return AllChem.ReactionFromSmarts(rxn_smarts) - def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): - """ - Create RDKit molecule objects from SMILES strings with explicit hydrogens. - - Args: - reactant_smiles_1 (str): SMILES string for first reactant - reactant_smiles_2 (str): SMILES string for second reactant - - Returns: - tuple: (mol_reactant_1, mol_reactant_2) - Both molecules with explicit hydrogens - - Example: - >>> mol1, mol2 = build_reactants("CCO", "CC=O") - """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) @@ -579,26 +415,6 @@ def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): return mol_reactant_1, mol_reactant_2 def _is_initiator_in_set(self, set_of_tuples, reactant): - """ - Find a tuple in the set that contains atom indices matching specific atom map numbers. - - This function searches for atoms in the reactant molecule that have atom map numbers - 101 or 102, then checks if those atom indices exist in any tuple within the provided set. - - Args: - set_of_tuples (set of tuples): Set of atom index tuples to search through - reactant (Chem.Mol): RDKit molecule object to search for mapped atoms - - Returns: - tuple: The first tuple found containing a matching atom index - - Raises: - ValueError: If no matching atom is found in the provided set of tuples - - Example: - >>> matches = {(0, 1, 2), (3, 4, 5)} - >>> result = is_initiator_in_set(matches, reactant_mol) - """ for atom in reactant.GetAtoms(): # Check for specific atom map numbers (101 or 102) if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: @@ -615,22 +431,6 @@ def reaction_templates_highlighted_image_grid( metadata_list: List[ReactionMetadata], highlight_type: str = "template", ) -> Image: - """ - Generate a grid image of reactant-product pairs with highlighted atoms. - - Clears atom maps before drawing. Supports multiple highlight types. - - Args: - metadata_list: List of ReactionMetadata. - highlight_type: Type of atoms to highlight: - - "template": Template-matched atoms (blue). - - "edge": Edge atoms (orange). - - "initiators": Initiator atoms (green). - - "delete": Byproduct atoms if delete_atom=True (red). - - Returns: - PIL Image of the grid. - """ mols = [] highlight_lists = [] highlight_colors = [] From 568dcb72adf3db2555da9ca015e1b19249e4d6fe Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:22:08 -0400 Subject: [PATCH 19/26] Update prepare_reactions.py --- .../reaction_processor/prepare_reactions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index cd43c16..85fe67e 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -9,7 +9,7 @@ """ # WARNING: -# When modifying this file for dataframe or any other indexing varibales use idx, do not use index or indicies or similar. +# When modifying this file for dataframe or any other indexing varibales use idx and idxs, do not use index or indicies or similar. from dataclasses import dataclass from pathlib import Path From 837fee9e4b5919088873e2a40b8f3c064c04d770 Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:22:56 -0400 Subject: [PATCH 20/26] Update prepare_reactions.py --- .../reaction_processor/prepare_reactions.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 85fe67e..d60fe6b 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -414,18 +414,6 @@ def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens return mol_reactant_1, mol_reactant_2 - def _is_initiator_in_set(self, set_of_tuples, reactant): - for atom in reactant.GetAtoms(): - # Check for specific atom map numbers (101 or 102) - if atom.GetAtomMapNum() == 101 or atom.GetAtomMapNum() == 102: - x = atom.GetIdx() - for t in set_of_tuples: - if x in t: - print(f"Found matching atom index {x} in tuple {t}") - return t - raise ValueError("No matching atom found in the provided set of tuples.") - - def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], From d7c947de003201a7893a3197876147f87268b58f Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:33:56 -0400 Subject: [PATCH 21/26] Refactor PrepareReactions: privatize helpers Reorganize PrepareReactions by converting several pipeline methods to private implementations and grouping related helpers. Renamed public pipeline entry points (process_reaction_instances -> _process_reaction_instances, process_reaction_products -> _process_reaction_products), moved and reinserted _detect_duplicates, and added new helper methods (_detect_byproducts, _validate_mapping, _assign_atom_map_numbers). Reordered methods into logical sections (PUBLIC, PIPELINE STEPS (PRIVATE), CORE REACTION LOGIC, ATOM MAPPING, BUILDERS, HELPERS, VISUALIZATION) and adjusted internal calls accordingly to improve encapsulation, readability, and maintainability while preserving existing behavior. --- .../reaction_processor/prepare_reactions.py | 176 ++++++++++-------- 1 file changed, 97 insertions(+), 79 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index d60fe6b..4498713 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -77,9 +77,11 @@ def __init__(self, cache: Path): self.cache = Path(cache) self.csv_cache = prepare_paths(self.cache, "csv_cache") + # --- PUBLIC --- + def prepare_reactions(self, reaction_instances: list[ReactionInstance]) -> list[ReactionMetadata]: # Initial processing: atom mapping and basic dictionary formatting - reactions_metadata = self.process_reaction_instances(reaction_instances) + reactions_metadata = self._process_reaction_instances(reaction_instances) # Detect duplicates after processing all reactions to ensure comprehensive comparison reaction_metadata = self._detect_duplicates(reactions_metadata) @@ -129,21 +131,9 @@ def prepare_reactions(self, reaction_instances: list[ReactionInstance]) -> list[ reaction.template_reactant_to_product_mapping = template_mapped_dict return reaction_metadata - - def _detect_duplicates(self, reaction_metadata_list: list[ReactionMetadata]) -> list[ReactionMetadata]: - unique_metadata: list[ReactionMetadata] = [] - for reaction in reaction_metadata_list: - reactants = reaction.reactant_combined_mol - products = reaction.product_combined_mol - - if compare_set(unique_metadata, reactants, products): - unique_metadata.append(reaction) - else: - reaction.activity_stats = False # mark duplicate reactions with False for activity_stats - - return unique_metadata - def process_reaction_instances(self, detected_reactions: list[ReactionInstance]) -> list[ReactionMetadata]: + # --- PIPELINE STEPS (PRIVATE) --- + def _process_reaction_instances(self, detected_reactions: list[ReactionInstance]) -> list[ReactionMetadata]: csv_cache = self.csv_cache reaction_metadata = [] @@ -167,17 +157,31 @@ def process_reaction_instances(self, detected_reactions: list[ReactionInstance]) reaction_tuple = self._build_reaction_tuple(same_reactants, mol_reactant_1, mol_reactant_2) # Process the reaction - reaction_metadata = self.process_reaction_products( + reaction_metadata = self._process_reaction_products( rxn, csv_cache, reaction_tuple, delete_atoms, reaction_metadata ) + return reaction_metadata + + def _detect_duplicates(self, reaction_metadata_list: list[ReactionMetadata]) -> list[ReactionMetadata]: + unique_metadata: list[ReactionMetadata] = [] + for reaction in reaction_metadata_list: + reactants = reaction.reactant_combined_mol + products = reaction.product_combined_mol + + if compare_set(unique_metadata, reactants, products): + unique_metadata.append(reaction) + else: + reaction.activity_stats = False # mark duplicate reactions with False for activity_stats + + return unique_metadata - def process_reaction_products(self, + def _process_reaction_products(self, rxn: Chem.rdChemReactions.ChemicalReaction, csv_cache: Path, reaction_tuple: list, @@ -261,6 +265,7 @@ def process_reaction_products(self, return reaction_metadata + # --- CORE REACTION LOGIC --- def _assign_first_shell_and_initiators(self, reactant_combined, product_combined, mapping_dict): first_shell = [] initiator_idxs = [] @@ -290,7 +295,54 @@ def _assign_first_shell_and_initiators(self, reactant_combined, product_combined raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") return first_shell, initiator_idxs + def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, int], delete_atoms: bool) -> list[int]: + if not delete_atoms: + return [] + + frags = rdmolops.GetMolFrags(product_combined, asMols=True) + smallest = min(frags, key=lambda m: m.GetNumAtoms()) + + byproduct = [] + + # reverse mapping: product_idx → reactant_idx + reversed_mapping_dict = {} + for react_idx, prod_idx in mapping_dict.items(): + reversed_mapping_dict[prod_idx] = react_idx + + for atom in smallest.GetAtoms(): + p_idx = atom.GetIdx() + if p_idx in reversed_mapping_dict: + byproduct.append(reversed_mapping_dict[p_idx]) + + return byproduct + + def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: + if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): + return False + if df["reactant_idx"].notna().sum() != reactant.GetNumAtoms(): + return False + if df["product_idx"].notna().sum() != product.GetNumAtoms(): + return False + if not self._is_consecutive(df["reactant_idx"].tolist()): + return False + if not self._is_consecutive(df["product_idx"].tolist()): + return False + return True + + + # --- ATOM MAPPING --- + def _assign_atom_map_numbers(self, r1: Chem.Mol, r2: Chem.Mol) -> None: + for atom in r1.GetAtoms(): + idx = 1001 + atom.GetIdx() + atom.SetAtomMapNum(idx) + atom.SetIsotope(idx) # The isotope is what will survive the reaction! + + for atom in r2.GetAtoms(): + idx = 2001 + atom.GetIdx() + atom.SetAtomMapNum(idx) + atom.SetIsotope(idx) # The isotope is what will survive the reaction! + def _reassign_atom_map_numbers_by_isotope(self, mol: Chem.Mol) -> None: """ surviving_idx = atom.GetIsotope() inside the atom's "Isotope" property because @@ -327,13 +379,9 @@ def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combine df = pd.DataFrame(rows) return mapping_dict, df - - def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: - '''Clear isotopes from a molecule to restore normal chemistry after using isotopes to store custom IDs''' - for atom in mol_1.GetAtoms(): - atom.SetIsotope(0) - for atom in mol_2.GetAtoms(): - atom.SetIsotope(0) + + + def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: '''Make map numbers assigned to products of reaction visible for display''' @@ -342,77 +390,47 @@ def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: map_num = atom.GetIntProp('old_mapno') atom.SetAtomMapNum(map_num) - def _assign_atom_map_numbers(self, r1: Chem.Mol, r2: Chem.Mol) -> None: - for atom in r1.GetAtoms(): - idx = 1001 + atom.GetIdx() - atom.SetAtomMapNum(idx) - atom.SetIsotope(idx) # The isotope is what will survive the reaction! - - for atom in r2.GetAtoms(): - idx = 2001 + atom.GetIdx() - atom.SetAtomMapNum(idx) - atom.SetIsotope(idx) # The isotope is what will survive the reaction! - - def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: - if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): - return False - if df["reactant_idx"].notna().sum() != reactant.GetNumAtoms(): - return False - if df["product_idx"].notna().sum() != product.GetNumAtoms(): - return False - if not self._is_consecutive(df["reactant_idx"].tolist()): - return False - if not self._is_consecutive(df["product_idx"].tolist()): - return False - return True + def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: + '''Clear isotopes from a molecule to restore normal chemistry after using isotopes to store custom IDs''' + for atom in mol_1.GetAtoms(): + atom.SetIsotope(0) + for atom in mol_2.GetAtoms(): + atom.SetIsotope(0) - def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, int], delete_atoms: bool) -> list[int]: - if not delete_atoms: - return [] - - frags = rdmolops.GetMolFrags(product_combined, asMols=True) - smallest = min(frags, key=lambda m: m.GetNumAtoms()) - - byproduct = [] - - # reverse mapping: product_idx → reactant_idx - reversed_mapping_dict = {} - for react_idx, prod_idx in mapping_dict.items(): - reversed_mapping_dict[prod_idx] = react_idx + - for atom in smallest.GetAtoms(): - p_idx = atom.GetIdx() - if p_idx in reversed_mapping_dict: - byproduct.append(reversed_mapping_dict[p_idx]) - return byproduct - def _is_consecutive(self, num_list: list[int]) -> bool: - if not num_list: - return False - return ( - len(set(num_list)) == len(num_list) - and max(num_list) - min(num_list) + 1 == len(num_list) - ) - - def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): - if same_reactants: - return [[mol_reactant_1, mol_reactant_1]] - return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] - + # --- BUILDERS --- def _build_reaction(self, rxn_smarts): return AllChem.ReactionFromSmarts(rxn_smarts) - def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens return mol_reactant_1, mol_reactant_2 + def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): + if same_reactants: + return [[mol_reactant_1, mol_reactant_1]] + + return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] + + # --- HELPERS --- + def _is_consecutive(self, num_list: list[int]) -> bool: + if not num_list: + return False + + return ( + len(set(num_list)) == len(num_list) + and max(num_list) - min(num_list) + 1 == len(num_list) + ) + + # --- VISUALIZATION --- def reaction_templates_highlighted_image_grid( self, From f11464c730b6ddf59af1f15f13f75b9691c7f92d Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 16:41:17 -0400 Subject: [PATCH 22/26] Improve mapping validation and add type hints Enhance PrepareReactions in prepare_reactions.py: remove unused imports (itertools, os), add type annotations to _assign_first_shell_and_initiators, and replace the previous brittle _validate_mapping checks with robust validation. The new validation ensures the dataframe and required columns exist, checks for matching counts, duplicate indices, index bounds, and full coverage, and raises MappingError with informative messages on failure. Also includes small whitespace/formatting cleanup. --- .../reaction_processor/prepare_reactions.py | 53 ++++++++++++------- 1 file changed, 34 insertions(+), 19 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 4498713..5ea56cf 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -14,8 +14,6 @@ from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Optional -import itertools -import os from rdkit import Chem from rdkit.Chem import AllChem, Draw, rdmolops @@ -266,7 +264,7 @@ def _process_reaction_products(self, return reaction_metadata # --- CORE REACTION LOGIC --- - def _assign_first_shell_and_initiators(self, reactant_combined, product_combined, mapping_dict): + def _assign_first_shell_and_initiators(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol, mapping_dict: dict[int, int]) -> tuple[list[int], list[int]]: first_shell = [] initiator_idxs = [] reversed_mapping_dict = {} @@ -295,6 +293,7 @@ def _assign_first_shell_and_initiators(self, reactant_combined, product_combined raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") return first_shell, initiator_idxs + def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, int], delete_atoms: bool) -> list[int]: if not delete_atoms: return [] @@ -317,16 +316,39 @@ def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, return byproduct def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: - if df["reactant_idx"].notna().sum() != df["product_idx"].notna().sum(): - return False - if df["reactant_idx"].notna().sum() != reactant.GetNumAtoms(): - return False - if df["product_idx"].notna().sum() != product.GetNumAtoms(): - return False - if not self._is_consecutive(df["reactant_idx"].tolist()): - return False - if not self._is_consecutive(df["product_idx"].tolist()): + # Ensure required columns exist + if df is None or df.empty: return False + + required_cols = {"reactant_idx", "product_idx"} + if not required_cols.issubset(df.columns): + raise MappingError(f"Mapping validation error: required columns {required_cols} not found in dataframe.") + + r_idxs = df["reactant_idx"].dropna().tolist() + p_idxs = df["product_idx"].dropna().tolist() + + # Basic sanity: counts must match + if len(r_idxs) != len(p_idxs): + raise MappingError(f"Mapping validation error: mismatch in atom counts between reactant and product.") + + # No duplicates (1-to-1 mapping) + if len(set(r_idxs)) != len(r_idxs): + raise MappingError(f"Mapping validation error: duplicate indices found in reactant mapping.") + if len(set(p_idxs)) != len(p_idxs): + raise MappingError(f"Mapping validation error: duplicate indices found in product mapping.") + + # Indices must be within bounds + if any(idx >= reactant.GetNumAtoms() for idx in r_idxs): + raise MappingError(f"Mapping validation error: reactant index {idx} is out of bounds.") + if any(idx >= product.GetNumAtoms() for idx in p_idxs): + raise MappingError(f"Mapping validation error: product index {idx} is out of bounds.") + + # Optional strict check: full coverage + if len(r_idxs) != reactant.GetNumAtoms(): + raise MappingError(f"Mapping validation error: incomplete mapping for reactant.") + if len(p_idxs) != product.GetNumAtoms(): + raise MappingError(f"Mapping validation error: incomplete mapping for product.") + return True @@ -398,12 +420,6 @@ def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: for atom in mol_2.GetAtoms(): atom.SetIsotope(0) - - - - - - # --- BUILDERS --- def _build_reaction(self, rxn_smarts): @@ -431,7 +447,6 @@ def _is_consecutive(self, num_list: list[int]) -> bool: ) # --- VISUALIZATION --- - def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], From 99e5e99cff33961f3808f77556694e94e962d51e Mon Sep 17 00:00:00 2001 From: janitha1996 <119646255+janitha-mahanthe@users.noreply.github.com> Date: Mon, 30 Mar 2026 21:03:48 -0400 Subject: [PATCH 23/26] Refactor reaction preparation and mapping --- .../reaction_processor/prepare_reactions.py | 503 ++++++++++++------ 1 file changed, 351 insertions(+), 152 deletions(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 5ea56cf..396e9f5 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -4,12 +4,13 @@ reaction metadata extraction, and visualization utilities using RDKit. This module processes reaction SMARTS, applies atom mappings, identifies key reaction features (e.g., first shell, -initiators, byproducts), and generates metadata and visualizations for downstream tasks like reaction prediction -or mechanistic analysis. +initiators, byproducts), and generates metadata and visualizations for downstream analysis. It also includes validation checks to ensure mapping +consistency and completeness. """ + # WARNING: -# When modifying this file for dataframe or any other indexing varibales use idx and idxs, do not use index or indicies or similar. +# When modifying this file for dataframe or any other indexing variables use idx and idxs, do not use index or indices or similar. from dataclasses import dataclass from pathlib import Path @@ -27,7 +28,6 @@ from AutoREACTER.reaction_preparation.reaction_processor.walker import reaction_atom_walker - class MappingError(Exception): """Custom exception raised when atom mapping between reactants and products fails or is inconsistent.""" @@ -38,17 +38,39 @@ class SMARTSParsingError(Exception): @dataclass(slots=True) class ReactionMetadata: + """ + Stores comprehensive metadata for a single reaction including molecular structures, + atom mappings, and analysis results. + reaction_id: Unique identifier for the reaction instance + reactant_combined_mol: RDKit molecule object representing combined reactants + product_combined_mol: RDKit molecule object representing combined products + reactant_to_product_mapping: Dictionary mapping reactant atom indices to product atom indices + product_to_reactant_mapping: Dictionary mapping product atom indices back to reactant atom indices + template_reactant_to_product_mapping: Optional dictionary mapping reactant indices in the template to product indices + edge_atoms: Optional list of reactant atom indices that are at the edge of the local environment + first_shell: Optional list of reactant atom indices in the first coordination shell (reaction center) + initiators: Optional list of reactant atom indices that are initiators (map numbers 1 or 2) + byproduct_indices: Optional list of reactant atom indices corresponding to detected byproducts + reaction_smarts: Optional string of the reaction SMARTS pattern + reactant_smarts: Optional string of the combined reactant SMILES + product_smiles: Optional string of the combined product SMILES + csv_path: Optional Path to the CSV file containing atom mappings and analysis + mol_3d_path: Optional Path to a file containing 3D structures of the molecules + reaction_dataframe: Optional pandas DataFrame containing detailed mapping and analysis results + delete_atom: Boolean indicating whether the reaction involves a delete atom (byproduct) + delete_atom_idx: Optional integer index of the reactant atom that corresponds to the byproduct + activity_stats: Boolean indicating whether this reaction should be included in activity statistics (e.g., not a duplicate) + """ reaction_id: int reactant_combined_mol: Chem.Mol product_combined_mol: Chem.Mol reactant_to_product_mapping: Dict[int, int] + product_to_reactant_mapping: Dict[int, int] template_reactant_to_product_mapping: Optional[Dict[int, int]] = None edge_atoms: Optional[List[int]] = None - first_shell: Optional[List[int]] = None initiators: Optional[List[int]] = None byproduct_indices: Optional[List[int]] = None - reaction_smarts: Optional[str] = None reactant_smarts: Optional[str] = None product_smiles: Optional[str] = None @@ -59,89 +81,96 @@ class ReactionMetadata: delete_atom_idx: Optional[int] = None activity_stats: bool = True + class PrepareReactions: - """ - Class for preparing reaction instances by processing SMILES/SMARTS, performing atom mapping, - extracting reaction features, and generating metadata and visualizations. - """ + """Processes chemical reactions: builds atom mappings, identifies reaction centers, and detects byproducts.""" def __init__(self, cache: Path): - """ - Initialize the reaction preparer with a cache directory for storing CSV outputs. - - Args: - cache: Path to the base cache directory for storing processed reaction data. - """ + """Initialize with cache directory for storing reaction CSVs.""" self.cache = Path(cache) self.csv_cache = prepare_paths(self.cache, "csv_cache") # --- PUBLIC --- def prepare_reactions(self, reaction_instances: list[ReactionInstance]) -> list[ReactionMetadata]: - # Initial processing: atom mapping and basic dictionary formatting + """ + Main pipeline: processes reaction instances, detects duplicates, and enriches metadata with template mappings. + + Args: + reaction_instances: List of detected reaction instances to process + + Returns: + List of processed ReactionMetadata objects with template mappings and edge atoms + """ reactions_metadata = self._process_reaction_instances(reaction_instances) - - # Detect duplicates after processing all reactions to ensure comprehensive comparison reaction_metadata = self._detect_duplicates(reactions_metadata) - # Iterate through each detected reaction to perform template analysis for reaction in reactions_metadata: + # Skip reactions marked as duplicates if not reaction.activity_stats: continue # Skip reactions marked as duplicates + combined_reactant_molecule_object = reaction.reactant_combined_mol reaction_dataframe = reaction.reaction_dataframe csv_save_path = reaction.csv_path - - # Create a mapping dictionary {reactant_idx: product_idx} from the dataframe - fully_mapped_dict = reaction_dataframe.set_index("reactant_idx")["product_idx"].to_dict() - # Extract the 'first shell' (atoms directly involved in bond changes) + # Build full atom mapping dictionary from dataframe + fully_mapped_dict = reaction_dataframe.set_index("reactant_idx")["product_idx"].to_dict() first_shell = reaction_dataframe["first_shell"].dropna().tolist() - # Perform atom walking to determine the reaction template and boundary (edge) atoms + # Generate template mapping by walking reaction graph template_mapped_dict, edge_atoms = reaction_atom_walker( combined_reactant_molecule_object, first_shell, fully_mapped_dict ) - - # Update the dataframe with specific template mapping indices + + # Add template mapping and edge atoms to dataframe reaction_dataframe = add_dict_as_new_columns( reaction_dataframe, template_mapped_dict, - titles = ["template_reactant_idx", "template_product_idx"] + titles=["template_reactant_idx", "template_product_idx"] ) - - # Append edge atoms information (crucial for building polymer chains) + + # Add edge atoms as a new column in the dataframe reaction_dataframe = add_column_safe( reaction_dataframe, edge_atoms, "edge_atoms" ) - # Store the updated dataframe back in the reaction object - # Using .copy() to avoid SettingWithCopyWarning in pandas - reaction.reaction_dataframe = reaction_dataframe.copy() - - # Persist the processed reaction data to a CSV file + # Save updated dataframe back to CSV and update metadata + reaction.reaction_dataframe = reaction_dataframe.copy() + # Save the updated dataframe with template mappings and edge atoms to CSV reaction_dataframe.to_csv(csv_save_path, index=False) + # Update metadata with template mapping and edge atoms reaction.edge_atoms = edge_atoms + # Store the template mapping in the metadata for later use reaction.template_reactant_to_product_mapping = template_mapped_dict return reaction_metadata # --- PIPELINE STEPS (PRIVATE) --- + def _process_reaction_instances(self, detected_reactions: list[ReactionInstance]) -> list[ReactionMetadata]: + """ + Converts ReactionInstance objects into ReactionMetadata by building molecules and running reactions. + + Args: + detected_reactions: List of detected reaction instances + + Returns: + List of ReactionMetadata objects with atom mappings + """ csv_cache = self.csv_cache reaction_metadata = [] - # Process each reaction in the detected reactions class for reaction in detected_reactions: rxn_smarts = reaction.reaction_smarts reactant_smiles_1 = reaction.monomer_1.smiles same_reactants = reaction.same_reactants - - # Handle same vs different reactants + + # Handle case where both reactants are identical if same_reactants: reactant_smiles_2 = reactant_smiles_1 else: @@ -149,34 +178,47 @@ def _process_reaction_instances(self, detected_reactions: list[ReactionInstance] delete_atoms = reaction.delete_atom - # Build reaction and reactants + # Build reaction and reactant molecules rxn = self._build_reaction(rxn_smarts) + # This function also runs the reaction and builds metadata for each product set, including atom mappings and byproduct detection mol_reactant_1, mol_reactant_2 = self._build_reactants(reactant_smiles_1, reactant_smiles_2) + # Build reaction tuple based on whether reactants are the same or different. If same, only one ordering is needed. If different, both orderings are processed to account for reaction directionality. reaction_tuple = self._build_reaction_tuple(same_reactants, mol_reactant_1, mol_reactant_2) - # Process the reaction - reaction_metadata = self._process_reaction_products( - rxn, - csv_cache, - reaction_tuple, - delete_atoms, - reaction_metadata - ) - + # Process products and build metadata + reaction_metadata = self._process_reaction_products( + rxn, + csv_cache, + reaction_tuple, + delete_atoms, + reaction_metadata + ) return reaction_metadata def _detect_duplicates(self, reaction_metadata_list: list[ReactionMetadata]) -> list[ReactionMetadata]: + """ + Filters duplicate reactions based on reactant and product molecules. + + Args: + reaction_metadata_list: List of reaction metadata to filter + + Returns: + List of unique reactions; duplicates marked with activity_stats=False + """ unique_metadata: list[ReactionMetadata] = [] + for reaction in reaction_metadata_list: + # Compare current reaction's reactants and products against unique reactions collected so far reactants = reaction.reactant_combined_mol products = reaction.product_combined_mol + # Keep reaction if it's unique, otherwise mark as duplicate if compare_set(unique_metadata, reactants, products): unique_metadata.append(reaction) else: - reaction.activity_stats = False # mark duplicate reactions with False for activity_stats - + reaction.activity_stats = False + return unique_metadata def _process_reaction_products(self, @@ -184,53 +226,68 @@ def _process_reaction_products(self, csv_cache: Path, reaction_tuple: list, delete_atoms: bool = True, - reaction_metadata: Optional[list[ReactionMetadata]] = None + reaction_metadata: Optional[list[ReactionMetadata]] = None ) -> list[ReactionMetadata]: + """ + Runs reactions on reactant pairs and builds metadata for each product set. + + Args: + rxn: RDKit ChemicalReaction object + csv_cache: Path to cache directory for saving CSVs + reaction_tuple: List of reactant pairs to process + delete_atoms: Whether to detect and track byproducts + reaction_metadata: Accumulator list for metadata objects + + Returns: + Updated list of ReactionMetadata objects + """ + if reaction_metadata is None: + reaction_metadata = [] - # Process each reactant pair in the reaction tuple for pair in reaction_tuple: r1, r2 = Chem.Mol(pair[0]), Chem.Mol(pair[1]) + + # Assign unique map numbers and isotopes to track atoms through reaction + self._assign_atom_map_numbers_and_set_isotopes(r1, r2) + # Run the reaction to get products products = rxn.RunReactants((r1, r2)) + # If no products are generated, skip to the next reactant pair if not products: - continue # Skip if no products are generated + continue - self._assign_atom_map_numbers(r1, r2) # Assign unique map numbers to reactant atoms to track them through the reaction - # Process each product set generated by the reaction for product_set in products: - # loop over ALL match combinations - - # IMPORTANT: copy reactants for each combination - r1_copy = Chem.Mol(r1) - r2_copy = Chem.Mol(r2) - - df = pd.DataFrame(columns=["reactant_idx", "product_idx"]) - # Step 2: combine for reactant→product mapping - reactant_combined = Chem.CombineMols(r1_copy, r2_copy) + # Combine molecules for mapping + reactant_combined = Chem.CombineMols(r1, r2) product_combined = Chem.CombineMols(*product_set) - # Restore Atom Map Numbers from Isotopes in the products + # Restore atom map numbers from isotopes (which survive the reaction) self._reassign_atom_map_numbers_by_isotope(product_combined) - - mapping_dict, df = self._build_atom_index_mapping(reactant_combined, product_combined) # Build mapping dictionary and dataframe of reactant to product atom indices based on map numbers + + # Build bidirectional atom index mappings + mapping_dict, df = self._build_atom_index_mapping(reactant_combined, product_combined) + reverse_mapping = {v: k for k, v in mapping_dict.items()} - self._reveal_template_map_numbers(product_combined) # Make map numbers visible for debugging and visualization + # Restore map numbers for visualization + self._reveal_template_map_numbers(product_combined) - # Validate the mapping to ensure consistency before proceeding - if not self._validate_mapping(df, reactant_combined, product_combined): - raise MappingError("Atom mapping validation failed: inconsistent mapping between reactants and products.") - - first_shell, initiator_idxs = self._assign_first_shell_and_initiators(reactant_combined, - product_combined, - mapping_dict) + # Validate mapping consistency + self._validate_mapping(df, reactant_combined, product_combined) + # Identify atoms involved in reaction center and initiators + first_shell, initiator_idxs = self._assign_first_shell_and_initiators( + reactant_combined, + product_combined, + reverse_mapping + ) - byproduct_reactant_idxs = self._detect_byproducts(product_combined, mapping_dict, delete_atoms) + # Detect byproducts (smallest fragments) + byproduct_reactant_idxs = self._detect_byproducts(product_combined, reverse_mapping, delete_atoms) - # Build dataframe + # Combine all mapping data into single dataframe df_combined = pd.concat([ df, pd.Series(first_shell, name="first_shell"), @@ -240,154 +297,224 @@ def _process_reaction_products(self, total_products = len(reaction_metadata) + 1 - self._clear_isotopes(reactant_combined, product_combined) # Clear isotopes to restore normal chemistry before saving + # Clear isotopes before saving to restore normal chemistry + self._clear_isotopes(reactant_combined, product_combined) - df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) + # Save mapping dataframe to CSV + df_combined.to_csv(csv_cache / f"reaction_{total_products}.csv", index=False) + # Create and store metadata object reaction_metadata.append( ReactionMetadata( - reaction_id = total_products, - reactant_combined_mol = reactant_combined, - product_combined_mol = product_combined, - reactant_to_product_mapping = mapping_dict, - first_shell = first_shell, - initiators = initiator_idxs, - byproduct_indices = byproduct_reactant_idxs, - csv_path = csv_cache / f"reaction_{total_products}.csv", - reaction_dataframe = df_combined, - delete_atom = delete_atoms, - delete_atom_idx = byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, - activity_stats = True - ) + reaction_id=total_products, + reactant_combined_mol=reactant_combined, + product_combined_mol=product_combined, + reactant_to_product_mapping=mapping_dict, + product_to_reactant_mapping=reverse_mapping, + first_shell=first_shell, + initiators=initiator_idxs, + byproduct_indices=byproduct_reactant_idxs, + csv_path=csv_cache / f"reaction_{total_products}.csv", + reaction_dataframe=df_combined, + delete_atom=delete_atoms, + delete_atom_idx=byproduct_reactant_idxs[0] if byproduct_reactant_idxs else None, + activity_stats=True ) + ) return reaction_metadata # --- CORE REACTION LOGIC --- - def _assign_first_shell_and_initiators(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol, mapping_dict: dict[int, int]) -> tuple[list[int], list[int]]: + + def _assign_first_shell_and_initiators(self, + reactant_combined: Chem.Mol, + product_combined: Chem.Mol, + reversed_mapping_dict: dict[int, int]) -> tuple[list[int], list[int]]: + """ + Identifies atoms in the first coordination shell (atoms with map numbers < 999) and initiator atoms. + Initiators are atoms with map numbers 1 or 2 (typically the reactive centers). + + Args: + reactant_combined: Combined reactant molecule + product_combined: Combined product molecule + reversed_mapping_dict: Product idx -> Reactant idx mapping + + Returns: + Tuple of (first_shell atom indices, initiator atom indices) + + Raises: + ValueError: If exactly 2 initiators are not found + """ first_shell = [] initiator_idxs = [] - reversed_mapping_dict = {} - for react_idx, prod_idx in mapping_dict.items(): - reversed_mapping_dict[prod_idx] = react_idx - for p_atom in product_combined.GetAtoms(): + # Only process atoms with valid map numbers (< 999 indicates non-byproduct) if p_atom.GetAtomMapNum() < 999: - p_idx = p_atom.GetIdx() if p_idx not in reversed_mapping_dict: raise ValueError(f"Mapping error: product atom {p_idx} not found in mapping_dict") r_idx = reversed_mapping_dict[p_idx] - atom = reactant_combined.GetAtomWithIdx(r_idx) atom.SetAtomMapNum(p_atom.GetAtomMapNum()) first_shell.append(r_idx) + # Initiators are atoms with map numbers 1 or 2 if p_atom.GetAtomMapNum() in [1, 2]: initiator_idxs.append(r_idx) + if len(initiator_idxs) != 2: - raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") + raise ValueError(f"Expected 2 initiators, got {len(initiator_idxs)}: {initiator_idxs}") return first_shell, initiator_idxs - def _detect_byproducts(self, product_combined: Chem.Mol, mapping_dict: dict[int, int], delete_atoms: bool) -> list[int]: + def _detect_byproducts(self, + product_combined: Chem.Mol, + reversed_mapping_dict: dict[int, int], + delete_atoms: bool) -> list[int]: + """ + Identifies byproduct atoms (smallest molecular fragment) and maps them back to reactant space. + + Args: + product_combined: Combined product molecule + reversed_mapping_dict: Product idx -> Reactant idx mapping + delete_atoms: Whether to perform byproduct detection + + Returns: + List of reactant indices corresponding to byproduct atoms + """ + # If delete_atoms is False, we skip byproduct detection and return an empty list if not delete_atoms: return [] + # Fragment molecule and find smallest fragment frags = rdmolops.GetMolFrags(product_combined, asMols=True) smallest = min(frags, key=lambda m: m.GetNumAtoms()) - byproduct = [] - - # reverse mapping: product_idx → reactant_idx - reversed_mapping_dict = {} - for react_idx, prod_idx in mapping_dict.items(): - reversed_mapping_dict[prod_idx] = react_idx + byproduct_reactant_indices = [] + # Map byproduct atoms back to reactant indices for atom in smallest.GetAtoms(): p_idx = atom.GetIdx() if p_idx in reversed_mapping_dict: - byproduct.append(reversed_mapping_dict[p_idx]) + byproduct_reactant_indices.append(reversed_mapping_dict[p_idx]) - return byproduct + return byproduct_reactant_indices - def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> bool: - # Ensure required columns exist + def _validate_mapping(self, df: pd.DataFrame, reactant: Chem.Mol, product: Chem.Mol) -> None: + """ + Validates atom mapping consistency: checks for required columns, duplicates, bounds, and completeness. + + Args: + df: Dataframe containing reactant_idx and product_idx columns + reactant: Reactant molecule + product: Product molecule + + Raises: + MappingError: If any validation check fails + """ + # Ensure dataframe exists and has required columns if df is None or df.empty: - return False + raise MappingError("Mapping validation failed: empty dataframe") + # Check for required columns required_cols = {"reactant_idx", "product_idx"} if not required_cols.issubset(df.columns): raise MappingError(f"Mapping validation error: required columns {required_cols} not found in dataframe.") + # Extract indices and perform validation checks r_idxs = df["reactant_idx"].dropna().tolist() p_idxs = df["product_idx"].dropna().tolist() - # Basic sanity: counts must match + # Atom counts must match if len(r_idxs) != len(p_idxs): raise MappingError(f"Mapping validation error: mismatch in atom counts between reactant and product.") - # No duplicates (1-to-1 mapping) + # No duplicate mappings (1-to-1 mapping required) if len(set(r_idxs)) != len(r_idxs): raise MappingError(f"Mapping validation error: duplicate indices found in reactant mapping.") if len(set(p_idxs)) != len(p_idxs): raise MappingError(f"Mapping validation error: duplicate indices found in product mapping.") - # Indices must be within bounds + # Indices must be within molecule bounds if any(idx >= reactant.GetNumAtoms() for idx in r_idxs): - raise MappingError(f"Mapping validation error: reactant index {idx} is out of bounds.") + raise MappingError(f"Mapping validation error: reactant index out of bounds.") if any(idx >= product.GetNumAtoms() for idx in p_idxs): - raise MappingError(f"Mapping validation error: product index {idx} is out of bounds.") + raise MappingError(f"Mapping validation error: product index out of bounds.") - # Optional strict check: full coverage + # All atoms must be mapped (complete mapping) if len(r_idxs) != reactant.GetNumAtoms(): raise MappingError(f"Mapping validation error: incomplete mapping for reactant.") if len(p_idxs) != product.GetNumAtoms(): raise MappingError(f"Mapping validation error: incomplete mapping for product.") - return True - - # --- ATOM MAPPING --- - def _assign_atom_map_numbers(self, r1: Chem.Mol, r2: Chem.Mol) -> None: + def _assign_atom_map_numbers_and_set_isotopes(self, r1: Chem.Mol, r2: Chem.Mol) -> None: + """ + Assigns unique map numbers and isotopes to reactant atoms for tracking through reaction. + Isotopes survive RDKit's reaction engine, allowing atom identity recovery post-reaction. + + Args: + r1: First reactant molecule + r2: Second reactant molecule + """ + # Assign map numbers 1001+ to first reactant atoms for atom in r1.GetAtoms(): idx = 1001 + atom.GetIdx() atom.SetAtomMapNum(idx) - atom.SetIsotope(idx) # The isotope is what will survive the reaction! + atom.SetIsotope(idx) # Isotope survives the reaction + # Assign map numbers 2001+ to second reactant atoms for atom in r2.GetAtoms(): idx = 2001 + atom.GetIdx() atom.SetAtomMapNum(idx) - atom.SetIsotope(idx) # The isotope is what will survive the reaction! - + atom.SetIsotope(idx) # Isotope survives the reaction + def _reassign_atom_map_numbers_by_isotope(self, mol: Chem.Mol) -> None: """ - surviving_idx = atom.GetIsotope() inside the atom's "Isotope" property because - RDKit's reaction engine wouldn't delete them there. Here, we are opening up that - safe box to retrieve the ID.""" + Restores atom map numbers from isotope values after reaction. + RDKit's reaction engine preserves isotopes, allowing recovery of original atom identities. + + Args: + mol: Product molecule with isotope information + """ for atom in mol.GetAtoms(): surviving_idx = atom.GetIsotope() if surviving_idx != 0: - atom.SetAtomMapNum(surviving_idx) # Restore map number - atom.SetIsotope(0) # Clear isotope to restore normal chemistry + atom.SetAtomMapNum(surviving_idx) # Restore original map number + atom.SetIsotope(0) # Clear isotope to restore normal chemistry - def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combined: Chem.Mol) -> tuple[dict[int, int], pd.DataFrame]: + def _build_atom_index_mapping(self, + reactant_combined: Chem.Mol, + product_combined: Chem.Mol) -> tuple[dict[int, int], pd.DataFrame]: + """ + Builds bidirectional atom index mapping between reactants and products using map numbers. + + Args: + reactant_combined: Combined reactant molecule + product_combined: Combined product molecule + + Returns: + Tuple of (mapping dict: reactant_idx -> product_idx, dataframe with mapping) + """ mapping_dict = {} - # Pre-index product atoms by map number (avoids nested loop) + + # Pre-index product atoms by map number for O(1) lookup product_map = { atom.GetAtomMapNum(): atom.GetIdx() for atom in product_combined.GetAtoms() if atom.GetAtomMapNum() != 0 } + rows = [] for r_atom in reactant_combined.GetAtoms(): r_map_num = r_atom.GetAtomMapNum() + # Match reactant atom to product atom via map number if r_map_num != 0 and r_map_num in product_map: r_idx = r_atom.GetIdx() p_idx = product_map[r_map_num] @@ -399,22 +526,29 @@ def _build_atom_index_mapping(self, reactant_combined: Chem.Mol, product_combine }) df = pd.DataFrame(rows) - return mapping_dict, df - - - - def _reveal_template_map_numbers(self, mol : Chem.Mol) -> None: - '''Make map numbers assigned to products of reaction visible for display''' + def _reveal_template_map_numbers(self, mol: Chem.Mol) -> None: + """ + Restores map numbers from RDKit's internal 'old_mapno' property for visualization. + RDKit stores original map numbers in this property after reaction execution. + + Args: + mol: Product molecule + """ for atom in mol.GetAtoms(): - if atom.HasProp('old_mapno'): # RDKit sets certain "magic" properties post-reaction, including map numbers and reactant atom indices + if atom.HasProp('old_mapno'): map_num = atom.GetIntProp('old_mapno') atom.SetAtomMapNum(map_num) - def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: - '''Clear isotopes from a molecule to restore normal chemistry after using isotopes to store custom IDs''' + """ + Clears isotope values from molecules to restore normal chemistry after using isotopes for atom tracking. + + Args: + mol_1: First molecule to clear + mol_2: Second molecule to clear + """ for atom in mol_1.GetAtoms(): atom.SetIsotope(0) for atom in mol_2.GetAtoms(): @@ -422,22 +556,59 @@ def _clear_isotopes(self, mol_1: Chem.Mol, mol_2: Chem.Mol) -> None: # --- BUILDERS --- - def _build_reaction(self, rxn_smarts): + def _build_reaction(self, rxn_smarts: str) -> Chem.rdChemReactions.ChemicalReaction: + """Builds RDKit ChemicalReaction object from SMARTS string.""" return AllChem.ReactionFromSmarts(rxn_smarts) - def _build_reactants(self, reactant_smiles_1, reactant_smiles_2): + + def _build_reactants(self, reactant_smiles_1: str, reactant_smiles_2: str) -> tuple[Chem.Mol, Chem.Mol]: + """ + Builds reactant molecules from SMILES strings with explicit hydrogens added. + + Args: + reactant_smiles_1: SMILES string for first reactant + reactant_smiles_2: SMILES string for second reactant + + Returns: + Tuple of (reactant1 molecule, reactant2 molecule) with explicit hydrogens + """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) - mol_reactant_1 = Chem.AddHs(mol_reactant_1) # Add explicit hydrogens + mol_reactant_1 = Chem.AddHs(mol_reactant_1) + mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) - mol_reactant_2 = Chem.AddHs(mol_reactant_2) # Add explicit hydrogens + mol_reactant_2 = Chem.AddHs(mol_reactant_2) + return mol_reactant_1, mol_reactant_2 - def _build_reaction_tuple(self, same_reactants, mol_reactant_1, mol_reactant_2): + + def _build_reaction_tuple(self, same_reactants: bool, mol_reactant_1: Chem.Mol, mol_reactant_2: Chem.Mol) -> list: + """ + Builds list of reactant pairs to process. If reactants are identical, returns single pair. + Otherwise returns both orderings to account for reaction directionality. + + Args: + same_reactants: Whether both reactants are identical + mol_reactant_1: First reactant molecule + mol_reactant_2: Second reactant molecule + + Returns: + List of reactant pairs [[r1, r2], ...] to process + """ if same_reactants: return [[mol_reactant_1, mol_reactant_1]] return [[mol_reactant_1, mol_reactant_2], [mol_reactant_2, mol_reactant_1]] # --- HELPERS --- + def _is_consecutive(self, num_list: list[int]) -> bool: + """ + Checks if list contains consecutive integers with no duplicates. + + Args: + num_list: List of integers to check + + Returns: + True if list is consecutive and has no duplicates, False otherwise + """ if not num_list: return False @@ -447,11 +618,22 @@ def _is_consecutive(self, num_list: list[int]) -> bool: ) # --- VISUALIZATION --- + def reaction_templates_highlighted_image_grid( self, metadata_list: List[ReactionMetadata], highlight_type: str = "template", ) -> Image: + """ + Generates grid image of reactions with highlighted atoms based on type. + + Args: + metadata_list: List of reaction metadata to visualize + highlight_type: Type of atoms to highlight - "template", "edge", "initiators", or "delete" + + Returns: + PIL Image containing 2-column grid of reactant-product pairs with highlighted atoms + """ mols = [] highlight_lists = [] highlight_colors = [] @@ -470,6 +652,7 @@ def reaction_templates_highlighted_image_grid( atoms: List[int] = [] color_map: Dict[int, tuple] = {} + # Select atoms to highlight based on type if highlight_type == "template": atoms = list((metadata.template_reactant_to_product_mapping or {}).keys()) for a in atoms: @@ -492,11 +675,27 @@ def reaction_templates_highlighted_image_grid( color_map[a] = (1.0, 0.0, 0.0) # red mols.extend([reactant, product]) - highlight_lists.append(atoms) - highlight_lists.append([]) # no highlights on products - highlight_colors.append(color_map) - highlight_colors.append({}) - + + # Build atom mappings for highlighting + forward_map = metadata.reactant_to_product_mapping + reactant_atoms = atoms + + # Map reactant atoms to product atoms + product_atoms = [] + for r_idx in reactant_atoms: + if r_idx in forward_map: + product_atoms.append(forward_map[r_idx]) + + # Build color maps for reactant and product + reactant_color_map = {a: color_map[a] for a in reactant_atoms} + product_color_map = {p: color_map[r] for r, p in forward_map.items() if r in reactant_atoms} + + highlight_lists.append(reactant_atoms) + highlight_lists.append(product_atoms) + highlight_colors.append(reactant_color_map) + highlight_colors.append(product_color_map) + + # Generate grid image with 2 molecules per row img = Draw.MolsToGridImage( mols, molsPerRow=2, @@ -505,4 +704,4 @@ def reaction_templates_highlighted_image_grid( subImgSize=(400, 400), useSVG=False, ) - return img \ No newline at end of file + return img From bde496ff68941ce407681d7d5291c71ee08372dd Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 31 Mar 2026 10:22:26 -0400 Subject: [PATCH 24/26] Update AutoREACTER/reaction_preparation/reaction_processor/utils.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../reaction_preparation/reaction_processor/utils.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/utils.py b/AutoREACTER/reaction_preparation/reaction_processor/utils.py index b2a8401..7f4a571 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/utils.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/utils.py @@ -40,7 +40,14 @@ def extract_unique_references(detected_reactions: List[ReactionInstance]) -> lis refs = [] for metadata in detected_reactions: - ref = metadata.reference or {} + # Prefer the correct 'references' attribute on ReactionInstance, with + # a backward-compatible fallback to 'reference' if present. + ref = getattr(metadata, "references", None) + if ref is None: + ref = getattr(metadata, "reference", {}) or {} + else: + if ref is None: + ref = {} for v in ref.values(): if isinstance(v, str): From 2aaa6bf00270ea45e40b54e7f88e290851ccd0a6 Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 31 Mar 2026 10:23:04 -0400 Subject: [PATCH 25/26] Clear LUNAR_ROOT_DIR variable in config.py --- AutoREACTER/reaction_preparation/lunar_client/config.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AutoREACTER/reaction_preparation/lunar_client/config.py b/AutoREACTER/reaction_preparation/lunar_client/config.py index adfc586..e8b270f 100644 --- a/AutoREACTER/reaction_preparation/lunar_client/config.py +++ b/AutoREACTER/reaction_preparation/lunar_client/config.py @@ -1 +1 @@ -LUNAR_ROOT_DIR = '/mnt/c/Users/Janitha/OneDrive - stevens.edu/research_code_projects/LUNAR' +LUNAR_ROOT_DIR = '' From 4f34fa48cda5335dce7ddfe18e5108d3adaf7bce Mon Sep 17 00:00:00 2001 From: Janitha Mahanthe <119646255+janitha-mahanthe@users.noreply.github.com> Date: Tue, 31 Mar 2026 10:23:37 -0400 Subject: [PATCH 26/26] Update AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../reaction_processor/prepare_reactions.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py index 396e9f5..03d0c35 100644 --- a/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py +++ b/AutoREACTER/reaction_preparation/reaction_processor/prepare_reactions.py @@ -572,9 +572,13 @@ def _build_reactants(self, reactant_smiles_1: str, reactant_smiles_2: str) -> tu Tuple of (reactant1 molecule, reactant2 molecule) with explicit hydrogens """ mol_reactant_1 = Chem.MolFromSmiles(reactant_smiles_1) + if mol_reactant_1 is None: + raise SMARTSParsingError(f"Failed to parse first reactant SMILES: {reactant_smiles_1!r}") mol_reactant_1 = Chem.AddHs(mol_reactant_1) mol_reactant_2 = Chem.MolFromSmiles(reactant_smiles_2) + if mol_reactant_2 is None: + raise SMARTSParsingError(f"Failed to parse second reactant SMILES: {reactant_smiles_2!r}") mol_reactant_2 = Chem.AddHs(mol_reactant_2) return mol_reactant_1, mol_reactant_2