synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Mapper/solvers/native/reaction_build.py

@@ -0,0 +1,277 @@
+"""Explicit immutable bundles for the optional RDKit C++ reaction pipeline."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import platform
+import shlex
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+@dataclass(frozen=True)
+class NativeReactionBuild:
+    library: Path
+    core: Path
+    executable: Path
+    manifest: Path
+
+
+# SDK discovery, optional adapters and artifact checks form one isolated build.
+def build_reaction_native(  # noqa: C901
+    output_dir,
+    *,
+    rdkit_dir,
+    compiler="g++",
+    ortools_dir=None,
+    openwbo_executable=None,
+    evalmaxsat_executable=None,
+):
+    """Compile an isolated native bundle; never install or compile on import.
+
+    ``rdkit_dir`` is an existing C++ SDK prefix, including compatible Boost and
+    Eigen development packages. The optional frontend uses C++20 for RDKit
+    2026 public headers; the prepared-graph core remains C++17.
+    """
+    root = Path(__file__).resolve().parent
+    cpp = root / "cpp"
+    payloads = {
+        str(path.relative_to(cpp)): path.read_bytes()
+        for path in sorted(cpp.rglob("*"))
+        if path.is_file()
+    }
+    legacy = (root.parent / "exact/native/native_distance.cpp").read_bytes()
+    compiler_path = shutil.which(compiler)
+    if not compiler_path:
+        raise RuntimeError(f"C++ compiler unavailable: {compiler}")
+    sdk = Path(rdkit_dir).resolve()
+    if not (sdk / "include/rdkit/GraphMol/ROMol.h").is_file():
+        raise ValueError("rdkit_dir lacks C++ development headers")
+    sdk_records = {
+        str(p.relative_to(sdk)): _sha(p)
+        for p in sorted((sdk / "conda-meta").glob("*.json"))
+    }
+    # Also cover non-Conda SDKs and detect binary/header replacement.
+    sdk_inputs = {
+        str(p.relative_to(sdk)): _sha(p)
+        for directory in (sdk / "include/rdkit", sdk / "lib/cmake/rdkit")
+        for p in sorted(directory.rglob("*"))
+        if p.is_file()
+    }
+    sdk_inputs.update(
+        {
+            str(p.relative_to(sdk)): _sha(p)
+            for p in sorted((sdk / "lib").glob("*RDKit*.so*"))
+            if p.is_file()
+        }
+    )
+    configuration = {
+        "builder_sha256": _sha(__file__),
+        "platform": sys.platform,
+        "machine": platform.machine(),
+        "compiler": compiler_path,
+        "compiler_version": subprocess.check_output(
+            [compiler_path, "--version"], text=True
+        ),
+        "sources": {
+            name: hashlib.sha256(data).hexdigest() for name, data in payloads.items()
+        },
+        "legacy_source_sha256": hashlib.sha256(legacy).hexdigest(),
+        "rdkit_dir": str(sdk),
+        "sdk_records": sdk_records,
+        "sdk_inputs": sdk_inputs,
+        "ortools_dir": str(Path(ortools_dir).resolve()) if ortools_dir else None,
+        "ortools_libraries": {
+            str(p): _sha(p)
+            for p in sorted(Path(ortools_dir).glob("lib*/libortools.so*"))
+        }
+        if ortools_dir
+        else {},
+        "openwbo": {
+            "path": str(Path(openwbo_executable).resolve()),
+            "sha256": _sha(openwbo_executable),
+        }
+        if openwbo_executable
+        else None,
+        "evalmaxsat": {
+            "path": str(Path(evalmaxsat_executable).resolve()),
+            "sha256": _sha(evalmaxsat_executable),
+        }
+        if evalmaxsat_executable
+        else None,
+    }
+    key = hashlib.sha256(json.dumps(configuration, sort_keys=True).encode()).hexdigest()
+    output = Path(output_dir).resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    bundle = output / key[:20]
+    suffix = (
+        ".dylib"
+        if sys.platform == "darwin"
+        else ".dll"
+        if sys.platform == "win32"
+        else ".so"
+    )
+
+    def artifacts():
+        return NativeReactionBuild(
+            bundle / f"libsynkit_mapper_reaction{suffix}",
+            bundle / f"libsynkit_mapper{suffix}",
+            bundle / "mapper_reaction",
+            bundle / "manifest.json",
+        )
+
+    if bundle.exists():
+        record = json.loads((bundle / "manifest.json").read_text())
+        if record["configuration"] != configuration or any(
+            _sha(bundle / name) != digest
+            for name, digest in record["artifacts"].items()
+        ):
+            raise RuntimeError("Native reaction bundle integrity verification failed")
+        for section in ("dependencies", "external_headers"):
+            if any(
+                not Path(name).is_file() or _sha(name) != digest
+                for name, digest in record.get(section, {}).items()
+            ):
+                raise RuntimeError(
+                    f"Native reaction bundle {section} integrity verification failed"
+                )
+        return artifacts()
+    with tempfile.TemporaryDirectory(prefix="reaction-build-", dir=output) as temporary:
+        working = Path(temporary)
+        source = working / "snapshot/Mapper/solvers/native/cpp"
+        for name, data in payloads.items():
+            path = source / name
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(data)
+        legacy_path = source.parents[1] / "exact/native/native_distance.cpp"
+        legacy_path.parent.mkdir(parents=True, exist_ok=True)
+        legacy_path.write_bytes(legacy)
+        build = working / "build"
+        command = [
+            "cmake",
+            "-S",
+            str(source),
+            "-B",
+            str(build),
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+            "-DCMAKE_BUILD_RPATH_USE_ORIGIN=ON",
+            f"-DCMAKE_CXX_COMPILER={compiler_path}",
+            "-DSYNKIT_MAPPER_WITH_RDKIT=ON",
+            "-DCMAKE_PREFIX_PATH="
+            + ";".join(
+                [str(sdk)] + ([str(Path(ortools_dir).resolve())] if ortools_dir else [])
+            ),
+        ]
+        if ortools_dir:
+            command.append("-DSYNKIT_MAPPER_WITH_ORTOOLS=ON")
+        for option, value in (
+            ("OPENWBO", openwbo_executable),
+            ("EVALMAXSAT", evalmaxsat_executable),
+        ):
+            if value:
+                command.append(
+                    f"-DSYNKIT_MAPPER_{option}_EXECUTABLE={Path(value).resolve()}"
+                )
+        configure = subprocess.run(command, capture_output=True, text=True, check=False)
+        if configure.returncode:
+            raise RuntimeError(configure.stdout + configure.stderr)
+        compile_command = ["cmake", "--build", str(build), "-j", "2"]
+        compiled = subprocess.run(
+            compile_command, capture_output=True, text=True, check=False
+        )
+        if compiled.returncode:
+            raise RuntimeError(compiled.stdout + compiled.stderr)
+        staged = working / "bundle"
+        staged.mkdir()
+        names = [
+            f"libsynkit_mapper{suffix}",
+            f"libsynkit_mapper_reaction{suffix}",
+            "mapper_reaction",
+        ]
+        for name in names:
+            shutil.copy2(build / name, staged / name)
+        dependencies = {}
+        if sys.platform.startswith("linux"):
+            native_inputs = [staged / name for name in names] + [
+                Path(value).resolve()
+                for value in (openwbo_executable, evalmaxsat_executable)
+                if value
+            ]
+            for native_input in native_inputs:
+                dependency_listing = subprocess.run(
+                    ["ldd", str(native_input)],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                listing = dependency_listing.stdout + dependency_listing.stderr
+                if dependency_listing.returncode and not any(
+                    message in listing
+                    for message in ("not a dynamic executable", "statically linked")
+                ):
+                    raise RuntimeError(
+                        f"Cannot inspect native dependencies:\n{listing}"
+                    )
+                if "not found" in listing:
+                    raise RuntimeError(f"Unresolved native dependency:\n{listing}")
+                for line in listing.splitlines():
+                    candidate = line.split("=>", 1)[-1].strip().split(" ", 1)[0]
+                    if candidate.startswith("/") and Path(candidate).is_file():
+                        resolved = Path(candidate).resolve()
+                        if resolved.parent != staged:
+                            dependencies[str(resolved)] = _sha(resolved)
+        external_headers = {}
+        for depfile in build.rglob("*.o.d"):
+            text = depfile.read_text().replace("\\\n", " ")
+            for name in shlex.split(text.split(":", 1)[-1]):
+                path = Path(name)
+                if path.is_file() and not path.is_relative_to(source.parents[2]):
+                    external_headers[str(path.resolve())] = _sha(path)
+        with tarfile.open(staged / "sources.tar.gz", "w:gz") as archive:
+            archive.add(source.parents[2], arcname="Mapper")
+        record = {
+            "configuration": configuration,
+            "build_key": key,
+            "commands": [command, compile_command],
+            "compile_commands": json.loads(
+                (build / "compile_commands.json").read_text()
+            ),
+            "dependencies": dependencies,
+            "external_headers": external_headers,
+            "artifacts": {
+                name: _sha(staged / name) for name in [*names, "sources.tar.gz"]
+            },
+            "compiler_log": compiled.stdout + compiled.stderr,
+        }
+        (staged / "manifest.json").write_text(json.dumps(record, indent=2) + "\n")
+        os.rename(staged, bundle)
+    return artifacts()
+
+
+def main():
+    """Run the explicit native-reaction build command."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--rdkit-dir", required=True)
+    parser.add_argument("--ortools-dir")
+    parser.add_argument("--openwbo-executable")
+    parser.add_argument("--evalmaxsat-executable")
+    options = parser.parse_args()
+    print(build_reaction_native(**vars(options)).library)
+
+
+if __name__ == "__main__":
+    main()

