rename

Author: evertlammerts

src/arrow/arrow_array_stream.cpp

@@ -14,9 +14,9 @@
 
 namespace duckdb {
 
-void TransformDuckToArrowChunk(py::object pyarrow_schema, ArrowArray &data, py::list &batches) {
+void TransformDuckToArrowChunk(nb::object pyarrow_schema, ArrowArray &data, nb::list &batches) {
 	duckdb::PyUtil::GilAssert();
-	auto pyarrow_lib_module = py::module_::import_("pyarrow").attr("lib");
+	auto pyarrow_lib_module = nb::module_::import_("pyarrow").attr("lib");
 	auto batch_import_func = pyarrow_lib_module.attr("RecordBatch").attr("_import_from_c");
 	batches.append(batch_import_func(reinterpret_cast<uint64_t>(&data), pyarrow_schema));
 }
@@ -28,10 +28,10 @@ void VerifyArrowDatasetLoaded() {
 	}
 }
 
-py::object PythonTableArrowArrayStreamFactory::ProduceScanner(py::object &arrow_scanner, py::handle &arrow_obj_handle,
+nb::object PythonTableArrowArrayStreamFactory::ProduceScanner(nb::object &arrow_scanner, nb::handle &arrow_obj_handle,
                                                               ArrowStreamParameters &parameters,
                                                               const ClientProperties &client_properties) {
-	D_ASSERT(!py::isinstance<py::capsule>(arrow_obj_handle));
+	D_ASSERT(!nb::isinstance<nb::capsule>(arrow_obj_handle));
 	ArrowSchemaWrapper schema;
 	PythonTableArrowArrayStreamFactory::GetSchemaInternal(arrow_obj_handle, schema);
 	ArrowTableSchema arrow_table;
@@ -41,18 +41,18 @@ py::object PythonTableArrowArrayStreamFactory::ProduceScanner(py::object &arrow_
 	auto filters = parameters.filters;
 	auto &column_list = parameters.projected_columns.columns;
 	auto &filter_to_col = parameters.projected_columns.filter_to_col;
-	py::list projection_list(py::cast(column_list));
+	nb::list projection_list(nb::cast(column_list));
 
 	bool has_filter = filters && filters->HasFilters();
-	py::dict kwargs;
+	nb::dict kwargs;
 	if (!column_list.empty()) {
 		kwargs["columns"] = projection_list;
 	}
 
 	if (has_filter) {
 		auto filter = PyArrowFilterPushdown::TransformFilter(*filters, parameters.projected_columns.projection_map,
 		                                                     filter_to_col, client_properties, arrow_table);
-		if (!filter.is(py::none())) {
+		if (!filter.is(nb::none())) {
 			kwargs["filter"] = filter;
 		}
 	}
@@ -61,20 +61,20 @@ py::object PythonTableArrowArrayStreamFactory::ProduceScanner(py::object &arrow_
 
 unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(uintptr_t factory_ptr,
                                                                                 ArrowStreamParameters &parameters) {
-	py::gil_scoped_acquire acquire;
+	nb::gil_scoped_acquire acquire;
 	auto factory = static_cast<PythonTableArrowArrayStreamFactory *>(reinterpret_cast<void *>(factory_ptr)); // NOLINT
 	D_ASSERT(factory->arrow_object);
-	py::handle arrow_obj_handle(factory->arrow_object);
+	nb::handle arrow_obj_handle(factory->arrow_object);
 	auto arrow_object_type = factory->cached_arrow_type;
 
 	if (arrow_object_type == PyArrowObjectType::PolarsLazyFrame) {
-		py::object lf = py::borrow<py::object>(arrow_obj_handle);
+		nb::object lf = nb::borrow<nb::object>(arrow_obj_handle);
 
 		auto filters = parameters.filters;
 		bool filters_pushed = false;
 
 		// Translate DuckDB filters to Polars expressions and push into the lazy plan.
-		// The walker only fails (throws / returns py::none()) for filters that are not
+		// The walker only fails (throws / returns nb::none()) for filters that are not
 		// required for correctness — optional/runtime wrappers it skips, or shapes the
 		// optimizer keeps above the scan. A throw here would mean the optimizer fully
 		// pushed something we can't translate (a correctness bug), so we let it surface
@@ -84,15 +84,15 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 			auto filter_expr = PolarsFilterPushdown::TransformFilter(
 			    *filters, parameters.projected_columns.projection_map, parameters.projected_columns.filter_to_col,
 			    factory->client_properties);
-			if (!filter_expr.is(py::none())) {
+			if (!filter_expr.is(nb::none())) {
 				lf = lf.attr("filter")(filter_expr);
 				filters_pushed = true;
 			}
 		}
 
 		// If no filters were pushed and we have a cached Arrow table, reuse it. This avoids re-reading from source and
 		// re-converting on repeated unfiltered scans.
-		py::object arrow_table;
+		nb::object arrow_table;
 		if (!filters_pushed && factory->cached_arrow_table.ptr() != nullptr) {
 			arrow_table = factory->cached_arrow_table;
 		} else {
@@ -106,11 +106,11 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 		// Apply column projection
 		auto &column_list = parameters.projected_columns.columns;
 		if (!column_list.empty()) {
-			arrow_table = arrow_table.attr("select")(py::cast(column_list));
+			arrow_table = arrow_table.attr("select")(nb::cast(column_list));
 		}
 
 		auto capsule_obj = arrow_table.attr("__arrow_c_stream__")();
-		auto capsule = py::borrow<py::capsule>(capsule_obj);
+		auto capsule = nb::borrow<nb::capsule>(capsule_obj);
 		auto stream = reinterpret_cast<ArrowArrayStream *>(capsule.data());
 		auto res = make_uniq<ArrowArrayStreamWrapper>();
 		res->arrow_array_stream = *stream;
@@ -119,8 +119,8 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 	}
 
 	if (arrow_object_type == PyArrowObjectType::PyCapsuleInterface || arrow_object_type == PyArrowObjectType::Table) {
-		py::object capsule_obj = arrow_obj_handle.attr("__arrow_c_stream__")();
-		auto capsule = py::borrow<py::capsule>(capsule_obj);
+		nb::object capsule_obj = arrow_obj_handle.attr("__arrow_c_stream__")();
+		auto capsule = nb::borrow<nb::capsule>(capsule_obj);
 		auto stream = reinterpret_cast<ArrowArrayStream *>(capsule.data());
 		if (!stream->release) {
 			throw InvalidInputException(
@@ -133,14 +133,14 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 		if (import_cache_check.pyarrow.dataset()) {
 			// Tier A: full pushdown via pyarrow.dataset
 			// Import as RecordBatchReader, feed through Scanner.from_batches for projection/filter pushdown.
-			auto pyarrow_lib_module = py::module_::import_("pyarrow").attr("lib");
+			auto pyarrow_lib_module = nb::module_::import_("pyarrow").attr("lib");
 			auto import_func = pyarrow_lib_module.attr("RecordBatchReader").attr("_import_from_c");
-			py::object reader = import_func(reinterpret_cast<uint64_t>(stream));
+			nb::object reader = import_func(reinterpret_cast<uint64_t>(stream));
 			// _import_from_c takes ownership of the stream; null out to prevent capsule double-free
 			stream->release = nullptr;
 			auto &import_cache = *DuckDBPyConnection::ImportCache();
-			py::object arrow_batch_scanner = import_cache.pyarrow.dataset.Scanner().attr("from_batches");
-			py::handle reader_handle = reader;
+			nb::object arrow_batch_scanner = import_cache.pyarrow.dataset.Scanner().attr("from_batches");
+			nb::handle reader_handle = reader;
 			auto scanner = ProduceScanner(arrow_batch_scanner, reader_handle, parameters, factory->client_properties);
 			auto record_batches = scanner.attr("to_reader")();
 			auto res = make_uniq<ArrowArrayStreamWrapper>();
@@ -159,7 +159,7 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 
 	if (arrow_object_type == PyArrowObjectType::PyCapsule) {
 		auto res = make_uniq<ArrowArrayStreamWrapper>();
-		auto capsule = py::borrow<py::capsule>(arrow_obj_handle);
+		auto capsule = nb::borrow<nb::capsule>(arrow_obj_handle);
 		auto stream = reinterpret_cast<ArrowArrayStream *>(capsule.data());
 		if (!stream->release) {
 			throw InvalidInputException("This ArrowArrayStream has already been consumed and cannot be scanned again.");
@@ -172,8 +172,8 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 	// Scanner and Dataset: require pyarrow.dataset for pushdown
 	VerifyArrowDatasetLoaded();
 	auto &import_cache = *DuckDBPyConnection::ImportCache();
-	py::object scanner;
-	py::object arrow_batch_scanner = import_cache.pyarrow.dataset.Scanner().attr("from_batches");
+	nb::object scanner;
+	nb::object arrow_batch_scanner = import_cache.pyarrow.dataset.Scanner().attr("from_batches");
 	switch (arrow_object_type) {
 	case PyArrowObjectType::Scanner: {
 		// If it's a scanner we have to turn it to a record batch reader, and then a scanner again since we can't stack
@@ -183,13 +183,13 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 		break;
 	}
 	case PyArrowObjectType::Dataset: {
-		py::object arrow_scanner = arrow_obj_handle.attr("__class__").attr("scanner");
+		nb::object arrow_scanner = arrow_obj_handle.attr("__class__").attr("scanner");
 		scanner = ProduceScanner(arrow_scanner, arrow_obj_handle, parameters, factory->client_properties);
 		break;
 	}
 	default: {
-		// py::object wrap: py::str() of a bare .attr() accessor is an ambiguous overload on MSVC.
-		auto py_object_type = py::cast<std::string>(py::str(py::object((arrow_obj_handle).type().attr("__name__"))));
+		// nb::object wrap: nb::str() of a bare .attr() accessor is an ambiguous overload on MSVC.
+		auto py_object_type = nb::cast<std::string>(nb::str(nb::object((arrow_obj_handle).type().attr("__name__"))));
 		throw InvalidInputException("Object of type '%s' is not a recognized Arrow object", py_object_type);
 	}
 	}
@@ -201,10 +201,10 @@ unique_ptr<ArrowArrayStreamWrapper> PythonTableArrowArrayStreamFactory::Produce(
 	return res;
 }
 
-void PythonTableArrowArrayStreamFactory::GetSchemaInternal(py::handle arrow_obj_handle, ArrowSchemaWrapper &schema) {
+void PythonTableArrowArrayStreamFactory::GetSchemaInternal(nb::handle arrow_obj_handle, ArrowSchemaWrapper &schema) {
 	// PyCapsule (from bare capsule Produce path)
-	if (py::isinstance<py::capsule>(arrow_obj_handle)) {
-		auto capsule = py::borrow<py::capsule>(arrow_obj_handle);
+	if (nb::isinstance<nb::capsule>(arrow_obj_handle)) {
+		auto capsule = nb::borrow<nb::capsule>(arrow_obj_handle);
 		auto stream = reinterpret_cast<ArrowArrayStream *>(capsule.data());
 		if (!stream->release) {
 			throw InvalidInputException("This ArrowArrayStream has already been consumed and cannot be scanned again.");
@@ -238,17 +238,17 @@ void PythonTableArrowArrayStreamFactory::GetSchema(uintptr_t factory_ptr, ArrowS
 		return;
 	}
 
-	py::gil_scoped_acquire acquire;
+	nb::gil_scoped_acquire acquire;
 	D_ASSERT(factory->arrow_object);
-	py::handle arrow_obj_handle(factory->arrow_object);
+	nb::handle arrow_obj_handle(factory->arrow_object);
 
 	auto type = factory->cached_arrow_type;
 	if (type == PyArrowObjectType::PolarsLazyFrame) {
 		// head(0).collect().to_arrow() gives the Arrow-exported schema (e.g. large_string) without materializing data.
 		// collect_schema() would give Polars-native types (e.g. string_view) that don't match the actual export.
 		const auto empty_arrow = arrow_obj_handle.attr("head")(0).attr("collect")().attr("to_arrow")();
 		const auto schema_capsule = empty_arrow.attr("schema").attr("__arrow_c_schema__")();
-		const auto capsule = py::borrow<py::capsule>(schema_capsule);
+		const auto capsule = nb::borrow<nb::capsule>(schema_capsule);
 		const auto arrow_schema = reinterpret_cast<ArrowSchema *>(capsule.data());
 		factory->cached_schema = *arrow_schema;
 		arrow_schema->release = nullptr;
@@ -259,9 +259,9 @@ void PythonTableArrowArrayStreamFactory::GetSchema(uintptr_t factory_ptr, ArrowS
 	}
 	if (type == PyArrowObjectType::PyCapsuleInterface || type == PyArrowObjectType::Table) {
 		// Get __arrow_c_schema__ if it exists
-		if (py::hasattr(arrow_obj_handle, "__arrow_c_schema__")) {
+		if (nb::hasattr(arrow_obj_handle, "__arrow_c_schema__")) {
 			auto schema_capsule = arrow_obj_handle.attr("__arrow_c_schema__")();
-			auto capsule = py::borrow<py::capsule>(schema_capsule);
+			auto capsule = nb::borrow<nb::capsule>(schema_capsule);
 			auto arrow_schema = reinterpret_cast<ArrowSchema *>(capsule.data());
 			factory->cached_schema = *arrow_schema; // factory takes ownership
 			arrow_schema->release = nullptr;
@@ -271,16 +271,16 @@ void PythonTableArrowArrayStreamFactory::GetSchema(uintptr_t factory_ptr, ArrowS
 			return;
 		}
 		// Otherwise try to use .schema with _export_to_c
-		if (py::hasattr(arrow_obj_handle, "schema")) {
+		if (nb::hasattr(arrow_obj_handle, "schema")) {
 			auto obj_schema = arrow_obj_handle.attr("schema");
-			if (py::hasattr(obj_schema, "_export_to_c")) {
+			if (nb::hasattr(obj_schema, "_export_to_c")) {
 				obj_schema.attr("_export_to_c")(reinterpret_cast<uint64_t>(&schema.arrow_schema));
 				return;
 			}
 		}
 		// Fallback: create a temporary stream just for the schema (consumes single-use streams!)
 		auto stream_capsule = arrow_obj_handle.attr("__arrow_c_stream__")();
-		auto capsule = py::borrow<py::capsule>(stream_capsule);
+		auto capsule = nb::borrow<nb::capsule>(stream_capsule);
 		auto stream = reinterpret_cast<ArrowArrayStream *>(capsule.data());
 		if (stream->get_schema(stream, &schema.arrow_schema)) {
 			throw InvalidInputException("Failed to get Arrow schema from stream: %s",

src/arrow/arrow_export_utils.cpp

@@ -17,24 +17,24 @@ namespace duckdb {
 
 namespace pyarrow {
 
-py::object ToPyArrowSchema(const ArrowSchema &schema) {
-	py::gil_scoped_acquire acquire;
+nb::object ToPyArrowSchema(const ArrowSchema &schema) {
+	nb::gil_scoped_acquire acquire;
 
-	auto pyarrow_lib_module = py::module_::import_("pyarrow").attr("lib");
+	auto pyarrow_lib_module = nb::module_::import_("pyarrow").attr("lib");
 	auto schema_import_func = pyarrow_lib_module.attr("Schema").attr("_import_from_c");
 	return schema_import_func(reinterpret_cast<uint64_t>(&schema));
 }
 
-py::object ToArrowTable(const py::list &batches, py::object pyarrow_schema) {
-	py::gil_scoped_acquire acquire;
+nb::object ToArrowTable(const nb::list &batches, nb::object pyarrow_schema) {
+	nb::gil_scoped_acquire acquire;
 
-	auto pyarrow_lib_module = py::module_::import_("pyarrow").attr("lib");
+	auto pyarrow_lib_module = nb::module_::import_("pyarrow").attr("lib");
 	auto from_batches_func = pyarrow_lib_module.attr("Table").attr("from_batches");
 
-	return py::cast<duckdb::pyarrow::Table>(from_batches_func(batches, pyarrow_schema));
+	return nb::cast<duckdb::pyarrow::Table>(from_batches_func(batches, pyarrow_schema));
 }
 
-py::object ToArrowTable(const vector<LogicalType> &types, const vector<string> &names, const py::list &batches,
+nb::object ToArrowTable(const vector<LogicalType> &types, const vector<string> &names, const nb::list &batches,
                         ClientProperties &options) {
 	ArrowSchema schema;
 	ArrowConverter::ToArrowSchema(&schema, types, names, options);

src/arrow/filter_pushdown_visitor.cpp

@@ -55,7 +55,7 @@ ResolvedColumn ResolveColumn(const Expression &expr, const vector<Identifier> &r
 	return inner;
 }
 
-py::object EmitCompare(FilterBackend &backend, ExpressionType op, py::object col, const Value &constant,
+nb::object EmitCompare(FilterBackend &backend, ExpressionType op, nb::object col, const Value &constant,
                        const ArrowType *arrow_type, const string &timezone_config) {
 	if (ValueIsNan(constant)) {
 		return backend.NaNCompare(op, std::move(col));
@@ -66,7 +66,7 @@ py::object EmitCompare(FilterBackend &backend, ExpressionType op, py::object col
 
 } // anonymous namespace
 
-py::object TransformExpression(const Expression &expression, const vector<Identifier> &column_path,
+nb::object TransformExpression(const Expression &expression, const vector<Identifier> &column_path,
                                FilterBackend &backend, const ArrowType *arrow_type, const string &timezone_config) {
 	auto expression_class = expression.GetExpressionClass();
 	auto expression_type = expression.GetExpressionType();
@@ -122,20 +122,20 @@ py::object TransformExpression(const Expression &expression, const vector<Identi
 				}
 			}
 			if (!child) {
-				return py::none();
+				return nb::none();
 			}
 			try {
 				return TransformExpression(*child, column_path, backend, arrow_type, timezone_config);
 			} catch (const NotImplementedException &) {
-				return py::none();
+				return nb::none();
 			}
 		}
 
 		// DYNAMIC / BLOOM / PERFECT_HASH_JOIN / PREFIX_RANGE are runtime filters with no
 		// static pyarrow/polars equivalent. They are not required for correctness (the
 		// engine applies them above the scan), so skip them.
 		if (TableFilterFunctions::IsTableFilterFunction(func_name)) {
-			return py::none();
+			return nb::none();
 		}
 	}
 
@@ -168,11 +168,11 @@ py::object TransformExpression(const Expression &expression, const vector<Identi
 		if (expression_type == ExpressionType::CONJUNCTION_OR || expression_type == ExpressionType::CONJUNCTION_AND) {
 			const bool is_and = expression_type == ExpressionType::CONJUNCTION_AND;
 			auto &conj_expr = expression.Cast<BoundConjunctionExpression>();
-			py::object result = py::none();
+			nb::object result = nb::none();
 			for (idx_t i = 0; i < conj_expr.GetChildren().size(); i++) {
-				py::object child_expression =
+				nb::object child_expression =
 				    TransformExpression(*conj_expr.GetChildren()[i], column_path, backend, arrow_type, timezone_config);
-				if (child_expression.is(py::none())) {
+				if (child_expression.is(nb::none())) {
 					if (is_and) {
 						// A conjunct we can't push can simply be dropped: the remaining AND
 						// terms still form a correct (if weaker) filter, and the engine
@@ -182,9 +182,9 @@ py::object TransformExpression(const Expression &expression, const vector<Identi
 					// An OR branch that can't be translated (e.g. a dynamic filter) would
 					// make the pushed-down predicate stricter than the engine intends —
 					// fall back to no pushdown for the whole disjunction.
-					return py::none();
+					return nb::none();
 				}
-				if (result.is(py::none())) {
+				if (result.is(nb::none())) {
 					result = std::move(child_expression);
 				} else if (is_and) {
 					result = backend.And(std::move(result), std::move(child_expression));
@@ -200,7 +200,7 @@ py::object TransformExpression(const Expression &expression, const vector<Identi
 	                              ExpressionClassToString(expression_class));
 }
 
-py::object TransformFilter(const TableFilter &filter, const vector<Identifier> &column_path, FilterBackend &backend,
+nb::object TransformFilter(const TableFilter &filter, const vector<Identifier> &column_path, FilterBackend &backend,
                            const ArrowType *arrow_type, const string &timezone_config) {
 	switch (filter.filter_type) {
 	case TableFilterType::EXPRESSION_FILTER: {