synkit 1.3.2__tar.gz → 1.4.0__tar.gz

{synkit-1.3.2 → synkit-1.4.0}/.gitignore

@@ -32,3 +32,8 @@ synkit/Graph/dev/*
 *.json
 *.txt
 *.log
+sprint/
+test_syn.py
+.gitignore
+measure_candidate_stages.py
+run_valid_bug_cases.py

{synkit-1.3.2 → synkit-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 1.3.2
+Version: 1.4.0
 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.2 → synkit-1.4.0}/pyproject.toml

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

{synkit-1.3.2 → synkit-1.4.0}/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.2 → synkit-1.4.0}/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.4.0/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.4.0/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.4.0/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