sapiopycommons 2025.7.10a595__py3-none-any.whl → 2025.7.14a610__py3-none-any.whl

sapiopycommons/chem/ps_commons.py

@@ -2,11 +2,12 @@
 Parallel Synthesis Commons
 Author: Yechen Qiao
 """
+import itertools
 import json
 from dataclasses import dataclass
 from typing import Any
 
-from indigo import IndigoObject
+from indigo import IndigoObject, IndigoException
 from sapiopycommons.chem.IndigoMolecules import indigo, get_aromatic_dearomatic_forms, renderer
 
 
@@ -56,6 +57,18 @@ class SerializableMoleculeMatch:
         """
         return self._record_id
 
+    @property
+    def query_atom_indexes(self) -> set[int]:
+        return set(self._query_atom_to_atom.keys())
+
+    @property
+    def matching_atom_indexes(self) -> set[int]:
+        return set(self._query_atom_to_atom.values())
+
+    @property
+    def matching_molecule_copy(self) -> IndigoObject:
+        return self._matching_molecule.clone()
+
     def __str__(self):
         return json.dumps(self.to_json())
 
@@ -123,12 +136,13 @@ class SerializableMoleculeMatch:
 
     @staticmethod
     def create(query_molecule: IndigoObject, matching_molecule: IndigoObject,
-               match: IndigoObject) -> 'SerializableMoleculeMatch':
+               match: IndigoObject, query_mol_atom_index_filter: set[int] | None = None) -> 'SerializableMoleculeMatch':
         """
         Create a SerializableMoleculeMatch from a query molecule, matching molecule, and match.
         :param query_molecule: The query molecule.
         :param matching_molecule: The matching molecule.
         :param match: The match object containing atom mappings.
+        :param query_mol_atom_index_filter: Optional list of atom indexes to filter the query molecule atoms.
         :return: A new SerializableMoleculeMatch instance.
         """
         smm = SerializableMoleculeMatch()
@@ -141,12 +155,19 @@ class SerializableMoleculeMatch:
         smm._record_id = 0
 
         for qatom in query_molecule.iterateAtoms():
+            if query_mol_atom_index_filter and qatom.index() not in query_mol_atom_index_filter:
+                continue
             concrete_atom = match.mapAtom(qatom)
             if concrete_atom is None:
                 continue
             smm._query_atom_to_atom[qatom.index()] = concrete_atom.index()
 
+        qbond: IndigoObject
         for qbond in query_molecule.iterateBonds():
+            if query_mol_atom_index_filter:
+                if (qbond.source().index() not in query_mol_atom_index_filter or
+                        qbond.destination().index() not in query_mol_atom_index_filter):
+                    continue
             concrete_bond = match.mapBond(qbond)
             if concrete_bond is None:
                 continue
@@ -157,6 +178,22 @@ class SerializableMoleculeMatch:
         return self._matching_molecule.clone()
 
 
