Fix weakref.finalize type arguments + test max_total_rows plumbing

Cycle 10 — mypy --strict flagged weakref.finalize as needing type
arguments. (run-tests.sh only runs mypy on the wire package, so
the error escaped earlier cycles; caught during cycle-10 audit.)
Corrected to weakref.finalize[Any, Any].

Added tests that verify max_total_rows propagates from the dbapi
Connection / AsyncConnection through to the underlying
DqliteConnection, using a MagicMock patch to assert the kwarg
reaches the constructor.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqlitedbapi/connection.py

@@ -99,7 +99,7 @@ def __init__(
         # close() flips to True. Using a list avoids the finalizer
         # closing over ``self`` and preventing GC.
         self._closed_flag: list[bool] = [False]
-        self._finalizer: weakref.finalize | None = None
+        self._finalizer: weakref.finalize[Any, Any] | None = None
 
     def _check_thread(self) -> None:
         """Raise ProgrammingError if called from a different thread than the creator."""

tests/test_max_total_rows_plumbing.py

@@ -0,0 +1,64 @@
+"""max_total_rows plumbing from Connection → DqliteConnection → Protocol.
+
+Cycle 9 added max_total_rows to every layer. This test verifies that
+a custom cap set on the DBAPI Connection actually propagates down to
+the protocol, so users can't silently end up with the default.
+"""
+
+import asyncio
+
+from dqlitedbapi.aio.connection import AsyncConnection
+from dqlitedbapi.connection import Connection
+
+
+class TestMaxTotalRowsPropagation:
+    def test_default_on_connection(self) -> None:
+        conn = Connection("localhost:19001", timeout=2.0)
+        try:
+            assert conn._max_total_rows == 10_000_000
+        finally:
+            conn.close()
+
+    def test_custom_cap_on_connection(self) -> None:
+        conn = Connection("localhost:19001", timeout=2.0, max_total_rows=42)
+        try:
+            assert conn._max_total_rows == 42
+        finally:
+            conn.close()
+
+    def test_none_disables_cap(self) -> None:
+        conn = Connection("localhost:19001", timeout=2.0, max_total_rows=None)
+        try:
+            assert conn._max_total_rows is None
+        finally:
+            conn.close()
+
+    def test_async_connection_default(self) -> None:
+        conn = AsyncConnection("localhost:19001", timeout=2.0)
+        assert conn._max_total_rows == 10_000_000
+
+    def test_async_connection_custom(self) -> None:
+        conn = AsyncConnection("localhost:19001", timeout=2.0, max_total_rows=7)
+        assert conn._max_total_rows == 7
+
+    def test_propagates_to_underlying_dqlite_connection(self) -> None:
+        """After the first use, the inner DqliteConnection should see the
+        same cap as the dbapi-level Connection."""
+        from unittest.mock import AsyncMock, patch
+
+        with patch("dqlitedbapi.connection.DqliteConnection") as MockConn:
+            instance = AsyncMock()
+            instance.connect = AsyncMock()
+            MockConn.return_value = instance
+            conn = Connection("localhost:19001", timeout=2.0, max_total_rows=123)
+            try:
+
+                async def warm_up() -> None:
+                    await conn._get_async_connection()
+
+                conn._run_sync(warm_up())
+                # DqliteConnection was constructed with max_total_rows=123
+                _args, kwargs = MockConn.call_args
+                assert kwargs["max_total_rows"] == 123
+            finally:
+                conn.close()