pythongh-95601: forbid non-futures in asyncio.wait

graingert · graingert · commit 88580c92168b · 2022-08-05T12:12:59.000+01:00
diff --git a/Lib/asyncio/tasks.py b/Lib/asyncio/tasks.py
@@ -412,19 +412,29 @@ 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()
 
-    if any(coroutines.iscoroutine(f) for f in fs):
-        raise TypeError("Passing coroutines is forbidden, use tasks explicitly.")
+    for f in fs:
+        if coroutines.iscoroutine(f):
+            raise TypeError("Passing coroutines is forbidden, use tasks explicitly.")
+        if not futures.isfuture(f):
+            warnings.warn("The explicit passing of awaitable objects to "
+                          "asyncio.wait() is deprecated since Python 3.11, and "
+                          "scheduled for removal in Python 3.14.",
+                          DeprecationWarning, stacklevel=2)
+            new_fs.add(ensure_future(f, loop=loop))
+        else:
+            new_fs.add(f)
 
-    loop = events.get_running_loop()
-    return await _wait(fs, timeout, return_when, loop)
+    if not new_fs:
+        raise ValueError('Iterable of Tasks/Futures is empty.')
+
+    return await _wait(new_fs, timeout, return_when, loop)
 
 
 def _release_waiter(waiter, *args):
diff --git a/Lib/test/test_asyncio/test_tasks.py b/Lib/test/test_asyncio/test_tasks.py
@@ -3247,6 +3247,52 @@ async def coro():
         self.assertEqual(result, 11)
 
 
+class WaitTests(test_utils.TestCase):
+    def setUp(self):
+        super().setUp()
+        self.loop = asyncio.new_event_loop()
+        self.set_event_loop(self.loop)
+
+    def tearDown(self):
+        self.loop.close()
+        self.loop = None
+        super().tearDown()
+
+    def test_awaitable_is_deprecated_in_wait(self):
+        # Remove test when passing awaitables to asyncio.wait() is removed in 3.14
+
+        class ExampleAwaitable:
+            def __await__(self):
+                async def _():
+                    return await asyncio.sleep(0)
+
+                return _().__await__()
+
+
+        with self.assertWarns(DeprecationWarning):
+            self.loop.run_until_complete(
+                asyncio.wait([ExampleAwaitable()]))
+
+        task = self.loop.create_task(coroutine_function())
+        with self.assertWarns(DeprecationWarning), self.assertRaises(TypeError):
+            self.loop.run_until_complete(
+                asyncio.wait([task, ExampleAwaitable(), coroutine_function()]))
+
+        # avoid: Task was destroyed but it is pending!
+        self.loop.run_until_complete(task)
+
+    def test_wait_supports_iterators(self):
+        with self.assertRaisesRegex(ValueError, "Iterable of .* is empty\."):
+            self.loop.run_until_complete(asyncio.wait(iter(())))
+
+        task = self.loop.create_task(coroutine_function())
+        done, pending = self.loop.run_until_complete(
+            asyncio.wait(iter((task,))),
+        )
+        self.assertSetEqual(done, {task})
+        self.assertSetEqual(pending, set())
+
+
 class CompatibilityTests(test_utils.TestCase):
     # Tests for checking a bridge between old-styled coroutines
     # and async/await syntax
