synkit 1.6.0__tar.gz → 1.6.1b1__tar.gz

synkit-1.6.1b1/.gitignore

@@ -0,0 +1,98 @@
+*.pyc
+*cachedir
+*.csv
+!Experiment/Lewis/Data/all.csv
+!Experiment/Lewis/Data/combinatorial_all.csv
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/polar-failures.csv
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/radical-failures.csv
+!Experiment/Lewis/mech_path/Data/reconstruction_audit/radical-arrow-review.csv
+*/catboost_info/*
+
+
+*.pkl.gz
+*.pdf
+
+.coverage
+dev/*
+# Local development, audit, and debugging helpers.
+/tools/
+!/tools/
+/tools/*
+!/tools/stereo_conformance.py
+!/tools/check_python_file_size.py
+/debug/
+/Test/Conformance/
+*.rdf
+test_syn_reactor.py
+
+Data/Benchmark/*
+!Data/Benchmark/partial_expand/
+!Data/Benchmark/partial_expand/**
+Data/Benchmark/partial_expand/results/
+!Data/Benchmark/mech/
+Data/Benchmark/mech/*
+!Data/Benchmark/mech/README.md
+!Data/Benchmark/mech/polar-failures.csv
+!Data/Benchmark/mech/radical-failures.csv
+*.json.gz
+!Experiment/Lewis/Data/benchmark.json.gz
+# *.png
+
+run.sh
+docs/*
+run_rdcanon.py
+Data/Fragment/*
+test_partial.py
+Data/Benchmark/synthesis/*
+Data/USPTO/*
+crn/*
+test_run.py
+Data/Study/CRN/case_formose/*
+
+synkit/Graph/dev/*
+*.ipynb
+*.json
+# Stereo benchmark inputs are versioned for reproducible fresh-clone runs.
+# Generated reports stay Git-visible so completed results can be committed
+# explicitly, including reports created by the long raw stress stages.
+!Experiment/Stereo/Data/**/*.csv
+!Experiment/Stereo/Data/**/*.json
+!Data/Schema/
+!Data/Schema/attribute_propagation_v1_5.json
+!/tools/python_file_size_baseline.json
+!Data/Mech/polar.json
+!Data/Mech/radical.json
+!Data/Mech/stereo.json
+# Canonical reviewed MechanismBench partitions are executable test data.
+!Experiment/Lewis/mech_path/Data/MechanismBench/polar.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/radical.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/stereo.json
+!Experiment/Lewis/mech_path/Data/MechanismBench/evidence/mechanismbench_evidence.json
+!Experiment/Lewis/rule_replay/Data/bidirectional-replay/results.json
+!Experiment/Lewis/rule_replay/Data/relative-lone-pair/results.json
+!Experiment/Stereo/Data/manifest.json
+!Experiment/Stereo/Data/Perception/perception_conformance_cases.json
+!Experiment/Stereo/Data/Perception/full_detection_report.json
+!Test/Synthesis/Reactor/fixtures/small_rewrite_conformance.json
+!Data/Conformance/stereomolgraph_graph_conformance.json
+!Data/Benchmark/Stereo/
+!Data/Benchmark/Stereo/**
+*.txt
+!LICENSES/*.txt
+*.log
+/dist/
+sprint/
+sprint/*
+test_syn.py
+.gitignore
+measure_candidate_stages.py
+run_valid_bug_cases.py
+paper/*
+
+# Fresh benchmark runs are reproducible and can be large. Retained reference
+# outputs live inside each experiment's Data directory.
+Experiment/Lewis/Runs/
+
+# Keep generated Python bytecode ignored after directory re-inclusions above.
+**/__pycache__/
+*.py[cod]

