tests: importorskip adbc which doesn't yet support free-threading, and linting cleanup

Author: paultiq

tests/fast/adbc/test_adbc.py

@@ -2,19 +2,22 @@
 import sys
 from pathlib import Path
 
-import adbc_driver_manager.dbapi
 import numpy as np
 import pyarrow
 import pytest
 
-import adbc_driver_duckdb.dbapi
+import adbc_driver_duckdb
 
-xfail = pytest.mark.xfail
 driver_path = adbc_driver_duckdb.driver_path()
 
 
+xfail = pytest.mark.xfail
+
+
 @pytest.fixture
 def duck_conn():
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     with adbc_driver_manager.dbapi.connect(driver=driver_path, entrypoint="duckdb_adbc_init") as conn:
         yield conn
 
@@ -95,6 +98,8 @@ def test_connection_get_objects_filters(duck_conn):
 
 
 def test_commit(tmp_path):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     db = Path(tmp_path) / "tmp.db"
     if db.exists():
         db.unlink()
@@ -142,6 +147,8 @@ def test_commit(tmp_path):
 
 
 def test_connection_get_table_schema(duck_conn):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     with duck_conn.cursor() as cursor:
         # Test Default Schema
         cursor.execute("CREATE TABLE tableschema (ints BIGINT)")
@@ -209,6 +216,8 @@ def test_statement_query(duck_conn):
 
 @xfail(sys.platform == "win32", reason="adbc-driver-manager returns an invalid table schema on windows")
 def test_insertion(duck_conn):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     table = example_table()
     reader = table.to_reader()
 
@@ -281,6 +290,8 @@ def test_read(duck_conn):
 
 
 def test_large_chunk(tmp_path):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     num_chunks = 3
     chunk_size = 10_000
 
@@ -318,6 +329,8 @@ def test_large_chunk(tmp_path):
 
 
 def test_dictionary_data(tmp_path):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     data = ["apple", "banana", "apple", "orange", "banana", "banana"]
 
     dict_type = pyarrow.dictionary(index_type=pyarrow.int32(), value_type=pyarrow.string())
@@ -346,6 +359,8 @@ def test_dictionary_data(tmp_path):
 
 
 def test_ree_data(tmp_path):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     run_ends = pyarrow.array([3, 5, 6], type=pyarrow.int32())  # positions: [0-2], [3-4], [5]
     values = pyarrow.array(["apple", "banana", "orange"], type=pyarrow.string())
 

tests/fast/adbc/test_statement_bind.py

@@ -1,6 +1,5 @@
 import sys
 
-import adbc_driver_manager
 import pyarrow as pa
 import pytest
 
@@ -10,6 +9,8 @@
 
 
 def _import(handle):
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     """Helper to import a C Data Interface handle."""
     if isinstance(handle, adbc_driver_manager.ArrowArrayStreamHandle):
         return pa.RecordBatchReader._import_from_c(handle.address)
@@ -20,6 +21,8 @@ def _import(handle):
 
 
 def _bind(stmt, batch) -> None:
+    adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
     array = adbc_driver_manager.ArrowArrayHandle()
     schema = adbc_driver_manager.ArrowSchemaHandle()
     batch._export_to_c(array.address, schema.address)
@@ -28,6 +31,8 @@ def _bind(stmt, batch) -> None:
 
 class TestADBCStatementBind:
     def test_bind_multiple_rows(self):
