style: apply ruff format to source and test files

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -30,12 +30,10 @@ def _parse_address(address: str) -> tuple[str, int]:
             )
         bracket_end = address.index("]")
         host = address[1:bracket_end]
-        port_str = address[bracket_end + 2:]  # Skip ']:
+        port_str = address[bracket_end + 2 :]  # Skip ']:
     else:
         if ":" not in address:
-            raise ValueError(
-                f"Invalid address format: expected 'host:port', got {address!r}"
-            )
+            raise ValueError(f"Invalid address format: expected 'host:port', got {address!r}")
         host, port_str = address.rsplit(":", 1)
 
     try:
@@ -101,13 +99,9 @@ async def connect(self) -> None:
                     timeout=self._timeout,
                 )
             except TimeoutError as e:
-                raise DqliteConnectionError(
-                    f"Connection to {self._address} timed out"
-                ) from e
+                raise DqliteConnectionError(f"Connection to {self._address} timed out") from e
             except OSError as e:
-                raise DqliteConnectionError(
-                    f"Failed to connect to {self._address}: {e}"
-                ) from e
+                raise DqliteConnectionError(f"Failed to connect to {self._address}: {e}") from e
 
             self._protocol = DqliteProtocol(reader, writer, timeout=self._timeout)
 

src/dqliteclient/pool.py

@@ -37,9 +37,7 @@ def __init__(
         if max_size < 1:
             raise ValueError(f"max_size must be at least 1, got {max_size}")
         if min_size > max_size:
-            raise ValueError(
-                f"min_size ({min_size}) must not exceed max_size ({max_size})"
-            )
+            raise ValueError(f"min_size ({min_size}) must not exceed max_size ({max_size})")
         if timeout <= 0:
             raise ValueError(f"timeout must be positive, got {timeout}")
 
@@ -122,9 +120,7 @@ async def acquire(self) -> AsyncIterator[DqliteConnection]:
                     f"(max_size={self._max_size}, timeout={self._timeout}s)"
                 )
             try:
-                conn = await asyncio.wait_for(
-                    self._pool.get(), timeout=min(remaining, 0.5)
-                )
+                conn = await asyncio.wait_for(self._pool.get(), timeout=min(remaining, 0.5))
             except TimeoutError:
                 # Don't fail yet — loop back to re-check _size
                 continue

src/dqliteclient/protocol.py

