fix: add retryable_exceptions parameter to retry_with_backoff

Previously retried all exceptions including programming bugs like
TypeError and KeyError. Now accepts a retryable_exceptions tuple
(defaults to (Exception,) for backward compatibility). The cluster
connect() call passes only connection/cluster/operational errors.

Also adds max_attempts validation (>= 1) and removes the assert
that would be stripped by python -O.

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

Author: antoineleclair

src/dqliteclient/cluster.py

@@ -3,7 +3,7 @@
 import asyncio
 
 from dqliteclient.connection import DqliteConnection
-from dqliteclient.exceptions import ClusterError
+from dqliteclient.exceptions import ClusterError, DqliteConnectionError, OperationalError
 from dqliteclient.node_store import MemoryNodeStore, NodeInfo, NodeStore
 from dqliteclient.protocol import DqliteProtocol
 from dqliteclient.retry import retry_with_backoff
@@ -102,7 +102,17 @@ async def try_connect() -> DqliteConnection:
             await conn.connect()
             return conn
 
-        return await retry_with_backoff(try_connect, max_attempts=5)
+        return await retry_with_backoff(
+            try_connect,
+            max_attempts=5,
+            retryable_exceptions=(
+                DqliteConnectionError,
+                ClusterError,
+                OperationalError,
+                OSError,
+                TimeoutError,
+            ),
+        )
 
     async def update_nodes(self, nodes: list[NodeInfo]) -> None:
         """Update the node store with new node information."""

src/dqliteclient/retry.py

@@ -11,6 +11,7 @@ async def retry_with_backoff[T](
     base_delay: float = 0.1,
     max_delay: float = 10.0,
     jitter: float = 0.1,
+    retryable_exceptions: tuple[type[Exception], ...] = (Exception,),
 ) -> T:
     """Retry an async function with exponential backoff.
 
@@ -20,12 +21,14 @@ async def retry_with_backoff[T](
         base_delay: Initial delay between retries in seconds
         max_delay: Maximum delay between retries
         jitter: Random jitter factor (0-1)
+        retryable_exceptions: Exception types to retry on
 
     Returns:
         Result of the function
 
     Raises:
-        The last exception if all attempts fail
+        The last exception if all attempts fail, or immediately
+        for non-retryable exceptions
     """
     if max_attempts < 1:
         raise ValueError("max_attempts must be at least 1")
@@ -35,7 +38,7 @@ async def retry_with_backoff[T](
     for attempt in range(max_attempts):
         try:
             return await func()
-        except Exception as e:
+        except retryable_exceptions as e:
             last_error = e
 
             if attempt == max_attempts - 1:

tests/test_retry.py

@@ -52,6 +52,24 @@ async def should_not_be_called() -> str:
         with pytest.raises(ValueError, match="max_attempts must be at least 1"):
             await retry_with_backoff(should_not_be_called, max_attempts=0)
 
+    async def test_non_retryable_exception_fails_immediately(self) -> None:
+        call_count = 0
+
+        async def raise_type_error() -> str:
+            nonlocal call_count
+            call_count += 1
+            raise TypeError("bug")
+
+        with pytest.raises(TypeError, match="bug"):
+            await retry_with_backoff(
+                raise_type_error,
+                max_attempts=5,
+                base_delay=0.01,
+                retryable_exceptions=(ValueError,),
+            )
+
+        assert call_count == 1  # Should not retry
+
     async def test_respects_max_delay(self) -> None:
         import time