cpp-pd-code-simplify-interface 0.1.0__tar.gz

cpp_pd_code_simplify_interface-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: cpp-pd-code-simplify-interface
+Version: 0.1.0
+Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
+License-Expression: MIT
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cpp-simple-interface (>=0.1.2)
+Project-URL: Documentation, https://github.com/GGN-2015/cpp-pd-code-simplify/blob/main/docs/python-interface.md
+Project-URL: Homepage, https://github.com/GGN-2015/cpp-pd-code-simplify
+Project-URL: Repository, https://github.com/GGN-2015/cpp-pd-code-simplify
+Description-Content-Type: text/markdown
+
+# cpp-pd-code-simplify-interface
+
+`cpp-pd-code-simplify-interface` is a Python package for calling the
+`cpp-pd-code-simplify` C++ implementation from Python.
+
+The package is designed for PyPI distribution:
+
+```sh
+pip install cpp-pd-code-simplify-interface
+```
+
+It ships the C++ source code inside the wheel and source distribution. On first
+use, the package compiles a cached local dynamic library through
+`cpp-simple-interface`; later calls reuse that library through `ctypes`. A C++14
+compiler compatible with `g++` must be available at runtime.
+
+Calls use the C++ library's default preprocessing pipeline: R1-move removal
+followed by nugatory-crossing removal.
+
+## Example
+
+```python
+import cpp_pd_code_simplify_interface as simplify
+
+pd_code = "PD[X[1,5,2,4],X[3,1,4,6],X[5,3,6,2]]"
+result = simplify.simplify(pd_code)
+print(result["simplification_found"])
+```
+
+Batch use:
+
+```python
+results = simplify.simplify_many([pd_code, "PD[]"])
+```
+
+To select a compiler:
+
+```sh
+CXX=clang++ python your_script.py
+```
+
+Windows PowerShell:
+
+```powershell
+$env:CXX = "C:\path\to\g++.exe"
+python your_script.py
+```
+
+On Windows, use a compiler whose target architecture matches Python. A 64-bit
+Python process needs a 64-bit compiler target.
+
+Command-line use also supports multi-line PD-code files:
+
+```sh
+python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths 100
+```
+
+## Build And Publish
+
+From this directory:
+
+```sh
+poetry build
+poetry publish
+```
+
+Use `poetry publish --build` to build and upload in one command.
+
+For local testing:
+
+```sh
+poetry run python -m cpp_pd_code_simplify_interface "PD[]"
+```
+

cpp_pd_code_simplify_interface-0.1.0/README.md

@@ -0,0 +1,73 @@
+# cpp-pd-code-simplify-interface
+
+`cpp-pd-code-simplify-interface` is a Python package for calling the
+`cpp-pd-code-simplify` C++ implementation from Python.
+
+The package is designed for PyPI distribution:
+
+```sh
+pip install cpp-pd-code-simplify-interface
+```
+
+It ships the C++ source code inside the wheel and source distribution. On first
+use, the package compiles a cached local dynamic library through
+`cpp-simple-interface`; later calls reuse that library through `ctypes`. A C++14
+compiler compatible with `g++` must be available at runtime.
+
+Calls use the C++ library's default preprocessing pipeline: R1-move removal
+followed by nugatory-crossing removal.
+
+## Example
+
+```python
+import cpp_pd_code_simplify_interface as simplify
+
+pd_code = "PD[X[1,5,2,4],X[3,1,4,6],X[5,3,6,2]]"
+result = simplify.simplify(pd_code)
+print(result["simplification_found"])
+```
+
+Batch use:
+
+```python
+results = simplify.simplify_many([pd_code, "PD[]"])
+```
+
+To select a compiler:
+
+```sh
+CXX=clang++ python your_script.py
+```
+
+Windows PowerShell:
+
+```powershell
+$env:CXX = "C:\path\to\g++.exe"
+python your_script.py
+```
+
+On Windows, use a compiler whose target architecture matches Python. A 64-bit
+Python process needs a 64-bit compiler target.
+
+Command-line use also supports multi-line PD-code files:
+
+```sh
+python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths 100
+```
+
+## Build And Publish
+
+From this directory:
+
+```sh
+poetry build
+poetry publish
+```
+
+Use `poetry publish --build` to build and upload in one command.
+
+For local testing:
+
+```sh
+poetry run python -m cpp_pd_code_simplify_interface "PD[]"
+```

cpp_pd_code_simplify_interface-0.1.0/build_backend/cpp_pd_code_simplify_interface_build_backend.py

