From fc4a5592d65207f5f64e2e94c35cbc43d2e6f42c Mon Sep 17 00:00:00 2001
From: Ken Museth <ken.museth@gmail.com>
Date: Fri, 27 Oct 2023 18:34:03 -0700
Subject: [PATCH] Cleanup several aspects of the Python bindings (copy of PR
 #1696) (#1696)

Signed-off-by: Ken Museth <ken.museth@gmail.com>
---
 openvdb/openvdb/python/pyGrid.h           |  50 +--
 openvdb/openvdb/python/pyGridBase.cc      |   8 +-
 openvdb/openvdb/python/pyOpenVDBModule.cc |  72 ---
 openvdb/openvdb/python/pyTransform.cc     |  19 +-
 openvdb/openvdb/python/pyTypeCasters.h    | 516 ++++++++++++++++++----
 openvdb/openvdb/python/pyutil.h           |  12 +-
 6 files changed, 462 insertions(+), 215 deletions(-)

diff --git a/openvdb/openvdb/python/pyGrid.h b/openvdb/openvdb/python/pyGrid.h
index 55d96c2622..9249eaf6d2 100644
--- a/openvdb/openvdb/python/pyGrid.h
+++ b/openvdb/openvdb/python/pyGrid.h
@@ -68,7 +68,7 @@ inline bool
 sharesWith(const GridType& grid, py::object other)
 {
     if (py::isinstance<GridType>(other)) {
-        typename GridType::ConstPtr otherGrid = other.cast<typename GridType::Ptr>();
+        typename GridType::ConstPtr otherGrid = py::cast<typename GridType::Ptr>(other);
         return (&otherGrid->tree() == &grid.tree());
     }
     return false;
@@ -893,7 +893,7 @@ applyMap(const char* methodName, GridType& grid, py::object funcObj)
 
         // Verify that the result is of type GridType::ValueType.
         try {
-            result.cast<ValueT>();
+            py::cast<ValueT>(result);
         } catch (py::cast_error&) {
             std::ostringstream os;
             os << "expected callable argument to ";
@@ -904,7 +904,7 @@ applyMap(const char* methodName, GridType& grid, py::object funcObj)
             throw py::type_error(os.str());
         }
 
-        it.setValue(result.cast<ValueT>());
+        it.setValue(py::cast<ValueT>(result));
     }
 }
 
@@ -955,7 +955,7 @@ struct TreeCombineOp
             throw py::type_error(os.str());
         }
 
-        result = resultObj.cast<ValueT>();
+        result = py::cast<ValueT>(resultObj);
     }
     py::function op;
 };
@@ -1177,7 +1177,7 @@ class IterValueProxy
     py::object getItem(py::object keyObj) const
     {
         if (py::isinstance<std::string>(keyObj)) {
-            const std::string key = keyObj.cast<std::string>();
+            const std::string key = py::cast<std::string>(keyObj);
             if (key == "value") return py::cast(this->getValue());
             else if (key == "active") return py::cast(this->getActive());
             else if (key == "depth") return py::cast(this->getDepth());
@@ -1185,7 +1185,7 @@ class IterValueProxy
             else if (key == "max") return py::cast(this->getBBoxMax());
             else if (key == "count") return py::cast(this->getVoxelCount());
         }
-        throw py::key_error(keyObj.attr("__repr__")().cast<std::string>());
+        throw py::key_error(py::cast<std::string>(keyObj.attr("__repr__")()));
         return py::object();
     }
 
@@ -1195,20 +1195,20 @@ class IterValueProxy
     void setItem(py::object keyObj, py::object valObj)
     {
         if (py::isinstance<std::string>(keyObj)) {
-            const std::string key = keyObj.cast<std::string>();
+            const std::string key = py::cast<std::string>(keyObj);
             if (key == "value") {
-                this->setValue(valObj.cast<ValueT>()); return;
+                this->setValue(py::cast<ValueT>(valObj)); return;
             } else if (key == "active") {
-                this->setActive(valObj.cast<bool>()); return;
+                this->setActive(py::cast<bool>(valObj)); return;
             } else if (this->hasKey(key)) {
                 std::ostringstream os;
                 os << "can't set attribute '";
-                os << keyObj.attr("__repr__")().cast<std::string>();
+                os << py::cast<std::string>(keyObj.attr("__repr__")());
                 os << "'";
                 throw py::attribute_error(os.str());
             }
         }
-        throw py::key_error(keyObj.attr("__repr__")().cast<std::string>());
+        throw py::key_error(py::cast<std::string>(keyObj.attr("__repr__")()));
     }
 
     bool operator==(const IterValueProxy& other) const
