Add helper for parsing tuples using nanobind

src/nrnpython/cast_tuple.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <cstddef>
+#include <stdexcept>
+
+#include <nanobind/nanobind.h>
+#include <fmt/format.h>
+
+namespace nrn {
+namespace detail {
+
+template <typename T, size_t I>
+T get(const nanobind::tuple& t) {
+    return nanobind::cast<T>(t[I]);
+}
+
+template <typename... Ts, typename Tuple, std::size_t... Is>
+auto cast_tuple_impl(Tuple&& tuple, std::index_sequence<Is...>) {
+    auto count = sizeof...(Is);
+    if (count > tuple.size()) {
+        throw std::runtime_error(fmt::format(
+            "Not enough arguments, expected {}, but only received {}", count, tuple.size()));
+    }
+    return std::make_tuple(get<Ts, Is>(std::forward<Tuple>(tuple))...);
+}
+}  // namespace detail
+
+/*!
+ * Extract an exact number of elements from a tuple, including casting them to certain types.
+ *
+ * This uses `nanobind::cast`, so expect a `nanobind::cast_error()` if there are incompatible types.
+ * If the number of supplied elements in the tuple is fewer than the expected number, a std::runtime
+ * error is thrown.
+ *
+ * @param tuple can either be a nanobind::args or a nanobind::tuple
+ */
+template <typename... Ts, typename Tuple>
+auto cast_tuple(Tuple&& tuple) {
+    return detail::cast_tuple_impl<Ts...>(std::forward<Tuple>(tuple),
+                                          std::make_index_sequence<sizeof...(Ts)>{});
+}
+
+}  // namespace nrn

src/nrnpython/nrnpy_hoc.cpp

@@ -7,6 +7,8 @@
 #include "nrnpy_utils.h"
 #include "nrnpython.h"
 #include "convert_cxx_exceptions.hpp"
+#include "cast_tuple.hpp"
+
 #include <unordered_map>
 
 #include "nrnwrap_dlfcn.h"
@@ -23,6 +25,7 @@
 #include <sstream>
 
 #include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
 
 namespace nb = nanobind;
 
@@ -157,11 +160,8 @@ static int hoc_evalpointer_err() {
 }
 
 static PyObject* nrnexec(PyObject* self, PyObject* args) {
-    const char* cmd;
-    if (!PyArg_ParseTuple(args, "s", &cmd)) {
-        return NULL;
-    }
-    bool b = hoc_valid_stmt(cmd, 0);
+    auto [cmd] = nrn::cast_tuple<const std::string>(nb::tuple(args));
+    bool b = hoc_valid_stmt(cmd.c_str(), 0);
     return b ? Py_True : Py_False;
 }
 

test/CMakeLists.txt

@@ -13,19 +13,24 @@ include(NeuronTestHelper)
 # =============================================================================
 # Test executables
 # =============================================================================
-add_executable(
-  testneuron
-  common/catch2_main.cpp
-  unit_tests/basic.cpp
-  unit_tests/iovec.cpp
-  unit_tests/container/container.cpp
-  unit_tests/container/generic_data_handle.cpp
-  unit_tests/container/mechanism.cpp
-  unit_tests/container/node.cpp
-  unit_tests/node_order_optim/permutations.cpp
-  unit_tests/utils/enumerate.cpp
-  unit_tests/oc/hoc_interpreter.cpp
-  cover/unit_tests/cover.cpp)
+set(TESTNEURON_SRC
+    common/catch2_main.cpp
+    unit_tests/basic.cpp
+    unit_tests/iovec.cpp
+    unit_tests/container/container.cpp
+    unit_tests/container/generic_data_handle.cpp
+    unit_tests/container/mechanism.cpp
+    unit_tests/container/node.cpp
+    unit_tests/node_order_optim/permutations.cpp
+    unit_tests/utils/enumerate.cpp
+    unit_tests/oc/hoc_interpreter.cpp
+    cover/unit_tests/cover.cpp)
+
+if(NRN_ENABLE_PYTHON)
+  list(APPEND TESTNEURON_SRC "unit_tests/utils/cast_tuple.cpp")
+endif()
+
+add_executable(testneuron ${TESTNEURON_SRC})
 set(catch2_targets testneuron)
 if(NRN_ENABLE_THREADS)
   add_executable(nrn-benchmarks common/catch2_main.cpp benchmarks/threads/test_multicore.cpp)

test/unit_tests/utils/cast_tuple.cpp

@@ -0,0 +1,38 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+#include "cast_tuple.hpp"
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("can_cast_nanobind_tuple", "[Neuron][nrnpython]") {
+    auto tup = nanobind::make_tuple(42, "test", 3.14);
+    auto [i, s, d] = nrn::cast_tuple<int, std::string, double>(tup);
+    REQUIRE(i == 42);
+    REQUIRE(s == "test");
+    REQUIRE(d == 3.14);
+}
+
+TEST_CASE("can_cast_nanobind_args", "[Neuron][nrnpython]") {
+    auto tup = nanobind::make_tuple(42, "test", 3.14);
+    auto args = nanobind::cast<nanobind::args>(tup);
+    auto [i, s, d] = nrn::cast_tuple<int, std::string, double>(args);
+    REQUIRE(i == 42);
+    REQUIRE(s == "test");
+    REQUIRE(d == 3.14);
+}
+
+TEST_CASE("can_cast_extra_arguments", "[Neuron][nrnpython]") {
+    auto tup = nanobind::make_tuple("test", 3.14, 42);
+    auto [s, d] = nrn::cast_tuple<std::string, double>(tup);
+    REQUIRE(s == "test");
+    REQUIRE(d == 3.14);
+}
+
+TEST_CASE("not_enough_arguments", "[Neuron][nrnpython]") {
+    auto tup = nanobind::make_tuple(42, std::string("test"));
+    REQUIRE_THROWS(nrn::cast_tuple<int, std::string, double>(tup));
+
+    auto empty_tuple = nanobind::tuple();
+    REQUIRE_THROWS(nrn::cast_tuple<int>(empty_tuple));
+}