synkit 1.3.1a0__tar.gz → 1.3.2b1__tar.gz

{synkit-1.3.1a0 → synkit-1.3.2b1}/.gitignore

@@ -27,4 +27,13 @@ crn/*
 test_run.py
 Data/Study/CRN/case_formose/*
 
-synkit/Graph/dev/*
+synkit/Graph/dev/*
+*.ipynb
+*.json
+*.txt
+*.log
+sprint/
+test_syn.py
+.gitignore
+measure_candidate_stages.py
+run_valid_bug_cases.py

{synkit-1.3.1a0 → synkit-1.3.2b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 1.3.1a0
+Version: 1.3.2b1
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit

{synkit-1.3.1a0 → synkit-1.3.2b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "1.3.1a"
+version = "1.3.2b1"
 description = "Utility for reaction modeling using graph grammar"
 readme = "README.md"
 long-description = { file = "CHANGELOG.md" }

{synkit-1.3.1a0 → synkit-1.3.2b1}/synkit/CRN/Query/kegg_parse.py

@@ -426,7 +426,7 @@ def parse_module_reaction_directions(
     in_reaction = False
     for line in text.splitlines():
         if line.startswith("REACTION"):
-            payload = line[len("REACTION"):].strip()
+            payload = line[len("REACTION") :].strip()  # noqa
             in_reaction = True
         elif in_reaction and (line.startswith(" ") or line.startswith("\t")):
             payload = line.strip()

{synkit-1.3.1a0 → synkit-1.3.2b1}/synkit/Chem/Molecule/atom_features.py

@@ -192,7 +192,6 @@ class AtomFeatureExtractor:
             "partial_charge": round(float(gcharge), 3),
             "hybridization": str(atom.GetHybridization()),
             "in_ring": bool(atom.IsInRing()),
-            "implicit_hcount": int(atom.GetNumImplicitHs()),
             "neighbors": neighbor_symbols,
             "atom_map": atom_map,
         }

{synkit-1.3.1a0 → synkit-1.3.2b1}/synkit/Chem/Reaction/standardize.py

@@ -72,7 +72,34 @@ class Standardize:
         return valid
 
     @staticmethod
-    def standardize_rsmi(rsmi: str, stereo: bool = False) -> Optional[str]:
+    def _parse_molecule_fragments(
+        smiles_list: List[str],
+    ) -> Tuple[List[Chem.Mol], bool]:
+        """Parse and sanitize SMILES fragments.
+
+        :param smiles_list: List of SMILES strings to validate.
+        :type smiles_list: List[str]
+        :returns: Tuple of valid molecules and whether any fragment was invalid.
+        :rtype: Tuple[List[rdkit.Chem.Mol], bool]
+        """
+        valid: List[Chem.Mol] = []
+        had_invalid = False
+        for smi in smiles_list:
+            mol = Chem.MolFromSmiles(smi, sanitize=False)
+            if mol:
+                try:
+                    Chem.SanitizeMol(mol)
+                    valid.append(mol)
+                except Exception:
+                    had_invalid = True
+            else:
+                had_invalid = True
+        return valid, had_invalid
+
+    @staticmethod
+    def standardize_rsmi(
+        rsmi: str, stereo: bool = False, remove_invalid: bool = True
+    ) -> Optional[str]:
         """
         Normalize a reaction SMILES: validate molecules, sort fragments, optionally keep stereo.
 
@@ -80,6 +107,10 @@ class Standardize:
         :type rsmi: str
         :param stereo: If True, include stereochemistry in the output. Defaults to False.
         :type stereo: bool
+        :param remove_invalid: If True, drop invalid fragments and standardize
+            remaining molecules. If False, return None when any invalid fragment
+            exists. Defaults to True.
+        :type remove_invalid: bool
         :returns: Standardized reaction SMILES or None if no valid molecules remain.
         :rtype: Optional[str]
         :raises ValueError: If the input format is invalid.
@@ -91,8 +122,15 @@ class Standardize:
                 "Invalid reaction SMILES format. Expected 'reactants>>products'."
             )
 
-        react_mols = Standardize.filter_valid_molecules(react_str.split("."))
-        prod_mols = Standardize.filter_valid_molecules(prod_str.split("."))
+        react_mols, react_invalid = Standardize._parse_molecule_fragments(
+            react_str.split(".")
+        )
+        prod_mols, prod_invalid = Standardize._parse_molecule_fragments(
+            prod_str.split(".")
+        )
+
+        if not remove_invalid and (react_invalid or prod_invalid):
+            return None
 
         if not react_mols or not prod_mols:
             return None
@@ -107,7 +145,11 @@ class Standardize:
         return f"{sorted_react}>>{sorted_prod}"
 
     def fit(
-        self, rsmi: str, remove_aam: bool = True, ignore_stereo: bool = True
+        self,
+        rsmi: str,
+        remove_aam: bool = True,
+        ignore_stereo: bool = True,
+        remove_invalid: bool = True,
     ) -> Optional[str]:
         """
         Full standardization pipeline: strip atom‑mapping, normalize SMILES, fix hydrogen notation.
@@ -118,16 +160,22 @@ class Standardize:
         :type remove_aam: bool
         :param ignore_stereo: If True, drop stereochemistry. Defaults to True.
         :type ignore_stereo: bool
+        :param remove_invalid: If True, drop invalid fragments and standardize
+            remaining molecules. If False, return None when any invalid fragment
+            exists. Defaults to True.
+        :type remove_invalid: bool
         :returns: The standardized reaction SMILES, or None if standardization fails.
         :rtype: Optional[str]
         """
-        if remove_aam:
-            rsmi = self.remove_atom_mapping(rsmi)
-
-        std = self.standardize_rsmi(rsmi, stereo=not ignore_stereo)
+        std = self.standardize_rsmi(
+            rsmi, stereo=not ignore_stereo, remove_invalid=remove_invalid
+        )
         if std is None:
             return None
 
+        if remove_aam:
+            std = self.remove_atom_mapping(std)
+
         # Format any double‑hydrogen notation
         return std.replace("[HH]", "[H][H]")
 

{synkit-1.3.1a0 → synkit-1.3.2b1}/synkit/Chem/Reaction/tautomerize.py

@@ -1,8 +1,9 @@
 from typing import List, Dict, Optional
 from rdkit import Chem
-from fgutils import FGQuery
 from joblib import Parallel, delayed
 
+from synkit.Graph.FG import smiles_to_graph_and_functional_groups
+
 
 class Tautomerize:
     """Standardize molecules by converting enol and hemiketal tautomers into
@@ -103,18 +104,60 @@ class Tautomerize:
         :returns: Canonical SMILES of the standardized molecule.
         :rtype: str
         """
-        query = FGQuery()
-        fg = query.get(smiles)
-        for item in fg:
-            label, indices = item
+        while True:
+            targets = Tautomerize._tautomer_targets(smiles)
+            if not targets:
+                break
+            label, indices = targets[0]
             if label == "hemiketal":
                 smiles = Tautomerize.standardize_hemiketal(smiles, indices)
-                fg = query.get(smiles)
             elif label == "enol":
                 smiles = Tautomerize.standardize_enol(smiles, indices)
-                fg = query.get(smiles)
         return Chem.CanonSmiles(smiles)
 
+    @staticmethod
+    def _tautomer_targets(smiles: str) -> list[tuple[str, List[int]]]:
+        """Return RDKit-index targets used by the tautomer repair helpers."""
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return []
+        graph, groups = smiles_to_graph_and_functional_groups(smiles)
+        node_to_idx = {
+            (
+                atom.GetAtomMapNum() if atom.GetAtomMapNum() else atom.GetIdx() + 1
+            ): atom.GetIdx()
+            for atom in mol.GetAtoms()
+        }
+
+        targets = [
+            (label, [node_to_idx[node] for node in nodes])
+            for label, nodes in groups
+            if label in {"hemiketal", "enol"}
+        ]
+        targets.extend(
+            ("hemiketal", [node_to_idx[node] for node in nodes])
+            for nodes in Tautomerize._geminal_diol_nodes(graph)
+        )
+        return targets
+
+    @staticmethod
+    def _geminal_diol_nodes(graph) -> list[tuple[int, ...]]:
+        """Legacy tautomerization compatibility for hydrated carbonyls."""
+        targets: list[tuple[int, ...]] = []
+        for carbon, data in graph.nodes(data=True):
+            if data.get("element") != "C":
+                continue
+            hydroxyls = [
+                neighbor
+                for neighbor in graph.neighbors(carbon)
+                if graph.nodes[neighbor].get("element") == "O"
+                and graph.nodes[neighbor].get("hcount", 0) >= 1
+                and graph.edges[carbon, neighbor].get("order") == 1.0
+            ]
+            if len(hydroxyls) >= 2:
+                targets.append((carbon, hydroxyls[0], hydroxyls[1]))
+        return targets
+
     @staticmethod
     def fix_dict(data: Dict[str, str], reaction_column: str) -> Dict[str, str]:
         """Standardize the reactant and product SMILES in a reaction

{synkit-1.3.1a0 → synkit-1.3.2b1}/synkit/Graph/Canon/canon_graph.py

@@ -316,8 +316,8 @@ class GraphCanonicaliser:
         nodes = sorted(g.nodes(data=True), key=lambda x: self._node_key(*x))
         edges = sorted(g.edges(data=True), key=lambda x: self._edge_key(*x))
 
-        node_str = ";".join(f"{n}:{self._node_key(n,d)}" for n, d in nodes)
-        edge_str = ";".join(f"{(u,v)}:{self._edge_key(u,v,d)}" for u, v, d in edges)
+        node_str = ";".join(f"{n}:{self._node_key(n, d)}" for n, d in nodes)
+        edge_str = ";".join(f"{(u, v)}:{self._edge_key(u, v, d)}" for u, v, d in edges)
         return f"N[{node_str}]|E[{edge_str}]"
 
     # ------------------------------------------------------------------ #

synkit-1.3.2b1/synkit/Graph/FG/__init__.py

@@ -0,0 +1,19 @@
+"""Functional-group detection on SynKit molecular graphs."""
+
+from .catalog import default_registry
+from .audit import FunctionalGroupAudit, audit_reaction_smiles
+from .api import FunctionalGroupLabels, smiles_to_graph_and_functional_groups
+from .detector import FunctionalGroupDetector
+from .model import FunctionalGroupMatch, FunctionalGroupPattern, FunctionalGroupRegistry
+
+__all__ = [
+    "FunctionalGroupDetector",
+    "FunctionalGroupLabels",
+    "FunctionalGroupAudit",
+    "FunctionalGroupMatch",
+    "FunctionalGroupPattern",
+    "FunctionalGroupRegistry",
+    "default_registry",
+    "audit_reaction_smiles",
+    "smiles_to_graph_and_functional_groups",
+]

synkit-1.3.2b1/synkit/Graph/FG/api.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import networkx as nx
+
+from synkit.IO.chem_converter import smiles_to_graph
+
+from .detector import FunctionalGroupDetector
+
+FunctionalGroupLabels = list[tuple[str, tuple[int, ...]]]
+
+
+def smiles_to_graph_and_functional_groups(
+    smiles: str,
+    *,
+    sanitize: bool = True,
+) -> tuple[nx.Graph, FunctionalGroupLabels]:
+    """Convert SMILES to a molecular graph and detect functional groups.
+
+    Atom-mapped SMILES keep their non-zero atom-map numbers as graph node IDs.
+    Unmapped atoms use their 1-based atom order as node IDs, so both mapped and
+    unmapped SMILES can be passed to the same API.
+
+    :param smiles: Input SMILES, with or without atom-map labels.
+    :type smiles: str
+    :param sanitize: If ``True``, sanitize the RDKit molecule during conversion.
+    :type sanitize: bool
+    :return: Molecular graph and detected ``(name, node_ids)`` FG labels.
+    :rtype: tuple[nx.Graph, list[tuple[str, tuple[int, ...]]]]
+    :raises ValueError: If the SMILES cannot be converted to a molecular graph.
+    """
+    graph = smiles_to_graph(
+        smiles,
+        drop_non_aam=False,
+        sanitize=sanitize,
+        use_index_as_atom_map=True,
+    )
+    if graph is None:
+        raise ValueError(f"Could not convert SMILES to molecular graph: {smiles!r}")
+    return graph, FunctionalGroupDetector().detect(graph)

synkit-1.3.2b1/synkit/Graph/FG/audit.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Iterable
+
+import networkx as nx
+
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.IO.chem_converter import smiles_to_graph
+
+from .detector import FunctionalGroupDetector
+from .ring_system import AromaticRingSystemDetector
+
+
+@dataclass(frozen=True)
+class FunctionalGroupAudit:
+    """Aggregated detector coverage over a reaction-SMILES corpus."""
+
+    reactions: int
+    molecules: int
+    parse_failures: int
+    elapsed_seconds: float
+    label_counts: Counter[str]
+    heteroaromatic_systems: int
+    named_heteroaromatic_systems: int
+    unnamed_heteroaromatic_systems: Counter[tuple]
+    uncovered_atom_signatures: Counter[tuple]
+    uncovered_edge_signatures: Counter[tuple]
+
+    @property
+    def unnamed_heteroaromatic_count(self) -> int:
+        return self.heteroaromatic_systems - self.named_heteroaromatic_systems
+
+
+def audit_reaction_smiles(
+    reactions: Iterable[str],
+    *,
+    standardizer: Standardize | None = None,
+) -> FunctionalGroupAudit:
+    """Audit FG coverage for an iterable of reaction SMILES strings."""
+    std = Standardize() if standardizer is None else standardizer
+    detector = FunctionalGroupDetector()
+
+    reaction_count = 0
+    molecule_count = 0
+    parse_failures = 0
+    heteroaromatic_systems = 0
+    named_heteroaromatic_systems = 0
+    label_counts: Counter[str] = Counter()
+    unnamed_systems: Counter[tuple] = Counter()
+    uncovered_atoms: Counter[tuple] = Counter()
+    uncovered_edges: Counter[tuple] = Counter()
+
+    started = perf_counter()
+    for reaction in reactions:
+        reaction_count += 1
+        standardized = std.fit(reaction, remove_aam=True)
+        for side in standardized.split(">>"):
+            for smiles in side.split("."):
+                graph = smiles_to_graph(
+                    smiles,
+                    drop_non_aam=False,
+                    use_index_as_atom_map=True,
+                )
+                if graph is None:
+                    parse_failures += 1
+                    continue
+                molecule_count += 1
+                matches = detector.matches(graph)
+                label_counts.update(match.name for match in matches)
+                covered = {node for match in matches for node in match.group_nodes}
+                _count_uncovered_signatures(
+                    graph,
+                    covered,
+                    uncovered_atoms,
+                    uncovered_edges,
+                )
+
+                named_ring_nodes = {
+                    match.group_nodes
+                    for match in matches
+                    if match.name != "heteroaromatic_ring"
+                    and match.pattern.priority == 70
+                }
+                for system in AromaticRingSystemDetector.detect(graph):
+                    if not system.hetero_nodes:
+                        continue
+                    heteroaromatic_systems += 1
+                    has_named_subring = any(
+                        set(nodes).issubset(system.nodes) for nodes in named_ring_nodes
+                    )
+                    if has_named_subring:
+                        named_heteroaromatic_systems += 1
+                        continue
+                    unnamed_systems[
+                        (
+                            system.hetero_pattern,
+                            system.is_fused,
+                            system.ring_sizes,
+                            tuple(sorted(system.element_counts.items())),
+                        )
+                    ] += 1
+
+    return FunctionalGroupAudit(
+        reactions=reaction_count,
+        molecules=molecule_count,
+        parse_failures=parse_failures,
+        elapsed_seconds=perf_counter() - started,
+        label_counts=label_counts,
+        heteroaromatic_systems=heteroaromatic_systems,
+        named_heteroaromatic_systems=named_heteroaromatic_systems,
+        unnamed_heteroaromatic_systems=unnamed_systems,
+        uncovered_atom_signatures=uncovered_atoms,
+        uncovered_edge_signatures=uncovered_edges,
+    )
+
+
+def _count_uncovered_signatures(
+    graph: nx.Graph,
+    covered: set[int],
+    atom_counts: Counter[tuple],
+    edge_counts: Counter[tuple],
+) -> None:
+    for node, data in graph.nodes(data=True):
+        if data.get("element") == "H" or node in covered:
+            continue
+        neighbors = tuple(
+            sorted(
+                graph.nodes[neighbor].get("element")
+                for neighbor in graph.neighbors(node)
+                if graph.nodes[neighbor].get("element") != "H"
+            )
+        )
+        atom_counts[
+            (
+                data.get("element"),
+                data.get("aromatic", False),
+                data.get("hcount", 0),
+                neighbors,
+            )
+        ] += 1
+
+    for left, right, data in graph.edges(data=True):
+        if left in covered or right in covered:
+            continue
+        left_element = graph.nodes[left].get("element")
+        right_element = graph.nodes[right].get("element")
+        if "H" in {left_element, right_element}:
+            continue
+        edge_counts[
+            tuple(sorted((left_element, right_element)))
+            + (data.get("order"), data.get("aromatic", False))
+        ] += 1