{synkit-1.6.0 → synkit-1.6.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 1.6.0
+Version: 1.6.1b1
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit
@@ -9,8 +9,6 @@ Project-URL: documentation, https://tieulongphan.github.io/SynKit/
 Author-email: Tieu Long Phan <tieu@bioinf.uni-leipzig.de>
 License: MIT
 License-File: LICENSE
-License-File: LICENSES/ACS-StereoMolGraph-SI-NOTICE.md
-License-File: LICENSES/StereoMolGraph-MIT.txt
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
@@ -78,7 +76,7 @@ Canonical internal electron loci are `lp`, `σ`, `π`, and `∙`; adapters accep
 documented ASCII and legacy spellings. Curved arrows carry two electrons and
 fishhooks carry one electron. Coupled radical events commit atomically.
 
-The current package version is `1.6.0`.
+The current package version is `1.6.1b1`.
 
 For more details on each utility within the repository, please refer to the documentation provided in the respective folders.
 

{synkit-1.6.0 → synkit-1.6.1b1}/README.md

@@ -37,7 +37,7 @@ Canonical internal electron loci are `lp`, `σ`, `π`, and `∙`; adapters accep
 documented ASCII and legacy spellings. Curved arrows carry two electrons and
 fishhooks carry one electron. Coupled radical events commit atomically.
 
-The current package version is `1.6.0`.
+The current package version is `1.6.1b1`.
 
 For more details on each utility within the repository, please refer to the documentation provided in the respective folders.
 

{synkit-1.6.0 → synkit-1.6.1b1}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "1.6.0"
+version = "1.6.1b1"
 description = "Utility for reaction modeling using graph grammar"
 readme = "README.md"
 requires-python = ">=3.11"
 license = { text = "MIT" }
-license-files = ["LICENSE", "LICENSES/*"]
+license-files = ["LICENSE", "synkit/Graph/Stereo/LICENSES/*"]
 authors = [
   { name = "Tieu Long Phan", email = "tieu@bioinf.uni-leipzig.de" }
 ]
@@ -67,12 +67,10 @@ packages = ["synkit"]
 [tool.hatch.build.targets.wheel.force-include]
 "synkit/Data/aldol.json.gz" = "synkit/Data/aldol.json.gz"
 "synkit/Data/paracetamol.json.gz" = "synkit/Data/paracetamol.json.gz"
-"Data/Mech" = "synkit/Data/Mech"
 
 [tool.hatch.build.targets.sdist]
 include = [
   "/synkit",
-  "/Data/Mech",
   "/LICENSE",
   "/LICENSES",
   "/README.md",
@@ -82,4 +80,3 @@ include = [
 [tool.hatch.build.targets.sdist.force-include]
 "synkit/Data/aldol.json.gz" = "synkit/Data/aldol.json.gz"
 "synkit/Data/paracetamol.json.gz" = "synkit/Data/paracetamol.json.gz"
-"Data/Mech" = "Data/Mech"

{synkit-1.6.0 → synkit-1.6.1b1}/synkit/CRN/Symmetry/_ir.py

@@ -7,6 +7,13 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import networkx as nx
 
+from synkit.Graph.Canon.exact import (
+    CanonicalSearchIncomplete,
+    ExactCanonicalResult,
+    ExactColoredGraphCanonicalizer,
+    IncompleteCanonicalResult,
+)
+
 from ._common import (
     AutomorphismResult,
     CanonicalResult,
@@ -723,6 +730,91 @@ class IRCanonicalEngine:
             Exact-search internal result.
         :rtype: IRInternalResult
         """
+        if max_count is not None or timeout_sec is not None or stop_after_two:
+            return self._run_bounded_compatibility(
+                max_count=max_count,
+                timeout_sec=timeout_sec,
+                stop_after_two=stop_after_two,
+            )
+        cached = self._reuse_cached_run(
+            max_count=max_count,
+            timeout_sec=timeout_sec,
+            stop_after_two=stop_after_two,
+        )
+        if cached is not None:
+            return cached
+
+        native = ExactColoredGraphCanonicalizer(
+            self.G,
+            node_color=lambda attrs: node_token(attrs, self.config),
+            edge_color=lambda attrs: edge_token(attrs, self.config),
+        ).search(timeout_seconds=timeout_sec)
+        if isinstance(native, IncompleteCanonicalResult):
+            raise CanonicalSearchIncomplete(
+                "CRN canonicalization did not complete: " f"{native.reason}."
+            )
+        if not isinstance(native, ExactCanonicalResult):
+            raise RuntimeError("Native exact canonicalizer returned no result.")
+
+        full_mappings = [witness.as_dict() for witness in native.automorphisms]
+        cap = 2 if stop_after_two else max_count
+        stopped = cap is not None and len(full_mappings) > cap
+        sample_mappings = full_mappings if cap is None else full_mappings[:cap]
+        best_order = list(native.canonical_order)
+        sample_perms = [
+            [mapping[node] for node in best_order] for mapping in sample_mappings
+        ]
+        orbits = orbits_from_mappings(
+            best_order,
+            (
+                sample_mappings
+                if sample_mappings
+                else [{node: node for node in best_order}]
+            ),
+        )
+        result = IRInternalResult(
+            canonical_order=best_order,
+            canonical_key=graph_key_from_order(
+                self.G,
+                best_order,
+                self.config,
+            ),
+            automorphism_count=len(sample_mappings),
+            sample_permutations=sample_perms,
+            sample_mappings=sample_mappings,
+            orbits=orbits,
+            elapsed_seconds=native.statistics.elapsed_seconds,
+            stopped_early=stopped,
+        )
+        if timeout_sec is None:
+            full_result = IRInternalResult(
+                canonical_order=best_order,
+                canonical_key=result.canonical_key,
+                automorphism_count=len(full_mappings),
+                sample_permutations=[
+                    [mapping[node] for node in best_order] for mapping in full_mappings
+                ],
+                sample_mappings=full_mappings,
+                orbits=[set(cell) for cell in native.orbits],
+                elapsed_seconds=native.statistics.elapsed_seconds,
+                stopped_early=False,
+            )
+            self._exact_full_cache = full_result
+        return result
+
+    def _run_bounded_compatibility(
+        self,
+        *,
+        max_count: Optional[int],
+        timeout_sec: Optional[float],
+        stop_after_two: bool,
+    ) -> IRInternalResult:
+        """Run the historical bounded diagnostic IR traversal.
+
+        This path preserves CRN automorphism-count and timeout diagnostics.
+        ``stopped_early`` is authoritative: callers may inspect the partial
+        evidence, but :meth:`canonical_result` refuses to promote it.
+        """
         cached = self._reuse_cached_run(
             max_count=max_count,
             timeout_sec=timeout_sec,
@@ -742,7 +834,12 @@ class IRCanonicalEngine:
             nonlocal best_key, best_order, sample_perms, count, stopped
             if stopped:
                 return
-            if should_stop(start, timeout_sec, count=count, max_count=max_count):
+            if should_stop(
+                start,
+                timeout_sec,
+                count=count,
+                max_count=max_count,
+            ):
                 stopped = True
                 return
 
@@ -770,18 +867,25 @@ class IRCanonicalEngine:
 
             target = self._target_cell(refined)
             ordered_candidates = sorted(
-                target, key=lambda v: self._candidate_order_key(v, refined)
+                target,
+                key=lambda value: self._candidate_order_key(
+                    value,
+                    refined,
+                ),
             )
-            for v in ordered_candidates:
-                child = self._build_child_partition(refined, target, v)
+            for value in ordered_candidates:
+                child = self._build_child_partition(
+                    refined,
+                    target,
+                    value,
+                )
                 dfs(child)
                 if stopped:
                     return
 
         dfs(init)
         assert best_key is not None and best_order is not None
-
-        result = self._assemble_result(
+        return self._assemble_result(
             start=start,
             best_key=best_key,
             best_order=best_order,
@@ -789,9 +893,6 @@ class IRCanonicalEngine:
             count=count,
             stopped=stopped,
         )
-        if timeout_sec is None and not result.stopped_early and not stop_after_two:
-            self._exact_full_cache = result
-        return result
 
     def canonical_result(
         self, *, timeout_sec: Optional[float] = None
@@ -808,6 +909,10 @@ class IRCanonicalEngine:
         :rtype: CanonicalResult
         """
         res = self.run(timeout_sec=timeout_sec)
+        if res.stopped_early:
+            raise CanonicalSearchIncomplete(
+                "CRN canonical identity requires a complete search."
+            )
         return CanonicalResult(
             canonical_order=res.canonical_order,
             canonical_key=res.canonical_key,

synkit-1.6.1b1/synkit/Chem/Molecule/_chirality_loci.py

@@ -0,0 +1,169 @@
+"""Topology-only detection of potential molecular stereo axes."""
+
+from __future__ import annotations
+
+import networkx as nx
+from rdkit import Chem
+
+from synkit.Graph.Stereo.descriptors import Reference, virtual_reference
+from synkit.Graph.Stereo.supports import AxisStereoSupport
+
+
+def _cumulene_end_references(
+    atom: Chem.Atom,
+    axis_neighbor: int,
+) -> tuple[Reference, Reference] | None:
+    """Return zero-based terminal references for one cumulene end."""
+    center = atom.GetIdx()
+    references: list[Reference] = [
+        neighbor.GetIdx()
+        for neighbor in atom.GetNeighbors()
+        if neighbor.GetIdx() != axis_neighbor
+    ]
+    hidden_hydrogens = int(atom.GetNumExplicitHs()) + int(atom.GetNumImplicitHs())
+    references.extend(virtual_reference("H", center) for _ in range(hidden_hydrogens))
+    if len(references) == 1 and atom.GetAtomicNum() == 15:
+        references.append(virtual_reference("LP", center))
+    if len(references) != 2 or references[0] == references[1]:
+        return None
+    return references[0], references[1]
+
+
+def _potential_cumulene_supports(
+    molecule: Chem.Mol,
+) -> tuple[AxisStereoSupport, ...]:
+    """Detect even-cumulene axes without assigning their orientation."""
+    double_graph = nx.Graph()
+    double_graph.add_edges_from(
+        (bond.GetBeginAtomIdx(), bond.GetEndAtomIdx())
+        for bond in molecule.GetBonds()
+        if bond.GetBondType() == Chem.BondType.DOUBLE
+    )
+    supports = []
+    for component in nx.connected_components(double_graph):
+        axis = double_graph.subgraph(component)
+        edge_count = axis.number_of_edges()
+        if edge_count < 2 or edge_count % 2 != 0:
+            continue
+        if edge_count != axis.number_of_nodes() - 1:
+            continue
+        degrees = dict(axis.degree())
+        if any(degree > 2 for degree in degrees.values()):
+            continue
+        ends = sorted(node for node, degree in degrees.items() if degree == 1)
+        if len(ends) != 2:
+            continue
+        path = nx.shortest_path(axis, ends[0], ends[1])
+        if any(molecule.GetAtomWithIdx(node).GetDegree() != 2 for node in path[1:-1]):
+            continue
+        left_refs = _cumulene_end_references(
+            molecule.GetAtomWithIdx(path[0]),
+            path[1],
+        )
+        right_refs = _cumulene_end_references(
+            molecule.GetAtomWithIdx(path[-1]),
+            path[-2],
+        )
+        if left_refs is None or right_refs is None:
+            continue
+        supports.append(AxisStereoSupport(tuple(path), (left_refs, right_refs)))
+    return tuple(supports)
+
+
+def _potential_biaryl_supports(
+    molecule: Chem.Mol,
+    *,
+    include_extended_ring_axes: bool,
+) -> tuple[AxisStereoSupport, ...]:
+    """Detect ring-associated bond axes without orientation or barrier claims."""
+    supports = []
+    for bond in molecule.GetBonds():
+        if bond.GetBondType() not in {
+            Chem.BondType.SINGLE,
+            Chem.BondType.AROMATIC,
+        }:
+            continue
+        left_atom = bond.GetBeginAtom()
+        right_atom = bond.GetEndAtom()
+        hybridizations = {
+            left_atom.GetHybridization(),
+            right_atom.GetHybridization(),
+        }
+        containing_ring_sizes = tuple(
+            len(ring)
+            for ring in molecule.GetRingInfo().BondRings()
+            if bond.GetIdx() in ring
+        )
+        aromatic_ring_axis = (
+            bond.GetIsAromatic()
+            and left_atom.GetIsAromatic()
+            and right_atom.GetIsAromatic()
+            and any(size > 6 for size in containing_ring_sizes)
+        )
+        linked_ring_axis = (
+            not bond.GetIsAromatic()
+            and (
+                left_atom.IsInRing()
+                or right_atom.IsInRing()
+            )
+            and Chem.HybridizationType.SP2 in hybridizations
+            and hybridizations
+            <= {
+                Chem.HybridizationType.SP2,
+                Chem.HybridizationType.SP3,
+            }
+        )
+        standard_biaryl_axis = (
+            not bond.GetIsAromatic()
+            and left_atom.GetIsAromatic()
+            and right_atom.GetIsAromatic()
+        )
+        if not standard_biaryl_axis and not (
+            include_extended_ring_axes
+            and (aromatic_ring_axis or linked_ring_axis)
+        ):
+            continue
+        left, right = left_atom.GetIdx(), right_atom.GetIdx()
+        left_refs = tuple(
+            neighbor.GetIdx()
+            for neighbor in left_atom.GetNeighbors()
+            if neighbor.GetIdx() != right_atom.GetIdx()
+        )
+        right_refs = tuple(
+            neighbor.GetIdx()
+            for neighbor in right_atom.GetNeighbors()
+            if neighbor.GetIdx() != left_atom.GetIdx()
+        )
+        if len(left_refs) != 2 or len(right_refs) != 2:
+            continue
+        supports.append(
+            AxisStereoSupport(
+                (left, right),
+                (left_refs, right_refs),
+            )
+        )
+    return tuple(supports)
+
+
+def detect_potential_axis_supports(
+    molecule: Chem.Mol,
+    *,
+    include_extended_ring_axes: bool = False,
+) -> tuple[tuple[str, AxisStereoSupport], ...]:
+    """Return typed topology supports for potential molecular stereo axes."""
+    if molecule is None:
+        raise ValueError("Potential stereo-locus detection requires a molecule.")
+    working = Chem.Mol(molecule)
+    return (
+        *(
+            ("cumulene_axis", support)
+            for support in _potential_cumulene_supports(working)
+        ),
+        *(
+            ("atrop_axis", support)
+            for support in _potential_biaryl_supports(
+                working,
+                include_extended_ring_axes=include_extended_ring_axes,
+            )
+        ),
+    )