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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppkh-interface
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python interface for cppkh Khovanov homology computation with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -33,11 +33,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 +75,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.1}/README.md

@@ -10,11 +10,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 +52,8 @@ poetry build
 poetry publish
 ```
 
+Use `poetry publish --build` to build and upload in one command.
+
 For local testing:
 
 ```sh

cppkh_interface-0.1.1/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.1}/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.1}/cppkh_interface/data/src/main.cpp

@@ -3409,6 +3409,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();

{cppkh_interface-0.1.0 → cppkh_interface-0.1.1}/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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cppkh-interface"
-version = "0.1.0"
+version = "0.1.1"
 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"]