synkit 1.6.5__py3-none-win_amd64.whl

synkit/CRN/Construct/flattener.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set
+
+import networkx as nx
+
+
+@dataclass
+class ReactionDeltaFlattener:
+    graph: nx.DiGraph
+    skip_no_change: bool = True
+    allow_empty_side: bool = False
+    deduplicate: bool = True
+    _cache: List[Dict[str, Any]] = field(default_factory=list, init=False)
+
+    def build(self) -> "ReactionDeltaFlattener":
+        self._cache = self._flatten()
+        return self
+
+    @property
+    def reactions(self) -> List[Dict[str, Any]]:
+        return list(self._cache)
+
+    def _collect_in(self, eid: int) -> List[str]:
+        out: List[str] = []
+        for u, _, ed in self.graph.in_edges(eid, data=True):
+            if ed.get("role") != "reactant":
+                continue
+            if self.graph.nodes[u].get("kind") != "species":
+                continue
+            stoich = int(ed.get("stoich", 1))
+            out.extend([self.graph.nodes[u].get("smiles", str(u))] * stoich)
+        return out
+
+    def _collect_out(self, eid: int) -> List[str]:
+        out: List[str] = []
+        for _, v, ed in self.graph.out_edges(eid, data=True):
+            if ed.get("role") != "product":
+                continue
+            if self.graph.nodes[v].get("kind") != "species":
+                continue
+            stoich = int(ed.get("stoich", 1))
+            out.extend([self.graph.nodes[v].get("smiles", str(v))] * stoich)
+        return out
+
+    def _nz(self, x: Optional[int]) -> int:
+        return 10**9 if x is None else int(x)
+
+    def _flatten(self) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+        seen: Set[str] = set()
+
+        for eid, nd in self.graph.nodes(data=True):
+            if nd.get("kind") != "rule":
+                continue
+
+            r_all = sorted(self._collect_in(eid))
+            p_all = sorted(self._collect_out(eid))
+
+            r_counter = Counter(r_all)
+            p_counter = Counter(p_all)
+            common = r_counter & p_counter
+
+            rchg = sorted(list((r_counter - common).elements()))
+            pchg = sorted(list((p_counter - common).elements()))
+
+            if self.skip_no_change and not rchg and not pchg:
+                continue
+            if (not self.allow_empty_side) and (not rchg or not pchg):
+                continue
+
+            rxn_smiles = f"{'.'.join(rchg)}>>{'.'.join(pchg)}"
+            if self.deduplicate and rxn_smiles in seen:
+                continue
+            seen.add(rxn_smiles)
+
+            out.append(
+                {
+                    "rule_id": eid,
+                    "label": nd.get("label"),
+                    "step": nd.get("step"),
+                    "rule_index": nd.get("rule_index"),
+                    "app_index": nd.get("app_index"),
+                    "reactants": rchg,
+                    "products": pchg,
+                    "rule_smiles": rxn_smiles,
+                }
+            )
+
+        out.sort(
+            key=lambda r: (
+                self._nz(r.get("step")),
+                self._nz(r.get("rule_index")),
+                self._nz(r.get("app_index")),
+                r["rule_id"],
+            )
+        )
+        return out

synkit/CRN/Construct/keys.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+
+def make_dedup_key(
+    *,
+    dedup_across_rules: bool,
+    rule_index: int,
+    r_keep_keys: Tuple[str, ...],
+    p_keep_keys: Tuple[str, ...],
+) -> Tuple[Optional[int], Tuple[str, ...], Tuple[str, ...]]:
+    ridx: Optional[int] = None if dedup_across_rules else int(rule_index)
+    return (ridx, r_keep_keys, p_keep_keys)

synkit/CRN/Construct/mixtures.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from itertools import combinations, combinations_with_replacement
+from typing import Iterator, List, Set, Tuple
+
+
+def iter_mixtures_arity1(
+    pool_keys: List[str],
+    frontier_keys: List[str],
+    *,
+    use_frontier: bool,
+    cap: int,
+) -> Iterator[Tuple[str, ...]]:
+    pool_u = sorted(set(pool_keys))
+    if not pool_u:
+        return
+
+    frontier_u = sorted(set(frontier_keys))
+    if not use_frontier:
+        frontier_u = pool_u
+
+    n = 0
+    for f in frontier_u:
+        yield (f,)
+        n += 1
+        if n >= cap:
+            return
+
+
+def iter_mixtures_arity2(
+    pool_keys: List[str],
+    frontier_keys: List[str],
+    *,
+    use_frontier: bool,
+    allow_self_mixtures: bool,
+    cap: int,
+) -> Iterator[Tuple[str, ...]]:
+    pool_u = sorted(set(pool_keys))
+    if not pool_u:
+        return
+
+    n = 0
+    if not use_frontier:
+        iterator = (
+            combinations_with_replacement(pool_u, 2)
+            if allow_self_mixtures
+            else combinations(pool_u, 2)
+        )
+        for tup in iterator:
+            yield tuple(sorted(tup))
+            n += 1
+            if n >= cap:
+                return
+        return
+
+    frontier_u = sorted(set(frontier_keys))
+    seen: Set[Tuple[str, ...]] = set()
+
+    for f in frontier_u:
+        candidates = pool_u if allow_self_mixtures else [x for x in pool_u if x != f]
+        for x in candidates:
+            tup = tuple(sorted((f, x)))
+            if tup in seen:
+                continue
+            seen.add(tup)
+            yield tup
+            n += 1
+            if n >= cap:
+                return
+
+
+def iter_mixtures_arityk(
+    pool_keys: List[str],
+    frontier_keys: List[str],
+    *,
+    use_frontier: bool,
+    allow_self_mixtures: bool,
+    arity: int,
+    cap: int,
+) -> Iterator[Tuple[str, ...]]:
+    pool_u = sorted(set(pool_keys))
+    if not pool_u:
+        return
+
+    n = 0
+    if not use_frontier:
+        iterator = (
+            combinations_with_replacement(pool_u, arity)
+            if allow_self_mixtures
+            else combinations(pool_u, arity)
+        )
+        for tup in iterator:
+            yield tuple(sorted(tup))
+            n += 1
+            if n >= cap:
+                return
+        return
+
+    frontier_u = sorted(set(frontier_keys))
+    seen: Set[Tuple[str, ...]] = set()
+
+    for f in frontier_u:
+        if allow_self_mixtures:
+            rest_iter = combinations_with_replacement(pool_u, arity - 1)
+        else:
+            others = [x for x in pool_u if x != f]
+            rest_iter = combinations(others, arity - 1)
+
+        for rest in rest_iter:
+            tup = tuple(sorted((f, *rest)))
+            if tup in seen:
+                continue
+            seen.add(tup)
+            yield tup
+            n += 1
+            if n >= cap:
+                return

synkit/CRN/Construct/rdkit_worker.py

@@ -0,0 +1,69 @@
+"""RDKit C++ reaction application for unmapped SMARTS-generated CRN inputs."""
+
+from functools import lru_cache
+from itertools import permutations
+from rdkit import Chem
+from rdkit.Chem import rdChemReactions
+
+
+@lru_cache(maxsize=128)
+def _reaction(template):
+    reaction = rdChemReactions.ReactionFromSmarts(template)
+    if reaction is None:
+        raise ValueError("Invalid RDKit reaction SMARTS")
+    reaction.Initialize()
+    return reaction
+
+
+def _canonical_product(outcome, explicit_h):
+    parts = []
+    for molecule in outcome:
+        Chem.SanitizeMol(molecule)
+        if not explicit_h:
+            molecule = Chem.RemoveHs(molecule)
+        for atom in molecule.GetAtoms():
+            atom.SetAtomMapNum(0)
+        parts.append(Chem.MolToSmiles(molecule, canonical=True))
+    return ".".join(sorted(parts))
+
+
+def apply_rdkit_rule_worker(args):
+    """Apply templates in RDKit's native matcher; return canonical unmapped products.
+
+    Atom-map-preserving output and SynReactor-specific strategies are outside
+    this adapter's supported semantics. Product truncation raises explicitly.
+    """
+    index, rule, substrate, explicit_h, implicit_temp, strategy, keys = args
+    if implicit_temp or strategy is not None:
+        raise ValueError(
+            "RDKit CRN input generation does not support SynReactor-specific template strategies"
+        )
+    reaction = _reaction(rule)
+    molecules = []
+    for text in keys:
+        molecule = Chem.MolFromSmiles(text)
+        if molecule is None:
+            raise ValueError(f"Invalid substrate: {text}")
+        molecules.append(Chem.AddHs(molecule))
+    if len(molecules) != reaction.GetNumReactantTemplates():
+        return index, keys, []
+    from ..backend import record_operation
+
+    record_operation("rdkit_cpp_rule_application")
+    results = []
+    seen = set()
+    for assignment in permutations(range(len(molecules))):
+        outcomes = reaction.RunReactants(
+            tuple(molecules[i] for i in assignment), maxProducts=10000
+        )
+        if len(outcomes) >= 10000:
+            raise RuntimeError("RDKit reaction product limit reached")
+        for outcome in outcomes:
+            try:
+                product = _canonical_product(outcome, explicit_h)
+            except (ValueError, RuntimeError):
+                continue
+            if product not in seen:
+                seen.add(product)
+                results.append(product)
+    return index, keys, results

synkit/CRN/Construct/smiles.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+try:
+    from rdkit import Chem
+except ImportError:
+    Chem = None
+
+
+def mol_from_smiles_safe(smiles: str) -> Optional[Any]:
+    if Chem is None or not smiles:
+        return None
+    try:
+        return Chem.MolFromSmiles(smiles, sanitize=False)
+    except Exception:
+        return None
+
+
+def sanitize_safe(mol: Any) -> bool:
+    try:
+        Chem.SanitizeMol(mol)
+        return True
+    except Exception:
+        return False
+
+
+def has_atom_maps(mol: Any) -> bool:
+    try:
+        return any(a.GetAtomMapNum() > 0 for a in mol.GetAtoms())
+    except Exception:
+        return False
+
+
+def strip_maps_and_canonical_from_mol(mol: Any) -> Optional[str]:
+    try:
+        for a in mol.GetAtoms():
+            a.SetAtomMapNum(0)
+        mol_nomap = Chem.RemoveAllHs(mol)
+        return Chem.MolToSmiles(mol_nomap, canonical=True)
+    except Exception:
+        return None
+
+
+def canonical_from_mol(mol: Any) -> Optional[str]:
+    try:
+        return Chem.MolToSmiles(mol, canonical=True)
+    except Exception:
+        return None
+
+
+def assign_deterministic_maps_and_canonical(nomap_smiles: str) -> Optional[str]:
+    try:
+        mol2 = Chem.MolFromSmiles(nomap_smiles, sanitize=False)
+        if mol2 is None:
+            return None
+        if not sanitize_safe(mol2):
+            return None
+        for a in mol2.GetAtoms():
+            a.SetAtomMapNum(a.GetIdx() + 1)
+        return Chem.MolToSmiles(mol2, canonical=True)
+    except Exception:
+        return None
+
+
+def standardize_smiles_rdkit(smiles: str, *, keep_aam: bool) -> Optional[str]:
+    """
+    Standardize one SMILES string.
+
+    Behavior:
+      - If RDKit is unavailable: passthrough.
+      - If keep_aam=False: strip atom maps, remove Hs, return canonical SMILES.
+      - If keep_aam=True:
+          * keep mapped canonical SMILES if maps already exist
+          * otherwise assign deterministic maps and return canonical mapped SMILES
+    """
+    if not smiles:
+        return None
+
+    if Chem is None:
+        return smiles
+
+    mol = mol_from_smiles_safe(smiles)
+    if mol is None:
+        return None
+
+    if not sanitize_safe(mol):
+        return None
+
+    if not keep_aam:
+        return strip_maps_and_canonical_from_mol(mol)
+
+    if has_atom_maps(mol):
+        return canonical_from_mol(mol)
+
+    nomap = strip_maps_and_canonical_from_mol(mol)
+    if nomap is None:
+        return None
+    return assign_deterministic_maps_and_canonical(nomap)

synkit/CRN/Construct/state.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Set
+
+
+@dataclass
+class DerivationState:
+    """
+    Lightweight builder state inspired by derivation-graph builders.
+
+    This keeps the active chemical universe separate from the graph object so
+    the orchestration layer does not need to treat NetworkX as its working
+    memory for frontier expansion.
+    """
+
+    pool_keys: Set[str] = field(default_factory=set)
+    frontier_keys: Set[str] = field(default_factory=set)
+    step: int = 0
+
+    def begin_step(self, step: int) -> None:
+        self.step = int(step)
+
+    def set_initial(self, *, pool_keys: Set[str], frontier_keys: Set[str]) -> None:
+        self.pool_keys = set(pool_keys)
+        self.frontier_keys = set(frontier_keys)
+        self.step = 0
+
+    def advance(self, next_frontier: Set[str]) -> None:
+        self.frontier_keys = set(next_frontier)
+        self.step += 1

synkit/CRN/Construct/strategy.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterator, List, Protocol, Tuple
+
+from .mixtures import (
+    iter_mixtures_arity1,
+    iter_mixtures_arity2,
+    iter_mixtures_arityk,
+)
+
+
+class ConstructionStrategy(Protocol):
+    def iter_mixtures(
+        self,
+        *,
+        pool_keys: List[str],
+        frontier_keys: List[str],
+        arity: int,
+        use_frontier: bool,
+        allow_self_mixtures: bool,
+        cap: int,
+        max_components: int,
+    ) -> Iterator[Tuple[str, ...]]: ...
+
+
+@dataclass(frozen=True)
+class FrontierStrategy:
+    """
+    Default strategy with the same semantics as the validated monolith.
+
+    The purpose is not to change chemistry, only to separate the exploration
+    strategy from the builder. This mirrors the derivation-graph idea of having
+    an execution policy distinct from rule application.
+    """
+
+    def iter_mixtures(
+        self,
+        *,
+        pool_keys: List[str],
+        frontier_keys: List[str],
+        arity: int,
+        use_frontier: bool,
+        allow_self_mixtures: bool,
+        cap: int,
+        max_components: int,
+    ) -> Iterator[Tuple[str, ...]]:
+        if arity < 1 or arity > max_components:
+            return iter(())
+
+        if arity == 1:
+            return iter_mixtures_arity1(
+                pool_keys,
+                frontier_keys,
+                use_frontier=use_frontier,
+                cap=cap,
+            )
+
+        if arity == 2:
+            return iter_mixtures_arity2(
+                pool_keys,
+                frontier_keys,
+                use_frontier=use_frontier,
+                allow_self_mixtures=allow_self_mixtures,
+                cap=cap,
+            )
+
+        return iter_mixtures_arityk(
+            pool_keys,
+            frontier_keys,
+            use_frontier=use_frontier,
+            allow_self_mixtures=allow_self_mixtures,
+            arity=arity,
+            cap=cap,
+        )

synkit/CRN/Construct/worker.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any, List, Optional, Set, Tuple
+
+from synkit.Synthesis.Reactor import SynReactor
+
+
+def apply_rule_worker(
+    args: Tuple[int, Any, str, bool, bool, Optional[str], Tuple[str, ...]],
+) -> Tuple[int, Tuple[str, ...], List[str]]:
+    """
+    Apply one rule to one substrate mixture.
+
+    This intentionally preserves the behavior of the validated monolith:
+    - automorphism=True
+    - order-preserving deduplication of raw output strings
+    """
+    idx, rule, substrate, explicit_h, implicit_temp, strategy, reactant_keys = args
+
+    kwargs = dict(
+        smiles=substrate,
+        template=rule,
+        invert=False,
+        explicit_h=explicit_h,
+        implicit_temp=implicit_temp,
+        automorphism=True,
+    )
+    if strategy is not None:
+        kwargs["strategy"] = strategy
+
+    reactor = SynReactor.from_smiles(**kwargs)
+
+    out: List[str] = []
+    seen: Set[str] = set()
+    for s in reactor.smiles_list:
+        val = (s or "").strip()
+        if not val or val in seen:
+            continue
+        seen.add(val)
+        out.append(val)
+
+    return idx, reactant_keys, out

synkit/CRN/IO/__init__.py

@@ -0,0 +1,36 @@
+"""Interchange formats for reaction networks.
+
+Currently one format is supported: **SBML**, the interchange format of the
+existing CRN tooling (``crnpy``, CRNT4SBML, CoNtRol, COPASI, BioModels). The
+adapter is self-contained — no ``libsbml`` installation is needed.
+
+.. rubric:: Example
+
+.. code-block:: python
+
+    from synkit.CRN import SynCRN
+    from synkit.CRN.IO import crn_to_sbml, crn_from_sbml
+
+    crn = SynCRN.from_reaction_strings(["A+B>>C", "C>>A+B"])
+    assert crn_from_sbml(crn_to_sbml(crn)).n_reactions == 2
+"""
+
+from __future__ import annotations
+
+from .sbml import (
+    SBML_NS,
+    SYNKIT_NS,
+    crn_from_sbml,
+    crn_to_sbml,
+    read_sbml,
+    write_sbml,
+)
+
+__all__ = [
+    "SBML_NS",
+    "SYNKIT_NS",
+    "crn_from_sbml",
+    "crn_to_sbml",
+    "read_sbml",
+    "write_sbml",
+]