Consolidate the max_total_rows validator into the shared helper

The protocol module had two positive-int-or-None validators with
byte-identical behaviour: a generic `_validate_positive_int_or_none`
that takes the parameter name as an argument, and an older
`_validate_max_total_rows` that hardcoded the name into its error
messages. Callers sometimes imported one, sometimes the other.

Drop the specialised wrapper and route the four call sites (the two
client modules, the pool, and the two dbapi connection modules)
through the generic helper. Error messages are byte-identical when
the helper is given `name="max_total_rows"`, so the existing
validation tests continue to match the exact wording.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -16,7 +16,6 @@
 )
 from dqliteclient.protocol import (
     DqliteProtocol,
-    _validate_max_total_rows,
     _validate_positive_int_or_none,
 )
 from dqlitewire.exceptions import EncodeError as _WireEncodeError
@@ -108,7 +107,7 @@ def __init__(
         self._address = address
         self._database = database
         self._timeout = timeout
-        self._max_total_rows = _validate_max_total_rows(max_total_rows)
+        self._max_total_rows = _validate_positive_int_or_none(max_total_rows, "max_total_rows")
         self._max_continuation_frames = _validate_positive_int_or_none(
             max_continuation_frames, "max_continuation_frames"
         )

src/dqliteclient/pool.py

@@ -11,7 +11,7 @@
 from dqliteclient.connection import DqliteConnection
 from dqliteclient.exceptions import DqliteConnectionError
 from dqliteclient.node_store import NodeStore
-from dqliteclient.protocol import _validate_max_total_rows, _validate_positive_int_or_none
+from dqliteclient.protocol import _validate_positive_int_or_none
 
 logger = logging.getLogger(__name__)
 
@@ -130,7 +130,7 @@ def __init__(
         self._min_size = min_size
         self._max_size = max_size
         self._timeout = timeout
-        self._max_total_rows = _validate_max_total_rows(max_total_rows)
+        self._max_total_rows = _validate_positive_int_or_none(max_total_rows, "max_total_rows")
         self._max_continuation_frames = _validate_positive_int_or_none(
             max_continuation_frames, "max_continuation_frames"
         )

src/dqliteclient/protocol.py

@@ -47,21 +47,6 @@ def _validate_positive_int_or_none(value: int | None, name: str) -> int | None:
     return value
 
 
-def _validate_max_total_rows(value: int | None) -> int | None:
-    """Validate the ``max_total_rows`` constructor argument.
-
-    ``None`` disables the cap. Otherwise the value must be a positive
-    ``int`` (``bool`` is rejected even though it's a subclass of int).
-    """
-    if value is None:
-        return None
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise TypeError(f"max_total_rows must be int or None, got {type(value).__name__}")
-    if value <= 0:
-        raise ValueError(f"max_total_rows must be > 0 or None, got {value}")
-    return value
-
-
 class DqliteProtocol:
     """Low-level protocol handler for a single dqlite connection."""
 
@@ -85,7 +70,7 @@ def __init__(
         # the per-operation deadline; without a cumulative cap, clients
         # could legitimately allocate hundreds of millions of rows over
         # the full deadline. None disables the cap.
-        self._max_total_rows = _validate_max_total_rows(max_total_rows)
+        self._max_total_rows = _validate_positive_int_or_none(max_total_rows, "max_total_rows")
         # Per-query frame cap. Complements max_total_rows: a server
         # sending 10M 1-row frames to reach the row cap would still
         # burn 10M × decode-cost of Python work; the frame cap bounds

tests/test_max_total_rows_validation.py

@@ -6,37 +6,37 @@
 
 from dqliteclient.connection import DqliteConnection
 from dqliteclient.pool import ConnectionPool
-from dqliteclient.protocol import DqliteProtocol, _validate_max_total_rows
+from dqliteclient.protocol import DqliteProtocol, _validate_positive_int_or_none
 
 
 class TestValidator:
     def test_none_allowed(self) -> None:
-        assert _validate_max_total_rows(None) is None
+        assert _validate_positive_int_or_none(None, "max_total_rows") is None
 
     def test_positive_int_allowed(self) -> None:
-        assert _validate_max_total_rows(1) == 1
-        assert _validate_max_total_rows(10_000_000) == 10_000_000
+        assert _validate_positive_int_or_none(1, "max_total_rows") == 1
+        assert _validate_positive_int_or_none(10_000_000, "max_total_rows") == 10_000_000
 
     def test_zero_rejected(self) -> None:
         with pytest.raises(ValueError, match="max_total_rows must be > 0"):
-            _validate_max_total_rows(0)
+            _validate_positive_int_or_none(0, "max_total_rows")
 
     def test_negative_rejected(self) -> None:
         with pytest.raises(ValueError, match="max_total_rows must be > 0"):
-            _validate_max_total_rows(-1)
+            _validate_positive_int_or_none(-1, "max_total_rows")
 
     def test_float_rejected(self) -> None:
         with pytest.raises(TypeError, match="max_total_rows must be int or None"):
-            _validate_max_total_rows(1.5)  # type: ignore[arg-type]
+            _validate_positive_int_or_none(1.5, "max_total_rows")  # type: ignore[arg-type]
 
     def test_bool_rejected(self) -> None:
         # True is technically int, but PEP-489-style APIs rightly reject it.
         with pytest.raises(TypeError, match="max_total_rows must be int or None"):
-            _validate_max_total_rows(True)  # type: ignore[arg-type]
+            _validate_positive_int_or_none(True, "max_total_rows")  # type: ignore[arg-type]
 
     def test_string_rejected(self) -> None:
         with pytest.raises(TypeError, match="max_total_rows must be int or None"):
-            _validate_max_total_rows("100")  # type: ignore[arg-type]
+            _validate_positive_int_or_none("100", "max_total_rows")  # type: ignore[arg-type]
 
 
 class TestConstructorValidation: