cppkh-interface 0.1.0__tar.gz → 0.1.2__tar.gz

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppkh-interface
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python interface for cppkh Khovanov homology computation with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -26,6 +26,10 @@ Description-Content-Type: text/markdown
 `cppkh-interface` is a Python package for computing integer Khovanov homology
 with the C++ `cppkh` implementation.
 
+Version `0.1.2` resolves link crossing signs by tracing directed PD edge
+incidences with the SageMath convention. It does not infer signs from numeric
+arc-label ordering.
+
 The package is compatible with the main `javakh-interface` function:
 
 ```python
@@ -33,11 +37,18 @@ import cppkh_interface
 
 pd_code = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
 print(cppkh_interface.solve_khovanov(pd_code, de_r1=True, de_k8=True))
+print(cppkh_interface.solve_many_khovanov([pd_code, pd_code]))
 ```
 
 Unlike wrappers that ship a prebuilt DLL or shared object, this package ships
-the `cppkh` C++ source file and compiles a local executable on first use through
-`cpp-simple-interface`. The compiled executable is cached for later calls.
+the `cppkh` C++ source file in built distributions and compiles a local
+executable on first use through `cpp-simple-interface`. The compiled executable
+is cached for later calls.
+
+In the repository checkout, the package does not keep a committed backup copy
+of the C++ source. The build backend copies `../../src/main.cpp` into the
+package data directory only while `poetry build` or `poetry publish --build` is
+running, then removes that temporary copy.
 
 ## Install
 
@@ -68,6 +79,8 @@ poetry build
 poetry publish
 ```
 
+Use `poetry publish --build` to build and upload in one command.
+
 For local testing:
 
 ```sh

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/README.md

@@ -3,6 +3,10 @@
 `cppkh-interface` is a Python package for computing integer Khovanov homology
 with the C++ `cppkh` implementation.
 
+Version `0.1.2` resolves link crossing signs by tracing directed PD edge
+incidences with the SageMath convention. It does not infer signs from numeric
+arc-label ordering.
+
 The package is compatible with the main `javakh-interface` function:
 
 ```python
@@ -10,11 +14,18 @@ import cppkh_interface
 
 pd_code = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
 print(cppkh_interface.solve_khovanov(pd_code, de_r1=True, de_k8=True))
+print(cppkh_interface.solve_many_khovanov([pd_code, pd_code]))
 ```
 
 Unlike wrappers that ship a prebuilt DLL or shared object, this package ships
-the `cppkh` C++ source file and compiles a local executable on first use through
-`cpp-simple-interface`. The compiled executable is cached for later calls.
+the `cppkh` C++ source file in built distributions and compiles a local
+executable on first use through `cpp-simple-interface`. The compiled executable
+is cached for later calls.
+
+In the repository checkout, the package does not keep a committed backup copy
+of the C++ source. The build backend copies `../../src/main.cpp` into the
+package data directory only while `poetry build` or `poetry publish --build` is
+running, then removes that temporary copy.
 
 ## Install
 
@@ -45,6 +56,8 @@ poetry build
 poetry publish
 ```
 
+Use `poetry publish --build` to build and upload in one command.
+
 For local testing:
 
 ```sh

cppkh_interface-0.1.2/build_backend/cppkh_interface_build_backend.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+
+from poetry.core.masonry import api as poetry_api
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+REPO_ROOT = PROJECT_ROOT.parents[1]
+SOURCE = REPO_ROOT / "src" / "main.cpp"
+TARGET = PROJECT_ROOT / "cppkh_interface" / "data" / "src" / "main.cpp"
+WHEEL_SOURCE_NAME = "cppkh_interface/data/src/main.cpp"
+
+
+def _sync_cpp_source() -> None:
+    if SOURCE.exists():
+        TARGET.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(SOURCE, TARGET)
+        return
+    if TARGET.exists():
+        return
+    raise FileNotFoundError(
+        "cppkh source file was not found. Expected either "
+        f"{SOURCE} in the repository checkout or {TARGET} in the source tree."
+    )
+
+
+def _clean_cpp_source() -> None:
+    if TARGET.exists() and SOURCE.exists():
+        TARGET.unlink()
+
+
+def _source_bytes() -> bytes:
+    if TARGET.exists():
+        return TARGET.read_bytes()
+    if SOURCE.exists():
+        return SOURCE.read_bytes()
+    raise FileNotFoundError("cppkh source file was not available for packaging")
+
+
+def _wheel_hash_and_size(data: bytes) -> tuple[str, str]:
+    digest = hashlib.sha256(data).digest()
+    encoded = base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+    return f"sha256={encoded}", str(len(data))
+
+
+def _make_universal_wheel_metadata(data: bytes) -> bytes:
+    text = data.decode("utf-8")
+    lines = []
+    tag_written = False
+    root_written = False
+    for line in text.splitlines():
+        if line.startswith("Root-Is-Purelib:"):
+            lines.append("Root-Is-Purelib: true")
+            root_written = True
+        elif line.startswith("Tag:"):
+            if not tag_written:
+                lines.append("Tag: py3-none-any")
+                tag_written = True
+        else:
+            lines.append(line)
+    if not root_written:
+        lines.append("Root-Is-Purelib: true")
+    if not tag_written:
+        lines.append("Tag: py3-none-any")
+    return ("\n".join(lines) + "\n").encode("utf-8")
+
+
+def _universal_wheel_path(wheel_path: Path, record_name: str) -> Path:
+    dist_info = record_name.split("/", 1)[0]
+    base = dist_info.removesuffix(".dist-info")
+    return wheel_path.with_name(f"{base}-py3-none-any.whl")
+
+
+def _rewrite_wheel_with_source(wheel_path: Path) -> Path:
+    source_data = _source_bytes()
+    rows: list[tuple[str, str, str]] = []
+
+    with zipfile.ZipFile(wheel_path, "r") as zin:
+        record_name = next(
+            (name for name in zin.namelist() if name.endswith(".dist-info/RECORD")),
+            None,
+        )
+        if record_name is None:
+            raise RuntimeError(f"wheel RECORD file not found in {wheel_path}")
+        output_path = _universal_wheel_path(wheel_path, record_name)
+        temp_path = output_path.with_name(output_path.name + ".tmp")
+
+        with zipfile.ZipFile(temp_path, "w", compression=zipfile.ZIP_DEFLATED) as zout:
+            wheel_metadata_name = record_name.removesuffix("RECORD") + "WHEEL"
+
+            for item in zin.infolist():
+                if item.filename in (WHEEL_SOURCE_NAME, record_name):
+                    continue
+                data = zin.read(item.filename)
+                if item.filename == wheel_metadata_name:
+                    data = _make_universal_wheel_metadata(data)
+                zout.writestr(item, data)
+                if not item.is_dir():
+                    digest, size = _wheel_hash_and_size(data)
+                    rows.append((item.filename, digest, size))
+
+            source_info = zipfile.ZipInfo(WHEEL_SOURCE_NAME, date_time=(2016, 1, 1, 0, 0, 0))
+            source_info.compress_type = zipfile.ZIP_DEFLATED
+            zout.writestr(source_info, source_data)
+            digest, size = _wheel_hash_and_size(source_data)
+            rows.append((WHEEL_SOURCE_NAME, digest, size))
+
+            rows.append((record_name, "", ""))
+            record_text = "".join(f"{path},{digest},{size}\n" for path, digest, size in rows)
+            record_info = zipfile.ZipInfo(record_name, date_time=(2016, 1, 1, 0, 0, 0))
+            record_info.compress_type = zipfile.ZIP_DEFLATED
+            zout.writestr(record_info, record_text.encode("utf-8"))
+
+    temp_path.replace(output_path)
+    if output_path != wheel_path and wheel_path.exists():
+        wheel_path.unlink()
+    return output_path
+
+
+def finalize_poetry_wheels() -> None:
+    dist = PROJECT_ROOT / "dist"
+    if not dist.exists():
+        return
+    for wheel_path in sorted(dist.glob("cppkh_interface-*.whl")):
+        _rewrite_wheel_with_source(wheel_path)
+
+
+def _rewrite_sdist_with_source(sdist_path: Path) -> None:
+    source_data = _source_bytes()
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".tar.gz")
+    temp_path = Path(temp_file.name)
+    temp_file.close()
+
+    try:
+        with tarfile.open(sdist_path, "r:gz") as tin, tarfile.open(temp_path, "w:gz") as tout:
+            names = tin.getnames()
+            if not names:
+                raise RuntimeError(f"sdist is empty: {sdist_path}")
+            root = names[0].split("/", 1)[0]
+            source_name = f"{root}/{WHEEL_SOURCE_NAME}"
+
+            for member in tin.getmembers():
+                if member.name == source_name:
+                    continue
+                if member.isfile():
+                    extracted = tin.extractfile(member)
+                    if extracted is None:
+                        raise RuntimeError(f"could not read {member.name} from {sdist_path}")
+                    with extracted:
+                        tout.addfile(member, extracted)
+                else:
+                    tout.addfile(member)
+
+            source_info = tarfile.TarInfo(source_name)
+            source_info.size = len(source_data)
+            source_info.mtime = 0
+            source_info.mode = 0o644
+            tout.addfile(source_info, io.BytesIO(source_data))
+
+        temp_path.replace(sdist_path)
+    finally:
+        if temp_path.exists():
+            temp_path.unlink()
+
+
+def get_requires_for_build_wheel(config_settings=None):
+    return poetry_api.get_requires_for_build_wheel(config_settings)
+
+
+def get_requires_for_build_sdist(config_settings=None):
+    return poetry_api.get_requires_for_build_sdist(config_settings)
+
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+    _sync_cpp_source()
+    try:
+        return poetry_api.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
+    finally:
+        _clean_cpp_source()
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    _sync_cpp_source()
+    try:
+        wheel_name = poetry_api.build_wheel(wheel_directory, config_settings, metadata_directory)
+        final_path = _rewrite_wheel_with_source(Path(wheel_directory) / wheel_name)
+        return final_path.name
+    finally:
+        _clean_cpp_source()
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    _sync_cpp_source()
+    try:
+        sdist_name = poetry_api.build_sdist(sdist_directory, config_settings)
+        _rewrite_sdist_with_source(Path(sdist_directory) / sdist_name)
+        return sdist_name
+    finally:
+        _clean_cpp_source()

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/cppkh_interface/__init__.py