+def is_reaction_atom_map_completed(q_reaction: IndigoObject) -> bool:
+    """
+    Tests each atom in product of query reaction.
+    :param q_reaction: The query reaction to test.
+    :return: True if and only if for every atom that is not an R-Site, it has a mapping number.
+    """
+    for product in q_reaction.iterateProducts():
+        for atom in product.iterateAtoms():
+            if atom.isRSite():
+                continue
+            map_num = q_reaction.atomMappingNumber(atom)
+            if map_num == 0:
+                return False
+    return True
+
+
 @dataclass
 class ReplacementReaction:
     """
@@ -330,127 +367,6 @@ def inherit_auto_map_by_match(target_reaction: IndigoObject, source_reaction: In
     target_reaction.automap("keep")
 
 
-def get_used_reactants_for_match(
-        reaction: IndigoObject, q_reaction: IndigoObject, reaction_match: IndigoObject,
-        kept_replacement_reaction_list_list: list[list[ReplacementReaction]]) -> list[ReplacementReaction]:
-    """
-    Find the replacement reactions that correspond to the reactants in reaction that also matches the query reaction.
-    Return None if any of the reactants do not have a corresponding replacement reaction, even though reaction may have matches directly to the query reaction.
-    Otherwise, return a list of ReplacementReaction objects that correspond to the reactants in the reaction ordered by the reactants in the query reaction.
-    """
-    q_reactants = []
-    for q_reactant in q_reaction.iterateReactants():
-        q_reactants.append(q_reactant)
-    q_products = []
-    for rr_product in q_reaction.iterateProducts():
-        q_products.append(rr_product)
-    reactants = []
-    for enum_r in reaction.iterateReactants():
-        reactants.append(enum_r)
-    products = []
-    for enum_p in reaction.iterateProducts():
-        products.append(enum_p)
-    q_reactant: IndigoObject
-    ret: list[ReplacementReaction] = []
-    for reactant_index, q_reactant in enumerate(q_reactants):
-        replacement_list = kept_replacement_reaction_list_list[reactant_index]
-        enum_r = reactants[reactant_index]
-        useful_enumr_atom_indexes = set()
-        for q_atom in q_reactant.iterateAtoms():
-            enum_atom = reaction_match.mapAtom(q_atom)
-            if enum_atom:
-                useful_enumr_atom_indexes.add(enum_atom.index())
-        found: ReplacementReaction | None = None
-        for rr_index, rr in enumerate(replacement_list):
-            exact_match = indigo.exactMatch(rr.replacement_reactant, enum_r)
-            if not exact_match:
-                # YQ Skip if this enumeration is not meant to be the same reactant as replacement we are iterating.
-                continue
-            query_reactant_atom_by_index: dict[int, IndigoObject] = {}
-            rr_reactant_atom_by_index: dict[int, IndigoObject] = {}
-            query_reactant_index_to_rr_reactant_index: dict[int, int] = {}
-            rr_reactant_index_to_query_reactant_index: dict[int, int] = {}
-            enum_r_atom_mapping_number_to_rr_atom: dict[int, IndigoObject] = {}
-            q_reaction_atom_mapping_number_to_rr_atom: dict[int, IndigoObject] = {}
-            q_r_site_to_rr_atom: dict[str, IndigoObject] = {}
-            for q_atom in q_reactant.iterateAtoms():
-                query_reactant_atom_by_index[q_atom.index()] = q_atom
-                rr_atom = rr.replacement_query_reaction_match.mapAtom(q_atom)
-                if rr_atom:
-                    query_reactant_index_to_rr_reactant_index[q_atom.index()] = rr_atom.index()
-                    rr_reactant_index_to_query_reactant_index[rr_atom.index()] = q_atom.index()
-                    q_reaction_atom_mapping_number = q_reaction.atomMappingNumber(q_atom)
-                    if q_reaction_atom_mapping_number > 0:
-                        q_reaction_atom_mapping_number_to_rr_atom[q_reaction_atom_mapping_number] = rr_atom
-                    if q_atom.isRSite():
-                        r_site = q_atom.symbol()
-                        q_r_site_to_rr_atom[r_site] = rr_atom
-            for rr_atom in rr.replacement_reactant.iterateAtoms():
-                rr_reactant_atom_by_index[rr_atom.index()] = rr_atom
-                enum_r_atom = exact_match.mapAtom(rr_atom)
-                if enum_r_atom:
-                    enum_r_atom_mapping_number = reaction.atomMappingNumber(enum_r_atom)
-                    if enum_r_atom_mapping_number > 0:
-                        enum_r_atom_mapping_number_to_rr_atom[enum_r_atom_mapping_number] = rr_atom
-
-            rr_products = []
-            for rr_product in rr.reaction.iterateProducts():
-                rr_products.append(rr_product)
-            still_valid_rr = True
-            for product_index, enum_product in enumerate(products):
-                if not still_valid_rr:
-                    break
-                query_product = q_products[product_index]
-                enum_r_atom_mapping_number_to_q_product_atom = {}
-                for q_atom in query_product.iterateAtoms():
-                    enum_atom = reaction_match.mapAtom(q_atom)
-                    if enum_atom:
-                        enum_mapping_number = reaction.atomMappingNumber(enum_atom)
-                        if enum_mapping_number > 0:
-                            enum_r_atom_mapping_number_to_q_product_atom[enum_mapping_number] = q_atom
-
-                for enum_atom in enum_product.iterateAtoms():
-                    enum_mapping_number = reaction.atomMappingNumber(enum_atom)
-                    if enum_mapping_number == 0:
-                        continue
-                    rr_atom = enum_r_atom_mapping_number_to_rr_atom.get(enum_mapping_number)
-                    if not rr_atom:
-                        continue
-                    q_product_atom: IndigoObject = enum_r_atom_mapping_number_to_q_product_atom.get(enum_mapping_number)
-                    if not q_product_atom:
-                        continue
-                    if q_product_atom.isRSite():
-                        r_site = q_product_atom.symbol()
-                        rr_atom_r_site = q_r_site_to_rr_atom.get(r_site)
-                        if not rr_atom_r_site:
-                            still_valid_rr = False
-                            break
-                        if rr_atom.index() != rr_atom_r_site.index():
-                            still_valid_rr = False
-                            break
-                    else:
-                        q_product_atom_mapping_number = q_reaction.atomMappingNumber(q_product_atom)
-                        if q_product_atom_mapping_number == 0:
-                            continue
-                        query_reactant_atom_index = rr_reactant_index_to_query_reactant_index.get(rr_atom.index())
-                        if query_reactant_atom_index is None:
-                            still_valid_rr = False
-                            break
-                        query_reactant_atom = query_reactant_atom_by_index.get(query_reactant_atom_index)
-                        query_reactant_atom_mapping_number = q_reaction.atomMappingNumber(query_reactant_atom)
-                        if q_product_atom_mapping_number != query_reactant_atom_mapping_number:
-                            still_valid_rr = False
-                            break
-            if still_valid_rr:
-                found = rr
-                break
-        if found:
-            ret.append(found)
-        else:
-            return []
-    return ret
-
-
 def are_symmetrical_subs(match1: SerializableMoleculeMatch, match2: SerializableMoleculeMatch) -> bool:
     """
     Check if two SerializableMoleculeMatch objects are symmetrical.
