pyroutingkit 0.1.0__tar.gz → 0.2.0__tar.gz

{pyroutingkit-0.1.0 → pyroutingkit-0.2.0}/.github/workflows/publish.yml

@@ -24,7 +24,7 @@ jobs:
           CIBW_BUILD: cp310-* cp311-* cp312-* cp313-*
           CIBW_SKIP: "*-win32 *-manylinux_i686 *musllinux* pp*"
           CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014
-          CIBW_TEST_COMMAND: python -c "from pyroutingkit import CCH, INF_WEIGHT; print('OK')"
+          CIBW_TEST_COMMAND: python -c "from pyroutingkit import CCH, CCHMetric, CCHTopology, HAS_OPENMP, INF_WEIGHT; print('OK, OpenMP:', HAS_OPENMP)"
 
       - uses: actions/upload-artifact@v4
         with:

{pyroutingkit-0.1.0 → pyroutingkit-0.2.0}/CMakeLists.txt

@@ -28,6 +28,16 @@ add_library(routingkit_static STATIC ${ROUTINGKIT_SOURCES})
 target_include_directories(routingkit_static PUBLIC ${ROUTINGKIT_DIR}/include)
 target_compile_options(routingkit_static PRIVATE -O3)
 
+# OpenMP enables parallel CCH customization (RoutingKit guards with #ifdef
+# _OPENMP, so building without it just makes customization serial).
+find_package(OpenMP QUIET)
+if(OpenMP_CXX_FOUND)
+    target_link_libraries(routingkit_static PUBLIC OpenMP::OpenMP_CXX)
+    message(STATUS "OpenMP found: parallel CCH customization enabled")
+else()
+    message(STATUS "OpenMP not found: CCH customization will be serial")
+endif()
+
 if(APPLE)
     target_compile_options(routingkit_static PRIVATE -Wno-deprecated -Wno-unused-parameter)
 endif()

{pyroutingkit-0.1.0 → pyroutingkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroutingkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python bindings for RoutingKit Customizable Contraction Hierarchies (CCH)
 Author: Ryan Fisk
 License-Expression: MIT

{pyroutingkit-0.1.0 → pyroutingkit-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyroutingkit"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python bindings for RoutingKit Customizable Contraction Hierarchies (CCH)"
 readme = "README.md"
 requires-python = ">=3.10"

pyroutingkit-0.2.0/src/pyroutingkit/__init__.py

@@ -0,0 +1,31 @@
+"""
+pyroutingkit: Python bindings for RoutingKit Customizable Contraction Hierarchies.
+
+Provides microsecond-scale shortest-path queries on large road networks,
+with one shared topology serving many customized metrics.
+
+Usage:
+    from pyroutingkit import CCHTopology, CCHMetric, INF_WEIGHT
+
+    topo = CCHTopology()
+    topo.build(tail, head, latitude, longitude, node_count)  # or topo.load(dir)
+
+    metric = CCHMetric(topo)
+    metric.customize(weights_uint32)                  # full customization
+    metric.update_weights(arc_ids, new_weights)       # partial (live edits)
+
+    distance, node_path, arc_path = metric.query(source, target)
+    matrix = metric.distances_many_to_many(sources, targets)
+
+The legacy single-metric `CCH` class is kept for backward compatibility.
+"""
+
+from pyroutingkit._core import (
+    CCH,
+    CCHMetric,
+    CCHTopology,
+    HAS_OPENMP,
+    INF_WEIGHT,
+)
+
+__all__ = ["CCH", "CCHMetric", "CCHTopology", "HAS_OPENMP", "INF_WEIGHT"]

pyroutingkit-0.2.0/src/routingkit_module.cpp

@@ -0,0 +1,586 @@
+/**
+ * pybind11 wrapper for RoutingKit's Customizable Contraction Hierarchy (CCH).
+ *
+ * Two-level API:
+ *
+ *   CCHTopology — metric-independent preprocessing (nested dissection order +
+ *       chordal supergraph). Built once per graph topology, save/load to disk.
+ *
+ *   CCHMetric — a customized weight set over a shared CCHTopology. Many
+ *       metrics (e.g. road-only/time, all-modes/cost, user-edited scratch)
+ *       can share one topology with no duplication. Supports full
+ *       (re-)customization, partial customization for small weight changes,
+ *       point-to-point queries with node+arc paths, and many-to-many
+ *       distance matrices.
+ *
+ *   CCH — legacy single-metric wrapper kept for backward compatibility.
+ */
+
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+
+#include <routingkit/customizable_contraction_hierarchy.h>
+#include <routingkit/nested_dissection.h>
+#include <routingkit/constants.h>
+#include <routingkit/vector_io.h>
+
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include <fstream>
+#include <cstdint>
+#include <cstring>
+
+namespace py = pybind11;
+
+// ---------------------------------------------------------------------------
+// CCHTopology — shared, metric-independent
+// ---------------------------------------------------------------------------
+
+class CCHTopologyWrapper {
+public:
+    CCHTopologyWrapper() : node_count_(0), built_(false) {}
+
+    /**
+     * Build CCH topology from graph arrays.
+     *
+     * Uses compute_nested_node_dissection_order_using_inertial_flow for the
+     * elimination order (requires node coordinates). Releases the GIL —
+     * this is the expensive phase.
+     */
+    void build(
+        py::array_t<uint32_t> tail_arr,
+        py::array_t<uint32_t> head_arr,
+        py::array_t<float> latitude_arr,
+        py::array_t<float> longitude_arr,
+        uint32_t node_count
+    ) {
+        auto tail_buf = tail_arr.request();
+        auto head_buf = head_arr.request();
+        auto lat_buf = latitude_arr.request();
+        auto lon_buf = longitude_arr.request();
+
+        if (tail_buf.size != head_buf.size) {
+            throw std::invalid_argument("tail and head must have same length");
+        }
+        if (lat_buf.size != (ssize_t)node_count || lon_buf.size != (ssize_t)node_count) {
+            throw std::invalid_argument("latitude/longitude must have length == node_count");
+        }
+
+        node_count_ = node_count;
+
+        auto* tail_ptr = static_cast<uint32_t*>(tail_buf.ptr);
+        auto* head_ptr = static_cast<uint32_t*>(head_buf.ptr);
+        auto* lat_ptr = static_cast<float*>(lat_buf.ptr);
+        auto* lon_ptr = static_cast<float*>(lon_buf.ptr);
+
+        tail_.assign(tail_ptr, tail_ptr + tail_buf.size);
+        head_.assign(head_ptr, head_ptr + head_buf.size);
+        std::vector<float> latitude(lat_ptr, lat_ptr + lat_buf.size);
+        std::vector<float> longitude(lon_ptr, lon_ptr + lon_buf.size);
+
+        {
+            py::gil_scoped_release release;
+            auto order = RoutingKit::compute_nested_node_dissection_order_using_inertial_flow(
+                node_count_, tail_, head_, latitude, longitude
+            );
+            cch_ = RoutingKit::CustomizableContractionHierarchy(order, tail_, head_);
+        }
+        built_ = true;
+        parallelization_ready_ = false;
+    }
+
+    void save(const std::string& dir_path) const {
+        if (!built_) {
+            throw std::runtime_error("Must call build or load before save");
+        }
+        RoutingKit::save_vector(dir_path + "/tail", tail_);
+        RoutingKit::save_vector(dir_path + "/head", head_);
+        RoutingKit::save_vector(dir_path + "/order", cch_.order);
+        RoutingKit::save_vector(dir_path + "/rank", cch_.rank);
+        std::vector<uint32_t> nc = {node_count_};
+        RoutingKit::save_vector(dir_path + "/node_count", nc);
+    }
+
+    /** Load topology from a directory (skips the expensive nested dissection). */
+    void load(const std::string& dir_path) {
+        {
+            py::gil_scoped_release release;
+            tail_ = RoutingKit::load_vector<unsigned>(dir_path + "/tail");
+            head_ = RoutingKit::load_vector<unsigned>(dir_path + "/head");
+            auto order = RoutingKit::load_vector<unsigned>(dir_path + "/order");
+            auto nc = RoutingKit::load_vector<unsigned>(dir_path + "/node_count");
+            if (nc.empty()) {
+                throw std::runtime_error("Invalid topology: missing node_count");
+            }
+            node_count_ = nc[0];
+            cch_ = RoutingKit::CustomizableContractionHierarchy(order, tail_, head_);
+        }
+        built_ = true;
+        parallelization_ready_ = false;
+    }
+
+    uint32_t get_node_count() const { return node_count_; }
+    size_t get_arc_count() const { return tail_.size(); }
+    bool is_built() const { return built_; }
+
+    const RoutingKit::CustomizableContractionHierarchy& cch() const {
+        if (!built_) {
+            throw std::runtime_error("Topology not built");
+        }
+        return cch_;
+    }
+
+    /** Lazily constructed, shared across metrics for parallel customization. */
+    RoutingKit::CustomizableContractionHierarchyParallelization& parallelization() {
+        if (!parallelization_ready_) {
+            parallelization_.reset(cch());
+            parallelization_ready_ = true;
+        }
+        return parallelization_;
+    }
+
+private:
+    uint32_t node_count_;
+    bool built_;
+    bool parallelization_ready_ = false;
+
+    std::vector<unsigned> tail_;
+    std::vector<unsigned> head_;
+
+    RoutingKit::CustomizableContractionHierarchy cch_;
+    RoutingKit::CustomizableContractionHierarchyParallelization parallelization_;
+};
+
+// ---------------------------------------------------------------------------
+// CCHMetric — one customized weight set over a shared topology
+// ---------------------------------------------------------------------------
+
+class CCHMetricWrapper {
+public:
+    explicit CCHMetricWrapper(CCHTopologyWrapper& topology)
+        : topology_(&topology), customized_(false) {
+        if (!topology.is_built()) {
+            throw std::runtime_error("Topology must be built before creating a metric");
+        }
+    }
+
+    /**
+     * Full (re-)customization with a new weight vector.
+     *
+     * thread_count: 0 = serial (also the fallback when built without OpenMP),
+     * N > 0 = parallel customization with N threads.
+     */
+    void customize(py::array_t<uint32_t> weights_arr, unsigned thread_count) {
+        auto buf = weights_arr.request();
+        if (buf.size != (ssize_t)topology_->get_arc_count()) {
+            throw std::invalid_argument(
+                "weights length (" + std::to_string(buf.size) +
+                ") must equal arc count (" + std::to_string(topology_->get_arc_count()) + ")"
+            );
+        }
+        auto* ptr = static_cast<uint32_t*>(buf.ptr);
+        weights_.assign(ptr, ptr + buf.size);
+
+        {
+            py::gil_scoped_release release;
+            metric_.reset(topology_->cch(), weights_);
+#ifdef _OPENMP
+            if (thread_count > 0) {
+                topology_->parallelization().customize(metric_, thread_count);
+            } else {
+                metric_.customize();
+            }
+#else
+            // Without OpenMP the parallelization path degrades to a SLOWER
+            // serial level-sweep — ignore thread_count entirely.
+            (void)thread_count;
+            metric_.customize();
+#endif
+            query_.reset(metric_);
+        }
+        customized_ = true;
+    }
+
+    /**
+     * Partial customization: change a few arc weights without a full
+     * re-customize. arc_ids are INPUT arc indices (row order of the arrays
+     * passed to CCHTopology.build). Milliseconds even on large graphs —
+     * this is the live-edit path (close a road, adjust a speed).
+     */
+    void update_weights(
+        py::array_t<uint32_t> arc_ids_arr,
+        py::array_t<uint32_t> new_weights_arr
+    ) {
+        if (!customized_) {
+            throw std::runtime_error("Must call customize before update_weights");
+        }
+        auto ids_buf = arc_ids_arr.request();
+        auto w_buf = new_weights_arr.request();
+        if (ids_buf.size != w_buf.size) {
+            throw std::invalid_argument("arc_ids and new_weights must have same length");
+        }
+
+        auto* ids = static_cast<uint32_t*>(ids_buf.ptr);
+        auto* vals = static_cast<uint32_t*>(w_buf.ptr);
+        size_t n = ids_buf.size;
+
+        for (size_t i = 0; i < n; i++) {
+            if (ids[i] >= weights_.size()) {
+                throw std::out_of_range(
+                    "arc id " + std::to_string(ids[i]) + " out of range (" +
+                    std::to_string(weights_.size()) + " arcs)"
+                );
+            }
+        }
+
+        {
+            py::gil_scoped_release release;
+            if (!partial_ready_) {
+                partial_.reset(topology_->cch());
+                partial_ready_ = true;
+            }
+            for (size_t i = 0; i < n; i++) {
+                weights_[ids[i]] = vals[i];
+                partial_.update_arc(ids[i]);
+            }
+            partial_.customize(metric_);
+            query_.reset(metric_);
+        }
+    }
+
+    /** Current weight vector (copy). */
+    py::array_t<uint32_t> get_weights() const {
+        auto arr = py::array_t<uint32_t>((ssize_t)weights_.size());
+        auto buf = arr.request();
+        std::memcpy(buf.ptr, weights_.data(), weights_.size() * sizeof(uint32_t));
+        return arr;
+    }
+
+    /**
+     * Point-to-point query.
+     * Returns (distance, node_path, arc_path); arc_path holds INPUT arc
+     * indices, usable directly to index edge-attribute arrays.
+     * Unreachable: (INF_WEIGHT, [], []).
+     */
+    py::tuple query(uint32_t source, uint32_t target) {
+        check_customized();
+        query_.reset().add_source(source).add_target(target).run();
+        unsigned dist = query_.get_distance();
+
+        if (dist == RoutingKit::inf_weight) {
+            return py::make_tuple(dist, py::list(), py::list());
+        }
+        auto node_path = query_.get_node_path();
+        auto arc_path = query_.get_arc_path();
+        return py::make_tuple(dist, py::cast(node_path), py::cast(arc_path));
+    }
+
+    /**
+     * Many-to-many distance matrix, shape (len(sources), len(targets)).
+     * Unreachable entries hold INF_WEIGHT.
+     */
+    py::array_t<uint32_t> distances_many_to_many(
+        py::array_t<uint32_t> sources_arr,
+        py::array_t<uint32_t> targets_arr
+    ) {
+        check_customized();
+        auto src_buf = sources_arr.request();
+        auto tgt_buf = targets_arr.request();
+        auto* src_ptr = static_cast<uint32_t*>(src_buf.ptr);
+        auto* tgt_ptr = static_cast<uint32_t*>(tgt_buf.ptr);
+
+        size_t n_src = src_buf.size;
+        size_t n_tgt = tgt_buf.size;
+
+        std::vector<uint32_t> targets(tgt_ptr, tgt_ptr + n_tgt);
+        std::vector<uint32_t> sources(src_ptr, src_ptr + n_src);
+        std::vector<uint32_t> result(n_src * n_tgt);
+
+        {
+            py::gil_scoped_release release;
+            query_.reset().pin_targets(targets);
+            for (size_t i = 0; i < n_src; i++) {
+                query_.reset_source().add_source(sources[i]).run_to_pinned_targets();
+                auto dists = query_.get_distances_to_targets();
+                std::memcpy(result.data() + i * n_tgt, dists.data(), n_tgt * sizeof(uint32_t));
+            }
+            // pinned state interferes with later point-to-point queries
+            query_.reset(metric_);
+        }
+
+        auto result_arr = py::array_t<uint32_t>({(ssize_t)n_src, (ssize_t)n_tgt});
+        auto result_buf = result_arr.request();
+        std::memcpy(result_buf.ptr, result.data(), result.size() * sizeof(uint32_t));
+        return result_arr;
+    }
+
+    bool is_customized() const { return customized_; }
+
+private:
+    void check_customized() const {
+        if (!customized_) {
+            throw std::runtime_error("Must call customize before querying");
+        }
+    }
+
+    CCHTopologyWrapper* topology_;
+    bool customized_;
+    bool partial_ready_ = false;
+
+    std::vector<unsigned> weights_;
+    RoutingKit::CustomizableContractionHierarchyMetric metric_;
+    RoutingKit::CustomizableContractionHierarchyQuery query_;
+    RoutingKit::CustomizableContractionHierarchyPartialCustomization partial_;
+};
+
+// ---------------------------------------------------------------------------
+// CCH — legacy single-metric wrapper (backward compatible)
+// ---------------------------------------------------------------------------
+
+class CCHWrapper {
+public:
+    CCHWrapper() : node_count_(0), built_(false), customized_(false) {}
+
+    void build_topology(
+        py::array_t<uint32_t> tail_arr,
+        py::array_t<uint32_t> head_arr,
+        py::array_t<float> latitude_arr,
+        py::array_t<float> longitude_arr,
+        uint32_t node_count
+    ) {
+        auto tail_buf = tail_arr.request();
+        auto head_buf = head_arr.request();
+        auto lat_buf = latitude_arr.request();
+        auto lon_buf = longitude_arr.request();
+
+        if (tail_buf.size != head_buf.size) {
+            throw std::invalid_argument("tail and head must have same length");
+        }
+        if (lat_buf.size != (ssize_t)node_count || lon_buf.size != (ssize_t)node_count) {
+            throw std::invalid_argument("latitude/longitude must have length == node_count");
+        }
+
+        node_count_ = node_count;
+
+        auto* tail_ptr = static_cast<uint32_t*>(tail_buf.ptr);
+        auto* head_ptr = static_cast<uint32_t*>(head_buf.ptr);
+        auto* lat_ptr = static_cast<float*>(lat_buf.ptr);
+        auto* lon_ptr = static_cast<float*>(lon_buf.ptr);
+
+        tail_.assign(tail_ptr, tail_ptr + tail_buf.size);
+        head_.assign(head_ptr, head_ptr + head_buf.size);
+        std::vector<float> latitude(lat_ptr, lat_ptr + lat_buf.size);
+        std::vector<float> longitude(lon_ptr, lon_ptr + lon_buf.size);
+
+        auto order = RoutingKit::compute_nested_node_dissection_order_using_inertial_flow(
+            node_count, tail_, head_, latitude, longitude
+        );
+
+        cch_ = RoutingKit::CustomizableContractionHierarchy(order, tail_, head_);
+        built_ = true;
+        customized_ = false;
+    }
+
+    void customize_weights(py::array_t<uint32_t> weights_arr) {
+        if (!built_) {
+            throw std::runtime_error("Must call build_topology before customize_weights");
+        }
+
+        auto buf = weights_arr.request();
+        if (buf.size != (ssize_t)tail_.size()) {
+            throw std::invalid_argument(
+                "weights length (" + std::to_string(buf.size) +
+                ") must equal arc count (" + std::to_string(tail_.size()) + ")"
+            );
+        }
+
+        auto* ptr = static_cast<uint32_t*>(buf.ptr);
+        weights_.assign(ptr, ptr + buf.size);
+
+        metric_ = RoutingKit::CustomizableContractionHierarchyMetric(cch_, weights_);
+        metric_.customize();
+        query_ = RoutingKit::CustomizableContractionHierarchyQuery(metric_);
+        customized_ = true;
+    }
+
+    py::tuple query(uint32_t source, uint32_t target) {
+        if (!customized_) {
+            throw std::runtime_error("Must call customize_weights before query");
+        }
+
+        query_.reset().add_source(source).add_target(target).run();
+        unsigned dist = query_.get_distance();
+
+        if (dist == RoutingKit::inf_weight) {
+            return py::make_tuple(dist, py::list());
+        }
+
+        auto path = query_.get_node_path();
+        return py::make_tuple(dist, py::cast(path));
+    }
+
+    py::array_t<uint32_t> distances_many_to_many(
+        py::array_t<uint32_t> sources_arr,
+        py::array_t<uint32_t> targets_arr
+    ) {
+        if (!customized_) {
+            throw std::runtime_error("Must call customize_weights before distances_many_to_many");
+        }
+
+        auto src_buf = sources_arr.request();
+        auto tgt_buf = targets_arr.request();
+        auto* src_ptr = static_cast<uint32_t*>(src_buf.ptr);
+        auto* tgt_ptr = static_cast<uint32_t*>(tgt_buf.ptr);
+
+        size_t n_src = src_buf.size;
+        size_t n_tgt = tgt_buf.size;
+
+        std::vector<uint32_t> targets(tgt_ptr, tgt_ptr + n_tgt);
+
+        std::vector<uint32_t> result(n_src * n_tgt);
+
+        query_.reset().pin_targets(targets);
+
+        for (size_t i = 0; i < n_src; i++) {
+            query_.reset_source().add_source(src_ptr[i]).run_to_pinned_targets();
+            auto dists = query_.get_distances_to_targets();
+            for (size_t j = 0; j < n_tgt; j++) {
+                result[i * n_tgt + j] = dists[j];
+            }
+        }
+
+        auto result_arr = py::array_t<uint32_t>({(ssize_t)n_src, (ssize_t)n_tgt});
+        auto result_buf = result_arr.request();
+        std::memcpy(result_buf.ptr, result.data(), result.size() * sizeof(uint32_t));
+        return result_arr;
+    }
+
+    void save_topology(const std::string& dir_path) {
+        if (!built_) {
+            throw std::runtime_error("Must call build_topology before save_topology");
+        }
+
+        RoutingKit::save_vector(dir_path + "/tail", tail_);
+        RoutingKit::save_vector(dir_path + "/head", head_);
+        RoutingKit::save_vector(dir_path + "/order", cch_.order);
+        RoutingKit::save_vector(dir_path + "/rank", cch_.rank);
+
+        std::vector<uint32_t> nc = {node_count_};
+        RoutingKit::save_vector(dir_path + "/node_count", nc);
+    }
+
+    void load_topology(const std::string& dir_path) {
+        tail_ = RoutingKit::load_vector<unsigned>(dir_path + "/tail");
+        head_ = RoutingKit::load_vector<unsigned>(dir_path + "/head");
+        auto order = RoutingKit::load_vector<unsigned>(dir_path + "/order");
+        auto nc = RoutingKit::load_vector<unsigned>(dir_path + "/node_count");
+
+        if (nc.empty()) {
+            throw std::runtime_error("Invalid topology: missing node_count");
+        }
+        node_count_ = nc[0];
+
+        cch_ = RoutingKit::CustomizableContractionHierarchy(order, tail_, head_);
+        built_ = true;
+        customized_ = false;
+    }
+
+    uint32_t get_node_count() const { return node_count_; }
+    size_t get_arc_count() const { return tail_.size(); }
+    bool is_built() const { return built_; }
+    bool is_customized() const { return customized_; }
+
+private:
+    uint32_t node_count_;
+    bool built_;
+    bool customized_;
+
+    std::vector<unsigned> tail_;
+    std::vector<unsigned> head_;
+    std::vector<unsigned> weights_;
+
+    RoutingKit::CustomizableContractionHierarchy cch_;
+    RoutingKit::CustomizableContractionHierarchyMetric metric_;
+    RoutingKit::CustomizableContractionHierarchyQuery query_;
+};
+
+
+PYBIND11_MODULE(_core, m) {
+    m.doc() = "RoutingKit CCH wrapper for Python";
+
+    py::class_<CCHTopologyWrapper>(m, "CCHTopology")
+        .def(py::init<>())
+        .def("build", &CCHTopologyWrapper::build,
+             py::arg("tail"), py::arg("head"),
+             py::arg("latitude"), py::arg("longitude"),
+             py::arg("node_count"),
+             "Build CCH topology (nested dissection + chordal supergraph). "
+             "Expensive; do once per graph topology and save().")
+        .def("save", &CCHTopologyWrapper::save, py::arg("dir_path"),
+             "Save topology to directory")
+        .def("load", &CCHTopologyWrapper::load, py::arg("dir_path"),
+             "Load topology from directory (skips nested dissection)")
+        .def_property_readonly("node_count", &CCHTopologyWrapper::get_node_count)
+        .def_property_readonly("arc_count", &CCHTopologyWrapper::get_arc_count)
+        .def_property_readonly("is_built", &CCHTopologyWrapper::is_built);
+
+    py::class_<CCHMetricWrapper>(m, "CCHMetric")
+        .def(py::init<CCHTopologyWrapper&>(), py::arg("topology"),
+             py::keep_alive<1, 2>(),  // metric keeps its topology alive
+             "Create an uncustomized metric over a shared topology")
+        .def("customize", &CCHMetricWrapper::customize,
+             py::arg("weights"), py::arg("thread_count") = 0,
+             "Full (re-)customization with uint32 weights. thread_count>0 "
+             "uses parallel customization when built with OpenMP.")
+        .def("update_weights", &CCHMetricWrapper::update_weights,
+             py::arg("arc_ids"), py::arg("new_weights"),
+             "Partial customization: change a few arc weights in "
+             "milliseconds. arc_ids are input arc indices.")
+        .def("query", &CCHMetricWrapper::query,
+             py::arg("source"), py::arg("target"),
+             "Point-to-point query. Returns (distance, node_path, arc_path); "
+             "arc_path holds input arc indices.")
+        .def("distances_many_to_many", &CCHMetricWrapper::distances_many_to_many,
+             py::arg("sources"), py::arg("targets"),
+             "Many-to-many distance matrix")
+        .def_property_readonly("weights", &CCHMetricWrapper::get_weights)
+        .def_property_readonly("is_customized", &CCHMetricWrapper::is_customized);
+
+    py::class_<CCHWrapper>(m, "CCH")
+        .def(py::init<>())
+        .def("build_topology", &CCHWrapper::build_topology,
+             py::arg("tail"), py::arg("head"),
+             py::arg("latitude"), py::arg("longitude"),
+             py::arg("node_count"),
+             "Build CCH topology from graph arrays with inertial flow ordering")
+        .def("customize_weights", &CCHWrapper::customize_weights,
+             py::arg("weights"),
+             "Customize CCH with uint32 weights")
+        .def("query", &CCHWrapper::query,
+             py::arg("source"), py::arg("target"),
+             "Point-to-point query. Returns (distance, node_path)")
+        .def("distances_many_to_many", &CCHWrapper::distances_many_to_many,
+             py::arg("sources"), py::arg("targets"),
+             "Many-to-many distance matrix")
+        .def("save_topology", &CCHWrapper::save_topology,
+             py::arg("dir_path"),
+             "Save CCH topology to directory")
+        .def("load_topology", &CCHWrapper::load_topology,
+             py::arg("dir_path"),
+             "Load CCH topology from directory")
+        .def_property_readonly("node_count", &CCHWrapper::get_node_count)
+        .def_property_readonly("arc_count", &CCHWrapper::get_arc_count)
+        .def_property_readonly("is_built", &CCHWrapper::is_built)
+        .def_property_readonly("is_customized", &CCHWrapper::is_customized);
+
+    // Expose inf_weight constant
+    m.attr("INF_WEIGHT") = RoutingKit::inf_weight;
+
+#ifdef _OPENMP
+    m.attr("HAS_OPENMP") = true;
+#else
+    m.attr("HAS_OPENMP") = false;
+#endif
+}