Inherit dqliteclient.ProtocolError from the wire-layer one

Two unrelated classes named ProtocolError lived in dqlitewire and
dqliteclient with no class relationship. A caller writing
``except ProtocolError:`` caught only the one whose module they
imported, which is an ergonomic trap at layering boundaries. Make the
client class inherit from both DqliteError (unchanged) and
dqlitewire.exceptions.ProtocolError so ``except dqlitewire.ProtocolError``
catches both variants and ``except dqliteclient.DqliteError`` keeps
working.

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

Author: antoineleclair

src/dqliteclient/exceptions.py

@@ -1,5 +1,7 @@
 """Exceptions for dqlite client."""
 
+from dqlitewire.exceptions import ProtocolError as _WireProtocolError
+
 
 class DqliteError(Exception):
     """Base exception for dqlite client errors."""
@@ -9,8 +11,18 @@ class DqliteConnectionError(DqliteError):
     """Error establishing or maintaining connection."""
 
 
-class ProtocolError(DqliteError):
-    """Protocol-level error."""
+class ProtocolError(DqliteError, _WireProtocolError):
+    """Protocol-level error.
+
+    Inherits from both the client's ``DqliteError`` hierarchy (so
+    ``except DqliteError`` still catches it) and the wire-layer
+    ``dqlitewire.exceptions.ProtocolError`` (so a caller who wants to
+    catch protocol-level problems at *any* layer can write
+    ``except dqlitewire.ProtocolError`` and get both the wire- and
+    client-level variants). Without the dual parent, the two identically
+    named classes caught only half the surface depending on which module
+    the caller imported.
+    """
 
 
 class InterfaceError(DqliteError):

tests/test_connection.py

@@ -1035,3 +1035,39 @@ async def hang_forever() -> None:
         # No outer timeout: the internal 0.5s wait_for expires, the
         # resulting TimeoutError is suppressed, and the call returns.
         await conn._abort_protocol()
+
+
+class TestProtocolErrorHierarchy:
+    """Cross-layer exception catching works: dqliteclient.ProtocolError
+    is a subclass of BOTH dqliteclient.DqliteError and
+    dqlitewire.exceptions.ProtocolError, so callers can catch either
+    ancestor and get both variants.
+    """
+
+    def test_client_protocol_error_subclass_of_wire_version(self) -> None:
+        import dqlitewire.exceptions
+        from dqliteclient.exceptions import ProtocolError
+
+        assert issubclass(ProtocolError, dqlitewire.exceptions.ProtocolError)
+
+    def test_client_protocol_error_subclass_of_dqlite_error(self) -> None:
+        from dqliteclient.exceptions import DqliteError, ProtocolError
+
+        assert issubclass(ProtocolError, DqliteError)
+
+    def test_except_wire_protocol_error_catches_client_variant(self) -> None:
+        import pytest as _pytest
+
+        import dqlitewire.exceptions
+        from dqliteclient.exceptions import ProtocolError
+
+        with _pytest.raises(dqlitewire.exceptions.ProtocolError):
+            raise ProtocolError("boom")
+
+    def test_except_dqlite_error_still_catches_client_variant(self) -> None:
+        import pytest as _pytest
+
+        from dqliteclient.exceptions import DqliteError, ProtocolError
+
+        with _pytest.raises(DqliteError):
+            raise ProtocolError("boom")