+        adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
         data = pa.record_batch(
             [
                 [1, 2, 3, 4],
@@ -141,6 +146,8 @@ def test_bind_composite_type(self):
             assert result == struct_array
 
     def test_too_many_parameters(self):
+        adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
         data = pa.record_batch(
             [[12423], ["not a short string"]],
             names=["ints", "strings"],
@@ -170,6 +177,8 @@ def test_too_many_parameters(self):
 
     @xfail(sys.platform == "win32", reason="adbc-driver-manager returns an invalid table schema on windows")
     def test_not_enough_parameters(self):
+        adbc_driver_manager = pytest.importorskip("adbc_driver_manager")
+
         data = pa.record_batch(
             [["not a short string"]],
             names=["strings"],

tests/fast/threading/test_basic_operations.py

@@ -1,13 +1,10 @@
 import gc
 import random
 import time
+import uuid
 import weakref
 from threading import get_ident
 
-import uuid
-
-import pytest
-
 import duckdb
 
 
@@ -23,16 +20,12 @@ def test_connection_instance_cache(tmp_path):
     thread_id = get_ident()
     for i in range(10):
         with duckdb.connect(tmp_path / f"{thread_id}_{uuid.uuid4()}.db") as conn:
-            conn.execute(
-                f"CREATE TABLE IF NOT EXISTS thread_{thread_id}_data_{i} (x BIGINT)"
-            )
+            conn.execute(f"CREATE TABLE IF NOT EXISTS thread_{thread_id}_data_{i} (x BIGINT)")
             conn.execute(f"INSERT INTO thread_{thread_id}_data_{i} VALUES (100), (100)")
 
             time.sleep(random.uniform(0.0001, 0.001))
 
-            result = conn.execute(
-                f"SELECT COUNT(*) FROM thread_{thread_id}_data_{i}"
-            ).fetchone()[0]
+            result = conn.execute(f"SELECT COUNT(*) FROM thread_{thread_id}_data_{i}").fetchone()[0]
             assert result == 2, f"Iteration {i}: expected 2 rows, got {result}"
 
 
@@ -65,9 +58,7 @@ def test_cleanup():
     gc.collect()
 
     alive_refs = [ref for ref in weak_refs if ref() is not None]
-    assert len(alive_refs) <= 10, (
-        f"{len(alive_refs)} connections still alive (expected <= 10)"
-    )
+    assert len(alive_refs) <= 10, f"{len(alive_refs)} connections still alive (expected <= 10)"
 
 
 def test_default_connection():
@@ -88,19 +79,15 @@ def test_type_system():
             duckdb.type("DOUBLE"),
             duckdb.type("BOOLEAN"),
             duckdb.list_type(duckdb.type("INTEGER")),
-            duckdb.struct_type(
-                {"a": duckdb.type("INTEGER"), "b": duckdb.type("VARCHAR")}
-            ),
+            duckdb.struct_type({"a": duckdb.type("INTEGER"), "b": duckdb.type("VARCHAR")}),
         ]
 
         for t in types:
             assert t is not None, "type creation failed"
 
         if i % 5 == 0:
             with duckdb.connect(":memory:") as conn:
-                conn.execute(
-                    "CREATE TABLE test (a INTEGER, b VARCHAR, c DOUBLE, d BOOLEAN)"
-                )
+                conn.execute("CREATE TABLE test (a INTEGER, b VARCHAR, c DOUBLE, d BOOLEAN)")
                 result = conn.execute("SELECT COUNT(*) FROM test").fetchone()
                 assert result[0] == 0
 

tests/fast/threading/test_concurrent_access.py

@@ -1,15 +1,14 @@
-"""
-Concurrent access tests for DuckDB Python bindings with free threading support.
+"""Concurrent access tests for DuckDB Python bindings with free threading support.
 
 These tests verify that the DuckDB Python module can handle concurrent access
 from multiple threads safely, testing module state isolation, memory management,
 and connection handling under various stress conditions.
 """
 
+import concurrent.futures
 import gc
 import random
 import time
-import concurrent.futures
 
 import pytest
 
@@ -28,9 +27,7 @@ def test_shared_connection_stress(num_threads_testing):
     iterations = 10
 
     with duckdb.connect(":memory:") as connection:
-        connection.execute(
-            "CREATE TABLE stress_test (id INTEGER, thread_id INTEGER, value TEXT)"
-        )
+        connection.execute("CREATE TABLE stress_test (id INTEGER, thread_id INTEGER, value TEXT)")
 
         def worker_thread(thread_id: int) -> None:
             cursor = connection.cursor()
@@ -39,24 +36,16 @@ def worker_thread(thread_id: int) -> None:
                     "INSERT INTO stress_test VALUES (?, ?, ?)",
                     [i, thread_id, f"thread_{thread_id}_value_{i}"],
                 )
-                cursor.execute(
-                    "SELECT COUNT(*) FROM stress_test WHERE thread_id = ?", [thread_id]
-                ).fetchone()
+                cursor.execute("SELECT COUNT(*) FROM stress_test WHERE thread_id = ?", [thread_id]).fetchone()
                 time.sleep(random.uniform(0.0001, 0.001))
 
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=num_threads_testing
-        ) as executor:
-            futures = [
-                executor.submit(worker_thread, i) for i in range(num_threads_testing)
-            ]
+        with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads_testing) as executor:
+            futures = [executor.submit(worker_thread, i) for i in range(num_threads_testing)]
             # Wait for all to complete, will raise if any fail
             for future in concurrent.futures.as_completed(futures):
                 future.result()
 
-        total_rows = connection.execute("SELECT COUNT(*) FROM stress_test").fetchone()[
-            0
-        ]
+        total_rows = connection.execute("SELECT COUNT(*) FROM stress_test").fetchone()[0]
         expected_rows = num_threads_testing * iterations
         assert total_rows == expected_rows
 

tests/fast/threading/test_connection_lifecycle_races.py

@@ -1,11 +1,10 @@
-"""
-Test connection lifecycle races.
+"""Test connection lifecycle races.
 
 Focused on DuckDBPyConnection constructor and Close
 """
 
-import gc
 import concurrent.futures
+import gc
 
 import pytest
 
@@ -43,16 +42,9 @@ def attempt_close_connection(cursor, thread_id):
 
             return True
 
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=num_threads_testing
-        ) as executor:
-            futures = [
-                executor.submit(attempt_close_connection, conn.cursor(), i)
-                for i in range(num_threads_testing)
-            ]
-            results = [
-                future.result() for future in concurrent.futures.as_completed(futures)
-            ]
+        with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads_testing) as executor:
+            futures = [executor.submit(attempt_close_connection, conn.cursor(), i) for i in range(num_threads_testing)]
+            results = [future.result() for future in concurrent.futures.as_completed(futures)]
 
         assert all(results)
 
@@ -62,31 +54,20 @@ def test_cursor_operations_race(num_threads_testing):
     conn = duckdb.connect(":memory:")
     try:
         conn.execute("CREATE TABLE cursor_test (id INTEGER, name VARCHAR)")
-        conn.execute(
-            "INSERT INTO cursor_test SELECT i, 'name_' || i FROM range(100) t(i)"
-        )
+        conn.execute("INSERT INTO cursor_test SELECT i, 'name_' || i FROM range(100) t(i)")
 
         def cursor_operations(thread_id):
             """Perform cursor operations concurrently."""
             # Get a cursor
             cursor = conn.cursor()
-            cursor.execute(
-                f"SELECT * FROM cursor_test WHERE id % {num_threads_testing} = {thread_id}"
-            )
-            results = cursor.fetchall()
+            cursor.execute(f"SELECT * FROM cursor_test WHERE id % {num_threads_testing} = {thread_id}")
+            cursor.fetchall()
 
             return True
 
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=num_threads_testing
-        ) as executor:
-            futures = [
-                executor.submit(cursor_operations, i)
-                for i in range(num_threads_testing)
-            ]
-            results = [
-                future.result() for future in concurrent.futures.as_completed(futures)
-            ]
+        with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads_testing) as executor:
+            futures = [executor.submit(cursor_operations, i) for i in range(num_threads_testing)]
+            results = [future.result() for future in concurrent.futures.as_completed(futures)]
 
         assert all(results)
     finally:

