more fixes

Author: kumaraditya303

Doc/library/asyncio-eventloop.rst

@@ -1312,8 +1312,13 @@ following:
 * a character device, such as a terminal.
 
 On Windows, where only :class:`ProactorEventLoop` implements these methods,
-*pipe* must wrap a handle opened for overlapped I/O, since the handle has to
-be associated with an I/O completion port.
+*pipe* must wrap a handle opened for overlapped I/O (that is, created with the
+``FILE_FLAG_OVERLAPPED`` flag), since the handle has to be associated with an
+I/O completion port.  Handles that were not opened for overlapped I/O are
+rejected.  In particular, the standard streams (:data:`sys.stdin`,
+:data:`sys.stdout` and :data:`sys.stderr`), console handles, and the pipes
+created by :func:`os.pipe` are **not** opened for overlapped I/O and therefore
+cannot be used with these methods.
 
 .. note::
 

Doc/library/asyncio-platforms.rst

@@ -68,12 +68,8 @@ All event loops on Windows do not support the following methods:
   methods are not supported.
 
 * :meth:`loop.connect_read_pipe` and :meth:`loop.connect_write_pipe` only
-  accept a handle opened for overlapped I/O, which in practice means a named
-  pipe such as those created by :func:`!asyncio.windows_utils.pipe`.  A
-  console handle cannot be associated with an I/O completion port, so
-  :data:`sys.stdin`, :data:`sys.stdout` and :data:`sys.stderr` are not
-  supported.  See :ref:`Supported pipe objects <asyncio-pipe-objects>` for
-  how such a handle is rejected, which differs between the two methods.
+  accept a handle opened for overlapped I/O.
+  See :ref:`Supported pipe objects <asyncio-pipe-objects>` for which objects are supported.
 
 The resolution of the monotonic clock on Windows is usually around 15.6
 milliseconds.  The best resolution is 0.5 milliseconds. The resolution depends on the

Lib/asyncio/proactor_events.py

@@ -62,6 +62,7 @@ def __init__(self, loop, sock, protocol, waiter=None,
         self._closing = False  # Set when close() called.
         self._called_connection_lost = False
         self._eof_written = False
+        self._empty_waiter = None
         if self._server is not None:
             self._server._attach(self)
         self._loop.call_soon(self._protocol.connection_made, self)
@@ -331,10 +332,6 @@ class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport,
 
     _start_tls_compatible = True
 
-    def __init__(self, *args, **kw):
-        super().__init__(*args, **kw)
-        self._empty_waiter = None
-
     def write(self, data):
         if not isinstance(data, (bytes, bytearray, memoryview)):
             raise TypeError(
@@ -465,7 +462,6 @@ class _ProactorDatagramTransport(_ProactorBasePipeTransport,
     def __init__(self, loop, sock, protocol, address=None,
                  waiter=None, extra=None):
         self._address = address
-        self._empty_waiter = None
         self._buffer_size = 0
         # We don't need to call _protocol.connection_made() since our base
         # constructor does it for us.

Lib/test/test_asyncio/test_windows_events.py

@@ -347,23 +347,22 @@ def connection_lost(self, exc):
 
         async def run():
             transport, _ = await self.loop.connect_read_pipe(Proto, pipe)
-            await lost
+            exc = await lost
             transport.close()
+            return exc
 
-        self.loop.run_until_complete(run())
-        self.assertTrue(self.errors, 'no error reached the exception handler')
-        self.assertIsInstance(self.errors[0]['exception'], OSError)
+        exc = self.loop.run_until_complete(run())
+        self.assertIsInstance(exc, OSError)
 
     def check_write_rejected(self, pipe):
         self.addCleanup(pipe.close)
         with self.assertRaises(OSError):
             self.loop.run_until_complete(
                 self.loop.connect_write_pipe(asyncio.BaseProtocol, pipe))
 
-    def test_overlapped_pipe(self):
-        rhandle, whandle = windows_utils.pipe(overlapped=(True, True))
-        rpipe = windows_utils.PipeHandle(rhandle)
-        wpipe = windows_utils.PipeHandle(whandle)
+    def check_accepted(self, rpipe, wpipe):
+        self.addCleanup(rpipe.close)
+        self.addCleanup(wpipe.close)
 
         chunks = []
         lost = self.loop.create_future()
@@ -389,6 +388,15 @@ async def run():
         self.assertEqual(b''.join(chunks), b'spam')
         self.assertFalse(self.errors)
 
+    def test_overlapped_pipe(self):
+        rhandle, whandle = windows_utils.pipe(duplex=True, overlapped=(True, True))
+        self.check_accepted(windows_utils.PipeHandle(rhandle),
+                            windows_utils.PipeHandle(whandle))
+
+    def test_socketpair(self):
+        rsock, wsock = socket.socketpair()
+        self.check_accepted(rsock, wsock)
+
     def test_read_non_overlapped_pipe(self):
         rhandle, whandle = windows_utils.pipe(overlapped=(False, False))
         self.addCleanup(windows_utils.PipeHandle(whandle).close)
@@ -409,6 +417,16 @@ def test_write_regular_file(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         self.check_write_rejected(open(os_helper.TESTFN, 'wb', 0))
 
+    def test_read_os_pipe(self):
+        rfd, wfd = os.pipe()
+        self.addCleanup(os.close, wfd)
+        self.check_read_rejected(open(rfd, 'rb', 0))
+
+    def test_write_os_pipe(self):
+        rfd, wfd = os.pipe()
+        self.addCleanup(os.close, rfd)
+        self.check_write_rejected(open(wfd, 'wb', 0))
+
 
 if __name__ == '__main__':
     unittest.main()