Shared subprocess impl

[graingert]

NOTE Erasing or replacing the contents of this template will result in your pull
request being summarily closed without consideration!

Changes

Fixes #783. Also resolves the asyncio/Trio inconsistencies reported in #828.

Moves the subprocess lifecycle logic (the Process object, spawning and reaping) into a
single, backend-agnostic implementation in anyio._core._subprocesses, built on
subprocess.Popen() plus a small set of backend primitives:

• create_subprocess_stdin_pipe / create_subprocess_output_pipe
• wait_for_child_exit

This removes the reliance on undocumented backend internals such as
StreamReader.set_exception().

Backends / platforms

• asyncio uses the shared implementation on every platform. Pipes are created with
  loop.connect_read_pipe / loop.connect_write_pipe:
  • stdlib ProactorEventLoop (Windows default): overlapped IOCP pipes via PipeHandle;
    the child is waited on with proactor.wait_for_handle.
  • winloop (libuv): pipes backed by real overlapped file descriptors.
  • Windows SelectorEventLoop (which can't do overlapped pipe I/O): the pipes run on
    a background ProactorEventLoop/winloop thread (mirroring the existing selector-thread
    helper), and operations are proxied to it.
  • POSIX: os.pipe() + wait_readable/wait_writable.
  • On Windows, waiting for a child that has no _proactor (winloop / SelectorEventLoop)
    uses a loop-agnostic RegisterWaitForSingleObject helper (thread-pool wait delivered
    via call_soon_threadsafe, no Python thread tied up).
• Trio uses the shared implementation on POSIX and keeps its native implementation on
  Windows.
• Reaping on POSIX uses a pidfd on Linux, or waitid(WNOWAIT) / Popen.wait() in a worker
  thread elsewhere (os.waitid is unavailable on macOS before Python 3.13).

The Python 3.10 asyncio.Runner backport was moved out of the asyncio backend into
anyio._core._asyncio_runner so the proactor thread can reuse it.

Fixed inconsistencies (#828)

• Process.wait() no longer waits for the standard streams to close, so it returns
  promptly once the process exits, even when a pipe is inherited by a grandchild process.
• Process.returncode now polls the process on both backends, so it no longer returns a
  stale None after the process has exited.
• Signalling an already-exited process via terminate() / kill() / send_signal() is
  now consistently a no-op instead of raising on asyncio.

A Windows SelectorEventLoop entry was added to the test matrix.

Checklist

If this is a user-facing code change, like a bugfix or a new feature, please ensure that
you've fulfilled the following conditions (where applicable):

• You've added tests (in tests/) which would fail without your patch
• You've updated the documentation (in docs/), in case of behavior changes or new
  features
• You've added a new changelog entry (in docs/versionhistory.rst).

If this is a trivial change, like a typo fix or a code reformatting, then you can ignore
these instructions.

Updating the changelog

If there are no entries after the last release, use **UNRELEASED** as the version.
If, say, your patch fixes issue #123, the entry should look like this:

- Fix big bad boo-boo in task groups
  (`#123 <https://github.com/agronholm/anyio/issues/123>`_; PR by @yourgithubaccount)

If there's no issue linked, just link to your pull request instead by updating the
changelog after you've created the PR.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR refactors AnyIO’s subprocess support by moving process lifecycle management into a shared, backend-agnostic implementation in anyio._core._subprocesses, with backends providing only a small set of primitives for pipe creation and child-exit waiting. It also aims to eliminate asyncio/Trio behavioral inconsistencies discussed in #828 and expands Windows coverage to include asyncio’s SelectorEventLoop.

Changes:

• Introduces a shared subprocess.Popen()-based Process implementation and POSIX child-exit waiting helpers (pidfd on Linux, worker-thread fallback elsewhere).
• Updates asyncio and Trio backends to use the shared implementation where applicable, adding Windows-specific helpers (proactor thread + threadpool wait) for asyncio.
• Adds/updates tests and changelog entries, including a Windows SelectorEventLoop test-matrix entry.

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
tests/test_subprocesses.py	Adds regression tests for returncode polling, signalling exited processes, and POSIX reaping fallbacks.
tests/conftest.py	Adds Windows asyncio SelectorEventLoop coverage to the backend test matrix.
src/anyio/abc/_eventloop.py	Extends backend interface with subprocess pipe creation and child-exit waiting primitives.
src/anyio/_core/_subprocesses.py	Implements shared Process + spawn/reap logic using subprocess.Popen() and backend primitives.
src/anyio/_core/_asyncio_windows_process.py	Adds loop-agnostic Windows child-exit waiting via RegisterWaitForSingleObject.
src/anyio/_core/_asyncio_runner.py	Extracts/backports asyncio.Runner for Python 3.10 to support background-loop usage.
src/anyio/_core/_asyncio_proactor_thread.py	Adds a long-lived background proactor loop for overlapped pipe I/O when main loop is a Windows selector loop.
src/anyio/_backends/_trio.py	Switches Trio POSIX subprocesses to the shared implementation and adds pipe primitives.
src/anyio/_backends/_asyncio.py	Switches asyncio subprocesses to the shared implementation; adds pipe primitives and new pipe stream implementations.
docs/versionhistory.rst	Adds UNRELEASED changelog entries describing the subprocess refactor and behavior fixes.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[agronholm]

This needs to be severely trimmed down before we merge.

[agronholm]

There's so much low-level code added here that it would be hard to justify merging all of it.

[tapetersen]

Looked through and couldn't see any obvious bugs but it's a lot of fiddly code.

[tapetersen]

This doesn't hit a checkpoint if the read is successful.
Is that intentional for speed? (also not sure how committed to following trio's guarantees regarding that)

[graingert]

This is certainly missing the checkpoint

[tapetersen]

This is actually a lot more common than that as the standalone python builds from uv don't include it

$ uv run --isolated --python 3.14 python -c "import os; print(hasattr(os, 'pidfd_open'))"
False

See astral-sh/python-build-standalone#193

(Just a note to as it surprised me)

[tapetersen]

It doesn't check for any pipe-cleanup as mentioned but that may be implicit (if so just resolve)

[tapetersen]

For what it's worth I at least got the Process.wait() waiting on streams and not just the process fixed upstream python/cpython#119710 . Looks like it may be backported to 3.13-

(We should fix it work-around it anyway but it al least confirms it as a bug and not intended behavior).