Cycle 11: apply ruff --fix; contextlib.suppress over try/except/pass

Extending linting to the full project (run-tests.sh previously only
linted the wire package) surfaced import ordering drift, SIM105
try/except/pass patterns, and SIM201 negated equality in tests.
Applied the auto-fixes (including --unsafe-fixes) and manually
rewrote the three remaining SIM105 sites in connection.py and
aio/connection.py to contextlib.suppress for readability.

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

Author: antoineleclair

src/dqlitedbapi/aio/connection.py

@@ -1,6 +1,7 @@
 """Async connection implementation for dqlite."""
 
 import asyncio
+import contextlib
 from typing import Any
 
 from dqliteclient import DqliteConnection
@@ -159,9 +160,7 @@ def cursor(self) -> AsyncCursor:
 
     def __repr__(self) -> str:
         state = "closed" if self._closed else ("connected" if self._async_conn else "unused")
-        return (
-            f"<AsyncConnection address={self._address!r} database={self._database!r} {state}>"
-        )
+        return f"<AsyncConnection address={self._address!r} database={self._database!r} {state}>"
 
     async def __aenter__(self) -> "AsyncConnection":
         await self.connect()
@@ -175,9 +174,7 @@ async def __aexit__(self, exc_type: type[BaseException] | None, *args: Any) -> N
             if exc_type is None:
                 await self.commit()
             else:
-                try:
-                    await self.rollback()
-                except Exception:
-                    pass  # Body's exception wins.
+                with contextlib.suppress(Exception):
+                    await self.rollback()  # Body's exception wins.
         finally:
             await self.close()

src/dqlitedbapi/connection.py

@@ -29,25 +29,21 @@ def _cleanup_loop_thread(
     if closed_flag[0] is False:
         # User never called close() → leak warning (matches stdlib
         # sqlite3). Don't crash at interpreter shutdown.
-        try:
+        with contextlib.suppress(Exception):
             warnings.warn(
                 f"Connection(address={address!r}) was garbage-collected "
                 f"without close(); cleaning up event-loop thread. Call "
                 f"Connection.close() explicitly to avoid this warning.",
                 ResourceWarning,
                 stacklevel=2,
             )
-        except Exception:
-            pass
     try:
         if not loop.is_closed():
             loop.call_soon_threadsafe(loop.stop)
     except Exception:
         pass
-    try:
+    with contextlib.suppress(Exception):
         thread.join(timeout=5)
-    except Exception:
-        pass
     try:
         if not loop.is_closed():
             loop.close()
@@ -170,13 +166,12 @@ def _run_sync(self, coro: Any) -> Any:
                 # half-written a request; the wire is in unknown state.
                 # Fire-and-forget on the loop thread (don't await).
                 if self._async_conn is not None:
-                    try:
+                    # RuntimeError if the loop is already shutting down.
+                    with contextlib.suppress(RuntimeError):
                         loop.call_soon_threadsafe(
                             self._async_conn._invalidate,
                             OperationalError(f"sync timeout after {self._timeout}s"),
                         )
-                    except RuntimeError:
-                        pass  # loop already shutting down
                 raise OperationalError(f"Operation timed out after {self._timeout} seconds") from e
 
     async def _get_async_connection(self) -> DqliteConnection:
@@ -306,9 +301,7 @@ def cursor(self) -> Cursor:
 
     def __repr__(self) -> str:
         state = "closed" if self._closed else ("connected" if self._async_conn else "unused")
-        return (
-            f"<Connection address={self._address!r} database={self._database!r} {state}>"
-        )
+        return f"<Connection address={self._address!r} database={self._database!r} {state}>"
 
     def __enter__(self) -> "Connection":
         return self
@@ -328,9 +321,7 @@ def __exit__(self, exc_type: type[BaseException] | None, *args: Any) -> None:
                 # Body already raised; attempt rollback but don't mask
                 # the original exception. If rollback itself fails, its
                 # error is attached via __context__ automatically.
-                try:
+                with contextlib.suppress(Exception):
                     self.rollback()
-                except Exception:
-                    pass  # Body's exception wins; rollback failure is attached as context.
         finally:
             self.close()

src/dqlitedbapi/cursor.py

@@ -4,8 +4,6 @@
 from typing import TYPE_CHECKING, Any
 
 import dqliteclient.exceptions as _client_exc
-from dqlitewire.constants import ValueType
-
 from dqlitedbapi.exceptions import (
     DataError,
     InterfaceError,
@@ -20,6 +18,7 @@
     _datetime_from_iso8601,
     _datetime_from_unixtime,
 )
+from dqlitewire.constants import ValueType
 
 
 async def _call_client(coro: Coroutine[Any, Any, Any]) -> Any:
@@ -49,6 +48,7 @@ async def _call_client(coro: Coroutine[Any, Any, Any]) -> Any:
     except _client_exc.InterfaceError as e:
         raise _DbapiInterfaceError(str(e)) from e
 
+
 if TYPE_CHECKING:
     from dqlitedbapi.connection import Connection
 

tests/integration/test_datetime_conversion.py

@@ -10,10 +10,10 @@
 import datetime
 
 import pytest
-from dqlitewire.constants import ValueType
 
 from dqlitedbapi import connect
 from dqlitedbapi.aio.connection import AsyncConnection
+from dqlitewire.constants import ValueType
 
 
 @pytest.mark.integration
@@ -29,7 +29,9 @@ def test_naive_datetime_stays_naive(self, cluster_address: str) -> None:
         dt = datetime.datetime(2024, 1, 15, 10, 30, 45)  # noqa: DTZ001 - naive is the point
         with connect(cluster_address, database="test_dt_naive") as conn:
             cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS dt_naive (id INTEGER PRIMARY KEY, ts DATETIME)")
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS dt_naive (id INTEGER PRIMARY KEY, ts DATETIME)"
+            )
             cursor.execute("DELETE FROM dt_naive")
             cursor.execute("INSERT INTO dt_naive (ts) VALUES (?)", [dt])
             cursor.execute("SELECT ts FROM dt_naive")
@@ -45,7 +47,9 @@ def test_aware_datetime_preserves_offset(self, cluster_address: str) -> None:
         dt = datetime.datetime(2024, 6, 15, 12, 30, 45, tzinfo=tz)
         with connect(cluster_address, database="test_dt_aware") as conn:
             cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS dt_aware (id INTEGER PRIMARY KEY, ts DATETIME)")
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS dt_aware (id INTEGER PRIMARY KEY, ts DATETIME)"
+            )
             cursor.execute("DELETE FROM dt_aware")
             cursor.execute("INSERT INTO dt_aware (ts) VALUES (?)", [dt])
             cursor.execute("SELECT ts FROM dt_aware")
@@ -72,7 +76,9 @@ def test_null_datetime_returns_none(self, cluster_address: str) -> None:
         """NULL in a DATETIME column is None on read (not an exception)."""
         with connect(cluster_address, database="test_dt_null") as conn:
             cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS dt_null (id INTEGER PRIMARY KEY, ts DATETIME)")
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS dt_null (id INTEGER PRIMARY KEY, ts DATETIME)"
+            )
             cursor.execute("DELETE FROM dt_null")
             cursor.execute("INSERT INTO dt_null (ts) VALUES (NULL)")
             cursor.execute("SELECT ts FROM dt_null")
@@ -117,7 +123,9 @@ def test_integer_value_in_datetime_column_decodes_as_datetime(
         epoch = int(expected.timestamp())
         with connect(cluster_address, database="test_unixtime") as conn:
             cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS ut_test (id INTEGER PRIMARY KEY, ts DATETIME)")
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS ut_test (id INTEGER PRIMARY KEY, ts DATETIME)"
+            )
             cursor.execute("DELETE FROM ut_test")
             # Bind an int — SQLite stores it as INTEGER affinity; server then
             # tags the column as DQLITE_UNIXTIME on readback.
@@ -136,11 +144,11 @@ class TestDescriptionTypeCode:
     def test_iso8601_column_description(self, cluster_address: str) -> None:
         with connect(cluster_address, database="test_desc_iso") as conn:
             cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS desc_iso (id INTEGER PRIMARY KEY, ts DATETIME)")
-            cursor.execute("DELETE FROM desc_iso")
             cursor.execute(
-                "INSERT INTO desc_iso (ts) VALUES (?)", ["2024-01-15 10:30:45"]
+                "CREATE TABLE IF NOT EXISTS desc_iso (id INTEGER PRIMARY KEY, ts DATETIME)"
             )
+            cursor.execute("DELETE FROM desc_iso")
+            cursor.execute("INSERT INTO desc_iso (ts) VALUES (?)", ["2024-01-15 10:30:45"])
             cursor.execute("SELECT id, ts FROM desc_iso")
             cursor.fetchall()
             assert cursor.description is not None

tests/integration/test_misc_coverage.py

@@ -5,9 +5,9 @@
 - ISSUE-28: multi-statement SQL is rejected with a specific error.
 """
 
-import dqliteclient.exceptions
 import pytest
 
+import dqliteclient.exceptions
 from dqlitedbapi import connect
 from dqlitedbapi.exceptions import OperationalError
 

tests/test_context_manager_exit.py

@@ -8,7 +8,6 @@
 instead of disappearing.
 """
 
-import asyncio
 from unittest.mock import AsyncMock
 
 import pytest
@@ -31,9 +30,8 @@ def test_clean_exit_commit_failure_propagates(self) -> None:
         """No body exception → commit failure surfaces, not swallowed."""
         conn = _make_conn_with_failing_commit()
         try:
-            with pytest.raises(OperationalError, match="disk full"):
-                with conn:
-                    pass  # clean body → __exit__ calls commit, which raises
+            with pytest.raises(OperationalError, match="disk full"), conn:
+                pass  # clean body → __exit__ calls commit, which raises
         finally:
             conn.close()
 
@@ -45,9 +43,8 @@ def test_body_exception_wins_over_rollback_failure(self) -> None:
         conn = _make_conn_with_failing_commit()
         body_error = ValueError("user bug")
         try:
-            with pytest.raises(ValueError, match="user bug"):
-                with conn:
-                    raise body_error
+            with pytest.raises(ValueError, match="user bug"), conn:
+                raise body_error
         finally:
             conn.close()
 

tests/test_exception_mapping.py

@@ -9,9 +9,9 @@
 import asyncio
 from unittest.mock import AsyncMock, MagicMock
 
-import dqliteclient.exceptions as client_exc
 import pytest
 
+import dqliteclient.exceptions as client_exc
 import dqlitedbapi.exceptions as dbapi_exc
 from dqlitedbapi.cursor import Cursor
 

tests/test_executemany_empty.py

@@ -1,6 +1,6 @@
 """executemany([]) doesn't leak stale SELECT state (ISSUE-34)."""
 
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 from dqlitedbapi.cursor import Cursor
 

tests/test_gc_cleanup.py

@@ -14,8 +14,6 @@
 import threading
 import warnings
 
-import pytest
-
 from dqlitedbapi.connection import Connection
 
 

tests/test_max_total_rows_plumbing.py

@@ -5,8 +5,6 @@
 the protocol, so users can't silently end up with the default.
 """
 
-import asyncio
-
 from dqlitedbapi.aio.connection import AsyncConnection
 from dqlitedbapi.connection import Connection