Add free-threaded support

Author: skogler

CMakeLists.txt

@@ -1,6 +1,28 @@
 cmake_minimum_required(VERSION 3.15...3.29)
 project(mapbox_earcut LANGUAGES CXX)
 
+if (NOT SKBUILD)
+  message(WARNING "\
+  This CMake file is meant to be executed using 'scikit-build-core'.
+  Running it directly will almost certainly not produce the desired
+  result. If you are a user trying to install this package, use the
+  command below, which will install all necessary build dependencies,
+  compile the package in an isolated environment, and then install it.
+  =====================================================================
+   $ uv sync
+  =====================================================================
+  If you are a software developer, and this is your own package, then
+  it is usually much more efficient to install the build dependencies
+  in your environment once and use the following command that avoids
+  a costly creation of a new virtual environment at every compilation:
+  =====================================================================
+   $ uv build
+  =====================================================================
+  You may optionally add -Ceditable.rebuild=true to auto-rebuild when
+  the package is imported. Otherwise, you need to rerun the above
+  after editing C++ files.")
+endif()
+
 find_package(Python COMPONENTS Interpreter Development
         REQUIRED)
 execute_process(
@@ -9,8 +31,28 @@ execute_process(
 find_package(nanobind CONFIG REQUIRED)
 
 nanobind_add_module(
-  mapbox_earcut
+  _core
+  # Target the stable ABI for Python 3.12+, which reduces
+  # the number of binary wheels that must be built. This
+  # does nothing on older Python versions
+  STABLE_ABI
+  FREE_THREADED
+  NB_DOMAIN mapbox_earcut
   src/main.cpp
 )
-target_include_directories(mapbox_earcut PRIVATE include)
-install(TARGETS mapbox_earcut DESTINATION .)
+target_include_directories(_core PRIVATE include)
+
+nanobind_add_stub(
+  mapbox_earcut_stubs
+  MODULE _core
+  OUTPUT _core.pyi
+  PYTHON_PATH $<TARGET_FILE_DIR:_core>
+  DEPENDS _core
+  MARKER_FILE py.typed
+)
+
+install(TARGETS _core LIBRARY DESTINATION mapbox_earcut)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/_core.pyi DESTINATION mapbox_earcut)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/py.typed DESTINATION mapbox_earcut)
+install(FILES mapbox_earcut/__init__.py DESTINATION mapbox_earcut)
+install(FILES mapbox_earcut/__init__.pyi DESTINATION mapbox_earcut)

mapbox_earcut/__init__.py

@@ -0,0 +1,22 @@
+"""
+Python bindings for the mapbox earcut C++ polygon triangulation library.
+
+This module provides fast triangulation of 2D polygons using the Mapbox Earcut algorithm.
+"""
+
+# Import all functions from the compiled extension module
+from ._core import (
+    triangulate_float32,
+    triangulate_float64,
+    triangulate_int32,
+    triangulate_int64,
+    __version__,
+)
+
+__all__ = [
+    "triangulate_float32",
+    "triangulate_float64",
+    "triangulate_int32",
+    "triangulate_int64",
+    "__version__",
+]

mapbox_earcut/__init__.pyi

@@ -0,0 +1,17 @@
+"""Type stubs for mapbox_earcut package."""
+
+from mapbox_earcut._core import (
+    __version__ as __version__,
+    triangulate_float32 as triangulate_float32,
+    triangulate_float64 as triangulate_float64,
+    triangulate_int32 as triangulate_int32,
+    triangulate_int64 as triangulate_int64,
+)
+
+__all__ = [
+    "__version__",
+    "triangulate_float32",
+    "triangulate_float64",
+    "triangulate_int32",
+    "triangulate_int64",
+]

mapbox_earcut/py.typed

@@ -17,12 +17,20 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Free Threading :: 1 - Unstable",
 ]
 dependencies = ["numpy"]
 
 [project.urls]
 Source = "https://github.com/skogler/mapbox_earcut_python"
 
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "mypy"]
+
+[tool.scikit-build]
+minimum-version = "build-system.requires"
+build-dir = "build/{wheel_tag}"
+
 [tool.scikit-build.metadata.version]
 provider = "scikit_build_core.metadata.regex"
 input = "include/version.hpp"
