fix(sorts): handle trivial inputs and unpickleable worker errors

Author: Ethereal49

sorts/odd_even_transposition_parallel.py

@@ -13,6 +13,7 @@
 
 import multiprocessing as mp
 from multiprocessing.connection import Connection, wait
+from multiprocessing.reduction import ForkingPickler
 from typing import Any, Protocol
 
 """
@@ -66,7 +67,12 @@ def oe_process[T: Comparable](
         # after all swaps are performed, send the values back to main
         result_pipe[1].send((value, None))
     except Exception as error:  # noqa: BLE001 -- propagate worker errors to the caller
-        result_pipe[1].send((None, error))
+        try:
+            payload = ForkingPickler.dumps((None, error))
+        except Exception:  # noqa: BLE001 -- user exceptions can fail to pickle
+            fallback = RuntimeError(f"{type(error).__name__}: {error}")
+            payload = ForkingPickler.dumps((None, fallback))
+        result_pipe[1].send_bytes(payload)
     finally:
         for pipe in (l_send, r_send, lr_cv, rr_cv, result_pipe):
             if pipe is not None:
@@ -83,6 +89,14 @@ def oe_process[T: Comparable](
 
 def odd_even_transposition[T: Comparable](arr: list[T]) -> list[T]:
     """
+    Sort in place, propagating worker errors to the caller. Unpickleable
+    exceptions become RuntimeError with the original type name and message.
+
+    >>> odd_even_transposition([])
+    []
+    >>> values = [42]
+    >>> odd_even_transposition(values) is values
+    True
     >>> odd_even_transposition(list(range(10)[::-1])) == sorted(list(range(10)[::-1]))
     True
     >>> odd_even_transposition(["a", "x", "c"]) == sorted(["x", "a", "c"])
@@ -113,6 +127,9 @@ def odd_even_transposition[T: Comparable](arr: list[T]) -> list[T]:
         ...
     TypeError: '<' not supported between instances of 'str' and 'int'
     """
+    if len(arr) < 2:
+        return arr
+
     # spawn method is considered safer than fork
     multiprocessing_context = mp.get_context("spawn")
 

tests/test_sorts.py

@@ -22,6 +22,7 @@
 import signal
 from dataclasses import dataclass
 from typing import NamedTuple
+from unittest.mock import patch
 
 import pytest
 
@@ -252,14 +253,36 @@ def test_bitonic_sort_comparable_items() -> None:
         bitonic_sort([1, "two", 3, "four"], 0, 4, 1)
 
 
-def _check_parallel_odd_even_transposition(case: list[object], rejects: bool) -> None:
+@dataclass
+class UnpicklableComparison:
+    value: int
+
+    def __lt__(self, _other: object, /) -> bool:
+        class LocalComparisonError(TypeError):
+            pass
+
+        raise LocalComparisonError("comparison failed")
+
+
+def _check_parallel_odd_even_transposition(
+    case: list[object], error: type[Exception] | None
+) -> None:
     # Give this probe and its workers a process group that the test alone owns.
     os.setsid()
     collection = list(case)
-    if rejects:
-        with pytest.raises(TypeError):
+    if error is not None:
+        with pytest.raises(error) as caught:
             parallel_odd_even_transposition(collection)
+        if isinstance(case[0], UnpicklableComparison):
+            assert "LocalComparisonError: comparison failed" in str(caught.value)
         assert collection == case
+    elif len(collection) < 2:
+        with patch(
+            "multiprocessing.process.BaseProcess.start",
+            side_effect=AssertionError("trivial input must not start a worker"),
+        ):
+            assert parallel_odd_even_transposition(collection) is collection
+        assert all(item is original for item, original in zip(collection, case))
     else:
         assert parallel_odd_even_transposition(collection) is collection
         assert collection == sorted(case)
@@ -270,19 +293,25 @@ def _check_parallel_odd_even_transposition(case: list[object], rejects: bool) ->
     os.name != "posix", reason="timeout cleanup requires process groups"
 )
 @pytest.mark.parametrize(
-    ("case", "rejects"),
+    ("case", "error"),
     [
-        (["c", "a", "b"], False),
-        ([2.5, -1, 0.0], False),
-        ([Person(cost=100.0), Person(cost=-100.0), Person(name="Al")], False),
-        ([Dog(weight=15.5), Dog(weight=15.1), Dog(name="Buddy")], False),
-        ([1, "a"], True),
-        ([3, 2, "a", 1], True),
+        ([], None),
+        ([1], None),
+        ([Person()], None),
+        (["c", "a", "b"], None),
+        ([2.5, -1, 0.0], None),
+        ([Person(cost=100.0), Person(cost=-100.0), Person(name="Al")], None),
+        ([Dog(weight=15.5), Dog(weight=15.1), Dog(name="Buddy")], None),
+        ([1, "a"], TypeError),
+        ([3, 2, "a", 1], TypeError),
+        ([UnpicklableComparison(3), UnpicklableComparison(2)], RuntimeError),
     ],
 )
-def test_parallel_odd_even_transposition(case: list[object], rejects: bool) -> None:
+def test_parallel_odd_even_transposition(
+    case: list[object], error: type[Exception] | None
+) -> None:
     process = mp.get_context("spawn").Process(
-        target=_check_parallel_odd_even_transposition, args=(case, rejects)
+        target=_check_parallel_odd_even_transposition, args=(case, error)
     )
     process.start()
     try: