potato-peeling 0.1.0a1__tar.gz

potato_peeling-0.1.0a1/.clang-format

@@ -0,0 +1,17 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 100
+BreakBeforeBraces: Attach
+NamespaceIndentation: All
+PointerAlignment: Right
+ReferenceAlignment: Right
+AccessModifierOffset: -4
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Empty
+FixNamespaceComments: true
+SortIncludes: Never
+ReflowComments: false
+SpacesBeforeTrailingComments: 2
+BreakBeforeBinaryOperators: All

potato_peeling-0.1.0a1/.github/workflows/ci.yml

@@ -0,0 +1,78 @@
+# Build and test on every push and pull request: the default C++ and Python test
+# sets against system packages (wheels use pinned dependencies, see wheels.yml).
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  # uv's own Python, which has the headers the extension builds against
+  UV_PYTHON_PREFERENCE: only-managed
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  version:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - run: python3 ci/check_version.py
+
+  linux:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Ubuntu (latest)
+            os: ubuntu-latest
+            python: true
+          # The oldest supported setup: CGAL 5.4, Boost 1.74, CMake 3.22. C++ only.
+          - name: Ubuntu 22.04 (minimum versions)
+            os: ubuntu-22.04
+            python: false
+    steps:
+      - uses: actions/checkout@v7
+      - name: Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            g++ cmake libcgal-dev libboost-dev libgmp-dev libmpfr-dev
+      - name: C++ build and tests
+        run: |
+          cmake -S . -B build/ci -DCMAKE_BUILD_TYPE=Release
+          cmake --build build/ci -j "$(nproc)"
+          ctest --test-dir build/ci -LE slow --output-on-failure
+      - if: matrix.python
+        uses: astral-sh/setup-uv@v10.3.3
+      - if: matrix.python
+        name: Python tests
+        run: |
+          uv sync
+          uv run pytest
+
+  macos:
+    name: macOS (arm64)
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v7
+      - name: Dependencies
+        run: brew install cgal boost gmp mpfr
+      - name: C++ build and tests
+        run: |
+          cmake -S . -B build/ci -DCMAKE_BUILD_TYPE=Release
+          cmake --build build/ci -j "$(sysctl -n hw.ncpu)"
+          ctest --test-dir build/ci -LE slow --output-on-failure
+      - uses: astral-sh/setup-uv@v10.3.3
+      - name: Python tests
+        run: |
+          uv sync
+          uv run pytest

potato_peeling-0.1.0a1/.github/workflows/wheels.yml

