cpp-pd-code-simplify-interface 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -125,6 +125,7 @@ struct ReductionResult {
 
 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_final_pd_code(const PDCode& code);
 PDCODE_SIMPLIFY_API std::string format_endpoint(const Endpoint& endpoint);
 PDCODE_SIMPLIFY_API std::string format_direction(Direction direction);
 

cpp_pd_code_simplify_interface/data/src/native_interface.cpp

@@ -92,7 +92,7 @@ std::string result_to_json(
         append_component_counts(out, *after_removal_components);
         out << "},";
     }
-    out << "\"final_pd_code\":\"" << json_escape(pdcode_simplify::format_pd_code(result.code))
+    out << "\"final_pd_code\":\"" << json_escape(pdcode_simplify::format_final_pd_code(result.code))
         << "\",";
     out << "\"final_crossings\":" << result.code.size() << ",";
     out << "\"final_components\":{";

cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp

@@ -1868,6 +1868,35 @@ std::string format_pd_code(const PDCode& code) {
     return out.str();
 }
 
+std::string format_final_pd_code(const PDCode& code) {
+    if (code.empty()) {
+        return format_pd_code(code);
+    }
+
+    bool has_label = false;
+    int minimum_label = 0;
+    for (const Crossing& crossing : code) {
+        for (int label : crossing) {
+            if (!has_label || label < minimum_label) {
+                minimum_label = label;
+                has_label = true;
+            }
+        }
+    }
+    if (!has_label || minimum_label == 1) {
+        return format_pd_code(code);
+    }
+
+    PDCode shifted = code;
+    const int offset = 1 - minimum_label;
+    for (Crossing& crossing : shifted) {
+        for (int& label : crossing) {
+            label += offset;
+        }
+    }
+    return format_pd_code(shifted);
+}
+
 std::string format_endpoint(const Endpoint& endpoint) {
     std::ostringstream out;
     out << '(' << endpoint.crossing << ", " << endpoint.strand << ')';

cpp_pd_code_simplify_interface/main.py

@@ -11,7 +11,9 @@ import pathlib
 import platform
 import re
 import shlex
+import shutil
 import struct
+import subprocess
 import sys
 from importlib import resources
 from typing import Any, Optional, Sequence, Union
@@ -229,12 +231,20 @@ def _library_suffix() -> str:
 
 def _default_compile_flags(include_dir: pathlib.Path, library_path: pathlib.Path) -> list[str]:
     flags = ["-std=c++14", "-O3", "-DNDEBUG", "-I" + str(include_dir)]
-    if platform.system() != "Windows":
+    system = platform.system()
+    if system != "Windows":
         flags.append("-fPIC")
-    if platform.system() == "Darwin":
-        flags.extend(["-dynamiclib", "-install_name", "@rpath/" + library_path.name])
+    if system == "Darwin":
+        flags.extend([
+            "-dynamiclib",
+            "-install_name",
+            "@rpath/" + library_path.name,
+            "-Wl,-rpath,@loader_path",
+        ])
     else:
         flags.append("-shared")
+        if system == "Linux":
+            flags.append("-Wl,-rpath,$ORIGIN")
     native = os.environ.get("CPP_PD_CODE_SIMPLIFY_INTERFACE_NATIVE", "1").strip().lower()
     if native not in ("0", "false", "no", "off"):
         flags.append("-march=native")
@@ -249,6 +259,7 @@ def _cache_key(source_bytes: bytes, flags: Sequence[str]) -> str:
     digest.update(source_bytes)
     digest.update("\0".join(flags).encode("utf-8"))
     digest.update(cpp_simple_interface.get_gpp_filepath().encode("utf-8"))
+    digest.update(_runtime_fingerprint())
     digest.update(platform.platform().encode("utf-8"))
     return digest.hexdigest()[:20]
 
@@ -274,9 +285,337 @@ def _compiler_runtime_path_entries() -> list[pathlib.Path]:
         path = pathlib.Path(candidate)
         if path.exists() and path.is_file() and path.parent not in paths:
             paths.append(path.parent)
+            continue
+        resolved = shutil.which(candidate)
+        if resolved:
+            resolved_path = pathlib.Path(resolved)
+            if resolved_path.exists() and resolved_path.parent not in paths:
+                paths.append(resolved_path.parent)
     return paths
 
 
+def _path_entries() -> list[pathlib.Path]:
+    paths: list[pathlib.Path] = []
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        path = pathlib.Path(entry)
+        if path.exists() and path.is_dir() and path not in paths:
+            paths.append(path)
+    return paths
+
+
+def _tool_path(names: Sequence[str], extra_dirs: Sequence[pathlib.Path] = ()) -> Optional[str]:
+    for directory in extra_dirs:
+        for name in names:
+            candidate = directory / name
+            if candidate.exists() and candidate.is_file():
+                return str(candidate)
+    for name in names:
+        resolved = shutil.which(name)
+        if resolved:
+            return resolved
+    return None
+
+
+def _run_dependency_tool(command: Sequence[str]) -> str:
+    try:
+        result = subprocess.run(
+            list(command),
+            check=False,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except OSError:
+        return ""
+    if result.returncode != 0 and not result.stdout:
+        return ""
+    return result.stdout
+
+
+def _objdump_dependency_names(path: pathlib.Path) -> list[str]:
+    tool = _tool_path(["objdump.exe", "objdump"], _compiler_runtime_path_entries())
+    if not tool:
+        return []
+    output = _run_dependency_tool([tool, "-p", str(path)])
+    names: list[str] = []
+    for line in output.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("DLL Name:"):
+            names.append(stripped.split(":", 1)[1].strip())
+        elif stripped.startswith("NEEDED"):
+            parts = stripped.split()
+            if len(parts) >= 2:
+                names.append(parts[-1])
+    return names
+
+
+def _dumpbin_dependency_names(path: pathlib.Path) -> list[str]:
+    tool = _tool_path(["dumpbin.exe", "dumpbin"])
+    if not tool:
+        return []
+    output = _run_dependency_tool([tool, "/DEPENDENTS", str(path)])
+    names: list[str] = []
+    for line in output.splitlines():
+        stripped = line.strip()
+        if stripped.lower().endswith(".dll"):
+            names.append(stripped)
+    return names
+
+
+def _ldd_dependency_paths(path: pathlib.Path) -> tuple[list[pathlib.Path], list[str]]:
+    tool = _tool_path(["ldd"])
+    if not tool:
+        return [], []
+    output = _run_dependency_tool([tool, str(path)])
+    paths: list[pathlib.Path] = []
+    missing: list[str] = []
+    for line in output.splitlines():
+        stripped = line.strip()
+        if "not found" in stripped:
+            missing.append(stripped.split()[0])
+            continue
+        candidate = ""
+        if "=>" in stripped:
+            right = stripped.split("=>", 1)[1].strip()
+            candidate = right.split("(", 1)[0].strip()
+        elif stripped.startswith("/"):
+            candidate = stripped.split("(", 1)[0].strip()
+        if candidate:
+            dependency = pathlib.Path(candidate)
+            if dependency.exists() and dependency not in paths:
+                paths.append(dependency)
+    return paths, missing
+
+
+def _otool_dependency_paths(path: pathlib.Path) -> list[pathlib.Path]:
+    tool = _tool_path(["otool"])
+    if not tool:
+        return []
+    output = _run_dependency_tool([tool, "-L", str(path)])
+    paths: list[pathlib.Path] = []
+    for line in output.splitlines()[1:]:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        name = stripped.split(" ", 1)[0]
+        dependency: Optional[pathlib.Path] = None
+        if name.startswith("/"):
+            dependency = pathlib.Path(name)
+        elif name.startswith("@loader_path/"):
+            dependency = path.parent / name.removeprefix("@loader_path/")
+        elif name.startswith("@rpath/"):
+            dependency = _find_dependency_file(
+                pathlib.Path(name).name,
+                _runtime_search_dirs(path.parent),
+            )
+        if dependency is not None and dependency.exists() and dependency not in paths:
+            paths.append(dependency)
+    return paths
+
+
+def _is_platform_library(path: pathlib.Path) -> bool:
+    if platform.system() == "Darwin":
+        text = str(path)
+        return text.startswith("/usr/lib/") or text.startswith("/System/Library/")
+    return False
+
+
+def _runtime_basename_is_cacheable(name: str) -> bool:
+    lowered = name.lower()
+    return (
+        lowered.startswith("libstdc++")
+        or lowered.startswith("libgcc_s")
+        or lowered.startswith("libwinpthread")
+        or lowered.startswith("libgomp")
+        or lowered.startswith("libquadmath")
+        or lowered.startswith("libatomic")
+        or lowered.startswith("libc++")
+        or lowered.startswith("libc++abi")
+    )
+
+
+def _runtime_search_dirs(cache_dir: pathlib.Path) -> list[pathlib.Path]:
+    directories = [cache_dir, *_compiler_runtime_path_entries(), *_path_entries()]
+    result: list[pathlib.Path] = []
+    for directory in directories:
+        if directory.exists() and directory.is_dir() and directory not in result:
+            result.append(directory)
+    return result
+
+
+def _find_dependency_file(name: str, directories: Sequence[pathlib.Path]) -> Optional[pathlib.Path]:
+    wanted = name.lower()
+    for directory in directories:
+        candidate = directory / name
+        if candidate.exists() and candidate.is_file():
+            return candidate
+        try:
+            for item in directory.iterdir():
+                if item.is_file() and item.name.lower() == wanted:
+                    return item
+        except OSError:
+            continue
+    return None
+
+
+def _copy_file_if_needed(source: pathlib.Path, destination: pathlib.Path) -> None:
+    try:
+        if destination.exists() and source.resolve() == destination.resolve():
+            return
+    except OSError:
+        pass
+    copy_needed = True
+    if destination.exists():
+        try:
+            source_stat = source.stat()
+            destination_stat = destination.stat()
+            copy_needed = (
+                source_stat.st_size != destination_stat.st_size
+                or source_stat.st_mtime_ns != destination_stat.st_mtime_ns
+            )
+        except OSError:
+            copy_needed = True
+    if copy_needed:
+        shutil.copy2(source, destination)
+
+
+def _windows_dependency_names(path: pathlib.Path) -> list[str]:
+    names = _objdump_dependency_names(path) or _dumpbin_dependency_names(path)
+    if names:
+        return names
+    return [
+        "libstdc++-6.dll",
+        "libgcc_s_seh-1.dll",
+        "libgcc_s_sjlj-1.dll",
+        "libgcc_s_dw2-1.dll",
+        "libwinpthread-1.dll",
+    ]
+
+
+def _runtime_fingerprint() -> bytes:
+    digest = hashlib.sha256()
+    if platform.system() == "Windows":
+        names = _windows_dependency_names(pathlib.Path("pdcode-simplify-placeholder.dll"))
+    else:
+        names = [
+            "libstdc++.so",
+            "libstdc++.so.6",
+            "libgcc_s.so",
+            "libgcc_s.so.1",
+            "libc++.dylib",
+            "libc++abi.dylib",
+        ]
+    for directory in _compiler_runtime_path_entries():
+        for name in names:
+            candidate = directory / name
+            if not candidate.exists():
+                continue
+            try:
+                stat = candidate.stat()
+            except OSError:
+                continue
+            digest.update(str(candidate).encode("utf-8", errors="replace"))
+            digest.update(str(stat.st_size).encode("ascii"))
+            digest.update(str(stat.st_mtime_ns).encode("ascii"))
+    return digest.digest()
+
+
+def _cache_runtime_dependencies(library: pathlib.Path) -> None:
+    system = platform.system()
+    if system == "Windows":
+        search_dirs = _runtime_search_dirs(library.parent)
+        pending = list(_windows_dependency_names(library))
+        visited: set[str] = set()
+        while pending:
+            name = pending.pop(0)
+            key = name.lower()
+            if key in visited:
+                continue
+            visited.add(key)
+            if not _runtime_basename_is_cacheable(name):
+                continue
+            source = _find_dependency_file(name, search_dirs)
+            if source is None:
+                continue
+            destination = library.parent / source.name
+            _copy_file_if_needed(source, destination)
+            for imported in _windows_dependency_names(destination):
+                if imported.lower() not in visited:
+                    pending.append(imported)
+        return
+
+    if system == "Linux":
+        paths, _ = _ldd_dependency_paths(library)
+    elif system == "Darwin":
+        paths = _otool_dependency_paths(library)
+    else:
+        paths = []
+
+    for dependency in paths:
+        if _is_platform_library(dependency):
+            continue
+        if _runtime_basename_is_cacheable(dependency.name):
+            _copy_file_if_needed(dependency, library.parent / dependency.name)
+
+
+def _cached_runtime_dependencies(library: pathlib.Path) -> list[pathlib.Path]:
+    result: list[pathlib.Path] = []
+    try:
+        items = list(library.parent.iterdir())
+    except OSError:
+        return result
+    for item in items:
+        if item == library or not item.is_file():
+            continue
+        if _runtime_basename_is_cacheable(item.name):
+            result.append(item)
+    return result
+
+
+def _missing_runtime_dependency_names(library: pathlib.Path) -> list[str]:
+    system = platform.system()
+    if system == "Windows":
+        search_dirs = _runtime_search_dirs(library.parent)
+        missing = []
+        for name in _windows_dependency_names(library):
+            if _runtime_basename_is_cacheable(name) and _find_dependency_file(name, search_dirs) is None:
+                missing.append(name)
+        return missing
+    if system == "Linux":
+        _, missing = _ldd_dependency_paths(library)
+        return missing
+    return []
+
+
+def _load_failure_message(path: pathlib.Path, error: OSError) -> str:
+    system = platform.system()
+    missing = _missing_runtime_dependency_names(path)
+    details = f"failed to load cached dynamic library {path}: {error}"
+    if missing:
+        details += "; missing dependencies: " + ", ".join(sorted(set(missing)))
+    if system == "Windows":
+        details += (
+            ". The interface caches MinGW runtime DLLs next to the generated DLL; "
+            "if this cache was created by an older package version, delete the cache directory "
+            f"{path.parent} or call compile_simplifier(force=True)."
+        )
+    elif system == "Linux":
+        details += (
+            ". Ensure the compiler runtime is installed, or set LD_LIBRARY_PATH before "
+            "starting Python when using a custom compiler runtime."
+        )
+    elif system == "Darwin":
+        details += (
+            ". Ensure the compiler runtime is installed, or set DYLD_LIBRARY_PATH before "
+            "starting Python when using a custom compiler runtime."
+        )
+    return details
+
+
 def _pe_machine_bits(path: pathlib.Path) -> Optional[int]:
     if platform.system() != "Windows":
         return None
@@ -334,6 +673,7 @@ def compile_simplifier(
             flags.extend(str(flag) for flag in extra_flags)
 
         if library.exists() and not force:
+            _cache_runtime_dependencies(library)
             return library
 
         tmp_library = cache / f"{library.name}.tmp-{os.getpid()}{_library_suffix()}"
@@ -358,6 +698,7 @@ def compile_simplifier(
         if not tmp_library.exists():
             raise PdCodeSimplifyInterfaceError(f"compiled dynamic library was not created: {tmp_library}")
         os.replace(tmp_library, library)
+        _cache_runtime_dependencies(library)
         return library
 
 
@@ -381,7 +722,7 @@ _DLL_DIRECTORY_HANDLES: list[Any] = []
 def _prepare_dll_search_path(path: pathlib.Path) -> None:
     if platform.system() != "Windows" or not hasattr(os, "add_dll_directory"):
         return
-    for directory in [path.parent, *_compiler_runtime_path_entries()]:
+    for directory in _runtime_search_dirs(path.parent):
         try:
             handle = os.add_dll_directory(str(directory))
         except OSError:
@@ -389,6 +730,17 @@ def _prepare_dll_search_path(path: pathlib.Path) -> None:
         _DLL_DIRECTORY_HANDLES.append(handle)
 
 
+def _preload_runtime_dependencies(path: pathlib.Path) -> None:
+    if platform.system() == "Windows":
+        return
+    mode = getattr(ctypes, "RTLD_GLOBAL", 0)
+    for dependency in _cached_runtime_dependencies(path):
+        try:
+            ctypes.CDLL(str(dependency), mode=mode)
+        except OSError:
+            continue
+
+
 def _load_library() -> ctypes.CDLL:
     global _LOADED_LIBRARY_PATH, _LOADED_LIBRARY
     path = compile_simplifier()
@@ -396,8 +748,13 @@ def _load_library() -> ctypes.CDLL:
         return _LOADED_LIBRARY
 
     _validate_library_architecture(path)
+    _cache_runtime_dependencies(path)
     _prepare_dll_search_path(path)
-    library = ctypes.CDLL(str(path))
+    _preload_runtime_dependencies(path)
+    try:
+        library = ctypes.CDLL(str(path))
+    except OSError as exc:
+        raise PdCodeSimplifyInterfaceError(_load_failure_message(path, exc)) from exc
     library.pdcode_simplify_run_json.argtypes = [
         ctypes.c_char_p,
         ctypes.c_int,

{cpp_pd_code_simplify_interface-0.1.7.dist-info → cpp_pd_code_simplify_interface-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpp-pd-code-simplify-interface
-Version: 0.1.7
+Version: 0.1.9
 Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -34,6 +34,13 @@ 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.
 
+Runtime dependencies are handled per platform. On Windows, the interface uses
+`objdump -p` or `dumpbin /DEPENDENTS` when available, then caches MinGW runtime
+DLLs such as `libstdc++-6.dll`, `libgcc_s_*.dll`, and `libwinpthread-1.dll`
+next to the generated DLL. On Linux it adds `$ORIGIN` rpath and can inspect
+`ldd`; on macOS it adds `@loader_path` rpath and can inspect `otool -L`. Load
+failures are wrapped with platform-specific dependency hints.
+
 The core C++ source and header are not stored as permanent generated copies in
 this subproject. The custom Poetry build backend syncs them from the repository
 root during `poetry build`, embeds them in the wheel and sdist, then removes the
@@ -52,6 +59,10 @@ result = simplify.simplify(pd_code)
 print(result["final_pd_code"])
 ```
 
+Returned `final_pd_code` strings are normalized so the smallest edge label is
+`1`. This is applied only at the final JSON boundary; the C++ backend keeps its
+internal numbering unchanged while simplifying.
+
 The default `max_paths=-1` uses deterministic heuristic green-path sampling in
 the C++ backend. Use `ban_heuristic=True` to request exhaustive green-path
 enumeration for a manageable input. Use `reduction_round=K` to cap applied

{cpp_pd_code_simplify_interface-0.1.7.dist-info → cpp_pd_code_simplify_interface-0.1.9.dist-info}/RECORD

@@ -1,11 +1,11 @@
 cpp_pd_code_simplify_interface/__init__.py,sha256=aaNwD--zgQX13xiU1hpuvgXy8vVTFGRk-r5zLm8zIRY,447
 cpp_pd_code_simplify_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
-cpp_pd_code_simplify_interface/main.py,sha256=_7dPNfbtUxAC8o9cZOOwicU04zIFIA55nHIzQ_UZunw,20624
+cpp_pd_code_simplify_interface/main.py,sha256=4t-6xvjQjsuEWP_oiwedGtgrLYu3316uATrl9t4Q8zs,32778
 cpp_pd_code_simplify_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cpp_pd_code_simplify_interface-0.1.7.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
-cpp_pd_code_simplify_interface-0.1.7.dist-info/METADATA,sha256=oGdPQe0rRiBKXmmsfral9TcvMyEwcbygYrfVamdFW3M,3275
-cpp_pd_code_simplify_interface-0.1.7.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=h5aob9gqRq8Gz2Hs4ePzyoRAXFCIGRBShlRw3TxQ7wQ,4843
-cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=yXUJ0LHZDqz7WgFTwsq0U9pddH0KFTiOPr5sNyj7o1Y,6549
-cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=hXBEDQQC3C2KlHlKTbmuKqC3l48XF5p76iODfMqolWQ,88691
-cpp_pd_code_simplify_interface-0.1.7.dist-info/RECORD,,
+cpp_pd_code_simplify_interface-0.1.9.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
+cpp_pd_code_simplify_interface-0.1.9.dist-info/METADATA,sha256=rtMStQ-caLgzlWUXmJhJfDQZstn1Sys_tSN-rKPM_LY,3933
+cpp_pd_code_simplify_interface-0.1.9.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=0WflWW2MB2EAK8GbcKKr9SbnoByMV3hFxt4m4mAerzQ,4917
+cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=16HbKJBPA_EGdbyom4sSoQ7lisDBwaKrl7NsphmlA-k,6555
+cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=c0aJLqzjHloMrVuDf0RD-JksSFfUiDAvSPnn9tC-gIs,89428
+cpp_pd_code_simplify_interface-0.1.9.dist-info/RECORD,,