Avoid duplicating code from ensure_future in Runner.run

Author: ronf

Lib/asyncio/runners.py

@@ -3,13 +3,11 @@
 import contextvars
 import enum
 import functools
-import inspect
 import threading
 import signal
 from . import coroutines
 from . import events
 from . import exceptions
-from . import futures
 from . import tasks
 from . import constants
 
@@ -104,20 +102,7 @@ def run(self, coro, *, context=None):
         if context is None:
             context = self._context
 
-        if futures.isfuture(coro):
-            # This covers the argument being an asyncio.Future or asyncio.Task
-            task = coro
-        elif coroutines.iscoroutine(coro):
-            task = self._loop.create_task(coro, context=context)
-        elif inspect.isawaitable(coro):
-            async def _wrap_awaitable(awaitable):
-                return await awaitable
-
-            task = _wrap_awaitable(coro)
-        else:
-            raise ValueError("An asyncio Future, asyncio.Task, "
-                             "awaitable, or coroutine was expected, "
-                             "got {!r}".format(coro))
+        task = tasks.ensure_future(coro, loop=self._loop, context=context)
 
         if (threading.current_thread() is threading.main_thread()
             and signal.getsignal(signal.SIGINT) is signal.default_int_handler

Lib/asyncio/tasks.py

@@ -720,7 +720,7 @@ async def sleep(delay, result=None):
         h.cancel()
 
 
-def ensure_future(coro_or_future, *, loop=None):
+def ensure_future(coro_or_future, *, loop=None, context=None):
     """Wrap a coroutine or an awaitable in a future.
 
     If the argument is a Future, it is returned directly.
@@ -745,7 +745,10 @@ async def _wrap_awaitable(awaitable):
     if loop is None:
         loop = events.get_event_loop()
     try:
-        return loop.create_task(coro_or_future)
+        if context is None:
+            return loop.create_task(coro_or_future)
+        else:
+            return loop.create_task(coro_or_future, context=context)
     except RuntimeError:
         if should_close:
             coro_or_future.close()

Lib/test/test_asyncio/test_runners.py

@@ -93,8 +93,8 @@ async def main():
     def test_asyncio_run_only_coro(self):
         for o in {1, lambda: None}:
             with self.subTest(obj=o), \
-                    self.assertRaisesRegex(ValueError,
-                                           'coroutine was expected'):
+                    self.assertRaisesRegex(TypeError,
+                                           'an awaitable is required'):
                 asyncio.run(o)
 
     def test_asyncio_run_debug(self):
@@ -319,8 +319,8 @@ async def f():
     def test_run_non_coro(self):
         with asyncio.Runner() as runner:
             with self.assertRaisesRegex(
-                ValueError,
-                "coroutine was expected"
+                TypeError,
+                "an awaitable is required"
             ):
                 runner.run(123)