nanobind: DuckDBPyType::TryConvert helper to restore implicit type conversion (shared_ptr caster strips convert)

Author: evertlammerts

src/duckdb_py/include/duckdb_python/pytype.hpp

@@ -28,6 +28,13 @@ class DuckDBPyType : public std::enable_shared_from_this<DuckDBPyType> {
 public:
 	static void Initialize(py::handle &m);
 
+	//! Convert a Python object (an existing DuckDBPyType, a type string, a Python type object such as `int`, or a
+	//! dict describing a struct) into a DuckDBPyType. nanobind's shared_ptr type caster strips the implicit-convert
+	//! flag, so a plain try_cast<shared_ptr<DuckDBPyType>> no longer triggers DuckDBPyType's registered implicit
+	//! conversion; this routes non-DuckDBPyType objects through the registered Python constructor. Returns false
+	//! (without throwing) when the object can't be converted.
+	static bool TryConvert(const py::object &object, std::shared_ptr<DuckDBPyType> &result);
+
 public:
 	bool Equals(const std::shared_ptr<DuckDBPyType> &other) const;
 	bool EqualsString(const string &type_str) const;

src/duckdb_py/native/python_conversion.cpp

@@ -1,5 +1,6 @@
 #include "duckdb_python/python_conversion.hpp"
 #include "duckdb_python/pybind11/pybind_wrapper.hpp"
+#include "duckdb_python/pytype.hpp"
 
 #include "duckdb_python/pyrelation.hpp"
 #include "duckdb_python/pyconnection/pyconnection.hpp"
@@ -594,9 +595,9 @@ struct PythonValueConversion {
 		case PythonObjectType::Value: {
 			// Extract the internal object and the type from the Value instance
 			auto object = ele.attr("object");
-			auto type = ele.attr("type");
+			py::object type = ele.attr("type");
 			std::shared_ptr<DuckDBPyType> internal_type;
-			if (!py::try_cast<std::shared_ptr<DuckDBPyType>>(type, internal_type)) {
+			if (!DuckDBPyType::TryConvert(type, internal_type)) {
 				string actual_type = py::cast<std::string>(py::str((type).type()));
 				throw InvalidInputException("The 'type' of a Value should be of type DuckDBPyType, not '%s'",
 				                            actual_type);

src/duckdb_py/pyconnection.cpp

@@ -1241,12 +1241,19 @@ std::unique_ptr<DuckDBPyRelation> DuckDBPyConnection::ReadCSV(const py::object &
 			child_list_t<Value> struct_fields;
 			py::dict dtype_dict = py::cast<py::dict>(dtype);
 			for (auto kv : dtype_dict) { // nanobind dict iteration yields std::pair<handle,handle> by value
-				std::shared_ptr<DuckDBPyType> sql_type;
-				if (!py::try_cast(kv.second, sql_type)) {
-					struct_fields.emplace_back(py::cast<std::string>(py::str(kv.first)),
-					                           Value(py::cast<std::string>(py::str(kv.second))));
+				auto key = py::cast<std::string>(py::str(kv.first));
+				auto value_obj = py::borrow<py::object>(kv.second);
+				if (py::isinstance<py::str>(value_obj)) {
+					// A type string -- pass through for DuckDB to parse.
+					struct_fields.emplace_back(key, Value(py::cast<std::string>(value_obj)));
 				} else {
-					struct_fields.emplace_back(py::cast<std::string>(py::str(kv.first)), Value(sql_type->ToString()));
+					// A DuckDBPyType instance, or a Python type object (int/str/...). nanobind's shared_ptr caster
+					// strips the implicit-convert flag, so build the DuckDBPyType via its registered constructor.
+					if (!py::isinstance<DuckDBPyType>(value_obj)) {
+						value_obj = py::type<DuckDBPyType>()(value_obj);
+					}
+					auto sql_type = py::cast<std::shared_ptr<DuckDBPyType>>(value_obj);
+					struct_fields.emplace_back(key, Value(sql_type->ToString()));
 				}
 			}
 			auto dtype_struct = Value::STRUCT(std::move(struct_fields));
@@ -1255,11 +1262,12 @@ std::unique_ptr<DuckDBPyRelation> DuckDBPyConnection::ReadCSV(const py::object &
 			vector<Value> list_values;
 			py::list dtype_list = py::cast<py::list>(dtype);
 			for (auto child : dtype_list) {
+				auto child_obj = py::borrow<py::object>(child);
 				std::shared_ptr<DuckDBPyType> sql_type;
-				if (!py::try_cast(child, sql_type)) {
-					list_values.push_back(Value(py::cast<std::string>(child)));
-				} else {
+				if (!py::isinstance<py::str>(child_obj) && DuckDBPyType::TryConvert(child_obj, sql_type)) {
 					list_values.push_back(sql_type->ToString());
+				} else {
+					list_values.push_back(Value(py::cast<std::string>(py::str(child_obj))));
 				}
 			}
 			bind_parameters["dtypes"] = Value::LIST(LogicalType::VARCHAR, std::move(list_values));

src/duckdb_py/pyconnection/type_creation.cpp

@@ -25,7 +25,7 @@ static child_list_t<LogicalType> GetChildList(const py::object &container) {
 		idx_t i = 1;
 		for (auto item : fields) {
 			std::shared_ptr<DuckDBPyType> pytype;
-			if (!py::try_cast<std::shared_ptr<DuckDBPyType>>(item, pytype)) {
+			if (!DuckDBPyType::TryConvert(py::borrow<py::object>(item), pytype)) {
 				string actual_type = py::cast<std::string>(py::str((item).type()));
 				throw InvalidInputException("object has to be a list of DuckDBPyType's, not '%s'", actual_type);
 			}
@@ -39,7 +39,7 @@ static child_list_t<LogicalType> GetChildList(const py::object &container) {
 			auto type_p = item.second;
 			auto name = Identifier(py::cast<std::string>(name_p));
 			std::shared_ptr<DuckDBPyType> pytype;
-			if (!py::try_cast<std::shared_ptr<DuckDBPyType>>(type_p, pytype)) {
+			if (!DuckDBPyType::TryConvert(py::borrow<py::object>(type_p), pytype)) {
 				string actual_type = py::cast<std::string>(py::str((type_p).type()));
 				throw InvalidInputException("object has to be a list of DuckDBPyType's, not '%s'", actual_type);
 			}

src/duckdb_py/python_udf.cpp

@@ -483,7 +483,7 @@ struct PythonUDFData {
 		auto empty = py::module_::import_("inspect").attr("Signature").attr("empty");
 		if (!py::none().is(return_annotation) && !empty.is(return_annotation)) {
 			std::shared_ptr<DuckDBPyType> pytype;
-			if (py::try_cast<std::shared_ptr<DuckDBPyType>>(return_annotation, pytype)) {
+			if (DuckDBPyType::TryConvert(py::borrow<py::object>(return_annotation), pytype)) {
 				return_type = pytype->Type();
 			}
 		}
@@ -493,7 +493,7 @@ struct PythonUDFData {
 		for (auto item : params) {
 			auto value = item.second;
 			std::shared_ptr<DuckDBPyType> pytype;
-			if (py::try_cast<std::shared_ptr<DuckDBPyType>>(value.attr("annotation"), pytype)) {
+			if (DuckDBPyType::TryConvert(py::borrow<py::object>(value.attr("annotation")), pytype)) {
 				parameters.push_back(pytype->Type());
 			} else {
 				std::string kind = py::cast<std::string>(py::str(value.attr("kind")));

src/duckdb_py/typing/pytype.cpp

@@ -328,6 +328,22 @@ static LogicalType FromObject(const py::object &object) {
 	}
 }
 
+bool DuckDBPyType::TryConvert(const py::object &object, std::shared_ptr<DuckDBPyType> &result) {
+	if (py::isinstance<DuckDBPyType>(object)) {
+		result = py::cast<std::shared_ptr<DuckDBPyType>>(object);
+		return true;
+	}
+	try {
+		// Construct via the registered DuckDBPyType type (DuckDBPyType(object)); this hits the same factories
+		// that drive the implicit conversion, which nanobind's shared_ptr caster otherwise bypasses.
+		py::object converted = py::type<DuckDBPyType>()(object);
+		result = py::cast<std::shared_ptr<DuckDBPyType>>(converted);
+		return true;
+	} catch (...) {
+		return false;
+	}
+}
+
 void DuckDBPyType::Initialize(py::handle &m) {
 	auto type_module = py::class_<DuckDBPyType>(m, "DuckDBPyType");