respond to code review comments

Author: graingert

Lib/asyncio/proactor_events.py

@@ -574,11 +574,9 @@ def _loop_reading(self, fut=None):
         except OSError as exc:
             self._protocol.error_received(exc)
             if not self._closing and not self._conn_lost:
-                # Some errors are transient and recoverable, e.g. a
-                # ConnectionResetError raised synchronously by WSARecvFrom()
-                # from a stale ICMP port-unreachable notification on a UDP
-                # socket. Re-arm the read loop instead of leaving it dead
-                # (gh-127057).
+                # The error can be transient, e.g. a ConnectionResetError
+                # from a stale ICMP port unreachable notification, so
+                # re-arm the read loop instead of leaving it dead.
                 self._loop.call_soon(self._loop_reading)
         except exceptions.CancelledError:
             if not self._closing:

Lib/test/test_asyncio/test_events.py

@@ -1584,14 +1584,9 @@ def create_socket():
         transport_2.close()
 
     def test_datagram_recvfrom_connection_reset_recovers(self):
-        # gh-127057: on Windows, a UDP socket that previously sent a
-        # datagram to an address that wasn't listening can raise
-        # ConnectionResetError (WSAECONNRESET) on a later receive
-        # attempt: synchronously from WSARecvFrom() on ProactorEventLoop
-        # (instead of via the completion result already handled in
-        # _finish_recvfrom() for gh-91227), or from a plain recvfrom()
-        # on SelectorEventLoop. Either way the transport must keep
-        # working afterwards instead of the read loop dying silently.
+        # gh-127057: a UDP socket that sent a datagram to an address that
+        # wasn't listening can raise ConnectionResetError on a later
+        # receive.  The transport must keep working afterwards.
         loop = self.loop
 
         class Protocol(asyncio.DatagramProtocol):
@@ -1621,27 +1616,21 @@ def datagram_received(self, data, addr):
         closed_addr = closed.getsockname()
         closed.close()
 
-        # Trigger a real ICMP port-unreachable now, before the socket is
-        # wrapped in a transport and before any read is armed for it --
-        # on Windows this is what makes a Proactor's first WSARecvFrom()
-        # call raise synchronously.
+        # Trigger the error before the socket is wrapped in a transport,
+        # so that the first read raises synchronously.
         sock.sendto(b'x', closed_addr)
 
         transport, protocol = loop.run_until_complete(
             loop.create_datagram_endpoint(Protocol, sock=sock))
 
-        # The transport must still be able to receive afterwards -- this
-        # is the actual regression check, and must hold regardless of
-        # whether this platform surfaced an error for the bad send above.
         transport.sendto(b'ping', addr)
-        loop.run_until_complete(
-            asyncio.wait_for(protocol.datagram_received_event, 10))
+        loop.run_until_complete(asyncio.wait_for(
+            protocol.datagram_received_event, support.SHORT_TIMEOUT))
         self.assertEqual(protocol.received, [b'ping'])
 
         if sys.platform == 'win32':
-            # Windows reliably reports the bad send via a later recvfrom();
-            # other platforms generally don't deliver ICMP errors to a
-            # plain recv() on an unconnected UDP socket.
+            # Other platforms don't report ICMP errors on an
+            # unconnected UDP socket.
             self.assertEqual(len(protocol.errors), 1)
             self.assertIsInstance(protocol.errors[0], ConnectionResetError)
 

Misc/NEWS.d/next/Library/2026-08-31-00-00-00.gh-issue-127057.N9yg62.rst

@@ -1,6 +1,3 @@
-Fix :class:`asyncio.ProactorEventLoop` UDP transports so a
-:exc:`ConnectionResetError` raised synchronously from ``WSARecvFrom``
-(reported when the same socket was previously used to send to an
-address that isn't listening) no longer breaks the read loop. This
-complements the existing handling of the equivalent asynchronous
-``ERROR_PORT_UNREACHABLE`` completion result.
+Fix :class:`asyncio.ProactorEventLoop` UDP transports so that a
+:exc:`ConnectionResetError` raised by ``WSARecvFrom`` no longer stops the
+read loop.