Classify wrapped DqliteConnectionError via __cause__ in is_disconnect

The dbapi's _call_client wraps a client-level DqliteConnectionError
into a bare OperationalError, so the direct isinstance check in
is_disconnect against DqliteConnectionError only fires for connect-
path errors, not cursor-path ones. Walk the standard __cause__ chain
— set automatically by `raise ... from e` — so the chained form is
classified identically without inventing a new attribute on the
dbapi exception. The existing substring fallback still catches any
wrapper without a __cause__.

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

Author: antoineleclair

src/sqlalchemydqlite/base.py

@@ -350,6 +350,15 @@ def is_disconnect(self, e: Any, connection: Any, cursor: Any) -> bool:
         # Explicit connection-level error types from the client layer.
         if isinstance(e, _client_exc.DqliteConnectionError):
             return True
+        # The dbapi ``_call_client`` handler wraps
+        # ``_client_exc.DqliteConnectionError`` into a bare
+        # ``dbapi.OperationalError`` (no code). The wrapped class is
+        # unreachable by the direct isinstance above, but Python sets
+        # ``__cause__`` from ``raise ... from e``, so walking the chain
+        # keeps the disconnect classification working without inventing
+        # a new attribute.
+        if isinstance(getattr(e, "__cause__", None), _client_exc.DqliteConnectionError):
+            return True
         # Underlying OS-level transport failures (socket RST, broken pipe,
         # DNS, connect refused) surface as these stdlib types.
         if isinstance(e, (ConnectionError, BrokenPipeError, TimeoutError, OSError)):

tests/test_dialect.py

@@ -381,6 +381,24 @@ def test_does_not_flag_other_interface_errors(self) -> None:
         e = dqlitedbapi.exceptions.InterfaceError("arraysize must be positive")
         assert dialect.is_disconnect(e, None, None) is False
 
+    def test_recognizes_wrapped_dqlite_connection_error_via_cause(self) -> None:
+        """The dbapi ``_call_client`` handler wraps a client-level
+        ``DqliteConnectionError`` into a bare ``OperationalError`` (no
+        code). Without walking ``__cause__`` the direct
+        isinstance branch would miss the wrapped form entirely. Pin
+        the chain inspection so the dead-code isinstance branch above
+        remains load-bearing for chained errors too.
+        """
+        import dqliteclient.exceptions as _client_exc
+        import dqlitedbapi.exceptions
+
+        dialect = DqliteDialect()
+        original = _client_exc.DqliteConnectionError("peer RST")
+        try:
+            raise dqlitedbapi.exceptions.OperationalError("wrapped") from original
+        except dqlitedbapi.exceptions.OperationalError as wrapped:
+            assert dialect.is_disconnect(wrapped, None, None) is True
+
 
 class TestIsolationLevel:
     def test_set_isolation_level_warns_on_unsupported(self) -> None: