synkit 1.3.1a0__tar.gz → 1.3.2__tar.gz

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

@@ -27,4 +27,8 @@ crn/*
 test_run.py
 Data/Study/CRN/case_formose/*
 
-synkit/Graph/dev/*
+synkit/Graph/dev/*
+*.ipynb
+*.json
+*.txt
+*.log

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

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

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

{synkit-1.3.1a0 → synkit-1.3.2}/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.2}/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.2}/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.2}/synkit/IO/mol_to_graph.py

@@ -46,7 +46,7 @@ class MolToGraph:
     .. code-block:: python
 
         from rdkit import Chem
-        from synkit.Chem.Molecule.mol_to_graph import MolToGraph
+        from synkit.IO.mol_to_graph import MolToGraph
 
         mol = Chem.MolFromSmiles("c1cc[nH]c1")
         graph = MolToGraph(attr_profile="minimal").transform(mol)
@@ -199,6 +199,7 @@ class MolToGraph:
                     atom,
                     props,
                     oxidation_state=oxidation_states.get(atom.GetIdx()),
+                    profile=self.attr_profile,
                 )
             except Exception as exc:
                 logger.debug(
@@ -209,6 +210,7 @@ class MolToGraph:
                 props = self._gather_atom_properties(
                     atom,
                     oxidation_state=oxidation_states.get(atom.GetIdx()),
+                    profile=self.attr_profile,
                 )
 
             if self.node_attrs is not None:
@@ -899,55 +901,78 @@ class MolToGraph:
         atom: Chem.Atom,
         props: Dict[str, Any],
         oxidation_state: Optional[float] = None,
+        *,
+        profile: str = "full",
     ) -> Dict[str, Any]:
-        """Add corrected electron-bookkeeping fields.
+        """Add electron-bookkeeping fields to existing atom attributes.
+
+        For both profiles sets ``oxidation_state``, ``radical``,
+        ``available_lp``, and the backward-compatible ``lone_pairs`` alias.
+        The ``"full"`` profile additionally sets ``bond_order_sum``,
+        ``lp_bond_order_sum``, ``valence_electrons``,
+        ``estimated_lone_pairs``, and ``available_lone_pairs``.
 
         :param atom: RDKit atom.
         :type atom: Chem.Atom
-        :param props: Existing atom attributes.
+        :param props: Existing atom attributes from
+            :class:`~synkit.Chem.Molecule.atom_features.AtomFeatureExtractor`.
         :type props: Dict[str, Any]
-        :param oxidation_state: Optional oxidation state.
+        :param oxidation_state: Pre-computed oxidation state, or ``None``.
         :type oxidation_state: Optional[float]
-        :returns: Augmented atom attributes.
+        :param profile: Feature profile — ``"minimal"`` or ``"full"``.
+        :type profile: str
+        :returns: Augmented atom attributes dict.
         :rtype: Dict[str, Any]
         """
         new_props = dict(props)
 
-        raw_bond_order_sum = cls._safe_bond_order_sum(atom)
-        lp_bond_order_sum = cls._bond_order_sum_for_lone_pairs(atom)
-        valence_electrons = cls._safe_valence_electrons(atom)
-
         estimated_lone_pairs = cls.estimate_lone_pairs(atom)
         available_lone_pairs = cls.estimate_available_lone_pairs(atom)
 
-        new_props["bond_order_sum"] = round(raw_bond_order_sum, 3)
-        new_props["lp_bond_order_sum"] = round(lp_bond_order_sum, 3)
-        new_props["valence_electrons"] = valence_electrons
         new_props["oxidation_state"] = (
             None if oxidation_state is None else round(float(oxidation_state), 3)
         )
-
-        new_props["estimated_lone_pairs"] = estimated_lone_pairs
-        new_props["available_lone_pairs"] = available_lone_pairs
+        new_props["radical"] = int(atom.GetNumRadicalElectrons())
         new_props["available_lp"] = available_lone_pairs > 0
-
         # Backward-compatible field used by SynEltra.
         new_props["lone_pairs"] = estimated_lone_pairs
 
+        if profile == "full":
+            new_props["bond_order_sum"] = round(cls._safe_bond_order_sum(atom), 3)
+            new_props["lp_bond_order_sum"] = round(
+                cls._bond_order_sum_for_lone_pairs(atom), 3
+            )
+            new_props["valence_electrons"] = cls._safe_valence_electrons(atom)
+            new_props["estimated_lone_pairs"] = estimated_lone_pairs
+            new_props["available_lone_pairs"] = available_lone_pairs
+
         return new_props
 
     @staticmethod
     def _gather_atom_properties(
         atom: Chem.Atom,
         oxidation_state: Optional[float] = None,
+        *,
+        profile: str = "full",
     ) -> Dict[str, Any]:
         """Collect fallback atom-level node attributes.
 
+        Minimal profile keys: ``element``, ``aromatic``, ``hcount``,
+        ``charge``, ``radical``, ``isomer``, ``partial_charge``,
+        ``hybridization``, ``in_ring``, ``neighbors``, ``atom_map``,
+        ``oxidation_state``, ``available_lp``, ``lone_pairs``.
+
+        Full profile additionally includes ``bond_order_sum``,
+        ``lp_bond_order_sum``, ``valence_electrons``,
+        ``estimated_lone_pairs``, ``available_lone_pairs``.
+
         :param atom: RDKit atom.
         :type atom: Chem.Atom
-        :param oxidation_state: Optional oxidation state.
+        :param oxidation_state: Pre-computed oxidation state, or ``None``.
         :type oxidation_state: Optional[float]
-        :returns: Node attributes.
+        :param profile: Feature profile — ``"minimal"`` or ``"full"``.
+        :type profile: str
+        :returns: Node attribute dict.
         :rtype: Dict[str, Any]
         """
         try:
@@ -965,14 +990,10 @@ class MolToGraph:
             neighbors = []
 
         atom_map = MolToGraph._safe_atom_map(atom)
-
-        raw_bond_order_sum = round(MolToGraph._safe_bond_order_sum(atom), 3)
-        lp_bond_order_sum = round(MolToGraph._bond_order_sum_for_lone_pairs(atom), 3)
-        valence_electrons = MolToGraph._safe_valence_electrons(atom)
         estimated_lone_pairs = MolToGraph.estimate_lone_pairs(atom)
         available_lone_pairs = MolToGraph.estimate_available_lone_pairs(atom)
 
-        return {
+        props: Dict[str, Any] = {
             "element": atom.GetSymbol(),
             "aromatic": atom.GetIsAromatic(),
             "hcount": atom.GetTotalNumHs(),
@@ -982,21 +1003,26 @@ class MolToGraph:
             "partial_charge": gcharge,
             "hybridization": str(atom.GetHybridization()),
             "in_ring": atom.IsInRing(),
-            "implicit_hcount": atom.GetNumImplicitHs(),
             "neighbors": neighbors,
             "atom_map": atom_map,
-            "bond_order_sum": raw_bond_order_sum,
-            "lp_bond_order_sum": lp_bond_order_sum,
-            "valence_electrons": valence_electrons,
             "oxidation_state": (
                 None if oxidation_state is None else round(float(oxidation_state), 3)
             ),
-            "estimated_lone_pairs": estimated_lone_pairs,
-            "available_lone_pairs": available_lone_pairs,
             "available_lp": available_lone_pairs > 0,
             "lone_pairs": estimated_lone_pairs,
         }
 
+        if profile == "full":
+            props["bond_order_sum"] = round(MolToGraph._safe_bond_order_sum(atom), 3)
+            props["lp_bond_order_sum"] = round(
+                MolToGraph._bond_order_sum_for_lone_pairs(atom), 3
+            )
+            props["valence_electrons"] = MolToGraph._safe_valence_electrons(atom)
+            props["estimated_lone_pairs"] = estimated_lone_pairs
+            props["available_lone_pairs"] = available_lone_pairs
+
+        return props
+
     @staticmethod
     def _gather_bond_properties(
         bond: Chem.Bond,
@@ -1197,11 +1223,18 @@ class MolToGraph:
     ) -> nx.Graph:
         """Create a lightweight graph with corrected lone-pair fields.
 
+        Node attributes: ``element``, ``aromatic``, ``hcount``, ``charge``,
+        ``radical``, ``neighbors``, ``atom_map``, ``oxidation_state``,
+        ``available_lp``, ``lone_pairs``.  Edge attributes: ``order``,
+        ``bond_type``, ``aromatic``, ``kekule_order``, ``kekule_bond_type``.
+
         :param mol: RDKit molecule.
         :type mol: Chem.Mol
-        :param drop_non_aam: If ``True``, remove unmapped atoms.
+        :param drop_non_aam: If ``True``, remove atoms with atom-map ``0``.
         :type drop_non_aam: bool
-        :param use_index_as_atom_map: If ``True``, use atom maps as node IDs.
+        :param use_index_as_atom_map: If ``True``, use atom-map numbers as node
+            IDs for mapped atoms; unmapped atoms fall back to
+            ``atom.GetIdx() + 1``.
         :type use_index_as_atom_map: bool
         :returns: Lightweight molecular graph.
         :rtype: nx.Graph
@@ -1235,16 +1268,12 @@ class MolToGraph:
                 aromatic=atom.GetIsAromatic(),
                 hcount=atom.GetTotalNumHs(),
                 charge=atom.GetFormalCharge(),
+                radical=atom.GetNumRadicalElectrons(),
                 neighbors=neighbors,
                 atom_map=atom_map,
-                bond_order_sum=round(cls._safe_bond_order_sum(atom), 3),
-                lp_bond_order_sum=round(cls._bond_order_sum_for_lone_pairs(atom), 3),
-                valence_electrons=cls._safe_valence_electrons(atom),
                 oxidation_state=round(
                     float(oxidation_states.get(atom.GetIdx(), 0.0)), 3
                 ),
-                estimated_lone_pairs=estimated_lone_pairs,
-                available_lone_pairs=available_lone_pairs,
                 available_lp=available_lone_pairs > 0,
                 lone_pairs=estimated_lone_pairs,
             )
@@ -1322,8 +1351,8 @@ class MolToGraph:
     def _create_detailed_graph(
         cls,
         mol: Chem.Mol,
-        drop_non_aam: bool = True,
-        use_index_as_atom_map: bool = True,
+        drop_non_aam: bool = False,
+        use_index_as_atom_map: bool = False,
     ) -> nx.Graph:
         """Create a detailed graph with fallback atom and bond attributes.
 

{synkit-1.3.1a0 → synkit-1.3.2}/synkit/Synthesis/Reactor/rbl_engine.py

@@ -953,7 +953,7 @@ class RBLEngine:
                     reason="quick_check_match",
                     metadata={"solution_index": idx, "n_solutions": len(sols)},
                 )
-                return sols[idx]
+                return sols
 
         return None