@@ -0,0 +1,228 @@
+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_FILES = [
+    (
+        REPO_ROOT / "src" / "pdcode_simplify.cpp",
+        PROJECT_ROOT / "cpp_pd_code_simplify_interface" / "data" / "src" / "pdcode_simplify.cpp",
+        "cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp",
+    ),
+    (
+        PROJECT_ROOT / "cpp_pd_code_simplify_interface" / "data" / "src" / "native_interface.cpp",
+        PROJECT_ROOT / "cpp_pd_code_simplify_interface" / "data" / "src" / "native_interface.cpp",
+        "cpp_pd_code_simplify_interface/data/src/native_interface.cpp",
+    ),
+    (
+        REPO_ROOT / "include" / "pdcode_simplify" / "pdcode_simplify.hpp",
+        PROJECT_ROOT
+        / "cpp_pd_code_simplify_interface"
+        / "data"
+        / "include"
+        / "pdcode_simplify"
+        / "pdcode_simplify.hpp",
+        "cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp",
+    ),
+]
+
+
+def _sync_cpp_sources() -> None:
+    missing = []
+    for source, target, _ in SOURCE_FILES:
+        if source.exists():
+            if source.resolve() != target.resolve():
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(source, target)
+        elif not target.exists():
+            missing.append((source, target))
+    if missing:
+        details = ", ".join(f"{source} or {target}" for source, target in missing)
+        raise FileNotFoundError(f"cpp-pd-code-simplify source files were not found: {details}")
+
+
+def _clean_cpp_sources() -> None:
+    for source, target, _ in SOURCE_FILES:
+        if source.exists() and target.exists() and source.resolve() != target.resolve():
+            target.unlink()
+
+
+def _source_payloads() -> dict[str, bytes]:
+    payloads = {}
+    for source, target, wheel_name in SOURCE_FILES:
+        if target.exists():
+            payloads[wheel_name] = target.read_bytes()
+        elif source.exists():
+            payloads[wheel_name] = source.read_bytes()
+        else:
+            raise FileNotFoundError(f"source file was not available for packaging: {wheel_name}")
+    return payloads
+
+
+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_sources(wheel_path: Path) -> Path:
+    payloads = _source_payloads()
+    payload_names = set(payloads)
+    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 payload_names or item.filename == 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))
+
+            for name, data in sorted(payloads.items()):
+                source_info = zipfile.ZipInfo(name, date_time=(2016, 1, 1, 0, 0, 0))
+                source_info.compress_type = zipfile.ZIP_DEFLATED
+                zout.writestr(source_info, data)
+                digest, size = _wheel_hash_and_size(data)
+                rows.append((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 _rewrite_sdist_with_sources(sdist_path: Path) -> None:
+    payloads = _source_payloads()
+    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]
+            payload_names = {f"{root}/{name}" for name in payloads}
+
+            for member in tin.getmembers():
+                if member.name in payload_names:
+                    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)
+
+            for name, data in sorted(payloads.items()):
+                source_info = tarfile.TarInfo(f"{root}/{name}")
+                source_info.size = len(data)
+                source_info.mtime = 0
+                source_info.mode = 0o644
+                tout.addfile(source_info, io.BytesIO(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_sources()
+    try:
+        return poetry_api.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
+    finally:
+        _clean_cpp_sources()
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    _sync_cpp_sources()
+    try:
+        wheel_name = poetry_api.build_wheel(wheel_directory, config_settings, metadata_directory)
+        final_path = _rewrite_wheel_with_sources(Path(wheel_directory) / wheel_name)
+        return final_path.name
+    finally:
+        _clean_cpp_sources()
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    _sync_cpp_sources()
+    try:
+        sdist_name = poetry_api.build_sdist(sdist_directory, config_settings)
+        _rewrite_sdist_with_sources(Path(sdist_directory) / sdist_name)
+        return sdist_name
+    finally:
+        _clean_cpp_sources()

cpp_pd_code_simplify_interface-0.1.0/cpp_pd_code_simplify_interface/__init__.py

@@ -0,0 +1,21 @@
+from .main import (
+    PdCodeSimplifyInterfaceError,
+    compile_simplifier,
+    get_simplifier_executable,
+    get_simplifier_library,
+    normalize_pd_code,
+    normalize_pd_codes,
+    simplify,
+    simplify_many,
+)
+
+__all__ = [
+    "PdCodeSimplifyInterfaceError",
+    "compile_simplifier",
+    "get_simplifier_executable",
+    "get_simplifier_library",
+    "normalize_pd_code",
+    "normalize_pd_codes",
+    "simplify",
+    "simplify_many",
+]

cpp_pd_code_simplify_interface-0.1.0/cpp_pd_code_simplify_interface/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cpp_pd_code_simplify_interface-0.1.0/cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -0,0 +1,145 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#if defined(_WIN32) && (defined(PDCODE_SIMPLIFY_SHARED) || defined(PDCODE_SIMPLIFY_BUILD_SHARED))
+#if defined(PDCODE_SIMPLIFY_BUILD_SHARED)
+#define PDCODE_SIMPLIFY_API __declspec(dllexport)
+#else
+#define PDCODE_SIMPLIFY_API __declspec(dllimport)
+#endif
+#elif defined(PDCODE_SIMPLIFY_BUILD_SHARED) && defined(__GNUC__)
+#define PDCODE_SIMPLIFY_API __attribute__((visibility("default")))
+#else
+#define PDCODE_SIMPLIFY_API
+#endif
+
+namespace pdcode_simplify {
+
+struct Endpoint {
+    int crossing = -1;
+    int strand = -1;
+
+    friend bool operator==(const Endpoint& lhs, const Endpoint& rhs) {
+        return lhs.crossing == rhs.crossing && lhs.strand == rhs.strand;
+    }
+
+    friend bool operator!=(const Endpoint& lhs, const Endpoint& rhs) {
+        return !(lhs == rhs);
+    }
+};
+
+using Crossing = std::array<int, 4>;
+using PDCode = std::vector<Crossing>;
+
+enum class Direction {
+    Left,
+    Right
+};
+
+struct GreenCrossing {
+    int from_face = -1;
+    int to_face = -1;
+    std::string strand_level;
+};
+
+struct SimplifierOptions {
+    int max_paths = 100;
+};
+
+struct LinkComponentSummary {
+    std::vector<int> crossing_indices;
+};
+
+struct ComponentAnalysis {
+    std::vector<LinkComponentSummary> components;
+    std::size_t crossingless_components = 0;
+
+    std::size_t components_with_crossings() const {
+        return components.size();
+    }
+
+    std::size_t total_components() const {
+        return components.size() + crossingless_components;
+    }
+};
+
+struct RandomInflationOptions {
+    int moves = 16;
+    unsigned int seed = 1;
+    int type_ii_percentage = 50;
+};
+
+struct RandomInflationResult {
+    PDCode code;
+    unsigned int seed = 1;
+    int type_i_moves = 0;
+    int type_ii_moves = 0;
+};
+
+struct ReidemeisterSimplificationResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+    int type_i_moves = 0;
+    int type_ii_moves = 0;
+};
+
+struct PDSimplificationResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+    int reidemeister_i_moves = 0;
+    int nugatory_crossing_moves = 0;
+};
+
+struct SimplificationResult {
+    bool found = false;
+    Direction direction = Direction::Left;
+    std::vector<Endpoint> red_path;
+    std::vector<int> green_path;
+    std::vector<GreenCrossing> green_crossings;
+    std::size_t tested_red_paths = 0;
+    std::size_t tested_green_paths = 0;
+};
+
+PDCODE_SIMPLIFY_API PDCode parse_pd_code(const std::string& text);
+PDCODE_SIMPLIFY_API std::string format_pd_code(const PDCode& code);
+PDCODE_SIMPLIFY_API std::string format_endpoint(const Endpoint& endpoint);
+PDCODE_SIMPLIFY_API std::string format_direction(Direction direction);
+
+PDCODE_SIMPLIFY_API ComponentAnalysis analyze_components(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API ComponentAnalysis analyze_components_after_removing_crossings(
+    const PDCode& code,
+    const std::vector<int>& removed_crossings,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API std::size_t count_crossingless_components_after_removing_crossings(
+    const PDCode& code,
+    const std::vector<int>& removed_crossings,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API RandomInflationResult randomly_increase_crossings(
+    const PDCode& code,
+    const RandomInflationOptions& options = RandomInflationOptions{});
+
+PDCODE_SIMPLIFY_API ReidemeisterSimplificationResult simplify_reidemeister_i_ii(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API PDSimplificationResult simplify_pd_code(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API SimplificationResult find_simplification(
+    const PDCode& code,
+    const SimplifierOptions& options = SimplifierOptions{});
+
+PDCODE_SIMPLIFY_API std::ostream& operator<<(std::ostream& out, const Endpoint& endpoint);
+
+}  // namespace pdcode_simplify