compas-sandbox-native 0.1.0__tar.gz

compas_sandbox_native-0.1.0/CMakeLists.txt

@@ -0,0 +1,109 @@
+# compas_sandbox_native: IPOPT bound into a Python extension module.
+#
+# IPOPT (and its MUMPS linear solver) are consumed as the static libraries produced by
+# packaging/build_ipopt.sh; point IPOPT_PREFIX (env or cache var) at that stage tree.
+# The result is one self-contained extension module: no ipopt executable, no DLLs.
+
+cmake_minimum_required(VERSION 3.18...3.30)
+project(compas_sandbox_native LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(NOT DEFINED IPOPT_PREFIX)
+    if(DEFINED ENV{IPOPT_PREFIX})
+        set(IPOPT_PREFIX "$ENV{IPOPT_PREFIX}")
+    else()
+        # the default location packaging/build_ipopt.sh stages into
+        get_filename_component(_repo "${CMAKE_CURRENT_SOURCE_DIR}/.." ABSOLUTE)
+        set(IPOPT_PREFIX "${_repo}/build/ipopt/stage")
+    endif()
+endif()
+if(NOT EXISTS "${IPOPT_PREFIX}/include/coin-or/IpTNLP.hpp")
+    message(FATAL_ERROR "No IPOPT build at IPOPT_PREFIX=${IPOPT_PREFIX}; run packaging/build_ipopt.sh first")
+endif()
+message(STATUS "IPOPT_PREFIX: ${IPOPT_PREFIX}")
+
+find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
+
+# nanobind is a build requirement; locate its CMake config through the interpreter
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_VARIABLE nanobind_ROOT OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY)
+find_package(nanobind CONFIG REQUIRED)
+
+# IPOPT + MUMPS themselves are linked as the static archives from the stage tree. The
+# Fortran/BLAS runtimes are linked dynamically instead: static Fortran runtimes do not
+# link cleanly into shared objects (local symbols, non-PIC objects), and the ecosystem
+# answer — what numpy/scipy wheels do — is to link the shared runtime and have the
+# platform wheel-repair tool (delocate / auditwheel / delvewheel) graft it into the
+# wheel afterwards.
+# everything needed is derivable from the stage tree itself; a pkg-config executable
+# is not reliably present on all builders (Windows in particular)
+set(IPOPT_INCLUDE_DIRS "${IPOPT_PREFIX}/include/coin-or")
+file(STRINGS "${IPOPT_PREFIX}/lib/pkgconfig/ipopt.pc" _ipopt_ver_line REGEX "^Version:")
+string(REGEX REPLACE "^Version: *" "" IPOPT_VERSION "${_ipopt_ver_line}")
+message(STATUS "IPOPT version: ${IPOPT_VERSION}")
+
+nanobind_add_module(_core src/ipopt_nb.cpp)
+
+target_include_directories(_core PRIVATE ${IPOPT_INCLUDE_DIRS})
+target_link_libraries(_core PRIVATE
+    "${IPOPT_PREFIX}/lib/libipopt${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    "${IPOPT_PREFIX}/lib/libcoinmumps${CMAKE_STATIC_LIBRARY_SUFFIX}")
+target_compile_definitions(_core PRIVATE IPOPT_VERSION="${IPOPT_VERSION}")
+
+# BLAS/LAPACK: Accelerate on macOS, OpenBLAS elsewhere (matching build_ipopt.sh)
+if(APPLE)
+    target_link_options(_core PRIVATE "-Wl,-framework,Accelerate")
+else()
+    target_link_libraries(_core PRIVATE openblas)
+endif()
+
+# the shared Fortran runtime, located through the Fortran compiler itself
+if(NOT DEFINED FORTRAN_COMPILER)
+    set(FORTRAN_COMPILER gfortran)
+endif()
+if(APPLE)
+    set(_frt libgfortran.dylib)
+elseif(WIN32)
+    set(_frt libgfortran.dll.a)
+else()
+    set(_frt libgfortran.so)
+endif()
+execute_process(
+    COMMAND ${FORTRAN_COMPILER} -print-file-name=${_frt}
+    OUTPUT_VARIABLE _frt_path OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY)
+if(NOT EXISTS "${_frt_path}")
+    message(FATAL_ERROR "no shared Fortran runtime found (${FORTRAN_COMPILER} -print-file-name=${_frt} -> ${_frt_path})")
+endif()
+get_filename_component(_frt_dir "${_frt_path}" DIRECTORY)
+message(STATUS "Fortran runtime: ${_frt_path}")
+target_link_directories(_core PRIVATE "${_frt_dir}")
+target_link_libraries(_core PRIVATE gfortran)
+if(NOT WIN32)
+    target_link_libraries(_core PRIVATE ${CMAKE_DL_LIBS})
+endif()
+if(WIN32)
+    target_link_libraries(_core PRIVATE quadmath)
+endif()
+
+# extra link directories/flags for special setups (e.g. the msys2 lib dir on Windows)
+if(DEFINED ENV{EXTRA_LINK_DIRS})
+    target_link_directories(_core PRIVATE "$ENV{EXTRA_LINK_DIRS}")
+endif()
+if(DEFINED ENV{IPOPT_EXTRA_LINK})
+    separate_arguments(_extra NATIVE_COMMAND "$ENV{IPOPT_EXTRA_LINK}")
+    target_link_options(_core PRIVATE ${_extra})
+endif()
+
+# arm64 macOS kills processes that load unsigned code, so make sure the module keeps a
+# valid ad-hoc signature whatever earlier steps did to it
+if(APPLE)
+    add_custom_command(TARGET _core POST_BUILD
+        COMMAND codesign --force -s - $<TARGET_FILE:_core>
+        COMMENT "ad-hoc signing $<TARGET_FILE:_core>")
+endif()
+
+install(TARGETS _core LIBRARY DESTINATION compas_sandbox_native)

compas_sandbox_native-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: compas_sandbox_native
+Version: 0.1.0
+Summary: In-process IPOPT solver for compas_sandbox (nanobind binding, statically linked)
+License: EPL-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3
+Project-URL: Repository, https://github.com/petrasvestartas/compas_sandbox
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.24
+Description-Content-Type: text/markdown
+
+# compas_sandbox_native
+
+IPOPT (with the MUMPS linear solver) compiled into a Python extension module with
+[nanobind](https://github.com/wjakob/nanobind), so `compas_sandbox` can solve CRA
+problems in-process: no bundled executable, no subprocess, no `.nl` files.
+
+## Building
+
+The extension links the static IPOPT tree produced by `packaging/build_ipopt.sh`:
+
+```bash
+packaging/build_ipopt.sh                  # stages into build/ipopt/stage
+pip install ./native                      # picks the stage tree up automatically
+```
+
+Point `IPOPT_PREFIX` at a different stage tree to override. Extra link flags (e.g. a
+static Fortran runtime) go in `IPOPT_EXTRA_LINK`.
+
+## Usage
+
+Installed alongside `compas_sandbox`, the `nlp` backend discovers it automatically:
+
+```python
+from compas_sandbox.equilibrium import cra_solve_native
+cra_solve_native(assembly)   # same inputs and results as cra_solve
+```

compas_sandbox_native-0.1.0/README.md

@@ -0,0 +1,26 @@
+# compas_sandbox_native
+
+IPOPT (with the MUMPS linear solver) compiled into a Python extension module with
+[nanobind](https://github.com/wjakob/nanobind), so `compas_sandbox` can solve CRA
+problems in-process: no bundled executable, no subprocess, no `.nl` files.
+
+## Building
+
+The extension links the static IPOPT tree produced by `packaging/build_ipopt.sh`:
+
+```bash
+packaging/build_ipopt.sh                  # stages into build/ipopt/stage
+pip install ./native                      # picks the stage tree up automatically
+```
+
+Point `IPOPT_PREFIX` at a different stage tree to override. Extra link flags (e.g. a
+static Fortran runtime) go in `IPOPT_EXTRA_LINK`.
+
+## Usage
+
+Installed alongside `compas_sandbox`, the `nlp` backend discovers it automatically:
+
+```python
+from compas_sandbox.equilibrium import cra_solve_native
+cra_solve_native(assembly)   # same inputs and results as cra_solve
+```

compas_sandbox_native-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+# nanobind 3.x dropped Python 3.9, which Rhino 8 still ships — stay on 2.x
+requires = ["scikit-build-core>=0.10", "nanobind>=2.2,<3"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "compas_sandbox_native"
+version = "0.1.0"
+description = "In-process IPOPT solver for compas_sandbox (nanobind binding, statically linked)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "EPL-2.0" }
+dependencies = ["numpy>=1.24"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Topic :: Scientific/Engineering",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Repository = "https://github.com/petrasvestartas/compas_sandbox"
+
+[tool.scikit-build]
+minimum-version = "0.10"
+wheel.packages = ["python/compas_sandbox_native"]
+# stripping would invalidate the macOS ad-hoc code signature; arm64 kills unsigned code
+install.strip = false

compas_sandbox_native-0.1.0/python/compas_sandbox_native/__init__.py

@@ -0,0 +1,10 @@
+"""In-process IPOPT solver for compas_sandbox.
+
+The heavy lifting happens in the compiled ``_core`` module, which links IPOPT and the
+MUMPS linear solver statically. See ``compas_sandbox.nlp`` for the high-level API.
+"""
+
+from ._core import IPOPT_VERSION
+from ._core import solve_nlp
+
+__all__ = ["solve_nlp", "IPOPT_VERSION"]

compas_sandbox_native-0.1.0/src/ipopt_nb.cpp

@@ -0,0 +1,310 @@
+// In-process IPOPT solver exposed to Python through nanobind.
+//
+// One function is exported: solve_nlp(...). It receives the problem data (bounds,
+// starting point, Jacobian/Hessian sparsity) as numpy arrays and the evaluation
+// callbacks as Python callables, drives Ipopt::IpoptApplication over a TNLP that
+// trampolines every evaluation back into Python, and returns the solution as a dict.
+//
+// Threading: everything runs on the calling thread and the GIL is held throughout,
+// so the Python callbacks need no locking. A Python exception raised inside a
+// callback is captured, the evaluation reports failure to IPOPT, and the exception
+// is re-raised to the caller once IPOPT returns.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/string.h>
+
+#include <IpIpoptApplication.hpp>
+#include <IpIpoptData.hpp>
+#include <IpSolveStatistics.hpp>
+#include <IpTNLP.hpp>
+
+#include <cstring>
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace nb = nanobind;
+
+using DArray = nb::ndarray<double, nb::ndim<1>, nb::c_contig, nb::device::cpu>;
+using IArray = nb::ndarray<int32_t, nb::ndim<1>, nb::c_contig, nb::device::cpu>;
+
+namespace {
+
+std::vector<double> to_vector(const DArray &a) {
+    return std::vector<double>(a.data(), a.data() + a.size());
+}
+
+std::vector<int32_t> to_vector_i(const IArray &a) {
+    return std::vector<int32_t>(a.data(), a.data() + a.size());
+}
+
+// A fresh numpy array holding a copy of `x`, handed to the Python callbacks.
+nb::object make_numpy(const double *x, size_t k) {
+    double *buf = new double[k];
+    std::memcpy(buf, x, k * sizeof(double));
+    nb::capsule owner(buf, [](void *p) noexcept { delete[] static_cast<double *>(p); });
+    return nb::cast(nb::ndarray<nb::numpy, double, nb::ndim<1>>(buf, {k}, owner));
+}
+
+// Copy a callback's numpy result into an IPOPT buffer, checking the length.
+void copy_result(const nb::object &res, double *out, size_t expected, const char *what) {
+    DArray arr = nb::cast<DArray>(res);
+    if (arr.size() != expected)
+        throw std::runtime_error(std::string(what) + ": expected " + std::to_string(expected) +
+                                 " values, got " + std::to_string(arr.size()));
+    std::memcpy(out, arr.data(), expected * sizeof(double));
+}
+
+const char *status_name(Ipopt::ApplicationReturnStatus s) {
+    using S = Ipopt::ApplicationReturnStatus;
+    switch (s) {
+        case S::Solve_Succeeded: return "Solve_Succeeded";
+        case S::Solved_To_Acceptable_Level: return "Solved_To_Acceptable_Level";
+        case S::Infeasible_Problem_Detected: return "Infeasible_Problem_Detected";
+        case S::Search_Direction_Becomes_Too_Small: return "Search_Direction_Becomes_Too_Small";
+        case S::Diverging_Iterates: return "Diverging_Iterates";
+        case S::User_Requested_Stop: return "User_Requested_Stop";
+        case S::Feasible_Point_Found: return "Feasible_Point_Found";
+        case S::Maximum_Iterations_Exceeded: return "Maximum_Iterations_Exceeded";
+        case S::Restoration_Failed: return "Restoration_Failed";
+        case S::Error_In_Step_Computation: return "Error_In_Step_Computation";
+        case S::Maximum_CpuTime_Exceeded: return "Maximum_CpuTime_Exceeded";
+        case S::Not_Enough_Degrees_Of_Freedom: return "Not_Enough_Degrees_Of_Freedom";
+        case S::Invalid_Problem_Definition: return "Invalid_Problem_Definition";
+        case S::Invalid_Option: return "Invalid_Option";
+        case S::Invalid_Number_Detected: return "Invalid_Number_Detected";
+        case S::Unrecoverable_Exception: return "Unrecoverable_Exception";
+        case S::NonIpopt_Exception_Thrown: return "NonIpopt_Exception_Thrown";
+        case S::Insufficient_Memory: return "Insufficient_Memory";
+        case S::Internal_Error: return "Internal_Error";
+        default: return "Unknown";
+    }
+}
+
+class CallbackNLP : public Ipopt::TNLP {
+public:
+    // problem data
+    Ipopt::Index n_ = 0, m_ = 0;
+    std::vector<double> x_l_, x_u_, g_l_, g_u_, x0_;
+    std::vector<int32_t> jac_rows_, jac_cols_, hess_rows_, hess_cols_;
+    nb::object eval_f_, eval_grad_, eval_g_, eval_jac_, eval_h_;
+    bool have_hess_ = false;
+
+    // captured Python error from a callback
+    std::exception_ptr error_;
+
+    // solution
+    bool solved_ = false;
+    double obj_ = 0.0;
+    std::vector<double> sol_x_, sol_g_, sol_mult_g_, sol_z_l_, sol_z_u_;
+
+    bool get_nlp_info(Ipopt::Index &n, Ipopt::Index &m, Ipopt::Index &nnz_jac_g,
+                      Ipopt::Index &nnz_h_lag, IndexStyleEnum &index_style) override {
+        n = n_;
+        m = m_;
+        nnz_jac_g = static_cast<Ipopt::Index>(jac_rows_.size());
+        nnz_h_lag = static_cast<Ipopt::Index>(hess_rows_.size());
+        index_style = C_STYLE;
+        return true;
+    }
+
+    bool get_bounds_info(Ipopt::Index n, Ipopt::Number *x_l, Ipopt::Number *x_u,
+                         Ipopt::Index m, Ipopt::Number *g_l, Ipopt::Number *g_u) override {
+        std::memcpy(x_l, x_l_.data(), n * sizeof(double));
+        std::memcpy(x_u, x_u_.data(), n * sizeof(double));
+        std::memcpy(g_l, g_l_.data(), m * sizeof(double));
+        std::memcpy(g_u, g_u_.data(), m * sizeof(double));
+        return true;
+    }
+
+    bool get_starting_point(Ipopt::Index n, bool init_x, Ipopt::Number *x, bool init_z,
+                            Ipopt::Number * /*z_L*/, Ipopt::Number * /*z_U*/, Ipopt::Index /*m*/,
+                            bool init_lambda, Ipopt::Number * /*lambda*/) override {
+        if (init_z || init_lambda)
+            return false;
+        if (init_x)
+            std::memcpy(x, x0_.data(), n * sizeof(double));
+        return true;
+    }
+
+    bool eval_f(Ipopt::Index n, const Ipopt::Number *x, bool /*new_x*/, Ipopt::Number &obj_value) override {
+        try {
+            obj_value = nb::cast<double>(eval_f_(make_numpy(x, n)));
+            return true;
+        } catch (...) {
+            error_ = std::current_exception();
+            return false;
+        }
+    }
+
+    bool eval_grad_f(Ipopt::Index n, const Ipopt::Number *x, bool /*new_x*/, Ipopt::Number *grad_f) override {
+        try {
+            copy_result(eval_grad_(make_numpy(x, n)), grad_f, n, "gradient");
+            return true;
+        } catch (...) {
+            error_ = std::current_exception();
+            return false;
+        }
+    }
+
+    bool eval_g(Ipopt::Index n, const Ipopt::Number *x, bool /*new_x*/, Ipopt::Index m, Ipopt::Number *g) override {
+        try {
+            copy_result(eval_g_(make_numpy(x, n)), g, m, "constraints");
+            return true;
+        } catch (...) {
+            error_ = std::current_exception();
+            return false;
+        }
+    }
+
+    bool eval_jac_g(Ipopt::Index n, const Ipopt::Number *x, bool /*new_x*/, Ipopt::Index /*m*/,
+                    Ipopt::Index nele_jac, Ipopt::Index *iRow, Ipopt::Index *jCol,
+                    Ipopt::Number *values) override {
+        if (values == nullptr) {
+            for (Ipopt::Index k = 0; k < nele_jac; ++k) {
+                iRow[k] = jac_rows_[k];
+                jCol[k] = jac_cols_[k];
+            }
+            return true;
+        }
+        try {
+            copy_result(eval_jac_(make_numpy(x, n)), values, nele_jac, "jacobian");
+            return true;
+        } catch (...) {
+            error_ = std::current_exception();
+            return false;
+        }
+    }
+
+    bool eval_h(Ipopt::Index n, const Ipopt::Number *x, bool /*new_x*/, Ipopt::Number obj_factor,
+                Ipopt::Index m, const Ipopt::Number *lambda, bool /*new_lambda*/, Ipopt::Index nele_hess,
+                Ipopt::Index *iRow, Ipopt::Index *jCol, Ipopt::Number *values) override {
+        if (!have_hess_)
+            return false;
+        if (values == nullptr) {
+            for (Ipopt::Index k = 0; k < nele_hess; ++k) {
+                iRow[k] = hess_rows_[k];
+                jCol[k] = hess_cols_[k];
+            }
+            return true;
+        }
+        try {
+            copy_result(eval_h_(make_numpy(x, n), obj_factor, make_numpy(lambda, m)), values, nele_hess,
+                        "hessian");
+            return true;
+        } catch (...) {
+            error_ = std::current_exception();
+            return false;
+        }
+    }
+
+    void finalize_solution(Ipopt::SolverReturn /*status*/, Ipopt::Index n, const Ipopt::Number *x,
+                           const Ipopt::Number *z_L, const Ipopt::Number *z_U, Ipopt::Index m,
+                           const Ipopt::Number *g, const Ipopt::Number *lambda, Ipopt::Number obj_value,
+                           const Ipopt::IpoptData * /*ip_data*/,
+                           Ipopt::IpoptCalculatedQuantities * /*ip_cq*/) override {
+        solved_ = true;
+        obj_ = obj_value;
+        sol_x_.assign(x, x + n);
+        sol_g_.assign(g, g + m);
+        sol_mult_g_.assign(lambda, lambda + m);
+        sol_z_l_.assign(z_L, z_L + n);
+        sol_z_u_.assign(z_U, z_U + n);
+    }
+};
+
+nb::object vec_to_numpy(const std::vector<double> &v) {
+    return make_numpy(v.data(), v.size());
+}
+
+nb::dict solve_nlp(int n, int m, DArray x_l, DArray x_u, DArray g_l, DArray g_u, DArray x0,
+                   IArray jac_rows, IArray jac_cols, nb::object eval_f, nb::object eval_grad,
+                   nb::object eval_g, nb::object eval_jac, nb::object hess_rows, nb::object hess_cols,
+                   nb::object eval_h, nb::dict options) {
+    if ((int)x_l.size() != n || (int)x_u.size() != n || (int)x0.size() != n)
+        throw std::invalid_argument("variable arrays must have length n");
+    if ((int)g_l.size() != m || (int)g_u.size() != m)
+        throw std::invalid_argument("constraint bound arrays must have length m");
+    if (jac_rows.size() != jac_cols.size())
+        throw std::invalid_argument("jac_rows and jac_cols must have the same length");
+
+    Ipopt::SmartPtr<CallbackNLP> nlp = new CallbackNLP();
+    nlp->n_ = n;
+    nlp->m_ = m;
+    nlp->x_l_ = to_vector(x_l);
+    nlp->x_u_ = to_vector(x_u);
+    nlp->g_l_ = to_vector(g_l);
+    nlp->g_u_ = to_vector(g_u);
+    nlp->x0_ = to_vector(x0);
+    nlp->jac_rows_ = to_vector_i(jac_rows);
+    nlp->jac_cols_ = to_vector_i(jac_cols);
+    nlp->eval_f_ = eval_f;
+    nlp->eval_grad_ = eval_grad;
+    nlp->eval_g_ = eval_g;
+    nlp->eval_jac_ = eval_jac;
+
+    if (!eval_h.is_none()) {
+        IArray hr = nb::cast<IArray>(hess_rows);
+        IArray hc = nb::cast<IArray>(hess_cols);
+        if (hr.size() != hc.size())
+            throw std::invalid_argument("hess_rows and hess_cols must have the same length");
+        nlp->hess_rows_ = to_vector_i(hr);
+        nlp->hess_cols_ = to_vector_i(hc);
+        nlp->eval_h_ = eval_h;
+        nlp->have_hess_ = true;
+    }
+
+    Ipopt::SmartPtr<Ipopt::IpoptApplication> app = IpoptApplicationFactory();
+    app->RethrowNonIpoptException(false);
+
+    for (auto item : options) {
+        std::string key = nb::cast<std::string>(item.first);
+        nb::handle value = item.second;
+        if (nb::isinstance<nb::str>(value)) {
+            app->Options()->SetStringValue(key, nb::cast<std::string>(value));
+        } else if (nb::isinstance<nb::bool_>(value)) {
+            app->Options()->SetStringValue(key, nb::cast<bool>(value) ? "yes" : "no");
+        } else if (nb::isinstance<nb::int_>(value)) {
+            app->Options()->SetIntegerValue(key, nb::cast<int>(value));
+        } else if (nb::isinstance<nb::float_>(value)) {
+            app->Options()->SetNumericValue(key, nb::cast<double>(value));
+        } else {
+            throw std::invalid_argument("option '" + key + "' must be str, bool, int or float");
+        }
+    }
+
+    Ipopt::ApplicationReturnStatus status = app->Initialize();
+    if (status == Ipopt::Solve_Succeeded)
+        status = app->OptimizeTNLP(Ipopt::SmartPtr<Ipopt::TNLP>(Ipopt::GetRawPtr(nlp)));
+
+    // a Python exception inside a callback beats whatever IPOPT made of the failure
+    if (nlp->error_)
+        std::rethrow_exception(nlp->error_);
+
+    nb::dict out;
+    out["status"] = static_cast<int>(status);
+    out["status_name"] = status_name(status);
+    out["obj"] = nlp->obj_;
+    out["x"] = vec_to_numpy(nlp->solved_ ? nlp->sol_x_ : nlp->x0_);
+    out["g"] = vec_to_numpy(nlp->sol_g_);
+    out["mult_g"] = vec_to_numpy(nlp->sol_mult_g_);
+    out["mult_x_l"] = vec_to_numpy(nlp->sol_z_l_);
+    out["mult_x_u"] = vec_to_numpy(nlp->sol_z_u_);
+    if (Ipopt::IsValid(app->Statistics()))
+        out["iterations"] = app->Statistics()->IterationCount();
+    return out;
+}
+
+}  // namespace
+
+NB_MODULE(_core, mod) {
+    mod.doc() = "In-process IPOPT solver for compas_sandbox";
+    mod.def("solve_nlp", &solve_nlp, nb::arg("n"), nb::arg("m"), nb::arg("x_l"), nb::arg("x_u"),
+            nb::arg("g_l"), nb::arg("g_u"), nb::arg("x0"), nb::arg("jac_rows"), nb::arg("jac_cols"),
+            nb::arg("eval_f"), nb::arg("eval_grad"), nb::arg("eval_g"), nb::arg("eval_jac"),
+            nb::arg("hess_rows").none(), nb::arg("hess_cols").none(), nb::arg("eval_h").none(),
+            nb::arg("options"),
+            "Solve a sparse NLP with IPOPT; see compas_sandbox.nlp for the friendly wrapper.");
+    mod.attr("IPOPT_VERSION") = IPOPT_VERSION;
+}

compas_sandbox_native-0.1.0/tests/smoke.py

@@ -0,0 +1,37 @@
+"""Minimal smoke test for a built compas_sandbox_native wheel.
+
+Solves min x^2 s.t. x >= 1 — enough to prove the extension loads, IPOPT runs, the
+MUMPS linear solver works and callbacks round-trip. Needs only numpy, so it can run
+in the bare test environments of the wheel-building CI.
+"""
+
+import numpy as np
+
+import compas_sandbox_native as csn
+
+print("compas_sandbox_native, IPOPT", csn.IPOPT_VERSION)
+
+res = csn.solve_nlp(
+    n=1,
+    m=1,
+    x_l=np.array([-10.0]),
+    x_u=np.array([10.0]),
+    g_l=np.array([1.0]),
+    g_u=np.array([1e19]),
+    x0=np.array([5.0]),
+    jac_rows=np.array([0], dtype=np.int32),
+    jac_cols=np.array([0], dtype=np.int32),
+    eval_f=lambda x: float(x[0] ** 2),
+    eval_grad=lambda x: np.array([2.0 * x[0]]),
+    eval_g=lambda x: np.array([x[0]]),
+    eval_jac=lambda x: np.array([1.0]),
+    hess_rows=np.array([0], dtype=np.int32),
+    hess_cols=np.array([0], dtype=np.int32),
+    eval_h=lambda x, sigma, lam: np.array([2.0 * sigma]),
+    options={"print_level": 0, "sb": "yes"},
+)
+
+assert res["status"] == 0, res["status_name"]
+assert abs(res["x"][0] - 1.0) < 1e-6, res["x"]
+assert abs(res["obj"] - 1.0) < 1e-6, res["obj"]
+print("smoke test OK: x =", res["x"][0])