@@ -1235,7 +1235,7 @@ class IterValueProxy
         }
         // print ", ".join(valuesAsStrings)
         py::object joined = py::str(", ").attr("join")(valuesAsStrings);
-        std::string s = joined.cast<std::string>();
+        std::string s = py::cast<std::string>(joined);
         os << "{" << s << "}";
         return os;
     }
@@ -1379,13 +1379,9 @@ struct PickleSuite
         }
 
         // Construct a state tuple for the serialized Grid.
-#if PY_MAJOR_VERSION >= 3
         // Convert the byte string to a "bytes" sequence.
         const std::string s = ostr.str();
         py::bytes bytesObj(s);
-#else
-        py::str bytesObj(ostr.str());
-#endif
         return py::make_tuple(bytesObj);
     }
 
@@ -1397,25 +1393,16 @@ struct PickleSuite
         std::string serialized;
         if (!badState) {
             // Extract the sequence containing the serialized Grid.
-#if PY_MAJOR_VERSION >= 3
             if (py::isinstance<py::bytes>(state[0]))
-                serialized = state[0].cast<py::bytes>();
-#else
-            if (py::isinstance<std::string>(state[0]))
-                serialized = state[0].cast<std::string>();
-#endif
+                serialized = py::cast<py::bytes>(state[0]);
             else
                 badState = true;
         }
 
         if (badState) {
             std::ostringstream os;
-#if PY_MAJOR_VERSION >= 3
             os << "expected (dict, bytes) tuple in call to __setstate__; found ";
-#else
-            os << "expected (dict, str) tuple in call to __setstate__; found ";
-#endif
-            os << state.attr("__repr__")().cast<std::string>();
+            os << py::cast<std::string>(state.attr("__repr__")());
             throw py::value_error(os.str());
         }
 
@@ -1457,14 +1444,15 @@ exportGrid(py::module_ m)
     using ValueAllIterT = typename GridType::ValueAllIter;
 
     const std::string pyGridTypeName = Traits::name();
-    const std::string defaultCtorDescr = "Initialize with a background value of "
-        + pyutil::str(pyGrid::getZeroValue<GridType>()) + ".";
+    std::stringstream docstream;
+    docstream << "Initialize with a background value of " << pyGrid::getZeroValue<GridType>() << ".";
+    std::string docstring = docstream.str();
 
     // Define the Grid wrapper class and make it the current scope.
     py::class_<GridType, GridPtr, GridBase>(m,
         /*classname=*/pyGridTypeName.c_str(),
         /*docstring=*/(Traits::descr()).c_str())
-        .def(py::init<>(), defaultCtorDescr.c_str())
+        .def(py::init<>(), docstring.c_str())
         .def(py::init<const ValueT&>(), py::arg("background"),
             "Initialize with the given background value.")
 
@@ -1711,7 +1699,7 @@ exportGrid(py::module_ m)
     IterWrap<GridType, ValueAllIterT>::wrap(m);
 
     // Add the Python type object for this grid type to the module-level list.
-    m.attr("GridTypes").cast<py::list>().append(m.attr(pyGridTypeName.c_str()));
+    py::cast<py::list>(m.attr("GridTypes")).append(m.attr(pyGridTypeName.c_str()));
 }
 
 } // namespace pyGrid
diff --git a/openvdb/openvdb/python/pyGridBase.cc b/openvdb/openvdb/python/pyGridBase.cc
index 19fa054dc6..0e10a58381 100644
--- a/openvdb/openvdb/python/pyGridBase.cc
+++ b/openvdb/openvdb/python/pyGridBase.cc
@@ -100,12 +100,8 @@ exportGridBase(py::module_ m)
 
 
     auto getMetadataKeys = [](GridBase::ConstPtr grid) {
-#if PY_MAJOR_VERSION >= 3
         // Return an iterator over the "keys" view of a dict.
         return py::make_key_iterator(static_cast<const MetaMap&>(*grid).beginMeta(), static_cast<const MetaMap&>(*grid).endMeta());
-#else
-        return py::dict(py::cast(static_cast<const MetaMap&>(*grid))).iterkeys();
-#endif
     };
 
 
@@ -118,7 +114,7 @@ exportGridBase(py::module_ m)
         MetaMap metamap;
         metamap.insertMeta(name, *metadata);
         // todo: Add/refactor out type_casters for each TypedMetadata from MetaMap's type_caster
-        return py::dict(py::cast(metamap))[py::str(name)].cast<py::object>();
+        return py::cast<py::object>(py::dict(py::cast(metamap))[py::str(name)]);
     };
 
 
@@ -135,7 +131,7 @@ exportGridBase(py::module_ m)
         // todo: Add/refactor out type_casters for each TypedMetadata from MetaMap's type_caster
         py::dict dictObj;
         dictObj[py::str(name)] = value;