@@ -521,3 +437,327 @@ def replace_r_site_with_wildcards(mol: IndigoObject) -> IndigoObject:
         if atom.isRSite():
             atom.resetAtom("*")
     return ret
+
+
+def get_r_substructure(query_mol: IndigoObject, mol: IndigoObject,
+                       initial_atom: IndigoObject, match: IndigoObject | SerializableMoleculeMatch,
+                       r_site: str) -> IndigoObject:
+    """
+    Return a connected R substructure sourced from the symbol, that is not within the original query match.
+    :param query_mol: The query molecule that contains the R site.
+    :param mol: The molecule that contains the R site.
+    :param initial_atom: The initial atom that is the R site.
+    :param match: The match object that maps atoms and bonds between the query and the molecule.
+    Note the within-R site molecules will not be part of the match.
+    But the starting position of R site is replaced with psuedoatom "*" and thus matches.
+    :param r_site: The R site symbol to match against.
+    """
+    keeping_atom_index_set = set()
+    visiting: set[int] = set()
+    visiting.add(initial_atom.index())
+    visited: set[int] = set()
+
+    exclusion_indexes = set()
+    for q_atom in query_mol.iterateAtoms():
+        mapped_atom = match.mapAtom(q_atom)
+        if mapped_atom:
+            to_exclude: bool
+            if q_atom.isRSite():
+                to_exclude = q_atom.symbol() != r_site
+            else:
+                to_exclude = True
+            if to_exclude:
+                exclusion_indexes.add(mapped_atom.index())
+    while visiting:
+        visiting_atom: IndigoObject = mol.getAtom(visiting.pop())
+        keeping_atom_index_set.add(visiting_atom.index())
+        visited.add(visiting_atom.index())
+        for nei in visiting_atom.iterateNeighbors():
+            nei_index = nei.index()
+            if nei_index in visited or nei_index in visiting:
+                continue
+            if nei_index in exclusion_indexes and nei_index != initial_atom.index():
+                continue
+            visiting.add(nei_index)
+    removing_index_set: list[int] = list()
+    for atom in mol.iterateAtoms():
+        if atom.index() not in keeping_atom_index_set:
+            removing_index_set.append(atom.index())
+    r_substructure = mol.clone()
+    r_substructure.removeAtoms(removing_index_set)
+    return r_substructure
+
+
+def get_rr_substructure_by_symbol(query_reactant, replacement_reaction) -> dict[str, IndigoObject]:
+    rr_substructure_by_symbol: dict[str, IndigoObject] = {}
+    for q_atom in query_reactant.iterateAtoms():
+        if not q_atom.isRSite():
+            continue
+        r_site_symbol = q_atom.symbol()
+        mapped_atom = replacement_reaction.replacement_query_reaction_match.mapAtom(q_atom)
+        if mapped_atom is None:
+            raise ValueError(
+                "The replacement reactant " + replacement_reaction.replacement_reactant.smiles() + " do not have R Site: " + r_site_symbol + ". This should not happen.")
+        r_substructure = get_r_substructure(query_reactant, replacement_reaction.replacement_reactant, mapped_atom,
+                                            replacement_reaction.replacement_query_reaction_match, r_site_symbol)
+        rr_substructure_by_symbol[r_site_symbol] = r_substructure
+    return rr_substructure_by_symbol
+
+
+def __test_reactant_match(replacement_reaction: ReplacementReaction,
+                          testing_reactant: IndigoObject,
+                          query_reactant: IndigoObject) -> SerializableMoleculeMatch | None:
+    """ YQ: Finally piecing together both sides...
+    Test whether the reactant in the replacement reaction matches the reactant in the testing reaction.
+    We will be matching against the highlighted portion on each section to ensure the highlighted atom and bonds match.
+    :param replacement_reaction: The replacement reaction containing the reactant to test.
+    :param testing_reactant: The reactant in the testing reaction to match against.
+    :param query_reactant: The reactant in the query reaction to match against.
+    """
+    orig_query_reactant = query_reactant
+    query_reactant = replace_r_site_with_wildcards(query_reactant)
+    if not indigo.exactMatch(replacement_reaction.replacement_reactant, testing_reactant):
+        return None
+    outer_matcher: IndigoObject = indigo.substructureMatcher(testing_reactant)
+    used_query_atom_indexes = replacement_reaction.replacement_query_reaction_match.query_atom_indexes
+    used_rr_atom_indexes = replacement_reaction.replacement_query_reaction_match.matching_atom_indexes
+    rr_substructure_by_symbol: dict[str, IndigoObject] = get_rr_substructure_by_symbol(orig_query_reactant,
+                                                                                       replacement_reaction)
+
+    for outer_match in outer_matcher.iterateMatches(query_reactant):
+        ret: SerializableMoleculeMatch = SerializableMoleculeMatch.create(
+            orig_query_reactant, testing_reactant, outer_match, used_query_atom_indexes)
+        used_testing_reactant_atoms = []
+        for q_atom in query_reactant.iterateAtoms():
+            if q_atom.index() not in used_query_atom_indexes:
+                continue
+            mapped_atom = outer_match.mapAtom(q_atom)
+            if mapped_atom is None:
+                continue
+            used_testing_reactant_atoms.append(mapped_atom.index())
+        used_replacement_mol = replacement_reaction.replacement_reactant.clone()
+        used_replacement_mol_delete_indexes = []
+        for atom in used_replacement_mol.iterateAtoms():
+            if atom.index() not in used_rr_atom_indexes:
+                used_replacement_mol_delete_indexes.append(atom.index())
+        used_replacement_mol.removeAtoms(used_replacement_mol_delete_indexes)
+        used_testing_mol = testing_reactant.clone()
+        used_testing_mol_delete_indexes = []
+        for atom in used_testing_mol.iterateAtoms():
+            if atom.index() not in used_testing_reactant_atoms:
+                used_testing_mol_delete_indexes.append(atom.index())
+        used_testing_mol.removeAtoms(used_testing_mol_delete_indexes)
+        try:
+            exact_match = indigo.exactMatch(used_replacement_mol, used_testing_mol)
+            if not exact_match:
+                continue
+        except IndigoException:
+            continue
+        # Now check each R site substructure and it should be an exact match.
+        outer_match_r_substructure_by_symbol: dict[str, IndigoObject] = {}
+        missing_r_site = False
+        for q_atom in query_reactant.iterateAtoms():
+            orig_q_atom = orig_query_reactant.getAtom(q_atom.index())
+            if not orig_q_atom.isRSite():
+                continue
+            r_site_symbol = orig_q_atom.symbol()
+            mapped_atom = outer_match.mapAtom(q_atom)
+            if mapped_atom is None:
+                missing_r_site = True
+                continue
+            r_substructure = get_r_substructure(orig_query_reactant, testing_reactant, mapped_atom, outer_match,
+                                                r_site_symbol)
+            outer_match_r_substructure_by_symbol[r_site_symbol] = r_substructure
+        if missing_r_site:
+            # If we are missing an R site, we cannot match.
+            continue
+        r_site_mismatch = False
+        for r_site_symbol in rr_substructure_by_symbol.keys():
+            rr_substructure = rr_substructure_by_symbol[r_site_symbol]
+            outer_match_r_substructure = outer_match_r_substructure_by_symbol[r_site_symbol]
+            if not indigo.exactMatch(rr_substructure, outer_match_r_substructure):
+                r_site_mismatch = True
+                break
+        if r_site_mismatch:
+            # If we have a mismatch in R site substructure, we cannot match.
+            continue
+
+        # We are done matching. Return the match mapping.
+        return ret
+    return None
+
+
+def __test_product_match(testing_reaction: IndigoObject, q_reaction: IndigoObject,
+                         cur_rr_list: list[ReplacementReaction],
+                         testing_reactants_match_list: list[SerializableMoleculeMatch]) -> list[
+                                                                                               SerializableMoleculeMatch] | None:
+    """ YQ: My fifth try OOF
+    For each product, we are testing against two criteria:
+    1. That every R site from a product would exact match to the R site defined within reactant.
+    2. That atomic mapping numbers for query matches are within the matches of intersection of cur_rr_list and testing_reactants_match_list.
+    And the matching result for each atom via their reaction atom mapping numbers should follow atomic conservation law:
+    2.1 For each atom number in the reactant part, there should be no more than one atom in the product part with the same mapping number.
+    2.2 For each atom number in the reactant part, the mapped atom in the product part has the nucleus.
+    :param testing_reaction:
+    :param q_reaction:
+    :param cur_rr_list:
+    :param testing_reactants_match_list:
+    :return:
+    """
+    # ********* PREPARE DATA *********
+    ret: list[SerializableMoleculeMatch] = []
+    testing_reactants = []
+    for testing_reactant in testing_reaction.iterateReactants():
+        testing_reactants.append(testing_reactant)
+    testing_products = []
+    for testing_product in testing_reaction.iterateProducts():
+        testing_products.append(testing_product)
+    query_reactants = []
+    for q_reactant in q_reaction.iterateReactants():
+        query_reactants.append(q_reactant)
+    query_products = []
+    for q_product in q_reaction.iterateProducts():
+        query_products.append(q_product)
+    replacement_reactants = []
+    replacement_reactant_match_list = []
+    q_atom_mapping_number_to_rr_reactant_atom: dict[int, IndigoObject] = {}
+    for reactant_index, replacement_reaction in enumerate(cur_rr_list):
+        replacement_reactants.append(replacement_reaction.replacement_reactant)
+        replacement_reactant_match_list.append(replacement_reaction.replacement_query_reaction_match)
+        query_reactant = query_reactants[reactant_index]
+        for q_atom in query_reactant.iterateAtoms():
+            mapped_atom = replacement_reaction.replacement_query_reaction_match.mapAtom(q_atom)
+            q_atom_mapping_number = q_reaction.atomMappingNumber(q_atom)
+            if q_atom_mapping_number == 0:
+                continue
+            if mapped_atom is None:
+                continue
+            q_atom_mapping_number_to_rr_reactant_atom[q_atom_mapping_number] = mapped_atom
+    rr_substructure_by_symbol: dict[str, IndigoObject] = {}
+    for reactant_index, replacement_reaction in enumerate(cur_rr_list):
+        query_reactant = query_reactants[reactant_index]
+        cur_dict = get_rr_substructure_by_symbol(query_reactant, replacement_reaction)
+        rr_substructure_by_symbol.update(cur_dict)
+
+    # ********* TESTING PRODUCTS *********
+    accepted_used_atom_mapping_numbers: set[int] = set()
+    for product_index, testing_product in enumerate(testing_products):
+        q_product = query_products[product_index]
+        orig_q_product = q_product
+        q_product = replace_r_site_with_wildcards(q_product)
+        outer_matcher: IndigoObject = indigo.substructureMatcher(testing_product)
+        found_match: SerializableMoleculeMatch | None = None
+        for outer_match in outer_matcher.iterateMatches(q_product):
+            ss_match: SerializableMoleculeMatch = SerializableMoleculeMatch.create(orig_q_product, testing_product,
+                                                                                   outer_match)
+            valid_q_product_aam = True
+            valid_r_group = True
+            used_atom_mapping_numbers: set[int] = set()
+            for q_atom in q_product.iterateAtoms():
+                mapped_product_atom = outer_match.mapAtom(q_atom)
+                orig_q_atom = orig_q_product.getAtom(q_atom.index())
+                q_atom_mapping_number = q_reaction.atomMappingNumber(orig_q_atom)
+                if q_atom_mapping_number > 0 and not orig_q_atom.isRSite():
+                    if q_atom_mapping_number in used_atom_mapping_numbers or q_atom_mapping_number in accepted_used_atom_mapping_numbers:
+                        raise ValueError(
+                            "Multiple atoms in the product with the same query atom mapping number: " + str(
+                                q_atom_mapping_number))
+                    rr_atom = q_atom_mapping_number_to_rr_reactant_atom.get(q_atom_mapping_number)
+                    if rr_atom is None:
+                        valid_q_product_aam = False
+                        break
+                    if not rr_atom.symbol() == mapped_product_atom.symbol():
+                        valid_q_product_aam = False
+                        break
+                    used_atom_mapping_numbers.add(q_atom_mapping_number)
+                elif orig_q_atom.isRSite():
+                    r_site_symbol = orig_q_atom.symbol()
+                    r_substructure = get_r_substructure(orig_q_product, testing_product, mapped_product_atom,
+                                                        outer_match,
+                                                        r_site_symbol)
+                    rr_substructure = rr_substructure_by_symbol.get(r_site_symbol)
+                    if rr_substructure is None:
+                        # This only happens if we didn't replace wildcard properly in original highlight or a misalignment between reactant and actual reaction template in Sapio.
+                        raise ValueError("Missing RR substructure for R site: " + r_site_symbol + ".")
+                    if not indigo.exactMatch(rr_substructure, r_substructure):
+                        valid_r_group = False
+                        break
+            if valid_q_product_aam and valid_r_group:
+                found_match = ss_match
+                accepted_used_atom_mapping_numbers.update(used_atom_mapping_numbers)
+                break
+        if not found_match:
+            return None
+        ret.append(found_match)
+    return ret
+
+
+def __get_final_highlighted_reaction(cur_rr_list: list[ReplacementReaction],
+                                     product_matches: list[SerializableMoleculeMatch]) -> tuple[IndigoObject, list[
+    ReplacementReaction]] | None:
+    """
+    Translates the final match into a highlighted reaction.
+    :param cur_rr_list: The selected reactants that together forms an acceptable reaction.
+    :param product_matches: The generated products coming from the selected reactants.
+    :return: An IndigoObject representing the final reaction with highlights.
+    """
+    ret: IndigoObject = indigo.createReaction()
+    for replacement_reaction in cur_rr_list:
+        reactant_mol = replacement_reaction.replacement_reactant.clone()
+        highlighting_atom_indexes = replacement_reaction.replacement_query_reaction_match.matching_atom_indexes
+        for atom in reactant_mol.iterateAtoms():
+            if atom.index() in highlighting_atom_indexes:
+                atom.highlight()
+            for nei in atom.iterateNeighbors():
+                if nei.index() in highlighting_atom_indexes:
+                    nei.bond().highlight()
+        ret.addReactant(reactant_mol)
+    for product_match in product_matches:
+        product_mol = product_match.get_matched_molecule_copy()
+        highlighting_atom_indexes = product_match.matching_atom_indexes
+        for atom in product_mol.iterateAtoms():
+            if atom.index() in highlighting_atom_indexes:
+                atom.highlight()
+            for nei in atom.iterateNeighbors():
+                if nei.index() in highlighting_atom_indexes:
+                    nei.bond().highlight()
+        ret.addProduct(product_mol)
+    _, ret = get_aromatic_dearomatic_forms(ret)
+    return ret, cur_rr_list
+
+
+def ps_match(testing_reaction: IndigoObject, q_reaction: IndigoObject,
+             kept_replacement_reaction_list_list: list[list[ReplacementReaction]]) -> tuple[IndigoObject, list[
+    ReplacementReaction]] | None:
+    testing_reactants = []
+    for testing_reactant in testing_reaction.iterateReactants():
+        testing_reactants.append(testing_reactant)
+    query_reactants = []
+    for q_reactant in q_reaction.iterateReactants():
+        query_reactants.append(q_reactant)
+
+    reactant_ranges = []
+    for replacement_reaction_list in kept_replacement_reaction_list_list:
+        reactant_ranges.append(range(len(replacement_reaction_list)))
+    reactant_cartesian_products = itertools.product(*reactant_ranges)
+    for reactant_combination in reactant_cartesian_products:
+        cur_rr_list: list[ReplacementReaction] = []
+        for reactant_index, replacement_reaction_index in enumerate(reactant_combination):
+            replacement_reaction: ReplacementReaction = kept_replacement_reaction_list_list[reactant_index][
+                replacement_reaction_index]
+            cur_rr_list.append(replacement_reaction)
+        is_valid_reactants = True
+        testing_reactants_match_list = []
+        for reactant_index, replacement_reaction in enumerate(cur_rr_list):
+            match = __test_reactant_match(
+                replacement_reaction, testing_reactants[reactant_index], query_reactants[reactant_index])
+            if not match:
+                is_valid_reactants = False
+                break
+            testing_reactants_match_list.append(match)
+        if not is_valid_reactants:
+            continue
+        product_matches = __test_product_match(testing_reaction, q_reaction, cur_rr_list, testing_reactants_match_list)
+        if product_matches:
+            return __get_final_highlighted_reaction(cur_rr_list, product_matches)
+    return None

