python · graingert · Aug 5, 2022 · Aug 5, 2022 · Aug 5, 2022 · Aug 5, 2022
diff --git a/Doc/library/asyncio-task.rst b/Doc/library/asyncio-task.rst
@@ -794,6 +794,10 @@ Waiting Primitives
    .. versionchanged:: 3.11
       Passing coroutine objects to ``wait()`` directly is forbidden.
 
+   .. deprecated-removed:: 3.11 3.14
+      Passing awaitable objects that are not futures to ``wait()``
+      directly is deprecated.
+
 .. function:: as_completed(aws, *, timeout=None)
 
    Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*

@@ -408,19 +408,37 @@ 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):
+            warnings.warn(
+                "The explicit passing of awaitable objects that are not futures "
+                "to asyncio.wait() is deprecated since Python 3.11, and "
+                "scheduled for removal in Python 3.14.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            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,58 @@ async def coro():
         self.assertEqual(result, 11)
 
 
+class WaitTests(unittest.IsolatedAsyncioTestCase):
+    async 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):
+                return asyncio.sleep(0).__await__()
+
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            "awaitable objects that are not futures",
+        ):
+            await asyncio.wait([ExampleAwaitable()])
+
+        task = asyncio.create_task(coroutine_function())
+        with (
+            self.assertWarnsRegex(
+                DeprecationWarning, "awaitable objects that are not futures"
+            ),
+            self.assertRaises(TypeError),
+        ):
+            await asyncio.wait([task, ExampleAwaitable(), coroutine_function()])
+
+        # 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 @@
+The explicit passing of awaitable objects that are not :class:`asyncio.Future` to :func:`asyncio.wait` is deprecated and will be removed in version 3.14.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		The explicit passing of awaitable objects that are not :class:`asyncio.Future` to :func:`asyncio.wait` is deprecated and will be removed in version 3.14.
graingert marked this conversation as resolved. Show resolved Hide resolved