synkit/Chem/Mapper/solvers/native/reaction_text.py

@@ -0,0 +1,26 @@
+"""Reaction-SMILES fields without interpreting endpoint chemistry."""
+
+from __future__ import annotations
+
+import re
+
+_REACTION_SEPARATOR = re.compile(r"(?<!-)>")
+
+
+def split_reaction_fields(
+    text: str, *, error_message: str = "Expected reactants>agents>products"
+) -> tuple[str, str, str]:
+    """Return exactly three fields, preserving dative ``->`` bond text.
+
+    A right angle bracket belongs to a dative bond when preceded by ``-``.
+    All other right angle brackets delimit reaction fields. Empty fields are
+    retained; each caller decides whether empty endpoints or agents are valid.
+    This function does not parse, normalize or rewrite any SMILES field.
+    """
+    parts = _REACTION_SEPARATOR.split(text)
+    if len(parts) != 3:
+        raise ValueError(error_message)
+    return parts[0], parts[1], parts[2]
+
+
+__all__ = ["split_reaction_fields"]

synkit/Chem/Mapper/solvers/native/runtime.py

@@ -0,0 +1,242 @@
+"""Versioned ctypes declarations for the common mapper C ABI."""
+
+import ctypes as ct
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+BACKENDS = {
+    "slap": 0,
+    "pabs": 1,
+    "cp_sat": 2,
+    "scip": 3,
+    "maxsat": 4,
+    "astar": 5,
+    "cpabs": 6,
+    "abb": 7,
+    "kbb": 8,
+    "kmilp": 9,
+    "edit": 10,
+    "dfs": 11,
+    "mces": 12,
+    "sepdp": 13,
+}
+
+
+def resolve_library_path(library_path=None):
+    """Use an explicit library or the wheel's bundled core; never compile implicitly."""
+    if library_path is not None:
+        return Path(library_path).expanduser().resolve()
+    name = (
+        "synkit_mapper.dll" if sys.platform == "win32"
+        else "libsynkit_mapper.dylib" if sys.platform == "darwin"
+        else "libsynkit_mapper.so"
+    )
+    library = Path(__file__).resolve().parent / "lib" / name
+    if not library.is_file():
+        raise FileNotFoundError(
+            "The bundled C++ mapper library is missing. Install a SynKit platform "
+            "wheel, or build with build_mapper_native and pass library_path explicitly. "
+            "Source checkouts and editable installs require an explicit native build."
+        )
+    return library
+
+
+def available_native_methods(library_path=None):
+    """Return the solver configurations advertised by the selected compiled core."""
+    library = load_core(str(resolve_library_path(library_path)))
+    capabilities = library.synkit_mapper_capabilities()
+    return tuple(name for name, index in BACKENDS.items() if capabilities & (1 << index))
+
+
+@lru_cache(maxsize=8)
+def has_core(path):
+    library = ct.CDLL(str(Path(path).resolve()))
+    if not hasattr(library, "synkit_mapper_core_abi"):
+        return False
+    if library.synkit_mapper_core_abi() != 1:
+        raise RuntimeError("Unsupported common mapper ABI")
+    return True
+
+
+REASONS = {
+    0: None,
+    1: "time_limit",
+    2: "max_states",
+    3: "max_mappings",
+    4: "max_classes",
+    5: "callback",
+    6: "max_frontier",
+    7: "memory_limit",
+    8: "unsupported",
+    9: "heuristic",
+    10: "cancelled",
+}
+INT = ct.POINTER(ct.c_int32)
+LONG = ct.POINTER(ct.c_int64)
+CALLBACK = ct.CFUNCTYPE(ct.c_int, INT, ct.c_int64, ct.c_void_p)
+
+
+class Problem(ct.Structure):
+    _fields_ = [
+        ("abi_version", ct.c_int32),
+        ("n", ct.c_int32),
+        ("a2", LONG),
+        ("b2", LONG),
+    ] + [
+        (name, INT)
+        for name in (
+            "types_r",
+            "types_p",
+            "node_colors_r",
+            "node_colors_p",
+            "edge_colors_r",
+            "edge_colors_p",
+        )
+    ]
+
+
+class Request(ct.Structure):
+    _fields_ = (
+        [
+            (name, ct.c_int32)
+            for name in (
+                "abi_version",
+                "backend",
+                "query",
+                "symmetry",
+                "classify",
+                "workers",
+            )
+        ]
+        + [("target2", ct.c_int64), ("seconds", ct.c_double)]
+        + [
+            (name, ct.c_int64)
+            for name in (
+                "max_states",
+                "max_candidates",
+                "max_classes",
+                "max_frontier",
+                "memory_limit_bytes",
+            )
+        ]
+        + [
+            ("slap_max_fingerprints", ct.c_int32),
+            ("slap_stop_flags", INT),
+            ("cancel_token", ct.c_void_p),
+        ]
+    )
+
+
+class Statistics(ct.Structure):
+    _fields_ = (
+        [
+            (name, ct.c_int32)
+            for name in (
+                "abi_version",
+                "backend",
+                "status",
+                "reason",
+                "minimum_proven",
+                "search_complete",
+                "classification_complete",
+                "hydrogen_complete",
+                "heuristic_finished",
+            )
+        ]
+        + [
+            (name, ct.c_int64)
+            for name in (
+                "minimum2",
+                "incumbent2",
+                "lower_bound2",
+                "nodes",
+                "leaves",
+                "candidate_count",
+                "class_count",
+                "labeled_count",
+                "peak_frontier",
+                "peak_frontier_bytes",
+                "peak_memory_bytes",
+            )
+        ]
+        + [
+            (name, ct.c_double)
+            for name in (
+                "model_seconds",
+                "optimization_seconds",
+                "enumeration_seconds",
+                "classification_seconds",
+                "callback_seconds",
+                "elapsed_seconds",
+            )
+        ]
+    )
+
+
+@lru_cache(maxsize=8)
+def load_core(path):
+    path = Path(path).resolve()
+    if path.parent == Path(__file__).resolve().parent / "lib":
+        from synkit._native import verify_wheel_library
+
+        verify_wheel_library(path)
+    library = ct.CDLL(str(path))
+    try:
+        if library.synkit_mapper_core_abi() != 1:
+            raise RuntimeError("Unsupported common mapper ABI")
+    except AttributeError as error:
+        raise RuntimeError(
+            "Library lacks common mapper ABI; build with build_mapper_native"
+        ) from error
+    library.synkit_mapper_capabilities.restype = ct.c_uint64
+    library.synkit_mapper_core_error.restype = ct.c_char_p
+    if hasattr(library, "synkit_mapper_backend_version"):
+        library.synkit_mapper_backend_version.argtypes = [ct.c_int]
+        library.synkit_mapper_backend_version.restype = ct.c_char_p
+    if hasattr(library, "synkit_mapper_backend_metadata"):
+        library.synkit_mapper_backend_metadata.argtypes = [ct.c_int]
+        library.synkit_mapper_backend_metadata.restype = ct.c_char_p
+    library.synkit_mapper_solve.argtypes = [
+        ct.POINTER(Problem),
+        ct.POINTER(Request),
+        CALLBACK,
+        ct.c_void_p,
+        ct.POINTER(Statistics),
+    ]
+    library.synkit_mapper_solve.restype = ct.c_int
+    if hasattr(library, "synkit_mapper_solve_domains"):
+        library.synkit_mapper_solve_domains.argtypes = [
+            ct.POINTER(Problem),
+            ct.POINTER(Request),
+            ct.POINTER(ct.c_uint8),
+            CALLBACK,
+            ct.c_void_p,
+            ct.POINTER(Statistics),
+        ]
+        library.synkit_mapper_solve_domains.restype = ct.c_int
+    library.synkit_mapper_cancel_create.restype = ct.c_void_p
+    for name in ("synkit_mapper_cancel_request", "synkit_mapper_cancel_free"):
+        getattr(library, name).argtypes = [ct.c_void_p]
+    return library
+
+
+class CancellationToken:
+    def __init__(self, library_path):
+        self.library = load_core(str(Path(library_path).resolve()))
+        self.pointer = self.library.synkit_mapper_cancel_create()
+
+    def cancel(self):
+        if self.pointer:
+            self.library.synkit_mapper_cancel_request(self.pointer)
+
+    def close(self):
+        if self.pointer:
+            self.library.synkit_mapper_cancel_free(self.pointer)
+            self.pointer = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()

synkit/Chem/Mapper/solvers/native/sepdp.py

@@ -0,0 +1,47 @@
+"""Exact separator-table DP with global target injectivity and weighted costs."""
+
+import ctypes as ct
+from pathlib import Path
+
+from .core import enumerate_core_mappings, map_reaction_core
+
+
+class _Profile(ct.Structure):
+    _fields_ = [
+        (name, ct.c_int64)
+        for name in (
+            "separator_width",
+            "states",
+            "predecessor_arcs",
+            "transitions",
+            "peak_accounted_table_bytes",
+        )
+    ]
+
+
+def sepdp_profile(library_path):
+    library = ct.CDLL(str(Path(library_path).resolve()))
+    function = library.synkit_mapper_sepdp_profile
+    function.argtypes = [ct.POINTER(_Profile)]
+    function.restype = None
+    profile = _Profile()
+    function(ct.byref(profile))
+    return {name: getattr(profile, name) for name, _ in _Profile._fields_}
+
+
+def enumerate_sepdp_mappings(graphs, *, library_path, **options):
+    """Exact arbitrary weighted graphs up to the declared 63-vertex mask limit.
+
+    State and memory growth remain exponential in target subsets and separator
+    width. The memory cap measures accounted retained table/DAG payload, not
+    process RSS or a theorem about polynomial general graph edit distance.
+    """
+    return enumerate_core_mappings(
+        graphs, library_path=library_path, backend="sepdp", **options
+    )
+
+
+def map_reaction_sepdp(reaction, *, library_path, **options):
+    return map_reaction_core(
+        reaction, library_path=library_path, backend="sepdp", **options
+    )