@@ -164,9 +164,7 @@ async def exec_sql(
                 raise OperationalError(response.code, response.message)
 
             if not isinstance(response, ResultResponse):
-                raise ProtocolError(
-                    f"Expected ResultResponse, got {type(response).__name__}"
-                )
+                raise ProtocolError(f"Expected ResultResponse, got {type(response).__name__}")
 
             last_insert_id = response.last_insert_id
             rows_affected += response.rows_affected
@@ -220,13 +218,9 @@ async def query_sql(
     async def _read_data(self) -> bytes:
         """Read data from the stream with timeout."""
         try:
-            data = await asyncio.wait_for(
-                self._reader.read(4096), timeout=self._timeout
-            )
+            data = await asyncio.wait_for(self._reader.read(4096), timeout=self._timeout)
         except TimeoutError:
-            raise DqliteConnectionError(
-                f"Server read timed out after {self._timeout}s"
-            ) from None
+            raise DqliteConnectionError(f"Server read timed out after {self._timeout}s") from None
         if not data:
             raise DqliteConnectionError("Connection closed by server")
         return data

tests/integration/test_single_node.py

@@ -23,9 +23,7 @@ async def test_connect_and_query(self, cluster_address: str) -> None:
     async def test_create_table_and_insert(self, cluster_address: str) -> None:
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_single")
-            await conn.execute(
-                "CREATE TABLE test_single (id INTEGER PRIMARY KEY, name TEXT)"
-            )
+            await conn.execute("CREATE TABLE test_single (id INTEGER PRIMARY KEY, name TEXT)")
             await conn.execute("INSERT INTO test_single (name) VALUES (?)", ["test"])
 
             rows = await conn.fetch("SELECT * FROM test_single WHERE name = ?", ["test"])
@@ -35,9 +33,7 @@ async def test_create_table_and_insert(self, cluster_address: str) -> None:
     async def test_transaction_commit(self, cluster_address: str) -> None:
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_tx")
-            await conn.execute(
-                "CREATE TABLE test_tx (id INTEGER PRIMARY KEY, val TEXT)"
-            )
+            await conn.execute("CREATE TABLE test_tx (id INTEGER PRIMARY KEY, val TEXT)")
 
             async with conn.transaction():
                 await conn.execute("INSERT INTO test_tx (val) VALUES (?)", ["committed"])
@@ -48,9 +44,7 @@ async def test_transaction_commit(self, cluster_address: str) -> None:
     async def test_transaction_rollback(self, cluster_address: str) -> None:
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_rollback")
-            await conn.execute(
-                "CREATE TABLE test_rollback (id INTEGER PRIMARY KEY, val TEXT)"
-            )
+            await conn.execute("CREATE TABLE test_rollback (id INTEGER PRIMARY KEY, val TEXT)")
 
             try:
                 async with conn.transaction():
@@ -61,18 +55,14 @@ async def test_transaction_rollback(self, cluster_address: str) -> None:
             except ValueError:
                 pass
 
-            rows = await conn.fetch(
-                "SELECT * FROM test_rollback WHERE val = ?", ["rollback_test"]
-            )
+            rows = await conn.fetch("SELECT * FROM test_rollback WHERE val = ?", ["rollback_test"])
             assert len(rows) == 0
 
     async def test_unicode_text(self, cluster_address: str) -> None:
         """Test Unicode text handling including emojis, CJK, RTL."""
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_unicode")
-            await conn.execute(
-                "CREATE TABLE test_unicode (id INTEGER PRIMARY KEY, val TEXT)"
-            )
+            await conn.execute("CREATE TABLE test_unicode (id INTEGER PRIMARY KEY, val TEXT)")
 
             unicode_values = [
                 # Emojis (4-byte UTF-8)
@@ -109,9 +99,7 @@ async def test_binary_blob(self, cluster_address: str) -> None:
         """Test binary blob handling including null bytes."""
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_blob")
-            await conn.execute(
-                "CREATE TABLE test_blob (id INTEGER PRIMARY KEY, data BLOB)"
-            )
+            await conn.execute("CREATE TABLE test_blob (id INTEGER PRIMARY KEY, data BLOB)")
 
             blob_values = [
                 b"simple",
@@ -126,9 +114,7 @@ async def test_binary_blob(self, cluster_address: str) -> None:
                 await conn.execute("INSERT INTO test_blob (data) VALUES (?)", [val])
 
                 # Retrieve and verify
-                rows = await conn.fetch(
-                    "SELECT data FROM test_blob ORDER BY id DESC LIMIT 1"
-                )
+                rows = await conn.fetch("SELECT data FROM test_blob ORDER BY id DESC LIMIT 1")
                 assert len(rows) == 1
                 assert rows[0]["data"] == val, f"Mismatch for blob: {repr(val)}"
 
@@ -172,9 +158,7 @@ async def test_boolean_values(self, cluster_address: str) -> None:
         """Test boolean handling (SQLite uses INTEGER 0/1)."""
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_bool")
-            await conn.execute(
-                "CREATE TABLE test_bool (id INTEGER PRIMARY KEY, flag INTEGER)"
-            )
+            await conn.execute("CREATE TABLE test_bool (id INTEGER PRIMARY KEY, flag INTEGER)")
 
             # Insert True and False as integers (SQLite doesn't have native BOOLEAN)
             await conn.execute("INSERT INTO test_bool (flag) VALUES (?)", [1])
@@ -190,21 +174,16 @@ async def test_datetime_as_text(self, cluster_address: str) -> None:
         async with await connect(cluster_address) as conn:
             await conn.execute("DROP TABLE IF EXISTS test_datetime")
             await conn.execute(
-                "CREATE TABLE test_datetime "
-                "(id INTEGER PRIMARY KEY, created_at TEXT)"
+                "CREATE TABLE test_datetime (id INTEGER PRIMARY KEY, created_at TEXT)"
             )
 
             # Store datetime as ISO8601 string
             now = datetime.datetime.now()
             iso_string = now.isoformat()
 
-            await conn.execute(
-                "INSERT INTO test_datetime (created_at) VALUES (?)", [iso_string]
-            )
+            await conn.execute("INSERT INTO test_datetime (created_at) VALUES (?)", [iso_string])
 
-            rows = await conn.fetch(
-                "SELECT created_at FROM test_datetime ORDER BY id DESC LIMIT 1"
-            )
+            rows = await conn.fetch("SELECT created_at FROM test_datetime ORDER BY id DESC LIMIT 1")
             assert len(rows) == 1
             assert rows[0]["created_at"] == iso_string
 

tests/test_pool.py

@@ -187,7 +187,6 @@ async def test_acquire_timeout_when_pool_exhausted(self) -> None:
                 async with pool.acquire():
                     pass
 
-
     async def test_close_during_acquire_does_not_corrupt_size(self) -> None:
         """Closing the pool while connections are in-use must not make _size negative."""
         import asyncio
@@ -430,7 +429,6 @@ async def test_close_then_return_closes_connection(self) -> None:
         # The connection should have been closed on return (not put back in queue)
         mock_conn.close.assert_called()
 
-
     async def test_user_exception_preserves_healthy_connection(self) -> None:
         """A user-code exception should not destroy a healthy connection."""
         pool = ConnectionPool(["localhost:9001"], max_size=2)

tests/test_protocol.py

@@ -38,9 +38,7 @@ async def test_handshake_caps_heartbeat_timeout(
 
         # Server sends an absurdly large heartbeat timeout (e.g., corrupted value)
         huge_timeout_ms = 10_000_000  # 10000 seconds
-        mock_reader.read.return_value = WelcomeResponse(
-            heartbeat_timeout=huge_timeout_ms
-        ).encode()
+        mock_reader.read.return_value = WelcomeResponse(heartbeat_timeout=huge_timeout_ms).encode()
 
         protocol = DqliteProtocol(mock_reader, mock_writer, timeout=10.0)
         await protocol.handshake()
@@ -265,9 +263,7 @@ async def test_prepare(
     ) -> None:
         from dqlitewire.messages import StmtResponse
 
-        mock_reader.read.return_value = StmtResponse(
-            db_id=1, stmt_id=1, num_params=2
-        ).encode()
+        mock_reader.read.return_value = StmtResponse(db_id=1, stmt_id=1, num_params=2).encode()
 
         stmt_id, num_params = await protocol.prepare(1, "INSERT INTO t VALUES (?, ?)")