@@ -1,19 +1,25 @@
 from .main import (
     CppkhInterfaceError,
     compile_cppkh,
+    compute_many_pd,
     compute_pd,
     get_cppkh_executable,
     normalize_pd_code,
+    normalize_pd_codes,
     simplify_pd,
+    solve_many_khovanov,
     solve_khovanov,
 )
 
 __all__ = [
     "CppkhInterfaceError",
     "compile_cppkh",
+    "compute_many_pd",
     "compute_pd",
     "get_cppkh_executable",
     "normalize_pd_code",
+    "normalize_pd_codes",
     "simplify_pd",
+    "solve_many_khovanov",
     "solve_khovanov",
 ]

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/cppkh_interface/data/src/main.cpp

@@ -2758,9 +2758,12 @@ std::string Komplex::KhForZ() {
     return ret;
 }
 
-static int chooseXingRecursive(const std::vector<int>& edges, const std::vector<std::vector<int> >& pd,
-                               std::vector<char>& in, std::vector<char>& done, int depth, std::vector<int>& retmax) {
-    int nedges = static_cast<int>(edges.size());
+static int chooseXingRecursive(const std::vector<int>& edges, const std::vector<std::vector<int> >& pd,
+                               std::vector<char>& in, std::vector<char>& done, int depth, std::vector<int>& retmax) {
+    // Choose the next crossing for the growing tangle. The heuristic maximizes
+    // already-attached boundary arcs, with a short lookahead to keep later
+    // intermediate girth smaller. It affects runtime, not the homology result.
+    int nedges = static_cast<int>(edges.size());
     int best = -1, nconbest = -1;
     std::vector<int> rbest(depth, 0);
     for (size_t i = 0; i < pd.size(); ++i) if (!done[i]) {
@@ -2819,15 +2822,91 @@ static int takeNextCrossing(const std::vector<int>&, const std::vector<std::vect
     throw std::runtime_error("no crossing left");
 }
 
-static std::vector<int> getSigns(const std::vector<std::vector<int> >& pd) {
-    std::vector<int> xsigns(pd.size());
-    for (size_t i = 0; i < pd.size(); ++i) {
-        if (pd[i][1] - pd[i][3] == 1 || pd[i][3] - pd[i][1] > 1) xsigns[i] = 1;
-        else if (pd[i][3] - pd[i][1] == 1 || pd[i][1] - pd[i][3] > 1) xsigns[i] = -1;
-        else throw std::runtime_error("error finding crossing signs");
-    }
-    return xsigns;
-}
+static std::vector<int> getSigns(const std::vector<std::vector<int> >& pd) {
+    const int nodeCount = static_cast<int>(pd.size() * 4);
+    if (nodeCount == 0) return std::vector<int>();
+
+    int maxLabel = -1;
+    for (size_t i = 0; i < pd.size(); ++i) {
+        if (pd[i].size() != 4) throw std::runtime_error("PD crossing must have four entries");
+        for (int label : pd[i]) {
+            if (label < 0) throw std::runtime_error("PD arc labels must be positive");
+            maxLabel = std::max(maxLabel, label);
+        }
+    }
+
+    std::vector<int> first(maxLabel + 1, -1), second(maxLabel + 1, -1);
+    for (size_t i = 0; i < pd.size(); ++i) {
+        for (int slot = 0; slot < 4; ++slot) {
+            int label = pd[i][slot];
+            int node = static_cast<int>(4 * i) + slot;
+            if (first[label] == -1) first[label] = node;
+            else if (second[label] == -1) second[label] = node;
+            else throw std::runtime_error("PD arc label appears more than twice");
+        }
+    }
+
+    std::vector<int> other(nodeCount, -1);
+    for (int label = 0; label <= maxLabel; ++label) {
+        if (first[label] == -1) continue;
+        if (second[label] == -1) throw std::runtime_error("PD arc label does not appear twice");
+        other[first[label]] = second[label];
+        other[second[label]] = first[label];
+    }
+
+    // 1 means that this edge leaves the crossing at this incidence, and 0
+    // means that it enters. Opposite incidences at a crossing and the two
+    // incidences of one edge always have opposite directions.
+    std::vector<signed char> outgoing(nodeCount, -1);
+    std::vector<int> queue;
+    queue.reserve(nodeCount);
+    auto orientComponent = [&](int seed, signed char direction) {
+        if (outgoing[seed] != -1) {
+            if (outgoing[seed] != direction) throw std::runtime_error("inconsistent PD orientation");
+            return;
+        }
+        queue.clear();
+        outgoing[seed] = direction;
+        queue.push_back(seed);
+        for (size_t head = 0; head < queue.size(); ++head) {
+            int node = queue[head];
+            int crossing = node / 4;
+            int slot = node % 4;
+            int neighbors[2] = {4 * crossing + ((slot + 2) % 4), other[node]};
+            for (int next : neighbors) {
+                if (next < 0) throw std::runtime_error("broken PD edge incidence");
+                signed char nextDirection = static_cast<signed char>(1 - outgoing[node]);
+                if (outgoing[next] == -1) {
+                    outgoing[next] = nextDirection;
+                    queue.push_back(next);
+                } else if (outgoing[next] != nextDirection) {
+                    throw std::runtime_error("inconsistent PD orientation");
+                }
+            }
+        }
+    };
+
+    // In SageMath's PD convention slot 0 is the incoming under-edge and slot
+    // 2 is the outgoing under-edge. These seeds orient every component that
+    // passes under at least once.
+    for (size_t i = 0; i < pd.size(); ++i) orientComponent(static_cast<int>(4 * i + 2), 1);
+
+    // A component which is over at every crossing has no orientation encoded
+    // by the PD tuples. Match SageMath's deterministic traversal by taking the
+    // first occurrence of the smallest still-unoriented edge as a tail.
+    for (int label = 0; label <= maxLabel; ++label) {
+        if (first[label] != -1 && outgoing[first[label]] == -1) orientComponent(first[label], 1);
+    }
+
+    std::vector<int> xsigns(pd.size());
+    for (size_t i = 0; i < pd.size(); ++i) {
+        const std::vector<int>& crossing = pd[i];
+        if (crossing[0] == crossing[3] || crossing[2] == crossing[1]) xsigns[i] = -1;
+        else if (crossing[3] == crossing[2] || crossing[0] == crossing[1]) xsigns[i] = 1;
+        else xsigns[i] = outgoing[4 * i + 3] ? -1 : 1;
+    }
+    return xsigns;
+}
 
 static bool sanityPD(const PDCode& pd) {
     std::map<int, int> counts;
@@ -2910,15 +2989,17 @@ static PDCode renumberR1Order(PDCode pd) {
     return pd;
 }
 
-static PDCode eraseR1(PDCode pd) {
-    if (!sanityPD(pd)) throw std::runtime_error("invalid PD code: every arc label must appear exactly twice");
-    bool hasR1 = true;
+static PDCode eraseR1(PDCode pd, std::vector<int>* signs) {
+    if (!sanityPD(pd)) throw std::runtime_error("invalid PD code: every arc label must appear exactly twice");
+    if (signs && signs->size() != pd.size()) throw std::runtime_error("crossing sign count does not match PD code");
+    bool hasR1 = true;
     while (hasR1) {
         hasR1 = false;
         for (size_t i = 0; i < pd.size(); ++i) {
             if (uniqueCount(pd[i]) <= 3) {
-                std::vector<int> crossing = pd[i];
-                pd.erase(pd.begin() + static_cast<std::ptrdiff_t>(i));
+                std::vector<int> crossing = pd[i];
+                pd.erase(pd.begin() + static_cast<std::ptrdiff_t>(i));
+                if (signs) signs->erase(signs->begin() + static_cast<std::ptrdiff_t>(i));
                 std::vector<int> singles;
                 for (int v : crossing) {
                     if (std::count(crossing.begin(), crossing.end(), v) == 1) singles.push_back(v);
@@ -3073,8 +3154,9 @@ static PDCode renumberFullDfs(PDCode pd) {
     return pd;
 }
 
-static PDCode eraseOneNugatory(PDCode pd, size_t index) {
-    if (uniqueCount(pd[index]) != 4) throw std::runtime_error("nugatory erase requires R1-free PD code");
+static PDCode eraseOneNugatory(PDCode pd, size_t index, std::vector<int>* signs) {
+    if (uniqueCount(pd[index]) != 4) throw std::runtime_error("nugatory erase requires R1-free PD code");
+    if (signs && signs->size() != pd.size()) throw std::runtime_error("crossing sign count does not match PD code");
     int ax = pd[index][0];
     int bx = pd[index][1];
     int cx = pd[index][2];
@@ -3096,22 +3178,23 @@ static PDCode eraseOneNugatory(PDCode pd, size_t index) {
     if (!loopSet.count(ax) || !loopSet.count(bx) || !loopSet.count(cx) || !loopSet.count(dx)) {
         throw std::runtime_error("nugatory crossing arcs are not in one component");
     }
-    PDCode bad = pd;
-    bad.erase(bad.begin() + static_cast<std::ptrdiff_t>(index));
+    PDCode bad = pd;
+    bad.erase(bad.begin() + static_cast<std::ptrdiff_t>(index));
+    if (signs) signs->erase(signs->begin() + static_cast<std::ptrdiff_t>(index));
     bad = replaceArcValue(bad, ax, cx);
     bad = replaceArcValue(bad, dx, bx);
     return renumberFullDfs(bad);
 }
 
-static PDCode simplifyPDCode(PDCode pd) {
-    pd = eraseR1(pd);
-    while (true) {
-        int index = findNugatory(pd);
-        if (index < 0) break;
-        pd = eraseOneNugatory(pd, static_cast<size_t>(index));
-    }
-    return pd;
-}
+static PDCode simplifyPDCode(PDCode pd, std::vector<int>* signs = nullptr) {
+    pd = eraseR1(pd, signs);
+    while (true) {
+        int index = findNugatory(pd);
+        if (index < 0) break;
+        pd = eraseOneNugatory(pd, static_cast<size_t>(index), signs);
+    }
+    return pd;
+}
 
 static int komplexSize(const Komplex& k) {
     int total = 0;
@@ -3119,8 +3202,8 @@ static int komplexSize(const Komplex& k) {
     return total;
 }
 
-static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std::vector<int>& xsigns) {
-    KH_PROFILE(generateFast);
+static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std::vector<int>& xsigns) {
+    KH_PROFILE(generateFast);
     if (pd.empty()) {
         Komplex kom(1);
         kom.columns[0] = SmoothingColumn(1);
@@ -3128,11 +3211,13 @@ static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std:
         kom.reduce();
         return kom;
     }
-    std::vector<char> in(pd.size() * 4, 0), done(pd.size(), 0);
-    std::vector<std::vector<int> > pd1(1, std::vector<int>{0,1,2,3});
-    Komplex kplus(pd1, std::vector<int>{1}, 4);
-    Komplex kminus(pd1, std::vector<int>{-1}, 4);
-    std::vector<int> edges;
+    std::vector<char> in(pd.size() * 4, 0), done(pd.size(), 0);
+    std::vector<std::vector<int> > pd1(1, std::vector<int>{0,1,2,3});
+    Komplex kplus(pd1, std::vector<int>{1}, 4);
+    Komplex kminus(pd1, std::vector<int>{-1}, 4);
+    // Build the full complex by composing one crossing complex at a time and
+    // reducing after every composition, following JavaKh's tangle-growth path.
+    std::vector<int> edges;
     int firstdepth = pd.size() > 4 ? 3 : static_cast<int>(pd.size()) - 1;
     std::vector<int> firstdummy(firstdepth + 1, 0);
     int first = g_options.reorderCrossings ? chooseXingRecursive(edges, pd, in, done, firstdepth, firstdummy)
@@ -3312,16 +3397,17 @@ static std::vector<std::string> listInputFiles(const std::string& dir) {
     return files;
 }
 
-static std::string computePD(const std::vector<std::vector<int> >& pd) {
-    flushCobCache();
-    g_smallArena.reset();
-    PDCode working = g_options.simplifyPD ? simplifyPDCode(pd) : pd;
-    Komplex k = generateFast(working, getSigns(working));
+static std::string computePD(const std::vector<std::vector<int> >& pd) {
+    flushCobCache();
+    g_smallArena.reset();
+    std::vector<int> signs = getSigns(pd);
+    PDCode working = g_options.simplifyPD ? simplifyPDCode(pd, &signs) : pd;
+    Komplex k = generateFast(working, signs);
     ProfileScope khScope(g_profile.kh);
     return k.KhForZ();
 }
 
-static std::string formatPDCode(const PDCode& pd) {
+static std::string formatPDCode(const PDCode& pd) {
     std::ostringstream out;
     out << "PD[";
     for (size_t i = 0; i < pd.size(); ++i) {
@@ -3334,10 +3420,22 @@ static std::string formatPDCode(const PDCode& pd) {
         out << "]";
     }
     out << "]";
-    return out.str();
-}
-
-static std::string simplifiedPDString(const PDCode& pd) {
+    return out.str();
+}
+
+static std::string formatCrossingSigns(const PDCode& pd) {
+    std::vector<int> signs = getSigns(pd);
+    std::ostringstream out;
+    out << "[";
+    for (size_t i = 0; i < signs.size(); ++i) {
+        if (i) out << ",";
+        out << signs[i];
+    }
+    out << "]";
+    return out.str();
+}
+
+static std::string simplifiedPDString(const PDCode& pd) {
     PDCode working = g_options.simplifyPD ? simplifyPDCode(pd) : pd;
     return formatPDCode(working);
 }
@@ -3409,6 +3507,38 @@ CPPKH_API char* cppkh_compute_pd(const char* pd_code) {
     return cppkh_compute_pd_ex(pd_code, 1, 1);
 }
 
+CPPKH_API char* cppkh_compute_pd_batch_ex(const char* pd_codes, int simplify_pd, int reorder_crossings) {
+    try {
+        g_cppkhLastError.clear();
+        if (!pd_codes) throw std::runtime_error("pd_codes is null");
+        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_codes, "ctypes-batch");
+        if (parsed.empty()) throw std::runtime_error("no PD code found");
+
+        CppkhOptionsGuard guard;
+        kh::g_options.progress = false;
+        kh::g_options.profile = false;
+        kh::g_options.simplifyPD = simplify_pd != 0;
+        kh::g_options.reorderCrossings = reorder_crossings != 0;
+
+        std::ostringstream out;
+        for (size_t i = 0; i < parsed.size(); ++i) {
+            if (i) out << "\n";
+            out << kh::computePD(parsed[i].second);
+        }
+        return cppkhDuplicateString(out.str());
+    } catch (const std::exception& e) {
+        g_cppkhLastError = e.what();
+        return nullptr;
+    } catch (...) {
+        g_cppkhLastError = "unknown error";
+        return nullptr;
+    }
+}
+
+CPPKH_API char* cppkh_compute_pd_batch(const char* pd_codes) {
+    return cppkh_compute_pd_batch_ex(pd_codes, 1, 1);
+}
+
 CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
     try {
         g_cppkhLastError.clear();
@@ -3432,7 +3562,7 @@ CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
 
 #ifndef CPPKH_SHARED_LIBRARY
 static void usage() {
-    std::cout << "Usage: javakh_cpp [--pd-file FILE] [--pd-dir DIR] [--pd-code CODE] [--ordered] [--threads N|auto] [--quiet] [--profile] [--no-simplify-pd] [--print-simplified-pd]\n";
+    std::cout << "Usage: cppkh [--pd-file FILE] [--pd-dir DIR] [--pd-code CODE] [--ordered] [--threads N|auto] [--quiet] [--profile] [--no-simplify-pd] [--print-simplified-pd] [--print-crossing-signs]\n";
     std::cout << "Thread backend: " << KH_THREAD_BACKEND_NAME << "\n";
     std::cout << "Detected CPU threads: " << kh::detectHardwareThreads() << "\n";
     std::cout << "PD simplification: R1 removal then nugatory crossing removal is enabled by default.\n";
@@ -3440,9 +3570,10 @@ static void usage() {
 
 int main(int argc, char** argv) {
     try {
-        std::vector<std::string> files;
-        std::vector<std::pair<std::string, std::vector<std::vector<int> > > > jobs;
-        bool printSimplifiedPD = false;
+        std::vector<std::string> files;
+        std::vector<std::pair<std::string, std::vector<std::vector<int> > > > jobs;
+        bool printSimplifiedPD = false;
+        bool printCrossingSigns = false;
         for (int i = 1; i < argc; ++i) {
             std::string a = argv[i];
             if (a == "--help" || a == "-h") { usage(); return 0; }
@@ -3461,8 +3592,9 @@ int main(int argc, char** argv) {
             else if (a == "--quiet" || a == "-q") kh::g_options.progress = false;
             else if (a == "--profile") kh::g_options.profile = true;
             else if (a == "--no-simplify-pd" || a == "--raw-pd") kh::g_options.simplifyPD = false;
-            else if (a == "--simplify-pd") kh::g_options.simplifyPD = true;
-            else if (a == "--print-simplified-pd") printSimplifiedPD = true;
+            else if (a == "--simplify-pd") kh::g_options.simplifyPD = true;
+            else if (a == "--print-simplified-pd") printSimplifiedPD = true;
+            else if (a == "--print-crossing-signs") printCrossingSigns = true;
             else if (a == "--threads" || a == "-j") {
                 if (++i >= argc) throw std::runtime_error("--threads needs a number");
                 std::string v = argv[i];
@@ -3489,9 +3621,10 @@ int main(int argc, char** argv) {
                 kh::g_profile.reset();
                 profileStart = kh::profileNowNs();
             }
-            if (label) std::cout << jobs[i].first << "\t";
-            if (printSimplifiedPD) std::cout << kh::simplifiedPDString(jobs[i].second) << "\n";
-            else std::cout << "\"" << kh::computePD(jobs[i].second) << "\"\n";
+            if (label) std::cout << jobs[i].first << "\t";
+            if (printSimplifiedPD) std::cout << kh::simplifiedPDString(jobs[i].second) << "\n";
+            else if (printCrossingSigns) std::cout << kh::formatCrossingSigns(jobs[i].second) << "\n";
+            else std::cout << "\"" << kh::computePD(jobs[i].second) << "\"\n";
             if (kh::g_options.profile) {
                 kh::g_profile.totalNs = kh::profileNowNs() - profileStart;
                 kh::printProfile();

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/cppkh_interface/main.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import ast
+import contextlib
 import hashlib
 import os
 import pathlib
@@ -22,6 +23,7 @@ import pd_code_sanity
 
 PathLike = Union[str, os.PathLike]
 PdInput = Union[str, Sequence[Sequence[int]]]
+PdManyInput = Union[str, Sequence[PdInput]]
 UNKNOT_RESULT = "q^-1*t^0*Z[0] + q^1*t^0*Z[0]"
 
 
@@ -88,9 +90,37 @@ def normalize_pd_code(pd_code: PdInput) -> str:
     return _format_pd(_as_crossings(pd_code))
 
 
+def normalize_pd_codes(pd_codes: PdManyInput) -> str:
+    """Normalize one or more PD codes into a newline-separated PD document."""
+
+    if isinstance(pd_codes, str):
+        return pd_codes.strip()
+    return "\n".join(normalize_pd_code(pd_code) for pd_code in pd_codes)
+
+
+@contextlib.contextmanager
 def _resource_source_path():
     source = resources.files("cppkh_interface") / "data" / "src" / "main.cpp"
-    return resources.as_file(source)
+    try:
+        with resources.as_file(source) as resource_path:
+            if pathlib.Path(resource_path).exists():
+                yield pathlib.Path(resource_path)
+                return
+    except FileNotFoundError:
+        pass
+
+    current = pathlib.Path(__file__).resolve()
+    for parent in current.parents:
+        candidate = parent / "src" / "main.cpp"
+        if candidate.exists():
+            yield candidate
+            return
+
+    raise CppkhInterfaceError(
+        "cppkh C++ source was not found. Installed wheels include it under "
+        "cppkh_interface/data/src/main.cpp; editable checkouts use the "
+        "repository root src/main.cpp."
+    )
 
 
 def _cache_dir() -> pathlib.Path:
@@ -217,17 +247,19 @@ def get_cppkh_executable() -> pathlib.Path:
     return compile_cppkh()
 
 
-def _run_cppkh(
+def _run_cppkh_document(
     pd_text: str,
     *,
     encoding: Optional[str] = None,
     threads: Union[str, int] = "1",
+    simplify_pd: bool = False,
     print_simplified_pd: bool = False,
-) -> str:
+) -> list[str]:
     exe = compile_cppkh()
     with tempfile.NamedTemporaryFile("w", suffix=".pd", encoding="utf-8", delete=False) as handle:
         handle.write(pd_text)
-        handle.write("\n")
+        if pd_text and not pd_text.endswith("\n"):
+            handle.write("\n")
         pd_file = handle.name
 
     command = [
@@ -237,8 +269,9 @@ def _run_cppkh(
         "--quiet",
         "--threads",
         str(threads),
-        "--no-simplify-pd",
     ]
+    if not simplify_pd:
+        command.append("--no-simplify-pd")
     if print_simplified_pd:
         command.append("--print-simplified-pd")
 
@@ -270,12 +303,32 @@ def _run_cppkh(
         raise CppkhInterfaceError(detail or f"cppkh exited with code {result.returncode}")
 
     if print_simplified_pd:
-        return result.stdout.strip()
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
 
     matches = re.findall(r'"([^"]*)"', result.stdout)
     if not matches:
         raise CppkhInterfaceError(f"result not found in cppkh output: {result.stdout!r}")
-    return matches[-1]
+    return matches
+
+
+def _run_cppkh(
+    pd_text: str,
+    *,
+    encoding: Optional[str] = None,
+    threads: Union[str, int] = "1",
+    simplify_pd: bool = False,
+    print_simplified_pd: bool = False,
+) -> str:
+    results = _run_cppkh_document(
+        pd_text,
+        encoding=encoding,
+        threads=threads,
+        simplify_pd=simplify_pd,
+        print_simplified_pd=print_simplified_pd,
+    )
+    if len(results) != 1:
+        raise CppkhInterfaceError(f"expected exactly one result, got {len(results)}")
+    return results[0]
 
 
 def _prepare_crossings(pd_code: PdInput, de_r1: bool, de_k8: bool) -> list[list[int]]:
@@ -288,6 +341,29 @@ def _prepare_crossings(pd_code: PdInput, de_r1: bool, de_k8: bool) -> list[list[
     return crossings
 
 
+def _prepare_many_for_cppkh(
+    pd_codes: PdManyInput,
+    *,
+    de_r1: bool,
+    de_k8: bool,
+) -> tuple[str, bool]:
+    if de_r1 != de_k8:
+        raise ValueError(
+            "cppkh batch mode supports de_r1 and de_k8 only as a pair. "
+            "Use both True for backend R1+nugatory simplification or both False for raw PD input."
+        )
+    if isinstance(pd_codes, str):
+        return pd_codes.strip(), bool(de_r1 and de_k8)
+
+    prepared = []
+    use_cpp_simplify = bool(de_r1 and de_k8)
+    for pd_code in pd_codes:
+        crossings = _as_crossings(pd_code)
+        _check_sanity(crossings)
+        prepared.append(_format_pd(crossings))
+    return "\n".join(prepared), use_cpp_simplify
+
+
 def solve_khovanov(
     pd_code: PdInput,
     encoding: Optional[str] = None,
@@ -297,6 +373,24 @@ def solve_khovanov(
 ) -> str:
     """Compute Khovanov homology with a javakh-interface compatible signature."""
 
+    if de_r1 == de_k8:
+        crossings = _as_crossings(pd_code)
+        _check_sanity(crossings)
+        if show_real_pdcode:
+            if de_r1:
+                simplified = _run_cppkh_document(
+                    _format_pd(crossings),
+                    encoding=encoding,
+                    simplify_pd=True,
+                    print_simplified_pd=True,
+                )
+                print(f"Real PD code after de_r1 and de_k8: {simplified[0] if simplified else ''}")
+            else:
+                print(f"Real PD code after de_r1 and de_k8: {crossings}")
+        if crossings == []:
+            return UNKNOT_RESULT
+        return _run_cppkh(_format_pd(crossings), encoding=encoding, simplify_pd=de_r1)
+
     crossings = _prepare_crossings(pd_code, de_r1=de_r1, de_k8=de_k8)
     if show_real_pdcode:
         print(f"Real PD code after de_r1 and de_k8: {crossings}")
@@ -305,6 +399,39 @@ def solve_khovanov(
     return _run_cppkh(_format_pd(crossings), encoding=encoding)
 
 
+def solve_many_khovanov(
+    pd_codes: PdManyInput,
+    encoding: Optional[str] = None,
+    de_r1: bool = True,
+    de_k8: bool = True,
+    show_real_pdcode: bool = False,
+    threads: Union[str, int] = "1",
+) -> list[str]:
+    """Compute many PD codes in one cppkh process.
+
+    With the default ``de_r1=True`` and ``de_k8=True`` settings, the raw PD
+    document is passed directly to cppkh and the C++ simplifier handles R1 then
+    nugatory crossing removal for the whole batch.
+    """
+
+    document, use_cpp_simplify = _prepare_many_for_cppkh(pd_codes, de_r1=de_r1, de_k8=de_k8)
+    if show_real_pdcode:
+        if use_cpp_simplify:
+            simplified = _run_cppkh_document(
+                document,
+                encoding=encoding,
+                threads=threads,
+                simplify_pd=True,
+                print_simplified_pd=True,
+            )
+            print(f"Real PD code after de_r1 and de_k8: {simplified}")
+        else:
+            print(f"Real PD code after de_r1 and de_k8: {document.splitlines()}")
+    if not document:
+        return []
+    return _run_cppkh_document(document, encoding=encoding, threads=threads, simplify_pd=use_cpp_simplify)
+
+
 def compute_pd(
     pd_code: PdInput,
     *,
@@ -316,6 +443,25 @@ def compute_pd(
 ) -> str:
     """Compute Khovanov homology using the same defaults as solve_khovanov."""
 
+    if de_r1 == de_k8:
+        crossings = _as_crossings(pd_code)
+        _check_sanity(crossings)
+        if show_real_pdcode:
+            if de_r1:
+                simplified = _run_cppkh_document(
+                    _format_pd(crossings),
+                    encoding=encoding,
+                    threads=threads,
+                    simplify_pd=True,
+                    print_simplified_pd=True,
+                )
+                print(f"Real PD code after de_r1 and de_k8: {simplified[0] if simplified else ''}")
+            else:
+                print(f"Real PD code after de_r1 and de_k8: {crossings}")
+        if crossings == []:
+            return UNKNOT_RESULT
+        return _run_cppkh(_format_pd(crossings), encoding=encoding, threads=threads, simplify_pd=de_r1)
+
     crossings = _prepare_crossings(pd_code, de_r1=de_r1, de_k8=de_k8)
     if show_real_pdcode:
         print(f"Real PD code after de_r1 and de_k8: {crossings}")
@@ -324,6 +470,27 @@ def compute_pd(
     return _run_cppkh(_format_pd(crossings), encoding=encoding, threads=threads)
 
 
+def compute_many_pd(
+    pd_codes: PdManyInput,
+    *,
+    encoding: Optional[str] = None,
+    de_r1: bool = True,
+    de_k8: bool = True,
+    show_real_pdcode: bool = False,
+    threads: Union[str, int] = "1",
+) -> list[str]:
+    """Compute many PD codes in one cached cppkh executable invocation."""
+
+    return solve_many_khovanov(
+        pd_codes,
+        encoding=encoding,
+        de_r1=de_r1,
+        de_k8=de_k8,
+        show_real_pdcode=show_real_pdcode,
+        threads=threads,
+    )
+
+
 def simplify_pd(pd_code: PdInput, *, de_r1: bool = True, de_k8: bool = True) -> str:
     """Return the normalized PD string after optional R1 and nugatory simplification."""
 

{cppkh_interface-0.1.0 → cppkh_interface-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cppkh-interface"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python interface for cppkh Khovanov homology computation with runtime C++ compilation."
 authors = [
     {name = "GGN_2015", email = "neko@jlulug.org"}
@@ -26,9 +26,11 @@ cppkh-interface = "cppkh_interface.main:main"
 [tool.poetry]
 packages = [{ include = "cppkh_interface" }]
 include = [
+    { path = "build_backend/cppkh_interface_build_backend.py", format = ["sdist"] },
     { path = "cppkh_interface/data/src/main.cpp", format = ["sdist", "wheel"] }
 ]
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core>=2.0.0,<3.0.0", "setuptools>=61"]
+build-backend = "cppkh_interface_build_backend"
+backend-path = ["build_backend"]