Pickle ServerFailure round-trip via separate (code, message) args

Previously ServerFailure stored only a pre-formatted string in
Exception.args, so pickle/copy.deepcopy reconstruction called the
class with a single positional argument against the 2-required
__init__ and raised TypeError. Pass code and message as separate
super-args and override __str__ to preserve the "[code] message"
display format. Mirrors the same fix already applied to
client.OperationalError.

Author: antoineleclair

src/dqlitewire/exceptions.py

@@ -84,7 +84,17 @@ class ServerFailure(ProtocolError):
         message: Human-readable error message from the server.
     """
 
+    code: int
+    message: str
+
     def __init__(self, code: int, message: str) -> None:
-        super().__init__(f"[{code}] {message}")
         self.code = code
         self.message = message
+        # Pass ``code`` and ``message`` through as separate args so
+        # ``self.args == (code, message)``; otherwise ``pickle`` /
+        # ``copy.deepcopy`` reconstruct via ``ServerFailure(*args)``
+        # with a single positional argument and raise ``TypeError``.
+        super().__init__(code, message)
+
+    def __str__(self) -> str:
+        return f"[{self.code}] {self.message}"

tests/test_exceptions.py

@@ -73,6 +73,36 @@ def test_str_includes_code_and_message(self) -> None:
         assert "5" in s
         assert "database is locked" in s
 
+    def test_pickle_round_trip(self) -> None:
+        """ServerFailure must survive ``pickle.dumps`` + ``pickle.loads``.
+
+        Workers that propagate exceptions back to a parent process
+        (multiprocessing, concurrent.futures.ProcessPoolExecutor, Celery)
+        unpickle by calling ``ServerFailure(*args)`` on the pickled args
+        tuple. If args hold a single pre-formatted string, unpickle calls
+        ``ServerFailure('[5] db locked')`` against a 2-arg ``__init__``
+        and raises ``TypeError``. Mirror the fix that landed for
+        ``client.OperationalError``.
+        """
+        import pickle
+
+        original = ServerFailure(code=5, message="database is locked")
+        restored = pickle.loads(pickle.dumps(original))
+        assert isinstance(restored, ServerFailure)
+        assert restored.code == 5
+        assert restored.message == "database is locked"
+        assert str(restored) == str(original)
+
+    def test_copy_deepcopy_round_trip(self) -> None:
+        """``copy.deepcopy`` uses the same reduce path as pickle."""
+        import copy
+
+        original = ServerFailure(code=10, message="no free pages")
+        restored = copy.deepcopy(original)
+        assert isinstance(restored, ServerFailure)
+        assert restored.code == 10
+        assert restored.message == "no free pages"
+
 
 class TestRaiseSiteSubclasses:
     """Each raise site in codec.py / buffer.py must raise a specific