Nanobind transition

BUILD.bazel

@@ -1,6 +1,7 @@
 # This file is named BUILD.bazel instead of the more typical BUILD, so that on
 # OSX it won't conflict with a build artifacts directory named "build".
 
+load("//tools/flags/internal:multi_config.bzl", "python_binder_reset")
 load("//tools/install:install.bzl", "install", "install_test")
 load("//tools/lint:lint.bzl", "add_lint_tests")
 load("//tools/skylark:drake_py.bzl", "drake_py_library")
@@ -37,10 +38,13 @@ drake_py_library(
 
 # Expose shared library for (a) installed binaries, (b) Drake Python bindings,
 # and (c) downstream C++ libraries which will also provide Python bindings.
-alias(
+# We use 'python_binder_reset' so that our multi-config test suite (which runs
+# tests using both pybind11 and nanobind) doesn't recompile libdrake for both
+# configs -- it resets the binder flag to its default value for this target.
+python_binder_reset(
     name = "drake_shared_library",
-    actual = "//tools/install/libdrake:drake_shared_library",
     visibility = ["//visibility:public"],
+    exports = "//tools/install/libdrake:drake_shared_library",
 )
 
 # A manually-curated collection of most model files in Drake, so that we can

bindings/pydrake/BUILD.bazel

@@ -57,7 +57,10 @@ drake_py_library(
 
 drake_cc_library(
     name = "pydrake_pybind",
-    hdrs = ["pydrake_pybind.h"],
+    hdrs = [
+        "pydrake_numpy_dtype_object_type_caster.h",
+        "pydrake_pybind.h",
+    ],
     declare_installed_headers = 0,
     defines = select({
         "//tools/workspace/nanobind:enabled": [
@@ -68,11 +71,14 @@ drake_cc_library(
         ],
     }),
     visibility = ["//visibility:public"],
-    deps = [
-        # TODO(#21572) Using pybind11 unconditionally here is wrong, but is
-        # easier for now until all/most binding code has been ported.
-        "@drake//tools/workspace/pybind11",
-    ],
+    deps = select({
+        "//tools/workspace/nanobind:enabled": [
+            "@drake//tools/workspace/nanobind",
+        ],
+        "//conditions:default": [
+            "@drake//tools/workspace/pybind11",
+        ],
+    }),
 )
 
 drake_cc_library(
@@ -380,6 +386,7 @@ drake_py_unittest(
         "//:.clang-format",
     ],
     tags = ["lint"],
+    test_alt_binder = False,
 )
 
 drake_py_unittest(

bindings/pydrake/common/BUILD.bazel

@@ -101,9 +101,13 @@ drake_pybind_library(
         "cpp_template.py",
         "deprecation.py",
         "jupyter.py",
-        "pybind11_version.py",
         "yaml.py",
-    ],
+    ] + select({
+        "//tools/workspace/nanobind:enabled": [],
+        "//conditions:default": [
+            "pybind11_version.py",
+        ],
+    }),
     visibility = [
         "//bindings/pydrake:__pkg__",
     ],
@@ -518,6 +522,7 @@ drake_py_unittest(
 
 drake_py_unittest(
     name = "pybind11_version_test",
+    opt_out_conditions = ["//tools/workspace/nanobind:enabled"],
     deps = [
         ":common",
     ],

bindings/pydrake/common/all.py

@@ -13,7 +13,3 @@
 from .schema import *
 from .yaml import *
 from .value import *
-
-# N.B. Since this is generic and relatively scoped, we import the module as a
-# symbol.
-from . import pybind11_version

bindings/pydrake/common/cpp_param_pybind.cc

@@ -57,8 +57,8 @@ template <typename T>
 void RegisterType(
     py::module_ m, py::object param_aliases, const std::string& canonical_str) {
   // Create an object that is a unique hash.
-  py::object canonical =
-      py::eval(py::str(canonical_str.c_str()), m.attr("__dict__"));
+  py::object canonical = py::eval(
+      py::str(canonical_str.c_str()), m.attr("__dict__"), py::globals());
   py::list aliases;
   aliases.append(GetPyHash(typeid(T)));
   param_aliases.attr("register")(canonical, aliases);
@@ -106,15 +106,23 @@ py::object GetPyParamScalarImpl(const std::type_info& tinfo) {
     // This type is not aliased. Get the pybind-registered type,
     // erroring out if it's not registered.
     // WARNING: Internal API :(
+#ifdef PYDRAKE_USE_PYBIND11
     auto* info = py::detail::get_type_info(tinfo);
+#else  // PYDRAKE_USE_NANOBIND
+    auto* info = py::detail::nb_type_lookup(&tinfo);
+#endif
     if (!info) {
       // TODO(eric.cousineau): Use NiceTypeName::Canonicalize(...Demangle(...))
       // once simpler dependencies are used (or something else is used to
       // justify linking in `libdrake.so`).
       const std::string name = tinfo.name();
       throw std::runtime_error("C++ type is not registered in pybind: " + name);
     }
+#ifdef PYDRAKE_USE_PYBIND11
     py::handle h(reinterpret_cast<PyObject*>(info->type));
+#else  // PYDRAKE_USE_NANOBIND
+    py::handle h(reinterpret_cast<PyObject*>(info));
+#endif
     return py::borrow<py::object>(h);
   }
 }

bindings/pydrake/common/cpp_param_pybind.h

@@ -100,7 +100,7 @@ py::object GetPyParamScalarImpl(const std::type_info& tinfo);
 // Gets Python type for a C++ type (base case).
 template <typename T>
 inline py::object GetPyParamScalarImpl(type_pack<T> = {}) {
-  static_assert(!py::detail::is_pyobject<T>::value,
+  static_assert(!internal::is_pyobject<T>::value,
       "You cannot use `pybind11` types (e.g. `py::object`). Use a publicly "
       "visible replacement type instead (e.g. `drake::pydrake::Object`).");
   return GetPyParamScalarImpl(typeid(T));
@@ -114,12 +114,12 @@ inline py::object GetPyParamScalarImpl(
 }
 
 // Gets Python type for a C++ vector that is not registered using
-// PYBIND11_MAKE_OPAQUE.
+// {PYBIND11,NB}_MAKE_OPAQUE.
 template <typename T>
 inline py::object GetPyParamScalarImpl(type_pack<std::vector<T>> = {}) {
   // Get inner type for validation.
   py::object py_T = GetPyParamScalarImpl(type_pack<T>{});
-  if constexpr (!internal::is_generic_pybind_v<std::vector<T>>) {
+  if constexpr (!internal::is_generic_caster_v<std::vector<T>>) {
     return py::module_::import_("pydrake.common.cpp_param").attr("List")[py_T];
   } else {
     return GetPyParamScalarImpl(typeid(std::vector<T>));
@@ -146,7 +146,7 @@ inline py::tuple GetPyParam(type_pack<Ts...> = {}) {
 }  // namespace pydrake
 }  // namespace drake
 
-namespace pybind11 {
+namespace PYDRAKE_BINDER_NAMESPACE {
 namespace detail {
 
 template <>
@@ -155,4 +155,4 @@ struct type_caster<drake::pydrake::Object>
           drake::pydrake::internal::wrapper_pydrake_object> {};
 
 }  // namespace detail
-}  // namespace pybind11
+}  // namespace PYDRAKE_BINDER_NAMESPACE

bindings/pydrake/common/cpp_template.py

@@ -439,14 +439,22 @@ def _rename_callable(f, scope, name, cls=None):
         qualname = cls.__qualname__ + "." + name
     else:
         qualname = name
+
     # If Python2, we have to wrap instancemethods + built-in functions to spoof
     # the metadata.
-    type_requires_wrap = (
-        types.MethodType,
-        types.BuiltinMethodType,
-        types.BuiltinFunctionType,
-    )
-    if isinstance(f, type_requires_wrap):
+    def needs_wrap(f):
+        type_requires_wrap = (
+            types.MethodType,
+            types.BuiltinMethodType,
+            types.BuiltinFunctionType,
+        )
+        return (
+            isinstance(f, type_requires_wrap)
+            or "nb_method" in f.__class__.__name__
+            or "nb_func" in f.__class__.__name__
+        )
+
+    if needs_wrap(f):
         orig = f
 
         def f(*args, **kwargs):

bindings/pydrake/common/cpp_template_pybind.h

@@ -23,6 +23,7 @@ inline py::object GetOrInitTemplate(  // BR
     py::tuple args = py::tuple(), py::dict kwargs = py::dict()) {
   const char module_name[] = "pydrake.common.cpp_template";
   py::handle m = py::module_::import_(module_name);
+  py::gil_scoped_acquire guard;
   return m.attr("get_or_init")(
       scope, name, m.attr(template_cls_name.c_str()), *args, **kwargs);
 }
@@ -153,7 +154,12 @@ py::object AddTemplateMethod(  // BR
   const std::string instantiation_name =
       internal::GetInstantiationName(py_template, param, mangle);
   py::object py_func = py::cpp_function(std::forward<Method>(method),
-      py::name(instantiation_name.c_str()), py::is_method(scope),
+      py::name(instantiation_name.c_str()),
+#ifdef PYDRAKE_USE_PYBIND11
+      py::is_method(scope),
+#else  // PYDRAKE_USE_NANOBIND
+      py::is_method(),
+#endif
       std::forward<Extra>(extra)...);
   internal::AddInstantiation(py_template, py_func, param);
   return py_template;

bindings/pydrake/common/deprecation_pybind.h

@@ -11,6 +11,7 @@
 
 #include "drake/bindings/pydrake/common/wrap_function.h"
 #include "drake/bindings/pydrake/pydrake_pybind.h"
+#include "drake/common/drake_export.h"
 
 namespace drake {
 namespace pydrake {
@@ -79,26 +80,76 @@ auto WrapDeprecated(std::string message, Func&& func) {
       internal::infer_function_info(std::forward<Func>(func)));
 }
 
+#ifdef PYDRAKE_USE_NANOBIND
+namespace internal {
+
+/// Deprecated wrapping of `py::init<>`.
+template <typename CppClass, typename... Args>
+struct DRAKE_NO_EXPORT PyInitDeprecatedCtorImpl
+    : py::def_visitor<PyInitDeprecatedCtorImpl<CppClass, Args...>> {
+  explicit PyInitDeprecatedCtorImpl(std::string message)
+      : message_(std::move(message)) {}
+  template <typename Class, typename... Extra>
+  void execute(Class& cl, const Extra&...) {
+    cl.def("__init__",
+        [message = std::move(message_)](CppClass* self, Args... args) {
+          WarnDeprecated(message);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+          new (self) CppClass(std::forward<Args>(args)...);
+#pragma GCC diagnostic pop
+        });
+  }
+  std::string message_;
+};
+
+/// Deprecated wrapping of `py::init(placement-new-callable)`.
+template <typename Func>
+struct PyInitDeprecatedCustomImpl
+    : py::def_visitor<PyInitDeprecatedCustomImpl<Func>> {
+  PyInitDeprecatedCustomImpl(std::string message, Func&& func)
+      : message_(std::move(message)), func_(std::forward<Func>(func)) {}
+  template <typename Class, typename... Extra>
+  void execute(Class& cl, const Extra&...) {
+    cl.def("__init__",
+        WrapDeprecated(std::move(message_), std::forward<Func>(func_)));
+  }
+  std::string message_;
+  Func&& func_;
+};
+
+}  // namespace internal
+#endif  // PYDRAKE_USE_NANOBIND
+
 /// Deprecated wrapping of `py::init<>`.
 /// @note Only for `unique_ptr` holders. If using `shared_ptr`, talk to Eric.
 template <typename Class, typename... Args>
 auto py_init_deprecated(std::string message) {
   // N.B. For simplicity, require that Class be passed up front, rather than
   // trying to figure out how to pipe code into / mock `py::detail::initimpl`
   // classes.
+#ifdef PYDRAKE_USE_PYBIND11
   return py::init([message = std::move(message)](Args... args) {
     WarnDeprecated(message);
     return std::make_unique<Class>(std::forward<Args>(args)...);
   });
+#else  // PYDRAKE_USE_NANOBIND
+  return internal::PyInitDeprecatedCtorImpl<Class, Args...>(message);
+#endif
 }
 
 /// Deprecated wrapping of `py::init(factory)`.
 template <typename Func>
 auto py_init_deprecated(std::string message, Func&& func) {
+#ifdef PYDRAKE_USE_PYBIND11
   return py::init(WrapDeprecated(std::move(message), std::forward<Func>(func)));
+#else  // PYDRAKE_USE_NANOBIND
+  return internal::PyInitDeprecatedCustomImpl<Func>(message, std::move(func));
+#endif
 }
 
 /// The deprecated flavor of ParamInit<>.
+#ifdef PYDRAKE_USE_PYBIND11
 template <typename Class>
 auto DeprecatedParamInit(std::string message) {
   return py::init(WrapDeprecated(std::move(message), [](py::kwargs kwargs) {
@@ -113,6 +164,26 @@ auto DeprecatedParamInit(std::string message) {
     return obj;
   }));
 }
+#else   // PYDRAKE_USE_NANOBIND
+template <typename CppClass>
+struct DRAKE_NO_EXPORT DeprecatedParamInit
+    : py::def_visitor<DeprecatedParamInit<CppClass>> {
+  explicit DeprecatedParamInit(std::string message)
+      : message_(std::move(message)) {}
+  template <typename Class, typename... Extra>
+  void execute(Class& cl, const Extra&...) {
+    cl.def("__init__", WrapDeprecated(std::move(message_),
+                           [](CppClass* self, py::kwargs kwargs) {
+                             new (self) Class();
+                             py::object py_obj =
+                                 py::cast(self, py_rvp::reference);
+                             py::module_::import_("pydrake").attr(
+                                 "_setattr_kwargs")(py_obj, kwargs);
+                           }));
+  }
+  std::string message_;
+};
+#endif  // PYDRAKE_USE_PYBIND11
 
 }  // namespace pydrake
 }  // namespace drake

bindings/pydrake/common/eigen_geometry_py.cc

@@ -177,7 +177,7 @@ void DoScalarDependentDefinitions(py::module_ m, T) {
         .def(
             "multiply",
             [](const Class& self, const Class& other) { return self * other; },
-            py::arg("other"), "RigidTransform multiplication")
+            py::arg("other").noconvert(), "RigidTransform multiplication")
         .def(
             "multiply",
             [](const Class& self, const Vector3<T>& position) {