tests/fast/threading/test_fetching.py

@@ -1,11 +1,7 @@
-"""
-Test fetching operations.
-"""
+"""Test fetching operations."""
 
 from threading import get_ident
 
-import pytest
-
 import duckdb
 
 
@@ -16,26 +12,18 @@ def test_fetching():
 
     conn = duckdb.connect()
     try:
-        batch_data = [
-            (thread_id * 100 + i, f"name_{thread_id}_{i}") for i in range(iterations)
-        ]
+        batch_data = [(thread_id * 100 + i, f"name_{thread_id}_{i}") for i in range(iterations)]
         conn.execute("CREATE TABLE batch_data (id BIGINT, name VARCHAR)")
         conn.executemany("INSERT INTO batch_data VALUES (?, ?)", batch_data)
 
         # Test different fetch methods
-        result1 = conn.execute(
-            f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'"
-        ).fetchone()
+        result1 = conn.execute(f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'").fetchone()
         assert result1[0] == iterations
 
-        result2 = conn.execute(
-            f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'"
-        ).fetchall()
+        result2 = conn.execute(f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'").fetchall()
         assert result2[0][0] == iterations
 
-        result3 = conn.execute(
-            f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'"
-        ).fetchdf()
+        result3 = conn.execute(f"SELECT COUNT(*) FROM batch_data WHERE name LIKE 'name_{thread_id}_%'").fetchdf()
         assert len(result3) == 1
 
         result4 = conn.execute(