fix: rename ConnectionError to DqliteConnectionError

Avoids shadowing Python's builtin ConnectionError, which caused
confusion in exception handlers and broke wildcard imports.

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

Author: antoineleclair

src/dqliteclient/__init__.py

@@ -4,7 +4,7 @@
 from dqliteclient.connection import DqliteConnection
 from dqliteclient.exceptions import (
     ClusterError,
-    ConnectionError,
+    DqliteConnectionError,
     DqliteError,
     OperationalError,
     ProtocolError,
@@ -21,7 +21,7 @@
     "NodeStore",
     "MemoryNodeStore",
     "DqliteError",
-    "ConnectionError",
+    "DqliteConnectionError",
     "ProtocolError",
     "ClusterError",
     "OperationalError",

src/dqliteclient/connection.py

@@ -5,7 +5,7 @@
 from contextlib import asynccontextmanager
 from typing import Any
 
-from dqliteclient.exceptions import ConnectionError, OperationalError, ProtocolError
+from dqliteclient.exceptions import DqliteConnectionError, OperationalError, ProtocolError
 from dqliteclient.protocol import DqliteProtocol
 
 
@@ -57,9 +57,9 @@ async def connect(self) -> None:
                 timeout=self._timeout,
             )
         except TimeoutError as e:
-            raise ConnectionError(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 ConnectionError(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)
 
@@ -89,7 +89,7 @@ async def __aexit__(self, *args: Any) -> None:
     def _ensure_connected(self) -> tuple[DqliteProtocol, int]:
         """Ensure we're connected and return protocol and db_id."""
         if self._protocol is None or self._db_id is None:
-            raise ConnectionError("Not connected")
+            raise DqliteConnectionError("Not connected")
         return self._protocol, self._db_id
 
     def _invalidate(self) -> None:
@@ -105,7 +105,7 @@ async def execute(self, sql: str, params: list[Any] | None = None) -> tuple[int,
         protocol, db_id = self._ensure_connected()
         try:
             return await protocol.exec_sql(db_id, sql, params)
-        except (ConnectionError, ProtocolError):
+        except (DqliteConnectionError, ProtocolError):
             self._invalidate()
             raise
 
@@ -114,7 +114,7 @@ async def fetch(self, sql: str, params: list[Any] | None = None) -> list[dict[st
         protocol, db_id = self._ensure_connected()
         try:
             columns, rows = await protocol.query_sql(db_id, sql, params)
-        except (ConnectionError, ProtocolError):
+        except (DqliteConnectionError, ProtocolError):
             self._invalidate()
             raise
         return [dict(zip(columns, row, strict=True)) for row in rows]
@@ -124,7 +124,7 @@ async def fetchall(self, sql: str, params: list[Any] | None = None) -> list[list
         protocol, db_id = self._ensure_connected()
         try:
             _, rows = await protocol.query_sql(db_id, sql, params)
-        except (ConnectionError, ProtocolError):
+        except (DqliteConnectionError, ProtocolError):
             self._invalidate()
             raise
         return rows
@@ -139,7 +139,7 @@ async def fetchval(self, sql: str, params: list[Any] | None = None) -> Any:
         protocol, db_id = self._ensure_connected()
         try:
             _, rows = await protocol.query_sql(db_id, sql, params)
-        except (ConnectionError, ProtocolError):
+        except (DqliteConnectionError, ProtocolError):
             self._invalidate()
             raise
         if rows and rows[0]:

src/dqliteclient/exceptions.py

@@ -7,7 +7,7 @@ class DqliteError(Exception):
     pass
 
 
-class ConnectionError(DqliteError):
+class DqliteConnectionError(DqliteError):
     """Error establishing or maintaining connection."""
 
     pass

src/dqliteclient/pool.py

@@ -7,7 +7,7 @@
 
 from dqliteclient.cluster import ClusterClient
 from dqliteclient.connection import DqliteConnection
-from dqliteclient.exceptions import ConnectionError
+from dqliteclient.exceptions import DqliteConnectionError
 
 
 class ConnectionPool:
@@ -59,7 +59,7 @@ async def _create_connection(self) -> DqliteConnection:
     async def acquire(self) -> AsyncIterator[DqliteConnection]:
         """Acquire a connection from the pool."""
         if self._closed:
-            raise ConnectionError("Pool is closed")
+            raise DqliteConnectionError("Pool is closed")
 
         conn: DqliteConnection | None = None
 

src/dqliteclient/protocol.py

@@ -3,7 +3,7 @@
 import asyncio
 from typing import Any
 
-from dqliteclient.exceptions import ConnectionError, OperationalError, ProtocolError
+from dqliteclient.exceptions import DqliteConnectionError, OperationalError, ProtocolError
 from dqlitewire import MessageDecoder, MessageEncoder, ReadBuffer
 from dqlitewire.messages import (
     ClientRequest,
@@ -198,15 +198,15 @@ async def _read_continuation(self) -> RowsResponse:
                 return result
             data = await self._reader.read(4096)
             if not data:
-                raise ConnectionError("Connection closed by server")
+                raise DqliteConnectionError("Connection closed by server")
             self._decoder.feed(data)
 
     async def _read_response(self) -> Message:
         """Read and decode the next response message."""
         while not self._decoder.has_message():
             data = await self._reader.read(4096)
             if not data:
-                raise ConnectionError("Connection closed by server")
+                raise DqliteConnectionError("Connection closed by server")
             self._decoder.feed(data)
 
         message = self._decoder.decode()

tests/test_connection.py

@@ -5,7 +5,7 @@
 import pytest
 
 from dqliteclient.connection import DqliteConnection
-from dqliteclient.exceptions import ConnectionError
+from dqliteclient.exceptions import DqliteConnectionError
 
 
 class TestDqliteConnection:
@@ -51,7 +51,7 @@ async def slow_connect(*args, **kwargs):
 
         with (
             patch("asyncio.open_connection", side_effect=slow_connect),
-            pytest.raises(ConnectionError, match="timed out"),
+            pytest.raises(DqliteConnectionError, match="timed out"),
         ):
             await conn.connect()
 
@@ -63,7 +63,7 @@ async def test_connect_refused(self) -> None:
                 "asyncio.open_connection",
                 side_effect=OSError("Connection refused"),
             ),
-            pytest.raises(ConnectionError, match="Failed to connect"),
+            pytest.raises(DqliteConnectionError, match="Failed to connect"),
         ):
             await conn.connect()
 
@@ -91,7 +91,7 @@ async def test_context_manager(self) -> None:
     async def test_execute_not_connected(self) -> None:
         conn = DqliteConnection("localhost:9001")
 
-        with pytest.raises(ConnectionError, match="Not connected"):
+        with pytest.raises(DqliteConnectionError, match="Not connected"):
             await conn.execute("SELECT 1")
 
     async def test_nested_transaction_raises(self) -> None:
@@ -132,7 +132,7 @@ async def mock_execute(sql: str, params=None):
     async def test_fetch_not_connected(self) -> None:
         conn = DqliteConnection("localhost:9001")
 
-        with pytest.raises(ConnectionError, match="Not connected"):
+        with pytest.raises(DqliteConnectionError, match="Not connected"):
             await conn.fetch("SELECT 1")
 
     async def test_transaction_rollback_failure_preserves_original_exception(self) -> None:
@@ -204,8 +204,6 @@ async def test_connection_invalidated_after_protocol_error(self) -> None:
         # Now make the reader return empty (connection closed)
         mock_reader.read.side_effect = [b""]
 
-        from dqliteclient.exceptions import ConnectionError as DqliteConnectionError
-
         with pytest.raises(DqliteConnectionError):
             await conn.execute("SELECT 1")
 

tests/test_pool.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from dqliteclient.exceptions import ConnectionError
+from dqliteclient.exceptions import DqliteConnectionError
 from dqliteclient.pool import ConnectionPool
 
 
@@ -28,7 +28,7 @@ async def test_acquire_when_closed(self) -> None:
         pool = ConnectionPool(["localhost:9001"])
         pool._closed = True
 
-        with pytest.raises(ConnectionError, match="Pool is closed"):
+        with pytest.raises(DqliteConnectionError, match="Pool is closed"):
             async with pool.acquire():
                 pass