Correct DqliteConnection.__reduce__ docstring on actual class state

The TypeError diagnostic and rationale comment named "a WeakSet of
registered cursors" — but DqliteConnection has no WeakSet, no
``_cursors`` attribute, no cursor tracking at all (verified by
``vars(conn)`` enumeration). The empirical "post-connect cryptic
AttributeError('Can't pickle local object
'WeakSet.__init__.<locals>._remove'')" claim in the docstring and
test docstring was also empirically wrong — pre-fix, bypassing the
guard, ``DqliteConnection`` actually pickled silently and produced
a corrupt duplicate (the same failure mode ConnectionPool's reject
correctly described).

Replace both pieces of misleading text with the actual class state
(live socket / loop-bound asyncio.Lock / loop-bound wire protocol)
and the actual pre-fix failure mode (silent corrupt duplicate via
default __reduce__). The runtime ``TypeError`` message and the
rationale comment now match what ``vars(conn)`` actually shows.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -950,18 +950,19 @@ def __repr__(self) -> str:
         return f"<DqliteConnection address={self._address!r} database={self._database!r} {state}>"
 
     def __reduce__(self) -> NoReturn:
-        # ``DqliteConnection`` holds a live socket, an event-loop-bound
-        # asyncio.Lock, and a WeakSet of registered cursors — none of
-        # which survive serialization. Surface a clear driver-level
-        # TypeError instead of leaking the underlying ``cannot pickle
-        # '_thread.lock'`` (or, worse, the cryptic
-        # ``Can't pickle local object 'WeakSet.__init__.<locals>._remove'``
-        # post-connect). Symmetric with the dbapi-layer guards on
-        # Connection / Cursor.
+        # ``DqliteConnection`` holds a live socket (writer transport),
+        # an event-loop-bound asyncio.Lock (``_op_lock``), and a
+        # ``DqliteProtocol`` that wraps loop-bound StreamReader /
+        # StreamWriter — none of which survive serialization. Surface
+        # a clear driver-level TypeError instead of leaking the
+        # underlying ``cannot pickle '_thread.lock'`` from pickle's
+        # default object-graph walk. Symmetric with the dbapi-layer
+        # guards on Connection / Cursor and the wire-layer guards on
+        # MessageEncoder / MessageDecoder / ReadBuffer / WriteBuffer.
         raise TypeError(
             f"cannot pickle {type(self).__name__!r} object — holds a "
-            f"live socket, loop-bound asyncio.Lock, and weak cursor "
-            f"refs; reconstruct from configuration in the target "
+            f"live socket, loop-bound asyncio.Lock, and a wire "
+            f"protocol; reconstruct from configuration in the target "
             f"process instead."
         )
 

tests/test_pickle_guards.py

@@ -7,10 +7,11 @@
   primitives became pickleable in 3.10+) — producing a
   "live"-looking duplicate detached from any loop. Any use yields
   opaque corruption.
-- ``DqliteConnection`` post-``connect()`` raises a cryptic
-  ``AttributeError("Can't pickle local object
-  'WeakSet.__init__.<locals>._remove'")`` from the cursor-tracking
-  weak set.
+- ``DqliteConnection`` (post- or pre-``connect()``) silently
+  produces a corrupt duplicate via the default
+  ``Exception.__reduce__`` walk; without an explicit reject the
+  duplicate looks "live" but holds severed loop bindings and
+  half-state.
 - ``DqliteProtocol`` raises an opaque error from wrapped
   StreamReader / StreamWriter.