review fixes

Author: evertlammerts

CLAUDE.md

@@ -10,7 +10,7 @@ This is the **production** duckdb-python client — the `duckdb` package on PyPI
 - **Package name**: `duckdb`
 - **Bindings**: pybind11
 - **Build backend**: `duckdb_packaging.build_backend` (custom wrapper around scikit-build-core)
-- **Supported Python**: 3.10, 3.11, 3.12, 3.13, 3.14
+- **Supported Python**: 3.11, 3.12, 3.13, 3.14
 - **Free-threaded Python**: not supported in this client. A separate prototype client based on DuckDB's C API targets free-threading, Stable ABI, and multi-interpreter support.
 
 ## IMPORTANT: build before running anything
@@ -115,7 +115,7 @@ uv sync --no-build-isolation -v --reinstall -p 3.11
 uv sync --no-build-isolation -v --reinstall -p 3.14
 ```
 
-Supported: `3.10`, `3.11`, `3.12`, `3.13`, `3.14`. Do **not** use free-threaded variants (`3.13t`, `3.14t`) — the production client does not support them.
+Supported: `3.11`, `3.12`, `3.13`, `3.14`. Do **not** use free-threaded variants (`3.13t`, `3.14t`) — the production client does not support them.
 
 ### Build configuration reference
 

pyproject.toml

@@ -10,7 +10,7 @@ dynamic = ["version"]
 description = "DuckDB in-process database"
 readme = "README.md"
 keywords = ["DuckDB", "Database", "SQL", "OLAP"]
-requires-python = ">=3.10.0"
+requires-python = ">=3.11.0"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: MIT License",
@@ -25,7 +25,6 @@ classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -480,7 +479,7 @@ before-build = ["yum install -y ccache"]
 [tool.cibuildwheel.macos]
 before-build = ["brew install ccache"]
 # nanobind uses C++17 aligned new/delete (std::align_val_t), which the runtime only provides on macOS 10.13+.
-# cp310/cp311's framework defaults to a 10.9 deployment target (used for the x86_64 slice of x86_64/universal2
+# cp311's framework defaults to a 10.9 deployment target (used for the x86_64 slice of x86_64/universal2
 # wheels), so nanobind fails to compile there; cp312+ frameworks already target 10.13+. Pin 10.14 so every CPython
 # version builds (arm64 slices are 11.0 regardless).
 environment = { MACOSX_DEPLOYMENT_TARGET = "10.14" }

src/arrow/filter_pushdown_visitor.cpp

@@ -61,6 +61,24 @@ nb::object EmitCompare(FilterBackend &backend, ExpressionType op, nb::object col
 		return backend.NaNCompare(op, std::move(col));
 	}
 	auto scalar = backend.MakeScalar(constant, arrow_type, timezone_config);
+	// DuckDB orders NaN as the greatest float value, so `nan > finite` and `nan >= finite` are TRUE, while
+	// IEEE (pyarrow) makes them FALSE. For a finite FLOAT/DOUBLE constant with `>` / `>=`, the plain
+	// comparison would silently drop NaN column rows the engine keeps (the arrow scan never re-applies
+	// pushed filters). OR the NaN rows back in so the pushed filter matches DuckDB semantics. `<`, `<=`,
+	// `=`, `<>` already agree with IEEE, so they are left unchanged. (Idempotent for the polars backend,
+	// which already treats NaN as greatest, and only reached for float constants so is_nan is always valid.)
+	// N3: keying is_nan on the CONSTANT's float-ness is safe -- a float constant here implies a float column
+	// (int/float comparisons are constant-folded to int bounds or wrapped in a non-pushed CAST upstream), so
+	// col.is_nan() always resolves to a valid pyarrow kernel.
+	const auto constant_type_id = constant.type().id();
+	const bool constant_is_float =
+	    constant_type_id == LogicalTypeId::FLOAT || constant_type_id == LogicalTypeId::DOUBLE;
+	if (constant_is_float &&
+	    (op == ExpressionType::COMPARE_GREATERTHAN || op == ExpressionType::COMPARE_GREATERTHANOREQUALTO)) {
+		auto compare = backend.Compare(op, col, std::move(scalar));
+		auto is_nan = backend.IsNaN(std::move(col));
+		return backend.Or(std::move(compare), std::move(is_nan));
+	}
 	return backend.Compare(op, std::move(col), std::move(scalar));
 }
 

src/arrow/polars_filter_pushdown.cpp

@@ -71,6 +71,10 @@ struct PolarsBackend : public FilterBackend {
 		}
 	}
 
+	nb::object IsNaN(nb::object col) override {
+		return col.attr("is_nan")();
+	}
+
 	nb::object IsNull(nb::object col) override {
 		return col.attr("is_null")();
 	}

src/arrow/pyarrow_filter_pushdown.cpp

@@ -243,6 +243,10 @@ struct PyArrowBackend : public FilterBackend {
 		}
 	}
 
+	nb::object IsNaN(nb::object col) override {
+		return col.attr("is_nan")();
+	}
+
 	nb::object IsNull(nb::object col) override {
 		return col.attr("is_null")();
 	}

src/duckdb_python.cpp

@@ -708,33 +708,36 @@ static void InitializeConnectionMethods(nb::module_ &m) {
 	    "run the query as-is.",
 	    nb::arg("query"), nb::kw_only(), nb::arg("alias") = "", nb::arg("params") = nb::none(),
 	    nb::arg("connection").none() = nb::none());
-	m.def(
-	    "read_csv",
-	    // nb::arg + nb::kwargs can't coexist under nanobind's annotation rules; drop the annotations.
-	    [](const nb::object &name, nb::kwargs &kwargs) {
-		    std::shared_ptr<DuckDBPyConnection> conn;
-		    if (kwargs.contains("conn") && !kwargs["conn"].is_none()) {
-			    conn = nb::cast<std::shared_ptr<DuckDBPyConnection>>(kwargs["conn"]);
-		    }
-		    if (!conn) {
-			    conn = DuckDBPyConnection::DefaultConnection();
-		    }
-		    return conn->ReadCSV(name, kwargs);
-	    },
-	    "Create a relation object from the CSV file in 'name'");
-	m.def(
-	    "from_csv_auto",
-	    [](const nb::object &name, nb::kwargs &kwargs) {
-		    std::shared_ptr<DuckDBPyConnection> conn;
-		    if (kwargs.contains("conn") && !kwargs["conn"].is_none()) {
-			    conn = nb::cast<std::shared_ptr<DuckDBPyConnection>>(kwargs["conn"]);
-		    }
-		    if (!conn) {
-			    conn = DuckDBPyConnection::DefaultConnection();
-		    }
-		    return conn->ReadCSV(name, kwargs);
-	    },
-	    "Create a relation object from the CSV file in 'name'");
+	// nanobind's all-or-nothing nb::arg rule forbids naming just the source parameter alongside **kwargs, so the
+	// module-level read_csv / from_csv_auto take (*args, **kwargs) and recover the advertised keywords by hand:
+	// the source may be positional or passed as `path_or_buffer=`, and the connection as `connection=` / `conn=`.
+	// Each recovered keyword is popped from kwargs so ReadCSV's unknown-parameter check only sees CSV options.
+	// N2: extra positional args (e.g. read_csv("a", "b")) are silently dropped rather than raising; negligible.
+	auto module_read_csv = [](nb::args args, nb::kwargs kwargs) {
+		nb::object name = nb::none();
+		if (args.size() >= 1) {
+			name = nb::object(args[0]);
+		} else if (kwargs.contains("path_or_buffer")) {
+			name = kwargs["path_or_buffer"];
+			PyDict_DelItemString(kwargs.ptr(), "path_or_buffer");
+		}
+		std::shared_ptr<DuckDBPyConnection> conn;
+		for (const char *conn_key : {"connection", "conn"}) {
+			if (kwargs.contains(conn_key)) {
+				nb::object conn_arg = kwargs[conn_key];
+				PyDict_DelItemString(kwargs.ptr(), conn_key);
+				if (!conn && !conn_arg.is_none()) {
+					conn = nb::cast<std::shared_ptr<DuckDBPyConnection>>(conn_arg);
+				}
+			}
+		}
+		if (!conn) {
+			conn = DuckDBPyConnection::DefaultConnection();
+		}
+		return conn->ReadCSV(name, kwargs);
+	};
+	m.def("read_csv", module_read_csv, "Create a relation object from the CSV file in 'name'");
+	m.def("from_csv_auto", module_read_csv, "Create a relation object from the CSV file in 'name'");
 	m.def(
 	    "from_df",
 	    [](const PandasDataFrame &value, std::shared_ptr<DuckDBPyConnection> conn = nullptr) {
@@ -822,9 +825,21 @@ static void InitializeConnectionMethods(nb::module_ &m) {
 	    "Load an installed extension", nb::arg("extension"), nb::kw_only(), nb::arg("connection").none() = nb::none());
 	m.def(
 	    "project",
-	    // nanobind forbids named typed parameters after nb::args; the keyword-only `groups` and `connection`
-	    // are therefore taken from **kwargs (preserving the previous defaults/None-handling).
-	    [](const PandasDataFrame &df, const nb::args &args, const nb::kwargs &kwargs) {
+	    // nanobind forbids named typed parameters after nb::args, so this takes (*args, **kwargs) and recovers the
+	    // advertised signature by hand: `df` may be positional (args[0]) or the `df=` keyword (the stubs advertise
+	    // it as positional-or-keyword); the remaining positionals are projection expressions; `groups` /
+	    // `connection` are keyword-only (pulled from kwargs, preserving the previous defaults/None-handling).
+	    [](const nb::args &args, const nb::kwargs &kwargs) {
+		    nb::object df_obj = nb::none();
+		    nb::args proj_args = nb::steal<nb::args>(PyTuple_New(0));
+		    if (args.size() >= 1) {
+			    df_obj = nb::object(args[0]);
+			    proj_args = nb::steal<nb::args>(PyTuple_GetSlice(args.ptr(), 1, static_cast<Py_ssize_t>(args.size())));
+		    } else if (kwargs.contains("df")) {
+			    df_obj = kwargs["df"];
+			    PyDict_DelItemString(kwargs.ptr(), "df");
+		    }
+		    auto df = nb::cast<PandasDataFrame>(df_obj);
 		    string groups = "";
 		    if (kwargs.contains("groups") && !kwargs["groups"].is_none()) {
 			    groups = nb::cast<std::string>(kwargs["groups"]);
@@ -836,7 +851,7 @@ static void InitializeConnectionMethods(nb::module_ &m) {
 		    if (!conn) {
 			    conn = DuckDBPyConnection::DefaultConnection();
 		    }
-		    return conn->FromDF(df)->Project(args, groups);
+		    return conn->FromDF(df)->Project(proj_args, groups);
 	    },
 	    "Project the relation object by the projection in project_expr");
 	m.def(

src/include/duckdb_python/arrow/filter_pushdown_visitor.hpp

@@ -55,6 +55,11 @@ struct FilterBackend {
 	// each operator decomposes into is_nan / ~is_nan / lit(true|false).
 	virtual nb::object NaNCompare(ExpressionType op, nb::object col) = 0;
 
+	// Column-side NaN predicate: `col.is_nan()`. Used to re-include NaN rows for `>` / `>=` against a
+	// finite float constant, since DuckDB orders NaN as the greatest value (so `nan > finite` is TRUE)
+	// while IEEE comparisons make them FALSE.
+	virtual nb::object IsNaN(nb::object col) = 0;
+
 	virtual nb::object IsNull(nb::object col) = 0;
 	virtual nb::object IsNotNull(nb::object col) = 0;
 

src/include/duckdb_python/filesystem_object.hpp

@@ -22,8 +22,14 @@ class FileSystemObject : public RegisteredObject {
 		// Assert that the 'obj' is a filesystem
 		D_ASSERT(duckdb::PyUtil::IsInstance(
 		    obj, DuckDBPyConnection::ImportCache()->duckdb.filesystem.ModifiedMemoryFileSystem()));
-		for (auto &file : filenames) {
-			obj.attr("delete")(file);
+		// Destructors are implicitly noexcept: a Python exception escaping here (fsspec `_rm` raises
+		// KeyError for a missing entry) would std::terminate the process. Swallow it, mirroring
+		// ~PythonFileHandle / ~PythonFilesystem.
+		try {
+			for (auto &file : filenames) {
+				obj.attr("delete")(file);
+			}
+		} catch (...) { // NOLINT: intentional catch-all in a destructor
 		}
 	}