-        MetaMap metamap = dictObj.cast<MetaMap>();
+        MetaMap metamap = py::cast<MetaMap>(dictObj);
 
         if (Metadata::Ptr metadata = metamap[name]) {
             grid->removeMeta(name);
diff --git a/openvdb/openvdb/python/pyOpenVDBModule.cc b/openvdb/openvdb/python/pyOpenVDBModule.cc
index 37dd42287f..ed6754ac56 100644
--- a/openvdb/openvdb/python/pyOpenVDBModule.cc
+++ b/openvdb/openvdb/python/pyOpenVDBModule.cc
@@ -371,78 +371,6 @@ PYBIND11_MODULE(PY_OPENVDB_MODULE_NAME, m)
 
 #undef PYOPENVDB_TRANSLATE_EXCEPTION
 
-    // Basic bindings for these Vec types are required to support them as
-    // default arguments to functions.
-    py::class_<openvdb::Coord>(m, "Coord")
-        .def(py::init<>())
-        .def(py::init<openvdb::Coord::Int32>())
-        .def(py::init<openvdb::Coord::Int32, openvdb::Coord::Int32, openvdb::Coord::Int32>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec2i>(m, "Vec2i")
-        .def(py::init<>())
-        .def(py::init<int32_t>())
-        .def(py::init<int32_t, int32_t>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec2f>(m, "Vec2f")
-        .def(py::init<>())
-        .def(py::init<float>())
-        .def(py::init<float, float>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec2d>(m, "Vec2d")
-        .def(py::init<>())
-        .def(py::init<double>())
-        .def(py::init<double, double>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec3i>(m, "Vec3i")
-        .def(py::init<>())
-        .def(py::init<int32_t>())
-        .def(py::init<int32_t, int32_t, int32_t>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec3f>(m, "Vec3f")
-        .def(py::init<>())
-        .def(py::init<float>())
-        .def(py::init<float, float, float>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec3d>(m, "Vec3d")
-        .def(py::init<>())
-        .def(py::init<double>())
-        .def(py::init<double, double, double>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec4i>(m, "Vec4i")
-        .def(py::init<>())
-        .def(py::init<int32_t>())
-        .def(py::init<int32_t, int32_t, int32_t, int32_t>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec4f>(m, "Vec4f")
-        .def(py::init<>())
-        .def(py::init<float>())
-        .def(py::init<float, float, float, float>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<openvdb::Vec4d>(m, "Vec4d")
-        .def(py::init<>())
-        .def(py::init<double>())
-        .def(py::init<double, double, double, double>())
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
     py::class_<openvdb::PointDataIndex32>(m, "PointDataIndex32")
         .def(py::init<openvdb::Index32>(), py::arg("i") = openvdb::Index32(0));
 
diff --git a/openvdb/openvdb/python/pyTransform.cc b/openvdb/openvdb/python/pyTransform.cc
index c335e60dcf..b5116dfaef 100644
--- a/openvdb/openvdb/python/pyTransform.cc
+++ b/openvdb/openvdb/python/pyTransform.cc
@@ -99,12 +99,8 @@ struct PickleSuite
 
         // Construct a state tuple comprising the version numbers of
         // the serialization format and the serialized Transform.
-#if PY_MAJOR_VERSION >= 3
         // Convert the byte string to a "bytes" sequence.
         py::bytes bytesObj(ostr.str());
-#else
-        py::str bytesObj(ostr.str());
-#endif
         return py::make_tuple(
             uint32_t(OPENVDB_LIBRARY_MAJOR_VERSION),
             uint32_t(OPENVDB_LIBRARY_MINOR_VERSION),
@@ -125,7 +121,7 @@ struct PickleSuite
             uint32_t version[3] = { 0, 0, 0 };
             for (int i = 0; i < 3 && !badState; ++i) {
                 if (py::isinstance<py::int_>(state[idx[i]]))
-                    version[i] = state[idx[i]].cast<uint32_t>();
+                    version[i] = py::cast<uint32_t>(state[idx[i]]);
                 else badState = true;
             }
             libVersion.first = version[0];
@@ -137,24 +133,15 @@ struct PickleSuite
         if (!badState) {
             // Extract the sequence containing the serialized Transform.
             py::object bytesObj = state[int(STATE_XFORM)];
-#if PY_MAJOR_VERSION >= 3
             if (py::isinstance<py::bytes>(bytesObj))
-                serialized = bytesObj.cast<py::bytes>();
-#else
-            if (py::isinstance<std::string>(bytesObj))
-                serialized = bytesObj.cast<std::string>();
-#endif
+                serialized = py::cast<py::bytes>(bytesObj);
             else badState = true;
         }
 
         if (badState) {
             std::ostringstream os;
-#if PY_MAJOR_VERSION >= 3
             os << "expected (int, int, int, bytes) tuple in call to __setstate__; found ";
-#else
-            os << "expected (int, int, int, str) tuple in call to __setstate__; found ";
-#endif
-            os << state.attr("__repr__")().cast<std::string>();
+            os << py::cast<std::string>(state.attr("__repr__")());
             throw py::value_error(os.str());
         }
 
diff --git a/openvdb/openvdb/python/pyTypeCasters.h b/openvdb/openvdb/python/pyTypeCasters.h
index ea176b4f96..b30af05c6a 100644
--- a/openvdb/openvdb/python/pyTypeCasters.h
+++ b/openvdb/openvdb/python/pyTypeCasters.h
@@ -633,11 +633,7 @@ namespace pybind11 { namespace detail {
             PyObject* source = src.ptr();
             PyObject* number = PyNumber_Long(source);
             if (number) {
-#if PY_MAJOR_VERSION >= 3
                 value = static_cast<typename openvdb::PointIndex32::IntType>(PyLong_AsLong(number));
-#else
-                value = static_cast<typename openvdb::PointIndex32::IntType>(PyInt_AsLong(number));
-#endif
             }
             Py_XDECREF(number);
 
@@ -661,11 +657,7 @@ namespace pybind11 { namespace detail {
             PyObject* source = src.ptr();
             PyObject* number = PyNumber_Long(source);
             if (number) {
-#if PY_MAJOR_VERSION >= 3
                 value = static_cast<typename openvdb::PointIndex64::IntType>(PyLong_AsLong(number));
-#else
-                value = static_cast<typename openvdb::PointIndex64::IntType>(PyInt_AsLong(number));
-#endif
             }
             Py_XDECREF(number);
 
@@ -681,44 +673,393 @@ namespace pybind11 { namespace detail {
         }
     };
 
-    template <> struct type_caster<openvdb::MetaMap> {
+    template <> struct type_caster<openvdb::PointDataIndex32> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::PointDataIndex32, const_name("openvdb::PointDataIndex32"));
+
+        bool load(handle src, bool) {
+            PyObject* source = src.ptr();
+            PyObject* number = PyNumber_Long(source);
+            if (number) {
+                value = static_cast<typename openvdb::PointDataIndex32::IntType>(PyLong_AsLong(number));
+            }
+            Py_XDECREF(number);
+
+            if (PyErr_Occurred())
+                return false;
+
+            return true;
+        }
+
+        static handle cast(openvdb::PointDataIndex32 src, return_value_policy, handle) {
+            py::int_ integer(static_cast<openvdb::PointDataIndex32::IntType>(src));
+            return integer.release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::PointDataIndex64> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::PointDataIndex64, const_name("openvdb::PointDataIndex64"));
+
+        bool load(handle src, bool) {
+            PyObject* source = src.ptr();
+            PyObject* number = PyNumber_Long(source);
+            if (number) {
+                value = static_cast<typename openvdb::PointDataIndex64::IntType>(PyLong_AsLong(number));
+            }
+            Py_XDECREF(number);
+
+            if (PyErr_Occurred())
+                return false;
+
+            return true;
+        }
+
+        static handle cast(openvdb::PointDataIndex64 src, return_value_policy, handle) {
+            py::int_ integer(static_cast<openvdb::PointDataIndex64::IntType>(src));
+            return integer.release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::StringMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::StringMetadata, _("openvdb::StringMetadata"));
+
+        bool load(handle src, bool) {
+            if (!py::isinstance<py::str>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<std::string>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::StringMetadata src, return_value_policy, handle) {
+            return py::str(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::BoolMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::BoolMetadata, _("openvdb::BoolMetadata"));
+
+        bool load(handle src, bool) {
+            if (!py::isinstance<py::bool_>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<bool>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::BoolMetadata src, return_value_policy, handle) {
+            return py::bool_(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::Int32Metadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Int32Metadata, _("openvdb::Int32Metadata"));
+
+        bool load(handle src, bool) {
+            if (!py::isinstance<py::int_>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<openvdb::Int32>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::Int32Metadata src, return_value_policy, handle) {
+            return py::int_(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::Int64Metadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Int64Metadata, _("openvdb::Int64Metadata"));
+
+        bool load(handle src, bool) {
+            if (!py::isinstance<py::int_>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<openvdb::Int64>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::Int64Metadata src, return_value_policy, handle) {
+            return py::int_(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::FloatMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::FloatMetadata, _("openvdb::FloatMetadata"));
+
+        bool load(handle src, bool) {
+            if (!py::isinstance<py::float_>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<float>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::FloatMetadata src, return_value_policy, handle) {
+            return py::float_(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::DoubleMetadata> {
     public:
-        PYBIND11_TYPE_CASTER(openvdb::MetaMap, _("openvdb::Metamap"));
+        PYBIND11_TYPE_CASTER(openvdb::DoubleMetadata, _("openvdb::DoubleMetadata"));
 
         bool load(handle src, bool) {
+            if (!py::isinstance<py::float_>(src)) {
+                return false;
+            }
+
+            value.setValue(py::cast<double>(src));
+            return true;
+        }
+
+        static handle cast(openvdb::DoubleMetadata src, return_value_policy, handle) {
+            return py::float_(src.value()).release();
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec2IMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec2IMetadata, _("openvdb::Vec2IMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec2i> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec2i&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec2IMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec2i>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec3IMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec3IMetadata, _("openvdb::Vec3IMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec3i> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec3i&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec3IMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec3i>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec4IMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec4IMetadata, _("openvdb::Vec4IMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec4i> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec4i&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec4IMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec4i>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec2DMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec2DMetadata, _("openvdb::Vec2DMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec2d> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec2d&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec2DMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec2d>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec3DMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec3DMetadata, _("openvdb::Vec3DMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec3d> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec3d&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec3DMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec3d>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Vec4DMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Vec4DMetadata, _("openvdb::Vec4DMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::tuple>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Vec4d> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Vec4d&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Vec4DMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Vec4d>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Mat4SMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Mat4SMetadata, _("openvdb::Mat4SMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::list>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Mat4s> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Mat4s&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Mat4SMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Mat4s>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::Mat4DMetadata> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::Mat4DMetadata, _("openvdb::Mat4DMetadata"));
+
+        bool load(handle src, bool convert) {
+            if (!py::isinstance<py::list>(src)) {
+                return false;
+            }
+
+            make_caster<openvdb::Mat4d> conv;
+            if (!conv.load(src, convert))
+                return false;
+
+            value.setValue(cast_op<openvdb::Mat4d&&>(std::move(conv)));
+            return true;
+        }
+
+        static handle cast(openvdb::Mat4DMetadata src, return_value_policy policy, handle parent) {
+            return make_caster<openvdb::Mat4d>::cast(src.value(), policy, parent);
+        }
+    };
+
+    template <> struct type_caster<openvdb::MetaMap> {
+    public:
+        PYBIND11_TYPE_CASTER(openvdb::MetaMap, _("openvdb::MetaMap"));
+
+        bool load(handle src, bool convert) {
             py::dict dictionary = py::reinterpret_borrow<py::dict>(src);
-            for (auto item : dictionary) {
+            for (auto [key, val] : dictionary) {
                 std::string name;
-                py::object key = py::reinterpret_borrow<py::object>(item.first);
                 if (py::isinstance<py::str>(key)) {
-                    name = key.cast<std::string>();
+                    name = py::cast<std::string>(key);
                 } else {
                     throw py::type_error("Expected string as metadata name");
                 }
 
-                openvdb::Metadata::Ptr metadata;
                 // Note: the order of the following tests is significant, as it
                 // avoids unnecessary type promotion (e.g., of ints to doubles).
                 // Python does not natively support single precision and therefore
                 // all floating point metadata is promoted to doubles.
-                py::object val = py::reinterpret_borrow<py::object>(item.second);
 
+                bool success = false;
                 if (py::isinstance<py::str>(val)) {
-                    metadata.reset(new openvdb::StringMetadata(val.cast<std::string>()));
+                    make_caster<openvdb::StringMetadata> conv;
+                    if(conv.load(val, convert)) {
+                        value.insertMeta(name, cast_op<openvdb::StringMetadata&&>(std::move(conv)));
+                        success = true;
+                    }
                 } else if (py::isinstance<py::bool_>(val)) {
-                    metadata.reset(new openvdb::BoolMetadata(val.cast<bool>()));
+                    make_caster<openvdb::BoolMetadata> conv;
+                    if(conv.load(val, convert)) {
+                        value.insertMeta(name, cast_op<openvdb::BoolMetadata&&>(std::move(conv)));
+                        success = true;
+                    }
                 } else if (py::isinstance<py::int_>(val)) {
-                    const openvdb::Int64 n = val.cast<openvdb::Int64>();
-                    if (n <= std::numeric_limits<openvdb::Int32>::max()
-                        && n >= std::numeric_limits<openvdb::Int32>::min()) {
-                        metadata.reset(new openvdb::Int32Metadata(static_cast<openvdb::Int32>(n)));
+                    const openvdb::Int64 n = py::cast<openvdb::Int64>(val);
+                    if (n <= std::numeric_limits<openvdb::Int32>::max() && n >= std::numeric_limits<openvdb::Int32>::min()) {
+                        make_caster<openvdb::Int32Metadata> conv;
+                        if(conv.load(val, convert)) {
+                            value.insertMeta(name, cast_op<openvdb::Int32Metadata&&>(std::move(conv)));
+                            success = true;
+                        }
                     } else {
-                        metadata.reset(new openvdb::Int64Metadata(n));
+                        make_caster<openvdb::Int64Metadata> conv;
+                        if(conv.load(val, convert)) {
+                            value.insertMeta(name, cast_op<openvdb::Int64Metadata&&>(std::move(conv)));
+                            success = true;
+                        }
                     }
                 } else if (py::isinstance<py::float_>(val)) {
-                    metadata.reset(new openvdb::DoubleMetadata(val.cast<double>()));
+                    make_caster<openvdb::DoubleMetadata> conv;
+                    if(conv.load(val, convert)) {
+                        value.insertMeta(name, cast_op<openvdb::DoubleMetadata&&>(std::move(conv)));
+                        success = true;
+                    }
                 } else if (py::isinstance<py::tuple>(val)) {
-                    py::tuple t = val.cast<py::tuple>();
+                    py::tuple t = py::cast<py::tuple>(val);
                     size_t size = t.size();
                     bool isIntegerTuple = true;
                     for (size_t i = 0; i < size; ++i) {
@@ -727,110 +1068,127 @@ namespace pybind11 { namespace detail {
 
                     if (isIntegerTuple) {
                         switch(size) {
-                            case 2:
-                                metadata.reset(new openvdb::Vec2IMetadata(t.cast<openvdb::Vec2i>()));
+                            case 2: {
+                                make_caster<openvdb::Vec2IMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec2IMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
-                            case 3:
-                                metadata.reset(new openvdb::Vec3IMetadata(t.cast<openvdb::Vec3i>()));
+                                }
+                            case 3: {
+                                make_caster<openvdb::Vec3IMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec3IMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
-                            case 4:
-                                metadata.reset(new openvdb::Vec4IMetadata(t.cast<openvdb::Vec4i>()));
+                                }
+                            case 4: {
+                                make_caster<openvdb::Vec4IMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec4IMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
+                                }
                             default:
                                 break;
                         }
                     } else {
                         switch(size) {
-                            case 2:
-                                metadata.reset(new openvdb::Vec2DMetadata(t.cast<openvdb::Vec2d>()));
+                            case 2: {
+                                make_caster<openvdb::Vec2DMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec2DMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
-                            case 3:
-                                metadata.reset(new openvdb::Vec3DMetadata(t.cast<openvdb::Vec3d>()));
+                                }
+                            case 3: {
+                                make_caster<openvdb::Vec3DMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec3DMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
-                            case 4:
-                                metadata.reset(new openvdb::Vec4DMetadata(t.cast<openvdb::Vec4d>()));
+                                }
+                            case 4: {
+                                make_caster<openvdb::Vec4DMetadata> conv;
+                                if (conv.load(val, convert)) {
+                                    value.insertMeta(name, cast_op<openvdb::Vec4DMetadata&&>(std::move(conv)));
+                                    success = true;
+                                }
                                 break;
+                                }
                             default:
                                 break;
                         }
                     }
                 } else if (py::isinstance<py::list>(val)) {
-                    py::list list = val.cast<py::list>();
-                    bool valid = (list.size() == 4);
-                    if (valid) {
-                        for (size_t i = 0; i < list.size(); ++i) {
-                            valid &= py::isinstance<py::list>(list[i]);
-                            if (valid) {
-                                py::list sublist = list[i].cast<py::list>();
-                                valid &= (sublist.size() == 4);
-                                if (valid) {
-                                    for (size_t j = 0; j < sublist.size(); ++j) {
-                                        valid &= (py::isinstance<py::float_>(sublist[j]) || py::isinstance<py::int_>(sublist[j]));
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (valid) {
-                        metadata.reset(new openvdb::Mat4DMetadata(val.cast<openvdb::Mat4d>()));
+                    make_caster<openvdb::Mat4DMetadata> conv;
+                    if (conv.load(val, convert)) {
+                        value.insertMeta(name, cast_op<openvdb::Mat4DMetadata&&>(std::move(conv)));
+                        success = true;
                     }
                 } else if (py::isinstance<openvdb::Metadata::Ptr>(val)) {
-                    metadata = val.cast<openvdb::Metadata::Ptr>();
+                    openvdb::Metadata::Ptr metadata = py::cast<openvdb::Metadata::Ptr>(val);
+                    if (metadata) {
+                        value.insertMeta(name, *metadata);
+                    }
+
                 }
 
-                if (metadata) {
-                    value.insertMeta(name, *metadata);
-                } else {
-                    const std::string valAsStr = (val.attr("__str__")()).cast<std::string>();
-                    const std::string valType = val.attr("__class__").attr("__name__").cast<std::string>();
+                if (!success) {
+                    const std::string valAsStr = py::cast<std::string>(val.attr("__str__")());
+                    const std::string valType = py::cast<std::string>(val.attr("__class__").attr("__name__"));
                     throw py::type_error(std::string("metadata value " + valAsStr + " of type " + valType + " is not allowed"));
                 }
-
             }
 
             return true;
         }
 
-        static handle cast(openvdb::MetaMap src, return_value_policy, handle) {
+        static handle cast(openvdb::MetaMap src, return_value_policy policy, handle parent) {
             py::dict dict;
             for (openvdb::MetaMap::ConstMetaIterator it = src.beginMeta(); it != src.endMeta(); ++it) {
                 if (openvdb::Metadata::Ptr meta = it->second) {
                     py::object obj(py::cast(meta));
                     const std::string typeName = meta->typeName();
                     if (typeName == openvdb::StringMetadata::staticTypeName()) {
-                        obj = py::str(static_cast<openvdb::StringMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::StringMetadata>::cast(static_cast<openvdb::StringMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::DoubleMetadata::staticTypeName()) {
-                        obj = py::float_(static_cast<openvdb::DoubleMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::DoubleMetadata>::cast(static_cast<openvdb::DoubleMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::FloatMetadata::staticTypeName()) {
-                        obj = py::float_(static_cast<openvdb::FloatMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::FloatMetadata>::cast(static_cast<openvdb::FloatMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Int32Metadata::staticTypeName()) {
-                        obj = py::int_(static_cast<openvdb::Int32Metadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Int32Metadata>::cast(static_cast<openvdb::Int32Metadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Int64Metadata::staticTypeName()) {
-                        obj = py::int_(static_cast<openvdb::Int64Metadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Int64Metadata>::cast(static_cast<openvdb::Int64Metadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::BoolMetadata::staticTypeName()) {
-                        obj = py::bool_(static_cast<openvdb::BoolMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::BoolMetadata>::cast(static_cast<openvdb::BoolMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec2DMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec2DMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec2DMetadata>::cast(static_cast<openvdb::Vec2DMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec2IMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec2IMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec2IMetadata>::cast(static_cast<openvdb::Vec2IMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec2SMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec2SMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec2SMetadata>::cast(static_cast<openvdb::Vec2SMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec3DMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec3DMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec3DMetadata>::cast(static_cast<openvdb::Vec3DMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec3IMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec3IMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec3IMetadata>::cast(static_cast<openvdb::Vec3IMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec3SMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec3SMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec3SMetadata>::cast(static_cast<openvdb::Vec3SMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec4DMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec4DMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec4DMetadata>::cast(static_cast<openvdb::Vec4DMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec4IMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec4IMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec4IMetadata>::cast(static_cast<openvdb::Vec4IMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Vec4SMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Vec4SMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Vec4SMetadata>::cast(static_cast<openvdb::Vec4SMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Mat4SMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Mat4SMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Mat4SMetadata>::cast(static_cast<openvdb::Mat4SMetadata&>(*meta), policy, parent));
                     } else if (typeName == openvdb::Mat4DMetadata::staticTypeName()) {
-                        obj = py::cast(static_cast<openvdb::Mat4DMetadata&>(*meta).value());
+                        obj = reinterpret_steal<py::object>(make_caster<openvdb::Mat4DMetadata>::cast(static_cast<openvdb::Mat4DMetadata&>(*meta), policy, parent));
                     }
                     dict[py::str(it->first)] = obj;
                 }
diff --git a/openvdb/openvdb/python/pyutil.h b/openvdb/openvdb/python/pyutil.h
index 52216666cc..1727e0aace 100644
--- a/openvdb/openvdb/python/pyutil.h
+++ b/openvdb/openvdb/python/pyutil.h
@@ -163,21 +163,11 @@ struct StringEnum
 
 ////////////////////////////////////////
 
-
-/// Return str(val) for the given value.
-template<typename T>
-inline std::string
-str(const T& val)
-{
-    return py::str(py::cast(val));
-}
-
-
 /// Return the name of the given Python object's class.
 inline std::string
 className(py::handle h)
 {
-    return h.attr("__class__").attr("__name__").cast<std::string>();
+    return py::cast<std::string>(h.attr("__class__").attr("__name__"));
 }
 
 } // namespace pyutil