@@ -34,7 +42,7 @@ regex = '''(?sx)
 result = "{major}.{minor}.{patch}"
 
 [build-system]
-requires = ["nanobind>=2.9.2", "scikit-build-core"]
+requires = ["nanobind>=2.9.2", "scikit-build-core>=0.11.6"]
 build-backend = "scikit_build_core.build"
 
 [tool.cibuildwheel]

pyproject.toml

@@ -72,20 +72,18 @@ auto triangulate(const VertexArray<CoordT>& vertices, const IndexArray<IndexT>&
     ).cast();
 }
 
-NB_MODULE(mapbox_earcut, m)
+NB_MODULE(_core, m)
 {
     m.attr("__version__") = MACRO_TO_STR(VERSION_MAJOR) "." MACRO_TO_STR(VERSION_MINOR) "." MACRO_TO_STR(VERSION_PATCH);
     m.doc() = R"pbdoc(
         Python bindings to mapbox/earcut.hpp
         -----------------------
 
-        .. currentmodule:: mapbox_earcut
+        .. currentmodule:: mapbox_earcut._core
 
         .. autosummary::
            :toctree: _generate
 
-           add
-           subtract
     )pbdoc";
 
     m.def("triangulate_int32", &triangulate<int32_t, uint32_t>);

src/main.cpp

@@ -10,64 +10,64 @@ def test_valid_triangulation_float32():
     result = earcut.triangulate_float32(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (3, )
-    assert np.all(result == np.array([1, 2, 0]))
+    assert result.shape == (3,)
+    assert np.array_equal(result, np.array([1, 2, 0]))
 
 
 def test_valid_triangulation_float64():
     verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.float64).reshape(-1, 2)
     rings = np.array([3])
 
-    result = earcut.triangulate_float32(verts, rings)
+    result = earcut.triangulate_float64(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (3, )
-    assert np.all(result == np.array([1, 2, 0]))
+    assert result.shape == (3,)
+    assert np.array_equal(result, np.array([1, 2, 0]))
 
 
 def test_valid_triangulation_int32():
     verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int32).reshape(-1, 2)
     rings = np.array([3])
 
-    result = earcut.triangulate_float32(verts, rings)
+    result = earcut.triangulate_int32(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (3, )
-    assert np.all(result == np.array([1, 2, 0]))
+    assert result.shape == (3,)
+    assert np.array_equal(result, np.array([1, 2, 0]))
 
 
-def test_inverted_vertex_order():
-    verts = np.array(
-        list(reversed([[0, 0], [1, 0], [1, 1]])), dtype=np.int32).reshape(
-            -1, 2)
+def test_valid_triangulation_int64():
+    verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int64).reshape(-1, 2)
     rings = np.array([3])
 
-    result = earcut.triangulate_float32(verts, rings)
+    result = earcut.triangulate_int64(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (3, )
-    assert np.all(result == np.array([1, 0, 2]))
+    assert result.shape == (3,)
+    assert np.array_equal(result, np.array([1, 2, 0]))
 
 
-def test_no_triangles():
-    verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int32).reshape(-1, 2)
-    rings = np.array([2, 3])
+def test_inverted_vertex_order():
+    verts = np.array(list(reversed([[0, 0], [1, 0], [1, 1]])), dtype=np.int32).reshape(
+        -1, 2
+    )
+    rings = np.array([3])
 
-    result = earcut.triangulate_float32(verts, rings)
+    result = earcut.triangulate_int32(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (0, )
+    assert result.shape == (3,)
+    assert np.array_equal(result, np.array([1, 0, 2]))
 
 
-def test_valid_triangulation_int64():
-    verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int64).reshape(-1, 2)
-    rings = np.array([3])
+def test_no_triangles():
+    verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int32).reshape(-1, 2)
+    rings = np.array([2, 3])
 
-    result = earcut.triangulate_float32(verts, rings)
+    result = earcut.triangulate_int32(verts, rings)
 
     assert result.dtype == np.uint32
-    assert result.shape == (3, )
-    assert np.all(result == np.array([1, 2, 0]))
+    assert result.shape == (0,)
 
 
 def test_end_index_too_large():
@@ -124,4 +124,4 @@ def test_empty_data():
 
     result = earcut.triangulate_float32(verts, rings)
 
-    assert result.shape == (0, )
+    assert result.shape == (0,)