cppkh-interface 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

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/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/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.dist-info → cppkh_interface-0.1.1.dist-info}/METADATA

@@ -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.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cppkh_interface/__init__.py,sha256=u6y6hezL7izQ_yVE9JhjU7znxICVzQNgLUPR3ObKLB0,489
+cppkh_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
+cppkh_interface/main.py,sha256=oIhYl-kh-2Ql_zxS1uHggww5Am3KRWUL2QXNGK1ayDM,16674
+cppkh_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+cppkh_interface-0.1.1.dist-info/entry_points.txt,sha256=CsnHBNaO_RJe4eFXmEZpSxWu-c1aF0RpjVFaEGlIm4Y,61
+cppkh_interface-0.1.1.dist-info/METADATA,sha256=2UIZgh_EM5hBfhBZ7huIx21nDDhclwcZRx0tKkCSS8k,2499
+cppkh_interface-0.1.1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cppkh_interface/data/src/main.cpp,sha256=lNg4DhWOcQNWCZoVfXGIObAiPHYWD2i7Pctd5445QT8,143069
+cppkh_interface-0.1.1.dist-info/RECORD,,

{cppkh_interface-0.1.0.dist-info → cppkh_interface-0.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.4.1
 Root-Is-Purelib: true
 Tag: py3-none-any

cppkh_interface-0.1.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-cppkh_interface/__init__.py,sha256=WJNYCnxkp3e-ebXMgoo20S5N3eJxJGlkqbiW844M0VQ,343
-cppkh_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
-cppkh_interface/data/src/main.cpp,sha256=T56Ftt152CN5a23juzwSAOXnCnLhdeL-0Wgj7Cbo3dw,141886
-cppkh_interface/main.py,sha256=WOwZd9owRN5K8wall_PW7JyRP0FYITBfOiHUrBwvsxY,11077
-cppkh_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cppkh_interface-0.1.0.dist-info/entry_points.txt,sha256=CsnHBNaO_RJe4eFXmEZpSxWu-c1aF0RpjVFaEGlIm4Y,61
-cppkh_interface-0.1.0.dist-info/METADATA,sha256=bmeNcT8rRTjyDrODAeurHKEMq6tZR-bqcEn6WBQTcAQ,2071
-cppkh_interface-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cppkh_interface-0.1.0.dist-info/RECORD,,