@@ -0,0 +1,153 @@
+# The sdist and wheels, each wheel tested with the default Python test set.
+#   - pull requests touching packaging, and manual runs: build and test only;
+#   - manual run with "publish" ticked: also upload to TestPyPI;
+#   - a v* tag (matching the version): also upload to PyPI.
+# Uploads use trusted publishing (environments testpypi and pypi).
+name: Wheels
+
+on:
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Upload to TestPyPI
+        type: boolean
+        default: false
+  push:
+    tags: ["v*"]
+  pull_request:
+    paths:
+      - pyproject.toml
+      - CMakeLists.txt
+      - ci/**
+      - .github/workflows/wheels.yml
+
+permissions:
+  contents: read
+
+jobs:
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Version
+        run: |
+          if [ "${{ github.ref_type }}" = tag ]; then
+            python3 ci/check_version.py --tag "${{ github.ref_name }}"
+          else
+            python3 ci/check_version.py
+          fi
+      - uses: astral-sh/setup-uv@v10.3.3
+      - run: uv build --sdist
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    name: Wheels (${{ matrix.os }})
+    needs: sdist
+    runs-on: ${{ matrix.os }}
+    # a hang (a stalled download, a stuck test) fails here instead of after 6 hours
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15, macos-15-intel]
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: sdist
+          path: sdist
+      # Built from the sdist, so a broken sdist fails here.
+      - name: Locate the sdist
+        id: sdist
+        run: echo "path=$(ls sdist/*.tar.gz)" >> "$GITHUB_OUTPUT"
+      # macOS builds GMP and MPFR from source (minutes); keep the installed prefix
+      # until ci/install_deps.sh changes. The script skips a prefix it filled.
+      - if: runner.os == 'macOS'
+        uses: actions/checkout@v7
+        with:
+          sparse-checkout: ci
+          path: src
+      - if: runner.os == 'macOS'
+        uses: actions/cache@v6
+        with:
+          path: /tmp/potato-peeling-deps
+          key: deps-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('src/ci/install_deps.sh') }}
+      - uses: pypa/cibuildwheel@v4.3.5
+        with:
+          package-dir: ${{ steps.sdist.outputs.path }}
+          output-dir: wheelhouse
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  # cibuildwheel tests the abi3 wheel on 3.12 only. Check it statically for
+  # anything outside the stable ABI, and test it on the newest Python; with 3.12
+  # passing too, the versions between are covered.
+  abi3:
+    name: abi3 wheel on ${{ matrix.python }} (${{ matrix.os }})
+    needs: wheels
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15, macos-15-intel]
+        python: ["3.15"]
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          sparse-checkout: |
+            tests
+            pyproject.toml
+          sparse-checkout-cone-mode: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+      - uses: actions/download-artifact@v8
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse
+      - name: Stable ABI
+        run: |
+          python -m pip install abi3audit
+          abi3audit --strict --summary wheelhouse/*-abi3-*.whl
+      - name: Install and test
+        run: |
+          python -m pip install pytest
+          # optional test dependencies: their tests skip if no wheel exists yet
+          python -m pip install --only-binary :all: numpy shapely || true
+          python -m pip install --no-index --find-links wheelhouse potato-peeling
+          python -m pytest tests/python
+
+  testpypi:
+    if: github.event_name == 'workflow_dispatch' && inputs.publish
+    needs: [sdist, wheels, abi3]
+    runs-on: ubuntu-latest
+    environment: testpypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@v1.14.3
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  pypi:
+    if: github.ref_type == 'tag' && startsWith(github.ref_name, 'v')
+    needs: [sdist, wheels, abi3]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@v1.14.3

potato_peeling-0.1.0a1/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+.venv/
+/build/
+/dist/
+.idea/

potato_peeling-0.1.0a1/CMakeLists.txt

@@ -0,0 +1,175 @@
+cmake_minimum_required(VERSION 3.20)
+project(potato_peeling VERSION 0.1.0 LANGUAGES CXX)
+
+foreach (policy CMP0135 CMP0167)
+    if (POLICY ${policy})
+        cmake_policy(SET ${policy} NEW)
+    endif ()
+endforeach ()
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif ()
+
+# Shared by default, so LGPL users can relink against a modified library.
+option(BUILD_SHARED_LIBS "Build potato_peeling as a shared library" ON)
+
+include(GNUInstallDirs)
+include(GenerateExportHeader)
+include(CMakePackageConfigHelpers)
+
+# CGAL's exact rational, and so FT, is GMP's mpq_class when GMP's C++ interface
+# is linked and Boost.Multiprecision's GMP rational otherwise. FT is part of the
+# API, and refine's double-steered search can differ between the two in the last
+# bits, so every build uses the second (and nothing links libgmpxx).
+set(CGAL_WITH_GMPXX OFF CACHE BOOL "Use GMP's C++ classes in CGAL; must be OFF for potato_peeling" FORCE)
+find_package(CGAL 5.4 REQUIRED)
+find_package(Boost 1.74 CONFIG REQUIRED)
+
+# CDT (MPL-2.0), header-only and private to the build: an installed package if
+# there is one, else this pinned release. The release is only unpacked (its
+# CMake project, with its install rules, is not added).
+find_package(CDT CONFIG QUIET)
+if (NOT TARGET CDT::CDT)
+    include(FetchContent)
+    FetchContent_Declare(CDT
+            URL https://github.com/artem-ogre/CDT/archive/refs/tags/2.0.1.tar.gz
+            URL_HASH SHA256=5e3c45715e55b5f2d4390082c8c1ac026f635ddee233516fdcf94b197954367d
+            SOURCE_SUBDIR no-cmake-project)
+    FetchContent_MakeAvailable(CDT)
+    add_library(potato_peeling_cdt INTERFACE)
+    target_include_directories(potato_peeling_cdt SYSTEM INTERFACE ${cdt_SOURCE_DIR}/CDT/include)
+    add_library(CDT::CDT ALIAS potato_peeling_cdt)
+endif ()
+
+# ── C++ core, compiled once ───────────────────────────────────────────────────
+# The library, the Python module and the tests all link these objects.
+add_library(potato_peeling_core OBJECT
+        src/internal/geometry.cpp
+        src/internal/longest_segment.cpp
+        src/potato_peeling.cpp
+        src/utilities.cpp
+        src/simple.cpp
+        src/internal/chang_and_yap/chang_and_yap.cpp
+        src/internal/aronov/mesh.cpp
+        src/internal/aronov/predicates.cpp
+        src/internal/aronov/sweep.cpp
+        src/internal/aronov/aronov.cpp
+        src/internal/cabello/kernel.cpp
+        src/internal/cabello/certify.cpp
+        src/internal/cabello/sampling.cpp
+        src/internal/cabello/visibility.cpp
+        src/internal/cabello/convex_clique.cpp
+        src/internal/cabello/a_bound.cpp
+        src/internal/cabello/cabello.cpp
+        src/internal/cabello/vertex_skull.cpp
+        src/internal/refinement/refinement.cpp
+        src/internal/bounds/upper_bound.cpp
+)
+target_include_directories(potato_peeling_core
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+target_compile_features(potato_peeling_core PUBLIC cxx_std_17)
+target_link_libraries(potato_peeling_core PUBLIC CGAL::CGAL PRIVATE Boost::headers CDT::CDT)
+# The upper bound's double-precision search must round the same everywhere.
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    set_source_files_properties(src/internal/bounds/upper_bound.cpp
+            PROPERTIES COMPILE_OPTIONS "-ffp-contract=off")
+endif ()
+target_compile_definitions(potato_peeling_core PRIVATE
+        # Fail the build if any GPL-licensed CGAL package is included.
+        CGAL_LICENSE_ERROR
+        CDT_ENSURE_PRECISE_MATH_IN_CONSTRUCTIONS)
+
+# The objects are compiled for the library, so they export under its name.
+set_target_properties(potato_peeling_core PROPERTIES DEFINE_SYMBOL potato_peeling_EXPORTS)
+generate_export_header(potato_peeling_core
+        BASE_NAME potato_peeling
+        EXPORT_FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/include/potato_peeling/export.hpp
+        STATIC_DEFINE POTATO_PEELING_STATIC_DEFINE)
+
+set(POTATO_PEELING_SHARED OFF)
+if (BUILD_SHARED_LIBS AND NOT SKBUILD)
+    set(POTATO_PEELING_SHARED ON)
+endif ()
+if (POTATO_PEELING_SHARED)
+    target_compile_definitions(potato_peeling_core PRIVATE potato_peeling_EXPORTS)
+else ()
+    target_compile_definitions(potato_peeling_core PUBLIC POTATO_PEELING_STATIC_DEFINE)
+endif ()
+
+# ── The C++ library: potato_peeling::potato_peeling ───────────────────────────
+if (NOT SKBUILD)
+    add_library(potato_peeling $<TARGET_OBJECTS:potato_peeling_core>)
+    add_library(potato_peeling::potato_peeling ALIAS potato_peeling)
+    target_include_directories(potato_peeling PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+    target_compile_features(potato_peeling PUBLIC cxx_std_17)
+    target_link_libraries(potato_peeling PUBLIC CGAL::CGAL)
+    if (NOT POTATO_PEELING_SHARED)
+        target_compile_definitions(potato_peeling PUBLIC POTATO_PEELING_STATIC_DEFINE)
+    endif ()
+    # The ABI may change with every minor release while the version is 0.x.
+    set_target_properties(potato_peeling PROPERTIES
+            VERSION ${PROJECT_VERSION}
+            SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR})
+
+    install(TARGETS potato_peeling EXPORT potato_peelingTargets
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT runtime
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT runtime
+            NAMELINK_COMPONENT development
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT development)
+    install(DIRECTORY include/potato_peeling ${CMAKE_CURRENT_BINARY_DIR}/include/potato_peeling
+            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT development)
+
+    set(config_dir ${CMAKE_INSTALL_LIBDIR}/cmake/potato_peeling)
+    install(EXPORT potato_peelingTargets NAMESPACE potato_peeling::
+            DESTINATION ${config_dir} COMPONENT development)
+    configure_package_config_file(cmake/potato_peelingConfig.cmake.in
+            ${CMAKE_CURRENT_BINARY_DIR}/potato_peelingConfig.cmake
+            INSTALL_DESTINATION ${config_dir})
+    write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/potato_peelingConfigVersion.cmake
+            COMPATIBILITY SameMinorVersion)
+    install(FILES
+            ${CMAKE_CURRENT_BINARY_DIR}/potato_peelingConfig.cmake
+            ${CMAKE_CURRENT_BINARY_DIR}/potato_peelingConfigVersion.cmake
+            DESTINATION ${config_dir} COMPONENT development)
+endif ()
+
+# ── C++ tests (ctest) ─────────────────────────────────────────────────────────
+if (CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR AND NOT SKBUILD)
+    set(POTATO_PEELING_TESTS_DEFAULT ON)
+else ()
+    set(POTATO_PEELING_TESTS_DEFAULT OFF)
+endif ()
+option(POTATO_PEELING_BUILD_TESTS "Build the C++ tests" ${POTATO_PEELING_TESTS_DEFAULT})
+if (POTATO_PEELING_BUILD_TESTS AND NOT SKBUILD)
+    enable_testing()
+    add_subdirectory(tests/cpp)
+endif ()
+
+# ── Python bindings: potato_peeling._core ─────────────────────────────────────
+if (SKBUILD)
+    find_package(Python COMPONENTS Interpreter Development.Module Development.SABIModule REQUIRED)
+    execute_process(
+            COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+            OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_ROOT)
+    find_package(nanobind 3.0 CONFIG REQUIRED)
+
+    nanobind_add_module(_core
+            STABLE_ABI
+            NB_STATIC
+            bindings/python/module.cpp
+    )
+    target_link_libraries(_core PRIVATE potato_peeling_core)
+    target_compile_definitions(_core PRIVATE CGAL_LICENSE_ERROR)
+    install(TARGETS _core DESTINATION potato_peeling COMPONENT python)
+endif ()