weakrefs work again

Author: evertlammerts

src/duckdb_py/pyconnection.cpp

@@ -477,7 +477,9 @@ DuckDBPyConnection::RegisterScalarUDF(const string &name, const py::callable &ud
 }
 
 void DuckDBPyConnection::Initialize(py::handle &m) {
-	auto connection_module = py::class_<DuckDBPyConnection>(m, "DuckDBPyConnection");
+	// Weak-referenceable like pybind11 (which set tp_weaklistoffset by default); nanobind requires the opt-in,
+	// otherwise weakref.ref/proxy/finalize on a connection raises TypeError.
+	auto connection_module = py::class_<DuckDBPyConnection>(m, "DuckDBPyConnection", py::is_weak_referenceable());
 
 	connection_module.def("__enter__", &DuckDBPyConnection::Enter)
 	    .def(

src/duckdb_py/pyexpression/initialize.cpp

@@ -325,7 +325,8 @@ static void InitializeImplicitConversion(py::class_<DuckDBPyExpression> &m) {
 }
 
 void DuckDBPyExpression::Initialize(py::module_ &m) {
-	auto expression = py::class_<DuckDBPyExpression>(m, "Expression");
+	// Weak-referenceable like pybind11 (nanobind requires the explicit opt-in).
+	auto expression = py::class_<DuckDBPyExpression>(m, "Expression", py::is_weak_referenceable());
 
 	InitializeStaticMethods(m);
 	InitializeDunderMethods(expression);

src/duckdb_py/pyrelation/initialize.cpp

@@ -278,7 +278,8 @@ static void InitializeMetaQueries(py::class_<DuckDBPyRelation> &m) {
 }
 
 void DuckDBPyRelation::Initialize(py::handle &m) {
-	auto relation_module = py::class_<DuckDBPyRelation>(m, "DuckDBPyRelation");
+	// Weak-referenceable like pybind11 (nanobind requires the explicit opt-in).
+	auto relation_module = py::class_<DuckDBPyRelation>(m, "DuckDBPyRelation", py::is_weak_referenceable());
 	InitializeReadOnlyProperties(relation_module);
 	InitializeAggregates(relation_module);
 	InitializeWindowOperators(relation_module);

src/duckdb_py/pystatement.cpp

@@ -15,7 +15,8 @@ static void InitializeReadOnlyProperties(py::class_<DuckDBPyStatement> &m) {
 }
 
 void DuckDBPyStatement::Initialize(py::handle &m) {
-	auto relation_module = py::class_<DuckDBPyStatement>(m, "Statement");
+	// Weak-referenceable like pybind11 (nanobind requires the explicit opt-in).
+	auto relation_module = py::class_<DuckDBPyStatement>(m, "Statement", py::is_weak_referenceable());
 	InitializeReadOnlyProperties(relation_module);
 }
 

src/duckdb_py/typing/pytype.cpp

@@ -352,7 +352,8 @@ bool DuckDBPyType::TryConvert(const py::object &object, std::unique_ptr<DuckDBPy
 }
 
 void DuckDBPyType::Initialize(py::handle &m) {
-	auto type_module = py::class_<DuckDBPyType>(m, "DuckDBPyType");
+	// Weak-referenceable like pybind11 (nanobind requires the explicit opt-in).
+	auto type_module = py::class_<DuckDBPyType>(m, "DuckDBPyType", py::is_weak_referenceable());
 
 	type_module.def("__repr__", &DuckDBPyType::ToString, "Stringified representation of the type object");
 	type_module.def("__eq__", &DuckDBPyType::Equals, "Compare two types for equality", py::arg("other"),

tests/fast/test_weakref.py

@@ -0,0 +1,54 @@
+"""Bound types must be weak-referenceable.
+
+pybind11 set ``tp_weaklistoffset`` on every bound type by default, so
+``weakref.ref``/``proxy``/``finalize`` and ``WeakValueDictionary`` worked out of the box.
+nanobind opts out by default and requires ``py::is_weak_referenceable()`` at registration; without
+it those calls raise ``TypeError: cannot create weak reference``. This guards that regression for
+every publicly handed-out bound type (Connection, Relation, Expression, Type, Statement).
+"""
+
+import platform
+import weakref
+
+import pytest
+
+import duckdb
+
+pytestmark = pytest.mark.skipif(
+    platform.system() == "Emscripten",
+    reason="Extensions are not supported on Emscripten",
+)
+
+
+@pytest.fixture
+def bound_objects():
+    con = duckdb.connect()
+    objs = {
+        "Connection": con,
+        "Relation": con.sql("SELECT 42 AS a"),
+        "Expression": duckdb.ColumnExpression("a"),
+        "Type": duckdb.type("INTEGER"),
+        "Statement": con.extract_statements("SELECT 42")[0],
+    }
+    yield objs
+    con.close()
+
+
+@pytest.mark.parametrize(
+    "name",
+    ["Connection", "Relation", "Expression", "Type", "Statement"],
+)
+def test_bound_type_is_weak_referenceable(bound_objects, name):
+    obj = bound_objects[name]
+
+    ref = weakref.ref(obj)
+    assert ref() is obj
+
+    weakref.proxy(obj)  # must not raise
+
+    finalized = []
+    weakref.finalize(obj, finalized.append, name)
+
+    wvd = weakref.WeakValueDictionary()
+    wvd["k"] = obj
+    assert wvd["k"] is obj