{sapiopycommons-2025.7.10a595.dist-info → sapiopycommons-2025.7.14a610.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.7.10a595
+Version: 2025.7.14a610
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2025.7.10a595.dist-info → sapiopycommons-2025.7.14a610.dist-info}/RECORD

@@ -5,7 +5,7 @@ sapiopycommons/callbacks/field_builder.py,sha256=rnIP-RJafk3mZlAx1eJ8a0eSW9Ps_L6
 sapiopycommons/chem/IndigoMolecules.py,sha256=30bsnZ2o4fJXUV6kUTI-I6fDa7bQj7zfE3rOQQ7WD5M,5287
 sapiopycommons/chem/Molecules.py,sha256=mVqPn32MPMjF0iZas-5MFkS-upIdoW5OB72KKZmJRJA,12523
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/chem/ps_commons.py,sha256=TobN8V9FW32x7o1C6i_WsqGkdldbyVTUfhG5W0xAxMM,23598
+sapiopycommons/chem/ps_commons.py,sha256=aUxytBeFkkNUzmwgK4KUKUUg5yIyfw6VUrHXnXCykNA,36032
 sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/auto_pagers.py,sha256=89p-tik0MhsOplYje6LbAW4WClldpAmb8YXFDoXhIlY,17144
 sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
@@ -63,7 +63,7 @@ sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
 sapiopycommons/webhook/webhook_handlers.py,sha256=tUVNCw05CDGu1gFDm2g558hX_O203WVm_n__ojjoRRM,39841
 sapiopycommons/webhook/webservice_handlers.py,sha256=tyaYGG1-v_JJrJHZ6cy5mGCxX9z1foLw7pM4MDJlFxs,14297
-sapiopycommons-2025.7.10a595.dist-info/METADATA,sha256=LBGGU5Is2VuGiTokZ-wlD74iKgZnbtr-_0Yp5-R4Z1A,3143
-sapiopycommons-2025.7.10a595.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-sapiopycommons-2025.7.10a595.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2025.7.10a595.dist-info/RECORD,,
+sapiopycommons-2025.7.14a610.dist-info/METADATA,sha256=9bpnGjMnsjoJME1IsB-lTJovX4HB3ZHKf6ffDNdjIPA,3143
+sapiopycommons-2025.7.14a610.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sapiopycommons-2025.7.14a610.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2025.7.14a610.dist-info/RECORD,,