:class:`~collections.abc.Coroutine` ABC are all instances of this ABC.
.. note::
- In CPython, generator-based coroutines are *awaitables*, even though
- they do not have an :meth:`__await__` method. This ABC
- implements an :meth:`~class.__instancecheck__` method to make them
- instances of itself.
+ In CPython, generator-based coroutines (generators decorated with
+ :func:`types.coroutine` or :func:`asyncio.coroutine`) are
+ *awaitables*, even though they do not have an :meth:`__await__` method.
+ Using ``isinstance(gencoro, Awaitable)`` for them will return ``False``.
+ Use :func:`inspect.isawaitable` to detect them.
.. versionadded:: 3.5
:class:`Awaitable`. See also the definition of :term:`coroutine`.
.. note::
- In CPython, generator-based coroutines are *awaitables* and *coroutines*,
- even though they do not have an :meth:`__await__` method. This ABC
- implements an :meth:`~class.__instancecheck__` method to make them
- instances of itself.
+ In CPython, generator-based coroutines (generators decorated with
+ :func:`types.coroutine` or :func:`asyncio.coroutine`) are
+ *awaitables*, even though they do not have an :meth:`__await__` method.
+ Using ``isinstance(gencoro, Coroutine)`` for them will return ``False``.
+ Use :func:`inspect.isawaitable` to detect them.
.. versionadded:: 3.5
.. versionadded:: 3.5
+.. function:: isawaitable(object)
+
+ Return true if the object can be used in :keyword:`await` expression.
+
+ Can also be used to distinguish generator-based coroutines from regular
+ generators::
+
+ def gen():
+ yield
+ @types.coroutine
+ def gen_coro():
+ yield
+
+ assert not isawaitable(gen())
+ assert isawaitable(gen_coro())
+
+ .. versionadded:: 3.5
+
+
.. function:: istraceback(object)
Return true if the object is a traceback.
* New argument ``follow_wrapped`` for :func:`inspect.signature`.
(Contributed by Yury Selivanov in :issue:`20691`.)
-* New :func:`~inspect.iscoroutine` and :func:`~inspect.iscoroutinefunction`
- functions. (Contributed by Yury Selivanov in :issue:`24017`.)
+* New :func:`~inspect.iscoroutine`, :func:`~inspect.iscoroutinefunction`
+ and :func:`~inspect.isawaitable` functions. (Contributed by
+ Yury Selivanov in :issue:`24017`.)
* New :func:`~inspect.getcoroutinelocals` and :func:`~inspect.getcoroutinestate`
functions. (Contributed by Yury Selivanov in :issue:`24400`.)
return NotImplemented
-class _AwaitableMeta(ABCMeta):
-
- def __instancecheck__(cls, instance):
- # This hook is needed because we can't add
- # '__await__' method to generator objects, and
- # we can't register GeneratorType on Awaitable.
- # NB: 0x100 = CO_ITERABLE_COROUTINE
- # (We don't want to import 'inspect' module, as
- # a dependency for 'collections.abc')
- if (instance.__class__ is generator and
- instance.gi_code.co_flags & 0x100):
- return True
- return super().__instancecheck__(instance)
-
-
-class Awaitable(metaclass=_AwaitableMeta):
+class Awaitable(metaclass=ABCMeta):
__slots__ = ()
"""Return true if the object is a coroutine."""
return isinstance(object, types.CoroutineType)
+def isawaitable(object):
+ """Return true is object can be passed to an ``await`` expression."""
+ return (isinstance(object, types.CoroutineType) or
+ isinstance(object, types.GeneratorType) and
+ object.gi_code.co_flags & CO_ITERABLE_COROUTINE or
+ isinstance(object, collections.abc.Awaitable))
+
def istraceback(object):
"""Return true if the object is a traceback.
self.assertTrue(issubclass(type(x), Awaitable))
c = coro()
- self.assertIsInstance(c, Awaitable)
- c.close() # awoid RuntimeWarning that coro() was not awaited
+ # Iterable coroutines (generators with CO_ITERABLE_COROUTINE
+ # flag don't have '__await__' method, hence can't be instances
+ # of Awaitable. Use inspect.isawaitable to detect them.
+ self.assertNotIsInstance(c, Awaitable)
c = new_coro()
self.assertIsInstance(c, Awaitable)
self.assertTrue(issubclass(type(x), Awaitable))
c = coro()
- self.assertIsInstance(c, Coroutine)
- c.close() # awoid RuntimeWarning that coro() was not awaited
+ # Iterable coroutines (generators with CO_ITERABLE_COROUTINE
+ # flag don't have '__await__' method, hence can't be instances
+ # of Coroutine. Use inspect.isawaitable to detect them.
+ self.assertNotIsInstance(c, Coroutine)
c = new_coro()
self.assertIsInstance(c, Coroutine)
coro.close(); gen_coro.close() # silence warnings
+ def test_isawaitable(self):
+ def gen(): yield
+ self.assertFalse(inspect.isawaitable(gen()))
+
+ coro = coroutine_function_example(1)
+ gen_coro = gen_coroutine_function_example(1)
+
+ self.assertTrue(inspect.isawaitable(coro))
+ self.assertTrue(inspect.isawaitable(gen_coro))
+
+ class Future:
+ def __await__():
+ pass
+ self.assertTrue(inspect.isawaitable(Future()))
+ self.assertFalse(inspect.isawaitable(Future))
+
+ class NotFuture: pass
+ not_fut = NotFuture()
+ not_fut.__await__ = lambda: None
+ self.assertFalse(inspect.isawaitable(not_fut))
+
+ coro.close(); gen_coro.close() # silence warnings
+
def test_isroutine(self):
self.assertTrue(inspect.isroutine(mod.spam))
self.assertTrue(inspect.isroutine([].count))
with self.assertRaisesRegex(Exception, 'ham'):
wrapper.throw(Exception, Exception('ham'))
+ def test_returning_itercoro(self):
+ @types.coroutine
+ def gen():
+ yield
+
+ gencoro = gen()
+
+ @types.coroutine
+ def foo():
+ return gencoro
+
+ self.assertIs(foo(), gencoro)
+
def test_genfunc(self):
def gen(): yield
self.assertIs(types.coroutine(gen), gen)
g = gen()
self.assertTrue(g.gi_code.co_flags & inspect.CO_ITERABLE_COROUTINE)
self.assertFalse(g.gi_code.co_flags & inspect.CO_COROUTINE)
- self.assertIsInstance(g, collections.abc.Coroutine)
- self.assertIsInstance(g, collections.abc.Awaitable)
- g.close() # silence warning
self.assertIs(types.coroutine(gen), gen)
@_functools.wraps(func)
def wrapped(*args, **kwargs):
coro = func(*args, **kwargs)
- if coro.__class__ is CoroutineType:
- # 'coro' is a native coroutine object.
+ if (coro.__class__ is CoroutineType or
+ coro.__class__ is GeneratorType and coro.gi_code.co_flags & 0x100):
+ # 'coro' is a native coroutine object or an iterable coroutine
return coro
- if (coro.__class__ is GeneratorType or
- (isinstance(coro, _collections_abc.Generator) and
- not isinstance(coro, _collections_abc.Coroutine))):
+ if (isinstance(coro, _collections_abc.Generator) and
+ not isinstance(coro, _collections_abc.Coroutine)):
# 'coro' is either a pure Python generator iterator, or it
# implements collections.abc.Generator (and does not implement
# collections.abc.Coroutine).
uses collections.abc.Coroutine, it's intended to test for pure 'async def'
coroutines only; add new opcode: GET_YIELD_FROM_ITER; fix generators wrapper
used in types.coroutine to be instance of collections.abc.Generator;
- inspect.isawaitable was removed (use collections.abc.Awaitable).
+ collections.abc.Awaitable and collections.abc.Coroutine can no longer
+ be used to detect generator-based coroutines--use inspect.isawaitable
+ instead.
- Issue #24450: Add gi_yieldfrom to generators and cr_await to coroutines.
Contributed by Benno Leslie and Yury Selivanov.
projects / python / commitdiff