python · graingert · Aug 5, 2022 · Aug 5, 2022 · Aug 5, 2022 · Aug 5, 2022
@@ -408,19 +408,30 @@ async def wait(fs, *, timeout=None, return_when=ALL_COMPLETED):
     when the timeout occurs are returned in the second set.
     """
     if futures.isfuture(fs) or coroutines.iscoroutine(fs):
-        raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
-    if not fs:
-        raise ValueError('Set of Tasks/Futures is empty.')
+        raise TypeError(f"expected an iterable of futures, not {type(fs).__name__}")
     if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
         raise ValueError(f'Invalid return_when value: {return_when}')
 
-    fs = set(fs)
+    loop = events.get_running_loop()
+    new_fs = set()
+
+    for f in fs:
+        if coroutines.iscoroutine(f):
+            raise TypeError("Passing coroutines is forbidden, use tasks explicitly.")
+        if not futures.isfuture(f):
+            try:
+                new_fs.add(ensure_future(f, loop=loop))
+            except TypeError:
+                raise TypeError(
+                    f"An asyncio.Future was expected, got {f!r}"
+                ) from None
+        else:
+            new_fs.add(f)
 
-    if any(coroutines.iscoroutine(f) for f in fs):
-        raise TypeError("Passing coroutines is forbidden, use tasks explicitly.")
+    if not new_fs:
+        raise ValueError('Iterable of Tasks/Futures is empty.')
 
-    loop = events.get_running_loop()
-    return await _wait(fs, timeout, return_when, loop)
+    return await _wait(new_fs, timeout, return_when, loop)
 
 
 def _release_waiter(waiter, *args):

@@ -2,6 +2,7 @@
 
 import collections
 import contextvars
+import concurrent.futures
 import gc
 import io
 import random
@@ -3239,6 +3240,54 @@ async def coro():
         self.assertEqual(result, 11)
 
 
+class WaitTests(unittest.IsolatedAsyncioTestCase):
+    async def test_wait_supports_awaitables(self):
+
+        class ExampleAwaitable:
+            def __await__(self):
+                return asyncio.sleep(0).__await__()
+
+        await asyncio.wait([ExampleAwaitable()])
+
+        task = asyncio.create_task(coroutine_function())
+        coro = coroutine_function()
+        with self.assertRaisesRegex(
+            TypeError,
+            r"Passing coroutines is forbidden, use tasks explicitly."
+        ):
+            await asyncio.wait([task, ExampleAwaitable(), coro])
+
+        # avoid: coroutine 'coroutine_function' was never awaited
+        coro.close()
+        # avoid: Task was destroyed but it is pending!
+        await task
+
+    async def test_wait_supports_iterators(self):
+        with self.assertRaisesRegex(ValueError, "Iterable of .* is empty\."):
+            await asyncio.wait(iter(()))
+
+        task = asyncio.create_task(coroutine_function())
+        done, pending = await asyncio.wait(iter((task,)))
+        self.assertSetEqual(done, {task})
+        self.assertSetEqual(pending, set())
+
+    async def test_wait_does_not_support_cf_future(self):
+        fut = concurrent.futures.Future()
+        with self.assertRaisesRegex(
+            TypeError,
+            r"An asyncio\.Future was expected, got <Future at 0x.* state=pending>",
+        ):
+            await asyncio.wait({fut})
+
+        fut.set_result(None)
+        with self.assertRaisesRegex(
+            TypeError,
+            r"An asyncio\.Future was expected, got <Future at 0x.* state=finished"
+            r" returned NoneType>",
+        ):
+            await asyncio.wait({fut})
+
+
 class CompatibilityTests(test_utils.TestCase):
     # Tests for checking a bridge between old-styled coroutines
     # and async/await syntax

diff --git a/Misc/NEWS.d/next/Library/2022-08-05-11-16-33.gh-issue-95601.hJvI9y.rst b/Misc/NEWS.d/next/Library/2022-08-05-11-16-33.gh-issue-95601.hJvI9y.rst
@@ -0,0 +1 @@
+Restore the support for the explicit passing of awaitable objects that are not :class:`asyncio.Future` to :func:`asyncio.wait`
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Restore the support for the explicit passing of awaitable objects that are not :class:`asyncio.Future` to :func:`asyncio.wait`