ci(#2484): satisfy pre-commit (ruff D212, C901) and pyright

CI on #2484 surfaced three categories of failures on every Python
version:

  1. ruff D212 — multi-line docstring summaries were split from the
     opening ``"""``. Collapsed the first line of each docstring
     touched by this PR to sit on the opening-quote line.
  2. ruff C901 — the asyncio-vs-task-group dispatch pushed
     ``stdio_client``'s cyclomatic complexity from below the
     project's max of 24 up to 29. Extracted the two branches into
     dedicated async context managers:

        _asyncio_background_tasks(...) — the asyncio path with
            add_done_callback to close streams on crash, and the
            ``__aexit__`` that re-raises non-cancellation exceptions.
        _anyio_task_group_background(...) — the trio / other-backend
            path that keeps the original task group.

     ``stdio_client`` now just picks one based on
     ``sniffio.current_async_library()`` and uses it as an
     ``async with`` alongside ``process``. The backend-dispatch
     behaviour is identical to the first commit — only the shape
     of the code changed.
  3. pyright reportArgumentType — the callable types for the helpers
     needed to be ``Callable[[], Coroutine[Any, Any, None]]`` because
     ``asyncio.create_task`` requires a Coroutine, not an Awaitable.
     Imported ``Coroutine`` and ``Any`` accordingly.

No behavioural change: all four regression tests still pass, the
pre-existing 10 stdio tests are unchanged, and the full
``tests/client/`` suite goes through clean (203 passed, 1 pre-existing
xfail, 1 Unix-only SIGINT skip).

Author: sakenuGOD

src/mcp/client/stdio.py

@@ -2,9 +2,10 @@
 import logging
 import os
 import sys
+from collections.abc import AsyncIterator, Callable, Coroutine
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Literal, TextIO
+from typing import Any, Literal, TextIO
 
 import anyio
 import anyio.lowlevel
@@ -103,6 +104,89 @@ class StdioServerParameters(BaseModel):
     """
 
 
+@asynccontextmanager
+async def _asyncio_background_tasks(
+    stdout_reader: Callable[[], Coroutine[Any, Any, None]],
+    stdin_writer: Callable[[], Coroutine[Any, Any, None]],
+    read_stream_writer: MemoryObjectSendStream[SessionMessage | Exception],
+    write_stream: MemoryObjectSendStream[SessionMessage],
+) -> AsyncIterator[None]:
+    """Spawn the stdio reader/writer as top-level asyncio tasks (see #577).
+
+    The tasks are detached from the caller's cancel-scope stack, which
+    is what lets callers clean up multiple transports in arbitrary
+    order without tripping anyio's LIFO cancel-scope check.
+
+    If a background task crashes while the caller is still inside the
+    yield, the memory streams are closed via ``add_done_callback`` so
+    in-flight reads wake up with ``ClosedResourceError`` instead of
+    hanging forever. Any non-cancellation, non-closed-resource
+    exception from the tasks is re-raised on exit so crashes do not
+    go unnoticed — matching the exception propagation an anyio task
+    group would have given.
+    """
+
+    def _on_done(task: asyncio.Task[None]) -> None:
+        if task.cancelled():
+            return
+        exc = task.exception()
+        if exc is None:
+            return
+        logger.debug(
+            "stdio_client background task raised %s — closing streams to wake up caller",
+            type(exc).__name__,
+            exc_info=exc,
+        )
+        for stream in (read_stream_writer, write_stream):
+            try:
+                stream.close()
+            except Exception:  # pragma: no cover
+                pass
+
+    stdout_task: asyncio.Task[None] = asyncio.create_task(stdout_reader())
+    stdin_task: asyncio.Task[None] = asyncio.create_task(stdin_writer())
+    stdout_task.add_done_callback(_on_done)
+    stdin_task.add_done_callback(_on_done)
+    tasks = (stdout_task, stdin_task)
+    try:
+        yield
+    finally:
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+        pending_exc: BaseException | None = None
+        for task in tasks:
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except anyio.ClosedResourceError:
+                pass
+            except BaseException as exc:  # noqa: BLE001
+                if pending_exc is None:
+                    pending_exc = exc
+        if pending_exc is not None:
+            raise pending_exc
+
+
+@asynccontextmanager
+async def _anyio_task_group_background(
+    stdout_reader: Callable[[], Coroutine[Any, Any, None]],
+    stdin_writer: Callable[[], Coroutine[Any, Any, None]],
+) -> AsyncIterator[None]:
+    """Structured-concurrency fallback for backends other than asyncio.
+
+    Trio forbids orphan tasks by design, so the historical task-group
+    pattern is retained here. Callers on trio must clean up multiple
+    transports in LIFO order; cross-task cleanup (#577) cannot be
+    fixed on that backend without violating its concurrency model.
+    """
+    async with anyio.create_task_group() as tg:
+        tg.start_soon(stdout_reader)
+        tg.start_soon(stdin_writer)
+        yield
+
+
 @asynccontextmanager
 async def stdio_client(server: StdioServerParameters, errlog: TextIO = sys.stderr):
     """Client transport for stdio: this will connect to a server by spawning a
@@ -215,75 +299,15 @@ async def _cleanup_process_and_streams() -> None:
     # design, and cross-task cleanup is fundamentally incompatible with
     # that model, so callers on trio still have to clean up LIFO.
     if sniffio.current_async_library() == "asyncio":
-
-        def _on_background_task_done(task: asyncio.Task[None]) -> None:
-            """
-            If a background reader/writer crashes while the caller is
-            still using the transport, close the memory streams so that
-            any in-flight user read wakes up with ``ClosedResourceError``
-            instead of hanging forever. An anyio task group would have
-            produced the same effect via scope cancellation — this
-            restores that observability on the asyncio path.
-            """
-            if task.cancelled():
-                return
-            exc = task.exception()
-            if exc is None:
-                return
-            logger.debug(
-                "stdio_client background task raised %s — closing streams to wake up caller",
-                type(exc).__name__,
-                exc_info=exc,
-            )
-            for stream in (read_stream_writer, write_stream):
-                try:
-                    stream.close()
-                except Exception:  # pragma: no cover
-                    pass
-
-        async with process:
-            stdout_task: asyncio.Task[None] = asyncio.create_task(stdout_reader())
-            stdin_task: asyncio.Task[None] = asyncio.create_task(stdin_writer())
-            stdout_task.add_done_callback(_on_background_task_done)
-            stdin_task.add_done_callback(_on_background_task_done)
-            background_tasks = (stdout_task, stdin_task)
-            try:
-                yield read_stream, write_stream
-            finally:
-                try:
-                    await _cleanup_process_and_streams()
-                finally:
-                    for task in background_tasks:
-                        if not task.done():
-                            task.cancel()
-                    # Collect results; swallow CancelledError (expected for
-                    # teardown) and anyio.ClosedResourceError (surfaced when
-                    # we closed the streams out from under the reader/writer
-                    # during cleanup). Re-raise anything else so a crash in
-                    # the background does not go unnoticed — matching the
-                    # exception propagation we'd get from an anyio task
-                    # group on the trio path.
-                    pending_exc: BaseException | None = None
-                    for task in background_tasks:
-                        try:
-                            await task
-                        except asyncio.CancelledError:
-                            pass
-                        except anyio.ClosedResourceError:
-                            pass
-                        except BaseException as exc:  # noqa: BLE001
-                            if pending_exc is None:
-                                pending_exc = exc
-                    if pending_exc is not None:
-                        raise pending_exc
+        bg_cm = _asyncio_background_tasks(stdout_reader, stdin_writer, read_stream_writer, write_stream)
     else:
-        async with anyio.create_task_group() as tg, process:
-            tg.start_soon(stdout_reader)
-            tg.start_soon(stdin_writer)
-            try:
-                yield read_stream, write_stream
-            finally:
-                await _cleanup_process_and_streams()
+        bg_cm = _anyio_task_group_background(stdout_reader, stdin_writer)
+
+    async with bg_cm, process:
+        try:
+            yield read_stream, write_stream
+        finally:
+            await _cleanup_process_and_streams()
 
 
 def _get_executable_command(command: str) -> str:

tests/client/test_stdio.py

@@ -575,8 +575,7 @@ def sigterm_handler(signum, frame):
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
 async def test_stdio_client_supports_fifo_cleanup_on_asyncio(anyio_backend):
-    """
-    Regression for https://github.com/modelcontextprotocol/python-sdk/issues/577.
+    """Regression for https://github.com/modelcontextprotocol/python-sdk/issues/577.
 
     Prior to the fix, closing two ``stdio_client`` transports in the order
     they were opened (FIFO) crashed with::
@@ -613,8 +612,7 @@ async def test_stdio_client_supports_fifo_cleanup_on_asyncio(anyio_backend):
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
 async def test_stdio_client_supports_lifo_cleanup_on_asyncio(anyio_backend):
-    """
-    Sanity check for the fix above: the historical LIFO cleanup path
+    """Sanity check for the fix above: the historical LIFO cleanup path
     must still work unchanged on asyncio.
     """
     params = StdioServerParameters(command=sys.executable, args=["-c", _QUIET_STDIN_STUB])
@@ -635,8 +633,7 @@ async def test_stdio_client_supports_lifo_cleanup_on_asyncio(anyio_backend):
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
 async def test_stdio_client_shared_exit_stack_fifo_on_asyncio(anyio_backend):
-    """
-    The same story, but through a single ``AsyncExitStack`` that the
+    """The same story, but through a single ``AsyncExitStack`` that the
     caller then closes once. ExitStack runs callbacks in LIFO order on
     its own, so this case already worked — the test pins that behavior
     so a future refactor of the asyncio branch cannot silently break
@@ -652,8 +649,7 @@ async def test_stdio_client_shared_exit_stack_fifo_on_asyncio(anyio_backend):
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
 async def test_stdio_client_reader_crash_propagates_on_asyncio(anyio_backend, monkeypatch):
-    """
-    Guardrail for the asyncio branch of #577: moving the reader/writer
+    """Guardrail for the asyncio branch of #577: moving the reader/writer
     out of an anyio task group must NOT silently swallow exceptions
     they raise. An anyio task group would have re-raised those through
     the async ``with`` block; the asyncio path has to reproduce that