2015-05-11 23:57:16 -03:00
|
|
|
import contextlib
|
2015-11-12 05:31:51 -04:00
|
|
|
import copy
|
2015-05-18 13:50:52 -03:00
|
|
|
import inspect
|
2015-11-12 05:31:51 -04:00
|
|
|
import pickle
|
2018-01-21 10:44:07 -04:00
|
|
|
import re
|
2015-05-11 23:57:16 -03:00
|
|
|
import sys
|
|
|
|
import types
|
|
|
|
import unittest
|
|
|
|
import warnings
|
|
|
|
from test import support
|
2018-01-26 15:28:31 -04:00
|
|
|
from test.support.script_helper import assert_python_ok
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
|
|
|
|
class AsyncYieldFrom:
|
|
|
|
def __init__(self, obj):
|
|
|
|
self.obj = obj
|
|
|
|
|
|
|
|
def __await__(self):
|
|
|
|
yield from self.obj
|
|
|
|
|
|
|
|
|
|
|
|
class AsyncYield:
|
|
|
|
def __init__(self, value):
|
|
|
|
self.value = value
|
|
|
|
|
|
|
|
def __await__(self):
|
|
|
|
yield self.value
|
|
|
|
|
|
|
|
|
|
|
|
def run_async(coro):
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
assert coro.__class__ in {types.GeneratorType, types.CoroutineType}
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
buffer = []
|
|
|
|
result = None
|
|
|
|
while True:
|
|
|
|
try:
|
|
|
|
buffer.append(coro.send(None))
|
|
|
|
except StopIteration as ex:
|
|
|
|
result = ex.args[0] if ex.args else None
|
|
|
|
break
|
|
|
|
return buffer, result
|
|
|
|
|
|
|
|
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
def run_async__await__(coro):
|
|
|
|
assert coro.__class__ is types.CoroutineType
|
|
|
|
aw = coro.__await__()
|
|
|
|
buffer = []
|
|
|
|
result = None
|
|
|
|
i = 0
|
|
|
|
while True:
|
|
|
|
try:
|
|
|
|
if i % 2:
|
|
|
|
buffer.append(next(aw))
|
|
|
|
else:
|
|
|
|
buffer.append(aw.send(None))
|
|
|
|
i += 1
|
|
|
|
except StopIteration as ex:
|
|
|
|
result = ex.args[0] if ex.args else None
|
|
|
|
break
|
|
|
|
return buffer, result
|
|
|
|
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
@contextlib.contextmanager
|
|
|
|
def silence_coro_gc():
|
|
|
|
with warnings.catch_warnings():
|
|
|
|
warnings.simplefilter("ignore")
|
|
|
|
yield
|
|
|
|
support.gc_collect()
|
|
|
|
|
|
|
|
|
|
|
|
class AsyncBadSyntaxTest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_badsyntax_1(self):
|
2016-09-09 14:36:01 -03:00
|
|
|
samples = [
|
|
|
|
"""def foo():
|
|
|
|
await something()
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""await something()""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
yield from []
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
await await fut
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo(a=await something()):
|
|
|
|
pass
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo(a:await something()):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i async for i in els]
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[await i for i in els]
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els
|
|
|
|
async for b in els]
|
|
|
|
""",
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els
|
|
|
|
for c in b
|
|
|
|
async for b in els]
|
|
|
|
""",
|
2015-06-30 13:49:04 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els
|
|
|
|
async for b in els
|
|
|
|
for c in b]
|
|
|
|
""",
|
2015-06-30 13:49:04 -03:00
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els
|
|
|
|
for b in await els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els
|
|
|
|
for b in els
|
|
|
|
if await b]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in await els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
[i for i in els if await i]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i async for i in els]
|
|
|
|
""",
|
|
|
|
|
2017-10-06 03:58:28 -03:00
|
|
|
"""def bar():
|
|
|
|
{i: i async for i in els}
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
{i async for i in els}
|
|
|
|
""",
|
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
"""def bar():
|
|
|
|
[await i for i in els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els
|
|
|
|
async for b in els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els
|
|
|
|
for c in b
|
|
|
|
async for b in els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els
|
|
|
|
async for b in els
|
|
|
|
for c in b]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els
|
|
|
|
for b in await els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els
|
|
|
|
for b in els
|
|
|
|
if await b]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in await els]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def bar():
|
|
|
|
[i for i in els if await i]
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
await
|
|
|
|
""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar(): pass
|
|
|
|
await = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
|
|
|
|
def bar(): pass
|
|
|
|
await = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar(): pass
|
|
|
|
if 1:
|
|
|
|
await = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
async def bar(): pass
|
|
|
|
if 1:
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
async def bar(): pass
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
def baz(): pass
|
|
|
|
async def bar(): pass
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
def baz(): pass
|
|
|
|
# 456
|
|
|
|
async def bar(): pass
|
|
|
|
# 123
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def baz(): pass
|
|
|
|
# 456
|
|
|
|
async def bar(): pass
|
|
|
|
# 123
|
|
|
|
await = 2
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
|
|
|
|
def baz(): pass
|
|
|
|
|
|
|
|
async def bar(): pass
|
|
|
|
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
|
|
|
|
def baz(): pass
|
|
|
|
|
|
|
|
async def bar(): pass
|
|
|
|
|
|
|
|
await = 2
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def async(): pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def await(): pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
await
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
return lambda async: await
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
return lambda a: await
|
|
|
|
""",
|
|
|
|
|
2015-07-22 08:48:57 -03:00
|
|
|
"""await a()""",
|
|
|
|
|
|
|
|
"""async def foo(a=await b):
|
2015-07-22 07:33:45 -03:00
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
2015-07-23 03:10:44 -03:00
|
|
|
"""async def foo(a:await b):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
2015-07-22 07:33:45 -03:00
|
|
|
"""def baz():
|
2015-07-22 08:48:57 -03:00
|
|
|
async def foo(a=await b):
|
2015-07-22 07:33:45 -03:00
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo(async):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
def baz():
|
|
|
|
async = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
def baz():
|
|
|
|
pass
|
|
|
|
async = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
async def bar():
|
|
|
|
|
|
|
|
async def baz():
|
|
|
|
pass
|
|
|
|
|
|
|
|
def baz():
|
|
|
|
42
|
|
|
|
|
|
|
|
async = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo():
|
|
|
|
def bar():
|
|
|
|
def baz():
|
|
|
|
pass\nawait foo()
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
def bar():
|
|
|
|
async def baz():
|
|
|
|
pass\nawait foo()
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""async def foo(await):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
|
|
|
|
async def bar(): pass
|
|
|
|
|
|
|
|
await a
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""def foo():
|
|
|
|
async def bar():
|
|
|
|
pass\nawait a
|
2018-04-27 12:58:56 -03:00
|
|
|
""",
|
|
|
|
"""def foo():
|
|
|
|
async for i in arange(2):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
"""def foo():
|
|
|
|
async with resource:
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
"""async with resource:
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
"""async for i in arange(2):
|
|
|
|
pass
|
|
|
|
""",
|
|
|
|
]
|
2015-07-22 07:33:45 -03:00
|
|
|
|
|
|
|
for code in samples:
|
|
|
|
with self.subTest(code=code), self.assertRaises(SyntaxError):
|
2015-07-22 08:48:57 -03:00
|
|
|
compile(code, "<test>", "exec")
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
def test_badsyntax_2(self):
|
|
|
|
samples = [
|
|
|
|
"""def foo():
|
|
|
|
await = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""class Bar:
|
|
|
|
def async(): pass
|
|
|
|
""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""class Bar:
|
|
|
|
async = 1
|
|
|
|
""",
|
|
|
|
|
|
|
|
"""class async:
|
2015-07-22 07:33:45 -03:00
|
|
|
pass
|
2016-09-15 13:50:23 -03:00
|
|
|
""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""class await:
|
|
|
|
pass
|
|
|
|
""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""import math as await""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""def async():
|
|
|
|
pass""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""def foo(*, await=1):
|
|
|
|
pass"""
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""async = 1""",
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2016-09-15 13:50:23 -03:00
|
|
|
"""print(await=1)"""
|
|
|
|
]
|
|
|
|
|
|
|
|
for code in samples:
|
2017-10-06 00:24:46 -03:00
|
|
|
with self.subTest(code=code), self.assertRaises(SyntaxError):
|
2016-09-15 13:50:23 -03:00
|
|
|
compile(code, "<test>", "exec")
|
|
|
|
|
|
|
|
def test_badsyntax_3(self):
|
2017-10-06 00:24:46 -03:00
|
|
|
with self.assertRaises(SyntaxError):
|
|
|
|
compile("async = 1", "<test>", "exec")
|
2016-09-15 13:50:23 -03:00
|
|
|
|
2017-10-06 00:24:46 -03:00
|
|
|
def test_badsyntax_4(self):
|
2016-09-15 13:50:23 -03:00
|
|
|
samples = [
|
|
|
|
'''def foo(await):
|
|
|
|
async def foo(): pass
|
|
|
|
async def foo():
|
|
|
|
pass
|
|
|
|
return await + 1
|
|
|
|
''',
|
|
|
|
|
|
|
|
'''def foo(await):
|
|
|
|
async def foo(): pass
|
|
|
|
async def foo(): pass
|
|
|
|
return await + 1
|
|
|
|
''',
|
|
|
|
|
|
|
|
'''def foo(await):
|
|
|
|
|
|
|
|
async def foo(): pass
|
|
|
|
|
|
|
|
async def foo(): pass
|
|
|
|
|
|
|
|
return await + 1
|
|
|
|
''',
|
|
|
|
|
|
|
|
'''def foo(await):
|
|
|
|
"""spam"""
|
|
|
|
async def foo(): \
|
|
|
|
pass
|
|
|
|
# 123
|
|
|
|
async def foo(): pass
|
|
|
|
# 456
|
|
|
|
return await + 1
|
|
|
|
''',
|
|
|
|
|
|
|
|
'''def foo(await):
|
|
|
|
def foo(): pass
|
|
|
|
def foo(): pass
|
|
|
|
async def bar(): return await_
|
|
|
|
await_ = await
|
|
|
|
try:
|
|
|
|
bar().send(None)
|
|
|
|
except StopIteration as ex:
|
|
|
|
return ex.args[0] + 1
|
|
|
|
'''
|
|
|
|
]
|
|
|
|
|
|
|
|
for code in samples:
|
2017-10-06 00:24:46 -03:00
|
|
|
with self.subTest(code=code), self.assertRaises(SyntaxError):
|
|
|
|
compile(code, "<test>", "exec")
|
2015-07-22 07:33:45 -03:00
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2015-05-18 13:50:52 -03:00
|
|
|
class TokenizerRegrTest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_oneline_defs(self):
|
|
|
|
buf = []
|
|
|
|
for i in range(500):
|
|
|
|
buf.append('def i{i}(): return {i}'.format(i=i))
|
|
|
|
buf = '\n'.join(buf)
|
|
|
|
|
|
|
|
# Test that 500 consequent, one-line defs is OK
|
|
|
|
ns = {}
|
|
|
|
exec(buf, ns, ns)
|
|
|
|
self.assertEqual(ns['i499'](), 499)
|
|
|
|
|
|
|
|
# Test that 500 consequent, one-line defs *and*
|
|
|
|
# one 'async def' following them is OK
|
|
|
|
buf += '\nasync def foo():\n return'
|
|
|
|
ns = {}
|
|
|
|
exec(buf, ns, ns)
|
|
|
|
self.assertEqual(ns['i499'](), 499)
|
|
|
|
self.assertTrue(inspect.iscoroutinefunction(ns['foo']))
|
|
|
|
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
class CoroutineTest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_gen_1(self):
|
|
|
|
def gen(): yield
|
|
|
|
self.assertFalse(hasattr(gen, '__await__'))
|
|
|
|
|
|
|
|
def test_func_1(self):
|
|
|
|
async def foo():
|
|
|
|
return 10
|
|
|
|
|
|
|
|
f = foo()
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
self.assertIsInstance(f, types.CoroutineType)
|
|
|
|
self.assertTrue(bool(foo.__code__.co_flags & inspect.CO_COROUTINE))
|
|
|
|
self.assertFalse(bool(foo.__code__.co_flags & inspect.CO_GENERATOR))
|
|
|
|
self.assertTrue(bool(f.cr_code.co_flags & inspect.CO_COROUTINE))
|
|
|
|
self.assertFalse(bool(f.cr_code.co_flags & inspect.CO_GENERATOR))
|
2015-05-11 23:57:16 -03:00
|
|
|
self.assertEqual(run_async(f), ([], 10))
|
|
|
|
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
self.assertEqual(run_async__await__(foo()), ([], 10))
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def bar(): pass
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
self.assertFalse(bool(bar.__code__.co_flags & inspect.CO_COROUTINE))
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_func_2(self):
|
|
|
|
async def foo():
|
|
|
|
raise StopIteration
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
RuntimeError, "coroutine raised StopIteration"):
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_func_3(self):
|
|
|
|
async def foo():
|
|
|
|
raise StopIteration
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = foo()
|
|
|
|
self.assertRegex(repr(coro), '^<coroutine object.* at 0x.*>$')
|
|
|
|
coro.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_func_4(self):
|
|
|
|
async def foo():
|
|
|
|
raise StopIteration
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = foo()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
check = lambda: self.assertRaisesRegex(
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
TypeError, "'coroutine' object is not iterable")
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with check():
|
2018-01-29 15:31:47 -04:00
|
|
|
list(coro)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with check():
|
2018-01-29 15:31:47 -04:00
|
|
|
tuple(coro)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with check():
|
2018-01-29 15:31:47 -04:00
|
|
|
sum(coro)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with check():
|
2018-01-29 15:31:47 -04:00
|
|
|
iter(coro)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
with check():
|
|
|
|
for i in coro:
|
2015-05-11 23:57:16 -03:00
|
|
|
pass
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
with check():
|
|
|
|
[i for i in coro]
|
|
|
|
|
|
|
|
coro.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_func_5(self):
|
|
|
|
@types.coroutine
|
|
|
|
def bar():
|
|
|
|
yield 1
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
await bar()
|
|
|
|
|
|
|
|
check = lambda: self.assertRaisesRegex(
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
TypeError, "'coroutine' object is not iterable")
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = foo()
|
2015-05-11 23:57:16 -03:00
|
|
|
with check():
|
2018-01-29 15:31:47 -04:00
|
|
|
for el in coro:
|
|
|
|
pass
|
|
|
|
coro.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
# the following should pass without an error
|
|
|
|
for el in bar():
|
|
|
|
self.assertEqual(el, 1)
|
|
|
|
self.assertEqual([el for el in bar()], [1])
|
|
|
|
self.assertEqual(tuple(bar()), (1,))
|
|
|
|
self.assertEqual(next(iter(bar())), 1)
|
|
|
|
|
|
|
|
def test_func_6(self):
|
|
|
|
@types.coroutine
|
|
|
|
def bar():
|
|
|
|
yield 1
|
|
|
|
yield 2
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
await bar()
|
|
|
|
|
|
|
|
f = foo()
|
2015-05-13 03:03:06 -03:00
|
|
|
self.assertEqual(f.send(None), 1)
|
|
|
|
self.assertEqual(f.send(None), 2)
|
2015-05-11 23:57:16 -03:00
|
|
|
with self.assertRaises(StopIteration):
|
|
|
|
f.send(None)
|
|
|
|
|
|
|
|
def test_func_7(self):
|
|
|
|
async def bar():
|
|
|
|
return 10
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = bar()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def foo():
|
2018-01-29 15:31:47 -04:00
|
|
|
yield from coro
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
|
|
|
"cannot 'yield from' a coroutine object in "
|
|
|
|
"a non-coroutine generator"):
|
2015-05-11 23:57:16 -03:00
|
|
|
list(foo())
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
coro.close()
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def test_func_8(self):
|
|
|
|
@types.coroutine
|
|
|
|
def bar():
|
2018-01-29 15:31:47 -04:00
|
|
|
return (yield from coro)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return 'spam'
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = foo()
|
|
|
|
self.assertEqual(run_async(bar()), ([], 'spam'))
|
|
|
|
coro.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_func_9(self):
|
2018-01-29 15:31:47 -04:00
|
|
|
async def foo():
|
|
|
|
pass
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with self.assertWarnsRegex(
|
2018-01-29 15:31:47 -04:00
|
|
|
RuntimeWarning,
|
|
|
|
r"coroutine '.*test_func_9.*foo' was never awaited"):
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
foo()
|
|
|
|
support.gc_collect()
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
with self.assertWarnsRegex(
|
|
|
|
RuntimeWarning,
|
|
|
|
r"coroutine '.*test_func_9.*foo' was never awaited"):
|
|
|
|
|
|
|
|
with self.assertRaises(TypeError):
|
|
|
|
# See bpo-32703.
|
|
|
|
for _ in foo():
|
|
|
|
pass
|
|
|
|
|
|
|
|
support.gc_collect()
|
|
|
|
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
def test_func_10(self):
|
|
|
|
N = 0
|
|
|
|
|
|
|
|
@types.coroutine
|
|
|
|
def gen():
|
|
|
|
nonlocal N
|
|
|
|
try:
|
|
|
|
a = yield
|
|
|
|
yield (a ** 2)
|
|
|
|
except ZeroDivisionError:
|
|
|
|
N += 100
|
|
|
|
raise
|
|
|
|
finally:
|
|
|
|
N += 1
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
await gen()
|
|
|
|
|
|
|
|
coro = foo()
|
|
|
|
aw = coro.__await__()
|
|
|
|
self.assertIs(aw, iter(aw))
|
|
|
|
next(aw)
|
|
|
|
self.assertEqual(aw.send(10), 100)
|
|
|
|
|
|
|
|
self.assertEqual(N, 0)
|
|
|
|
aw.close()
|
|
|
|
self.assertEqual(N, 1)
|
|
|
|
|
|
|
|
coro = foo()
|
|
|
|
aw = coro.__await__()
|
|
|
|
next(aw)
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
|
|
|
aw.throw(ZeroDivisionError, None, None)
|
|
|
|
self.assertEqual(N, 102)
|
|
|
|
|
|
|
|
def test_func_11(self):
|
|
|
|
async def func(): pass
|
|
|
|
coro = func()
|
|
|
|
# Test that PyCoro_Type and _PyCoroWrapper_Type types were properly
|
|
|
|
# initialized
|
|
|
|
self.assertIn('__await__', dir(coro))
|
|
|
|
self.assertIn('__iter__', dir(coro.__await__()))
|
|
|
|
self.assertIn('coroutine_wrapper', repr(coro.__await__()))
|
|
|
|
coro.close() # avoid RuntimeWarning
|
|
|
|
|
|
|
|
def test_func_12(self):
|
|
|
|
async def g():
|
|
|
|
i = me.send(None)
|
|
|
|
await foo
|
|
|
|
me = g()
|
|
|
|
with self.assertRaisesRegex(ValueError,
|
|
|
|
"coroutine already executing"):
|
|
|
|
me.send(None)
|
|
|
|
|
|
|
|
def test_func_13(self):
|
|
|
|
async def g():
|
|
|
|
pass
|
2018-01-29 15:31:47 -04:00
|
|
|
|
|
|
|
coro = g()
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
with self.assertRaisesRegex(
|
2018-01-29 15:31:47 -04:00
|
|
|
TypeError,
|
|
|
|
"can't send non-None value to a just-started coroutine"):
|
|
|
|
coro.send('spam')
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
coro.close()
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
|
|
|
|
def test_func_14(self):
|
|
|
|
@types.coroutine
|
|
|
|
def gen():
|
|
|
|
yield
|
|
|
|
async def coro():
|
|
|
|
try:
|
|
|
|
await gen()
|
|
|
|
except GeneratorExit:
|
|
|
|
await gen()
|
|
|
|
c = coro()
|
|
|
|
c.send(None)
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
"coroutine ignored GeneratorExit"):
|
|
|
|
c.close()
|
|
|
|
|
2016-02-13 18:59:05 -04:00
|
|
|
def test_func_15(self):
|
|
|
|
# See http://bugs.python.org/issue25887 for details
|
|
|
|
|
|
|
|
async def spammer():
|
|
|
|
return 'spam'
|
|
|
|
async def reader(coro):
|
|
|
|
return await coro
|
|
|
|
|
|
|
|
spammer_coro = spammer()
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(StopIteration, 'spam'):
|
|
|
|
reader(spammer_coro).send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
reader(spammer_coro).send(None)
|
|
|
|
|
|
|
|
def test_func_16(self):
|
|
|
|
# See http://bugs.python.org/issue25887 for details
|
|
|
|
|
|
|
|
@types.coroutine
|
|
|
|
def nop():
|
|
|
|
yield
|
|
|
|
async def send():
|
|
|
|
await nop()
|
|
|
|
return 'spam'
|
|
|
|
async def read(coro):
|
|
|
|
await nop()
|
|
|
|
return await coro
|
|
|
|
|
|
|
|
spammer = send()
|
|
|
|
|
|
|
|
reader = read(spammer)
|
|
|
|
reader.send(None)
|
|
|
|
reader.send(None)
|
|
|
|
with self.assertRaisesRegex(Exception, 'ham'):
|
|
|
|
reader.throw(Exception('ham'))
|
|
|
|
|
|
|
|
reader = read(spammer)
|
|
|
|
reader.send(None)
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
reader.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
reader.throw(Exception('wat'))
|
|
|
|
|
|
|
|
def test_func_17(self):
|
|
|
|
# See http://bugs.python.org/issue25887 for details
|
|
|
|
|
|
|
|
async def coroutine():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
coro = coroutine()
|
|
|
|
with self.assertRaisesRegex(StopIteration, 'spam'):
|
|
|
|
coro.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
coro.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
coro.throw(Exception('wat'))
|
|
|
|
|
|
|
|
# Closing a coroutine shouldn't raise any exception even if it's
|
|
|
|
# already closed/exhausted (similar to generators)
|
|
|
|
coro.close()
|
|
|
|
coro.close()
|
|
|
|
|
|
|
|
def test_func_18(self):
|
|
|
|
# See http://bugs.python.org/issue25887 for details
|
|
|
|
|
|
|
|
async def coroutine():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
coro = coroutine()
|
|
|
|
await_iter = coro.__await__()
|
|
|
|
it = iter(await_iter)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(StopIteration, 'spam'):
|
|
|
|
it.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
it.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
# Although the iterator protocol requires iterators to
|
|
|
|
# raise another StopIteration here, we don't want to do
|
|
|
|
# that. In this particular case, the iterator will raise
|
|
|
|
# a RuntimeError, so that 'yield from' and 'await'
|
|
|
|
# expressions will trigger the error, instead of silently
|
|
|
|
# ignoring the call.
|
|
|
|
next(it)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
it.throw(Exception('wat'))
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
'cannot reuse already awaited coroutine'):
|
|
|
|
it.throw(Exception('wat'))
|
|
|
|
|
|
|
|
# Closing a coroutine shouldn't raise any exception even if it's
|
|
|
|
# already closed/exhausted (similar to generators)
|
|
|
|
it.close()
|
|
|
|
it.close()
|
|
|
|
|
|
|
|
def test_func_19(self):
|
|
|
|
CHK = 0
|
|
|
|
|
|
|
|
@types.coroutine
|
|
|
|
def foo():
|
|
|
|
nonlocal CHK
|
|
|
|
yield
|
|
|
|
try:
|
|
|
|
yield
|
|
|
|
except GeneratorExit:
|
|
|
|
CHK += 1
|
|
|
|
|
|
|
|
async def coroutine():
|
|
|
|
await foo()
|
|
|
|
|
|
|
|
coro = coroutine()
|
|
|
|
|
|
|
|
coro.send(None)
|
|
|
|
coro.send(None)
|
|
|
|
|
|
|
|
self.assertEqual(CHK, 0)
|
|
|
|
coro.close()
|
|
|
|
self.assertEqual(CHK, 1)
|
|
|
|
|
|
|
|
for _ in range(3):
|
|
|
|
# Closing a coroutine shouldn't raise any exception even if it's
|
|
|
|
# already closed/exhausted (similar to generators)
|
|
|
|
coro.close()
|
|
|
|
self.assertEqual(CHK, 1)
|
|
|
|
|
2016-11-06 12:44:42 -04:00
|
|
|
def test_coro_wrapper_send_tuple(self):
|
|
|
|
async def foo():
|
|
|
|
return (10,)
|
|
|
|
|
|
|
|
result = run_async__await__(foo())
|
|
|
|
self.assertEqual(result, ([], (10,)))
|
|
|
|
|
|
|
|
def test_coro_wrapper_send_stop_iterator(self):
|
|
|
|
async def foo():
|
|
|
|
return StopIteration(10)
|
|
|
|
|
|
|
|
result = run_async__await__(foo())
|
|
|
|
self.assertIsInstance(result[1], StopIteration)
|
|
|
|
self.assertEqual(result[1].value, 10)
|
|
|
|
|
2015-07-03 01:23:30 -03:00
|
|
|
def test_cr_await(self):
|
|
|
|
@types.coroutine
|
|
|
|
def a():
|
|
|
|
self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
yield
|
|
|
|
self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
|
|
|
|
async def c():
|
|
|
|
await a()
|
|
|
|
|
|
|
|
async def b():
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
await c()
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
|
|
|
|
coro_b = b()
|
|
|
|
self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CREATED)
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
|
|
|
|
coro_b.send(None)
|
|
|
|
self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_SUSPENDED)
|
|
|
|
self.assertEqual(coro_b.cr_await.cr_await.gi_code.co_name, 'a')
|
|
|
|
|
|
|
|
with self.assertRaises(StopIteration):
|
|
|
|
coro_b.send(None) # complete coroutine
|
|
|
|
self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CLOSED)
|
|
|
|
self.assertIsNone(coro_b.cr_await)
|
|
|
|
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
def test_corotype_1(self):
|
|
|
|
ct = types.CoroutineType
|
|
|
|
self.assertIn('into coroutine', ct.send.__doc__)
|
|
|
|
self.assertIn('inside coroutine', ct.close.__doc__)
|
|
|
|
self.assertIn('in coroutine', ct.throw.__doc__)
|
|
|
|
self.assertIn('of the coroutine', ct.__dict__['__name__'].__doc__)
|
|
|
|
self.assertIn('of the coroutine', ct.__dict__['__qualname__'].__doc__)
|
|
|
|
self.assertEqual(ct.__name__, 'coroutine')
|
|
|
|
|
|
|
|
async def f(): pass
|
|
|
|
c = f()
|
|
|
|
self.assertIn('coroutine object', repr(c))
|
|
|
|
c.close()
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def test_await_1(self):
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
await 1
|
|
|
|
with self.assertRaisesRegex(TypeError, "object int can.t.*await"):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_await_2(self):
|
|
|
|
async def foo():
|
|
|
|
await []
|
|
|
|
with self.assertRaisesRegex(TypeError, "object list can.t.*await"):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_await_3(self):
|
|
|
|
async def foo():
|
|
|
|
await AsyncYieldFrom([1, 2, 3])
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([1, 2, 3], None))
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
self.assertEqual(run_async__await__(foo()), ([1, 2, 3], None))
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_await_4(self):
|
|
|
|
async def bar():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return await bar()
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([], 42))
|
|
|
|
|
|
|
|
def test_await_5(self):
|
|
|
|
class Awaitable:
|
|
|
|
def __await__(self):
|
|
|
|
return
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return (await Awaitable())
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError, "__await__.*returned non-iterator of type"):
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_await_6(self):
|
|
|
|
class Awaitable:
|
|
|
|
def __await__(self):
|
|
|
|
return iter([52])
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return (await Awaitable())
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([52], None))
|
|
|
|
|
|
|
|
def test_await_7(self):
|
|
|
|
class Awaitable:
|
|
|
|
def __await__(self):
|
|
|
|
yield 42
|
|
|
|
return 100
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return (await Awaitable())
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([42], 100))
|
|
|
|
|
|
|
|
def test_await_8(self):
|
|
|
|
class Awaitable:
|
|
|
|
pass
|
|
|
|
|
2015-07-22 07:33:45 -03:00
|
|
|
async def foo(): return await Awaitable()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError, "object Awaitable can't be used in 'await' expression"):
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_await_9(self):
|
|
|
|
def wrap():
|
|
|
|
return bar
|
|
|
|
|
|
|
|
async def bar():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
db = {'b': lambda: wrap}
|
|
|
|
|
|
|
|
class DB:
|
|
|
|
b = wrap
|
|
|
|
|
|
|
|
return (await bar() + await wrap()() + await db['b']()()() +
|
|
|
|
await bar() * 1000 + await DB.b()())
|
|
|
|
|
|
|
|
async def foo2():
|
|
|
|
return -await bar()
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([], 42168))
|
|
|
|
self.assertEqual(run_async(foo2()), ([], -42))
|
|
|
|
|
|
|
|
def test_await_10(self):
|
|
|
|
async def baz():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
async def bar():
|
|
|
|
return baz()
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return await (await bar())
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo()), ([], 42))
|
|
|
|
|
|
|
|
def test_await_11(self):
|
|
|
|
def ident(val):
|
|
|
|
return val
|
|
|
|
|
|
|
|
async def bar():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return ident(val=await bar())
|
|
|
|
|
|
|
|
async def foo2():
|
|
|
|
return await bar(), 'ham'
|
|
|
|
|
|
|
|
self.assertEqual(run_async(foo2()), ([], ('spam', 'ham')))
|
|
|
|
|
|
|
|
def test_await_12(self):
|
|
|
|
async def coro():
|
|
|
|
return 'spam'
|
2018-01-29 15:31:47 -04:00
|
|
|
c = coro()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
class Awaitable:
|
|
|
|
def __await__(self):
|
2018-01-29 15:31:47 -04:00
|
|
|
return c
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return await Awaitable()
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
2018-01-29 15:31:47 -04:00
|
|
|
TypeError, r"__await__\(\) returned a coroutine"):
|
2015-05-11 23:57:16 -03:00
|
|
|
run_async(foo())
|
|
|
|
|
2018-01-29 15:31:47 -04:00
|
|
|
c.close()
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def test_await_13(self):
|
|
|
|
class Awaitable:
|
|
|
|
def __await__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return await Awaitable()
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError, "__await__.*returned non-iterator of type"):
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
2015-07-01 13:29:55 -03:00
|
|
|
def test_await_14(self):
|
|
|
|
class Wrapper:
|
|
|
|
# Forces the interpreter to use CoroutineType.__await__
|
|
|
|
def __init__(self, coro):
|
|
|
|
assert coro.__class__ is types.CoroutineType
|
|
|
|
self.coro = coro
|
|
|
|
def __await__(self):
|
|
|
|
return self.coro.__await__()
|
|
|
|
|
|
|
|
class FutureLike:
|
|
|
|
def __await__(self):
|
|
|
|
return (yield)
|
|
|
|
|
|
|
|
class Marker(Exception):
|
|
|
|
pass
|
|
|
|
|
|
|
|
async def coro1():
|
|
|
|
try:
|
|
|
|
return await FutureLike()
|
|
|
|
except ZeroDivisionError:
|
|
|
|
raise Marker
|
|
|
|
async def coro2():
|
|
|
|
return await Wrapper(coro1())
|
|
|
|
|
|
|
|
c = coro2()
|
|
|
|
c.send(None)
|
|
|
|
with self.assertRaisesRegex(StopIteration, 'spam'):
|
|
|
|
c.send('spam')
|
|
|
|
|
|
|
|
c = coro2()
|
|
|
|
c.send(None)
|
|
|
|
with self.assertRaises(Marker):
|
|
|
|
c.throw(ZeroDivisionError)
|
|
|
|
|
2016-03-02 12:30:46 -04:00
|
|
|
def test_await_15(self):
|
|
|
|
@types.coroutine
|
|
|
|
def nop():
|
|
|
|
yield
|
|
|
|
|
|
|
|
async def coroutine():
|
|
|
|
await nop()
|
|
|
|
|
|
|
|
async def waiter(coro):
|
|
|
|
await coro
|
|
|
|
|
|
|
|
coro = coroutine()
|
|
|
|
coro.send(None)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
"coroutine is being awaited already"):
|
|
|
|
waiter(coro).send(None)
|
|
|
|
|
2017-03-12 16:53:07 -03:00
|
|
|
def test_await_16(self):
|
|
|
|
# See https://bugs.python.org/issue29600 for details.
|
|
|
|
|
|
|
|
async def f():
|
|
|
|
return ValueError()
|
|
|
|
|
|
|
|
async def g():
|
|
|
|
try:
|
|
|
|
raise KeyError
|
|
|
|
except:
|
|
|
|
return await f()
|
|
|
|
|
|
|
|
_, result = run_async(g())
|
|
|
|
self.assertIsNone(result.__context__)
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def test_with_1(self):
|
|
|
|
class Manager:
|
|
|
|
def __init__(self, name):
|
|
|
|
self.name = name
|
|
|
|
|
|
|
|
async def __aenter__(self):
|
|
|
|
await AsyncYieldFrom(['enter-1-' + self.name,
|
|
|
|
'enter-2-' + self.name])
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, *args):
|
|
|
|
await AsyncYieldFrom(['exit-1-' + self.name,
|
|
|
|
'exit-2-' + self.name])
|
|
|
|
|
|
|
|
if self.name == 'B':
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with Manager("A") as a, Manager("B") as b:
|
|
|
|
await AsyncYieldFrom([('managers', a.name, b.name)])
|
|
|
|
1/0
|
|
|
|
|
|
|
|
f = foo()
|
|
|
|
result, _ = run_async(f)
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
result, ['enter-1-A', 'enter-2-A', 'enter-1-B', 'enter-2-B',
|
|
|
|
('managers', 'A', 'B'),
|
|
|
|
'exit-1-B', 'exit-2-B', 'exit-1-A', 'exit-2-A']
|
|
|
|
)
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with Manager("A") as a, Manager("C") as c:
|
|
|
|
await AsyncYieldFrom([('managers', a.name, c.name)])
|
|
|
|
1/0
|
|
|
|
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_with_2(self):
|
|
|
|
class CM:
|
|
|
|
def __aenter__(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with CM():
|
|
|
|
pass
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(AttributeError, '__aexit__'):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_with_3(self):
|
|
|
|
class CM:
|
|
|
|
def __aexit__(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with CM():
|
|
|
|
pass
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(AttributeError, '__aenter__'):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_with_4(self):
|
|
|
|
class CM:
|
|
|
|
def __enter__(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def __exit__(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with CM():
|
|
|
|
pass
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(AttributeError, '__aexit__'):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_with_5(self):
|
|
|
|
# While this test doesn't make a lot of sense,
|
|
|
|
# it's a regression test for an early bug with opcodes
|
|
|
|
# generation
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, *exc):
|
|
|
|
pass
|
|
|
|
|
|
|
|
async def func():
|
|
|
|
async with CM():
|
|
|
|
assert (1, ) == 1
|
|
|
|
|
|
|
|
with self.assertRaises(AssertionError):
|
|
|
|
run_async(func())
|
|
|
|
|
|
|
|
def test_with_6(self):
|
|
|
|
class CM:
|
|
|
|
def __aenter__(self):
|
|
|
|
return 123
|
|
|
|
|
|
|
|
def __aexit__(self, *e):
|
|
|
|
return 456
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async with CM():
|
|
|
|
pass
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
2018-04-02 19:41:38 -03:00
|
|
|
TypeError,
|
|
|
|
"'async with' received an object from __aenter__ "
|
|
|
|
"that does not implement __await__: int"):
|
2015-05-11 23:57:16 -03:00
|
|
|
# it's important that __aexit__ wasn't called
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
def test_with_7(self):
|
2015-05-13 02:54:02 -03:00
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
def __aexit__(self, *e):
|
|
|
|
return 444
|
|
|
|
|
2018-04-04 12:45:10 -03:00
|
|
|
# Exit with exception
|
2015-05-13 02:54:02 -03:00
|
|
|
async def foo():
|
|
|
|
async with CM():
|
|
|
|
1/0
|
|
|
|
|
|
|
|
try:
|
|
|
|
run_async(foo())
|
|
|
|
except TypeError as exc:
|
|
|
|
self.assertRegex(
|
2018-04-02 19:41:38 -03:00
|
|
|
exc.args[0],
|
|
|
|
"'async with' received an object from __aexit__ "
|
|
|
|
"that does not implement __await__: int")
|
2015-05-13 02:54:02 -03:00
|
|
|
self.assertTrue(exc.__context__ is not None)
|
|
|
|
self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
|
|
|
|
else:
|
|
|
|
self.fail('invalid asynchronous context manager did not fail')
|
|
|
|
|
|
|
|
|
|
|
|
def test_with_8(self):
|
|
|
|
CNT = 0
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
def __aexit__(self, *e):
|
|
|
|
return 456
|
|
|
|
|
2018-04-04 12:45:10 -03:00
|
|
|
# Normal exit
|
2015-05-11 23:57:16 -03:00
|
|
|
async def foo():
|
2015-05-13 02:54:02 -03:00
|
|
|
nonlocal CNT
|
2015-05-11 23:57:16 -03:00
|
|
|
async with CM():
|
2015-05-13 02:54:02 -03:00
|
|
|
CNT += 1
|
2018-04-04 12:45:10 -03:00
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
|
|
|
"'async with' received an object from __aexit__ "
|
|
|
|
"that does not implement __await__: int"):
|
|
|
|
run_async(foo())
|
|
|
|
self.assertEqual(CNT, 1)
|
2015-05-13 02:54:02 -03:00
|
|
|
|
2018-04-04 12:45:10 -03:00
|
|
|
# Exit with 'break'
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
for i in range(2):
|
|
|
|
async with CM():
|
|
|
|
CNT += 1
|
|
|
|
break
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
|
|
|
"'async with' received an object from __aexit__ "
|
|
|
|
"that does not implement __await__: int"):
|
|
|
|
run_async(foo())
|
|
|
|
self.assertEqual(CNT, 2)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-04-04 12:45:10 -03:00
|
|
|
# Exit with 'continue'
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
for i in range(2):
|
|
|
|
async with CM():
|
|
|
|
CNT += 1
|
|
|
|
continue
|
2015-05-11 23:57:16 -03:00
|
|
|
with self.assertRaisesRegex(
|
2018-04-02 19:41:38 -03:00
|
|
|
TypeError,
|
|
|
|
"'async with' received an object from __aexit__ "
|
|
|
|
"that does not implement __await__: int"):
|
2015-05-11 23:57:16 -03:00
|
|
|
run_async(foo())
|
2018-04-04 12:45:10 -03:00
|
|
|
self.assertEqual(CNT, 3)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-04-04 12:45:10 -03:00
|
|
|
# Exit with 'return'
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async with CM():
|
|
|
|
CNT += 1
|
|
|
|
return
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
|
|
|
"'async with' received an object from __aexit__ "
|
|
|
|
"that does not implement __await__: int"):
|
|
|
|
run_async(foo())
|
|
|
|
self.assertEqual(CNT, 4)
|
2015-05-13 02:54:02 -03:00
|
|
|
|
|
|
|
|
|
|
|
def test_with_9(self):
|
|
|
|
CNT = 0
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, *e):
|
|
|
|
1/0
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async with CM():
|
|
|
|
CNT += 1
|
|
|
|
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
self.assertEqual(CNT, 1)
|
|
|
|
|
|
|
|
def test_with_10(self):
|
|
|
|
CNT = 0
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, *e):
|
|
|
|
1/0
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async with CM():
|
|
|
|
async with CM():
|
|
|
|
raise RuntimeError
|
|
|
|
|
|
|
|
try:
|
|
|
|
run_async(foo())
|
|
|
|
except ZeroDivisionError as exc:
|
|
|
|
self.assertTrue(exc.__context__ is not None)
|
|
|
|
self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
|
|
|
|
self.assertTrue(isinstance(exc.__context__.__context__,
|
|
|
|
RuntimeError))
|
|
|
|
else:
|
|
|
|
self.fail('exception from __aexit__ did not propagate')
|
|
|
|
|
|
|
|
def test_with_11(self):
|
|
|
|
CNT = 0
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
raise NotImplementedError
|
|
|
|
|
|
|
|
async def __aexit__(self, *e):
|
|
|
|
1/0
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async with CM():
|
|
|
|
raise RuntimeError
|
|
|
|
|
|
|
|
try:
|
|
|
|
run_async(foo())
|
|
|
|
except NotImplementedError as exc:
|
|
|
|
self.assertTrue(exc.__context__ is None)
|
|
|
|
else:
|
|
|
|
self.fail('exception from __aenter__ did not propagate')
|
|
|
|
|
|
|
|
def test_with_12(self):
|
|
|
|
CNT = 0
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, *e):
|
|
|
|
return True
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async with CM() as cm:
|
|
|
|
self.assertIs(cm.__class__, CM)
|
|
|
|
raise RuntimeError
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
2015-05-13 17:49:35 -03:00
|
|
|
def test_with_13(self):
|
|
|
|
CNT = 0
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
1/0
|
|
|
|
|
|
|
|
async def __aexit__(self, *e):
|
|
|
|
return True
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
CNT += 1
|
|
|
|
async with CM():
|
|
|
|
CNT += 1000
|
|
|
|
CNT += 10000
|
|
|
|
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
|
|
|
run_async(foo())
|
|
|
|
self.assertEqual(CNT, 1)
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
def test_for_1(self):
|
|
|
|
aiter_calls = 0
|
|
|
|
|
|
|
|
class AsyncIter:
|
|
|
|
def __init__(self):
|
|
|
|
self.i = 0
|
|
|
|
|
2017-10-06 03:08:57 -03:00
|
|
|
def __aiter__(self):
|
2015-05-11 23:57:16 -03:00
|
|
|
nonlocal aiter_calls
|
|
|
|
aiter_calls += 1
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __anext__(self):
|
|
|
|
self.i += 1
|
|
|
|
|
|
|
|
if not (self.i % 10):
|
|
|
|
await AsyncYield(self.i * 10)
|
|
|
|
|
|
|
|
if self.i > 100:
|
|
|
|
raise StopAsyncIteration
|
|
|
|
|
|
|
|
return self.i, self.i
|
|
|
|
|
|
|
|
|
|
|
|
buffer = []
|
|
|
|
async def test1():
|
2017-10-06 03:08:57 -03:00
|
|
|
async for i1, i2 in AsyncIter():
|
|
|
|
buffer.append(i1 + i2)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
yielded, _ = run_async(test1())
|
|
|
|
# Make sure that __aiter__ was called only once
|
|
|
|
self.assertEqual(aiter_calls, 1)
|
|
|
|
self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
|
|
|
|
self.assertEqual(buffer, [i*2 for i in range(1, 101)])
|
|
|
|
|
|
|
|
|
|
|
|
buffer = []
|
|
|
|
async def test2():
|
|
|
|
nonlocal buffer
|
2017-10-06 03:08:57 -03:00
|
|
|
async for i in AsyncIter():
|
|
|
|
buffer.append(i[0])
|
|
|
|
if i[0] == 20:
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
buffer.append('what?')
|
2015-05-11 23:57:16 -03:00
|
|
|
buffer.append('end')
|
|
|
|
|
|
|
|
yielded, _ = run_async(test2())
|
|
|
|
# Make sure that __aiter__ was called only once
|
|
|
|
self.assertEqual(aiter_calls, 2)
|
|
|
|
self.assertEqual(yielded, [100, 200])
|
|
|
|
self.assertEqual(buffer, [i for i in range(1, 21)] + ['end'])
|
|
|
|
|
|
|
|
|
|
|
|
buffer = []
|
|
|
|
async def test3():
|
|
|
|
nonlocal buffer
|
2017-10-06 03:08:57 -03:00
|
|
|
async for i in AsyncIter():
|
|
|
|
if i[0] > 20:
|
|
|
|
continue
|
|
|
|
buffer.append(i[0])
|
|
|
|
else:
|
|
|
|
buffer.append('what?')
|
2015-05-11 23:57:16 -03:00
|
|
|
buffer.append('end')
|
|
|
|
|
|
|
|
yielded, _ = run_async(test3())
|
|
|
|
# Make sure that __aiter__ was called only once
|
|
|
|
self.assertEqual(aiter_calls, 3)
|
|
|
|
self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
|
|
|
|
self.assertEqual(buffer, [i for i in range(1, 21)] +
|
|
|
|
['what?', 'end'])
|
|
|
|
|
|
|
|
def test_for_2(self):
|
|
|
|
tup = (1, 2, 3)
|
|
|
|
refs_before = sys.getrefcount(tup)
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async for i in tup:
|
|
|
|
print('never going to happen')
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError, "async for' requires an object.*__aiter__.*tuple"):
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
self.assertEqual(sys.getrefcount(tup), refs_before)
|
|
|
|
|
|
|
|
def test_for_3(self):
|
|
|
|
class I:
|
|
|
|
def __aiter__(self):
|
|
|
|
return self
|
|
|
|
|
|
|
|
aiter = I()
|
|
|
|
refs_before = sys.getrefcount(aiter)
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async for i in aiter:
|
|
|
|
print('never going to happen')
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
2017-10-06 03:08:57 -03:00
|
|
|
r"that does not implement __anext__"):
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
self.assertEqual(sys.getrefcount(aiter), refs_before)
|
|
|
|
|
|
|
|
def test_for_4(self):
|
|
|
|
class I:
|
2016-06-09 16:08:31 -03:00
|
|
|
def __aiter__(self):
|
2015-05-11 23:57:16 -03:00
|
|
|
return self
|
|
|
|
|
|
|
|
def __anext__(self):
|
|
|
|
return ()
|
|
|
|
|
|
|
|
aiter = I()
|
|
|
|
refs_before = sys.getrefcount(aiter)
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
async for i in aiter:
|
|
|
|
print('never going to happen')
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError,
|
|
|
|
"async for' received an invalid object.*__anext__.*tuple"):
|
|
|
|
|
|
|
|
run_async(foo())
|
|
|
|
|
|
|
|
self.assertEqual(sys.getrefcount(aiter), refs_before)
|
|
|
|
|
|
|
|
def test_for_6(self):
|
|
|
|
I = 0
|
|
|
|
|
|
|
|
class Manager:
|
|
|
|
async def __aenter__(self):
|
|
|
|
nonlocal I
|
|
|
|
I += 10000
|
|
|
|
|
|
|
|
async def __aexit__(self, *args):
|
|
|
|
nonlocal I
|
|
|
|
I += 100000
|
|
|
|
|
|
|
|
class Iterable:
|
|
|
|
def __init__(self):
|
|
|
|
self.i = 0
|
|
|
|
|
2016-06-09 16:08:31 -03:00
|
|
|
def __aiter__(self):
|
2015-05-11 23:57:16 -03:00
|
|
|
return self
|
|
|
|
|
|
|
|
async def __anext__(self):
|
|
|
|
if self.i > 10:
|
|
|
|
raise StopAsyncIteration
|
|
|
|
self.i += 1
|
|
|
|
return self.i
|
|
|
|
|
|
|
|
##############
|
|
|
|
|
|
|
|
manager = Manager()
|
|
|
|
iterable = Iterable()
|
|
|
|
mrefs_before = sys.getrefcount(manager)
|
|
|
|
irefs_before = sys.getrefcount(iterable)
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
nonlocal I
|
|
|
|
|
|
|
|
async with manager:
|
|
|
|
async for i in iterable:
|
|
|
|
I += 1
|
|
|
|
I += 1000
|
|
|
|
|
2016-06-09 16:08:31 -03:00
|
|
|
with warnings.catch_warnings():
|
|
|
|
warnings.simplefilter("error")
|
2016-06-12 03:14:03 -03:00
|
|
|
# Test that __aiter__ that returns an asynchronous iterator
|
2016-06-09 16:08:31 -03:00
|
|
|
# directly does not throw any warnings.
|
|
|
|
run_async(main())
|
2015-05-11 23:57:16 -03:00
|
|
|
self.assertEqual(I, 111011)
|
|
|
|
|
|
|
|
self.assertEqual(sys.getrefcount(manager), mrefs_before)
|
|
|
|
self.assertEqual(sys.getrefcount(iterable), irefs_before)
|
|
|
|
|
|
|
|
##############
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
nonlocal I
|
|
|
|
|
|
|
|
async with Manager():
|
|
|
|
async for i in Iterable():
|
|
|
|
I += 1
|
|
|
|
I += 1000
|
|
|
|
|
|
|
|
async with Manager():
|
|
|
|
async for i in Iterable():
|
|
|
|
I += 1
|
|
|
|
I += 1000
|
|
|
|
|
|
|
|
run_async(main())
|
|
|
|
self.assertEqual(I, 333033)
|
|
|
|
|
|
|
|
##############
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
nonlocal I
|
|
|
|
|
|
|
|
async with Manager():
|
|
|
|
I += 100
|
|
|
|
async for i in Iterable():
|
|
|
|
I += 1
|
|
|
|
else:
|
|
|
|
I += 10000000
|
|
|
|
I += 1000
|
|
|
|
|
|
|
|
async with Manager():
|
|
|
|
I += 100
|
|
|
|
async for i in Iterable():
|
|
|
|
I += 1
|
|
|
|
else:
|
|
|
|
I += 10000000
|
|
|
|
I += 1000
|
|
|
|
|
|
|
|
run_async(main())
|
|
|
|
self.assertEqual(I, 20555255)
|
|
|
|
|
2015-05-13 17:49:35 -03:00
|
|
|
def test_for_7(self):
|
|
|
|
CNT = 0
|
|
|
|
class AI:
|
2017-10-06 03:08:57 -03:00
|
|
|
def __aiter__(self):
|
2015-05-13 17:49:35 -03:00
|
|
|
1/0
|
2016-06-09 16:08:31 -03:00
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
2017-10-06 03:08:57 -03:00
|
|
|
async for i in AI():
|
|
|
|
CNT += 1
|
2016-06-09 16:08:31 -03:00
|
|
|
CNT += 10
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
|
|
|
run_async(foo())
|
|
|
|
self.assertEqual(CNT, 0)
|
|
|
|
|
|
|
|
def test_for_8(self):
|
|
|
|
CNT = 0
|
|
|
|
class AI:
|
|
|
|
def __aiter__(self):
|
|
|
|
1/0
|
2015-05-13 17:49:35 -03:00
|
|
|
async def foo():
|
|
|
|
nonlocal CNT
|
|
|
|
async for i in AI():
|
|
|
|
CNT += 1
|
|
|
|
CNT += 10
|
|
|
|
with self.assertRaises(ZeroDivisionError):
|
2016-06-09 16:08:31 -03:00
|
|
|
with warnings.catch_warnings():
|
|
|
|
warnings.simplefilter("error")
|
|
|
|
# Test that if __aiter__ raises an exception it propagates
|
|
|
|
# without any kind of warning.
|
|
|
|
run_async(foo())
|
2015-05-13 17:49:35 -03:00
|
|
|
self.assertEqual(CNT, 0)
|
|
|
|
|
2017-03-02 23:20:00 -04:00
|
|
|
def test_for_11(self):
|
|
|
|
class F:
|
|
|
|
def __aiter__(self):
|
|
|
|
return self
|
|
|
|
def __anext__(self):
|
|
|
|
return self
|
|
|
|
def __await__(self):
|
|
|
|
1 / 0
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
async for _ in F():
|
|
|
|
pass
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(TypeError,
|
|
|
|
'an invalid object from __anext__') as c:
|
|
|
|
main().send(None)
|
|
|
|
|
|
|
|
err = c.exception
|
|
|
|
self.assertIsInstance(err.__cause__, ZeroDivisionError)
|
|
|
|
|
2016-11-06 12:44:42 -04:00
|
|
|
def test_for_tuple(self):
|
|
|
|
class Done(Exception): pass
|
|
|
|
|
|
|
|
class AIter(tuple):
|
|
|
|
i = 0
|
|
|
|
def __aiter__(self):
|
|
|
|
return self
|
|
|
|
async def __anext__(self):
|
|
|
|
if self.i >= len(self):
|
|
|
|
raise StopAsyncIteration
|
|
|
|
self.i += 1
|
|
|
|
return self[self.i - 1]
|
|
|
|
|
|
|
|
result = []
|
|
|
|
async def foo():
|
|
|
|
async for i in AIter([42]):
|
|
|
|
result.append(i)
|
|
|
|
raise Done
|
|
|
|
|
|
|
|
with self.assertRaises(Done):
|
|
|
|
foo().send(None)
|
|
|
|
self.assertEqual(result, [42])
|
|
|
|
|
|
|
|
def test_for_stop_iteration(self):
|
|
|
|
class Done(Exception): pass
|
|
|
|
|
|
|
|
class AIter(StopIteration):
|
|
|
|
i = 0
|
|
|
|
def __aiter__(self):
|
|
|
|
return self
|
|
|
|
async def __anext__(self):
|
|
|
|
if self.i:
|
|
|
|
raise StopAsyncIteration
|
|
|
|
self.i += 1
|
|
|
|
return self.value
|
|
|
|
|
|
|
|
result = []
|
|
|
|
async def foo():
|
|
|
|
async for i in AIter(42):
|
|
|
|
result.append(i)
|
|
|
|
raise Done
|
|
|
|
|
|
|
|
with self.assertRaises(Done):
|
|
|
|
foo().send(None)
|
|
|
|
self.assertEqual(result, [42])
|
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
def test_comp_1(self):
|
|
|
|
async def f(i):
|
|
|
|
return i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [await c for c in [f(1), f(41)]]
|
|
|
|
|
|
|
|
async def run_set():
|
|
|
|
return {await c for c in [f(1), f(41)]}
|
|
|
|
|
|
|
|
async def run_dict1():
|
|
|
|
return {await c: 'a' for c in [f(1), f(41)]}
|
|
|
|
|
|
|
|
async def run_dict2():
|
|
|
|
return {i: await c for i, c in enumerate([f(1), f(41)])}
|
|
|
|
|
|
|
|
self.assertEqual(run_async(run_list()), ([], [1, 41]))
|
|
|
|
self.assertEqual(run_async(run_set()), ([], {1, 41}))
|
|
|
|
self.assertEqual(run_async(run_dict1()), ([], {1: 'a', 41: 'a'}))
|
|
|
|
self.assertEqual(run_async(run_dict2()), ([], {0: 1, 1: 41}))
|
|
|
|
|
|
|
|
def test_comp_2(self):
|
|
|
|
async def f(i):
|
|
|
|
return i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [s for c in [f(''), f('abc'), f(''), f(['de', 'fg'])]
|
|
|
|
for s in await c]
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], ['a', 'b', 'c', 'de', 'fg']))
|
|
|
|
|
|
|
|
async def run_set():
|
|
|
|
return {d
|
|
|
|
for c in [f([f([10, 30]),
|
|
|
|
f([20])])]
|
|
|
|
for s in await c
|
|
|
|
for d in await s}
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_set()),
|
|
|
|
([], {10, 20, 30}))
|
|
|
|
|
|
|
|
async def run_set2():
|
|
|
|
return {await s
|
|
|
|
for c in [f([f(10), f(20)])]
|
|
|
|
for s in await c}
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_set2()),
|
|
|
|
([], {10, 20}))
|
|
|
|
|
|
|
|
def test_comp_3(self):
|
|
|
|
async def f(it):
|
|
|
|
for i in it:
|
|
|
|
yield i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i + 1 async for i in f([10, 20])]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], [11, 21]))
|
|
|
|
|
|
|
|
async def run_set():
|
|
|
|
return {i + 1 async for i in f([10, 20])}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_set()),
|
|
|
|
([], {11, 21}))
|
|
|
|
|
|
|
|
async def run_dict():
|
|
|
|
return {i + 1: i + 2 async for i in f([10, 20])}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_dict()),
|
|
|
|
([], {11: 12, 21: 22}))
|
|
|
|
|
|
|
|
async def run_gen():
|
|
|
|
gen = (i + 1 async for i in f([10, 20]))
|
|
|
|
return [g + 100 async for g in gen]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_gen()),
|
|
|
|
([], [111, 121]))
|
|
|
|
|
|
|
|
def test_comp_4(self):
|
|
|
|
async def f(it):
|
|
|
|
for i in it:
|
|
|
|
yield i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i + 1 async for i in f([10, 20]) if i > 10]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], [21]))
|
|
|
|
|
|
|
|
async def run_set():
|
|
|
|
return {i + 1 async for i in f([10, 20]) if i > 10}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_set()),
|
|
|
|
([], {21}))
|
|
|
|
|
|
|
|
async def run_dict():
|
|
|
|
return {i + 1: i + 2 async for i in f([10, 20]) if i > 10}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_dict()),
|
|
|
|
([], {21: 22}))
|
|
|
|
|
|
|
|
async def run_gen():
|
|
|
|
gen = (i + 1 async for i in f([10, 20]) if i > 10)
|
|
|
|
return [g + 100 async for g in gen]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_gen()),
|
|
|
|
([], [121]))
|
|
|
|
|
2018-03-23 09:34:35 -03:00
|
|
|
def test_comp_4_2(self):
|
|
|
|
async def f(it):
|
|
|
|
for i in it:
|
|
|
|
yield i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i + 10 async for i in f(range(5)) if 0 < i < 4]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], [11, 12, 13]))
|
|
|
|
|
|
|
|
async def run_set():
|
|
|
|
return {i + 10 async for i in f(range(5)) if 0 < i < 4}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_set()),
|
|
|
|
([], {11, 12, 13}))
|
|
|
|
|
|
|
|
async def run_dict():
|
|
|
|
return {i + 10: i + 100 async for i in f(range(5)) if 0 < i < 4}
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_dict()),
|
|
|
|
([], {11: 101, 12: 102, 13: 103}))
|
|
|
|
|
|
|
|
async def run_gen():
|
|
|
|
gen = (i + 10 async for i in f(range(5)) if 0 < i < 4)
|
|
|
|
return [g + 100 async for g in gen]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_gen()),
|
|
|
|
([], [111, 112, 113]))
|
|
|
|
|
2016-09-09 14:36:01 -03:00
|
|
|
def test_comp_5(self):
|
|
|
|
async def f(it):
|
|
|
|
for i in it:
|
|
|
|
yield i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i + 1 for pair in ([10, 20], [30, 40]) if pair[0] > 10
|
|
|
|
async for i in f(pair) if i > 30]
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], [41]))
|
|
|
|
|
|
|
|
def test_comp_6(self):
|
|
|
|
async def f(it):
|
|
|
|
for i in it:
|
|
|
|
yield i
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i + 1 async for seq in f([(10, 20), (30,)])
|
|
|
|
for i in seq]
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(run_list()),
|
|
|
|
([], [11, 21, 31]))
|
|
|
|
|
|
|
|
def test_comp_7(self):
|
|
|
|
async def f():
|
|
|
|
yield 1
|
|
|
|
yield 2
|
|
|
|
raise Exception('aaa')
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
return [i async for i in f()]
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(Exception, 'aaa'):
|
|
|
|
run_async(run_list())
|
|
|
|
|
|
|
|
def test_comp_8(self):
|
|
|
|
async def f():
|
|
|
|
return [i for i in [1, 2, 3]]
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(f()),
|
|
|
|
([], [1, 2, 3]))
|
|
|
|
|
|
|
|
def test_comp_9(self):
|
|
|
|
async def gen():
|
|
|
|
yield 1
|
|
|
|
yield 2
|
|
|
|
async def f():
|
|
|
|
l = [i async for i in gen()]
|
|
|
|
return [i for i in l]
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(f()),
|
|
|
|
([], [1, 2]))
|
|
|
|
|
|
|
|
def test_comp_10(self):
|
|
|
|
async def f():
|
|
|
|
xx = {i for i in [1, 2, 3]}
|
|
|
|
return {x: x for x in xx}
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
run_async(f()),
|
|
|
|
([], {1: 1, 2: 2, 3: 3}))
|
|
|
|
|
2015-11-12 05:31:51 -04:00
|
|
|
def test_copy(self):
|
|
|
|
async def func(): pass
|
|
|
|
coro = func()
|
|
|
|
with self.assertRaises(TypeError):
|
|
|
|
copy.copy(coro)
|
|
|
|
|
|
|
|
aw = coro.__await__()
|
|
|
|
try:
|
|
|
|
with self.assertRaises(TypeError):
|
|
|
|
copy.copy(aw)
|
|
|
|
finally:
|
|
|
|
aw.close()
|
|
|
|
|
|
|
|
def test_pickle(self):
|
|
|
|
async def func(): pass
|
|
|
|
coro = func()
|
|
|
|
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
|
|
|
|
with self.assertRaises((TypeError, pickle.PicklingError)):
|
|
|
|
pickle.dumps(coro, proto)
|
|
|
|
|
|
|
|
aw = coro.__await__()
|
|
|
|
try:
|
|
|
|
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
|
|
|
|
with self.assertRaises((TypeError, pickle.PicklingError)):
|
|
|
|
pickle.dumps(aw, proto)
|
|
|
|
finally:
|
|
|
|
aw.close()
|
|
|
|
|
2016-09-05 14:14:54 -03:00
|
|
|
def test_fatal_coro_warning(self):
|
|
|
|
# Issue 27811
|
|
|
|
async def func(): pass
|
2016-09-07 13:00:48 -03:00
|
|
|
with warnings.catch_warnings(), support.captured_stderr() as stderr:
|
2016-09-05 14:14:54 -03:00
|
|
|
warnings.filterwarnings("error")
|
|
|
|
func()
|
|
|
|
support.gc_collect()
|
2016-09-07 13:00:48 -03:00
|
|
|
self.assertIn("was never awaited", stderr.getvalue())
|
2016-09-05 14:14:54 -03:00
|
|
|
|
2018-03-10 12:22:34 -04:00
|
|
|
def test_for_assign_raising_stop_async_iteration(self):
|
|
|
|
class BadTarget:
|
|
|
|
def __setitem__(self, key, value):
|
|
|
|
raise StopAsyncIteration(42)
|
|
|
|
tgt = BadTarget()
|
|
|
|
async def source():
|
|
|
|
yield 10
|
|
|
|
|
|
|
|
async def run_for():
|
|
|
|
with self.assertRaises(StopAsyncIteration) as cm:
|
|
|
|
async for tgt[0] in source():
|
|
|
|
pass
|
|
|
|
self.assertEqual(cm.exception.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_for()), ([], 'end'))
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
with self.assertRaises(StopAsyncIteration) as cm:
|
|
|
|
return [0 async for tgt[0] in source()]
|
|
|
|
self.assertEqual(cm.exception.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_list()), ([], 'end'))
|
|
|
|
|
|
|
|
async def run_gen():
|
|
|
|
gen = (0 async for tgt[0] in source())
|
|
|
|
a = gen.asend(None)
|
|
|
|
with self.assertRaises(RuntimeError) as cm:
|
|
|
|
await a
|
|
|
|
self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
|
|
|
|
self.assertEqual(cm.exception.__cause__.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_gen()), ([], 'end'))
|
|
|
|
|
|
|
|
def test_for_assign_raising_stop_async_iteration_2(self):
|
|
|
|
class BadIterable:
|
|
|
|
def __iter__(self):
|
|
|
|
raise StopAsyncIteration(42)
|
|
|
|
async def badpairs():
|
|
|
|
yield BadIterable()
|
|
|
|
|
|
|
|
async def run_for():
|
|
|
|
with self.assertRaises(StopAsyncIteration) as cm:
|
|
|
|
async for i, j in badpairs():
|
|
|
|
pass
|
|
|
|
self.assertEqual(cm.exception.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_for()), ([], 'end'))
|
|
|
|
|
|
|
|
async def run_list():
|
|
|
|
with self.assertRaises(StopAsyncIteration) as cm:
|
|
|
|
return [0 async for i, j in badpairs()]
|
|
|
|
self.assertEqual(cm.exception.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_list()), ([], 'end'))
|
|
|
|
|
|
|
|
async def run_gen():
|
|
|
|
gen = (0 async for i, j in badpairs())
|
|
|
|
a = gen.asend(None)
|
|
|
|
with self.assertRaises(RuntimeError) as cm:
|
|
|
|
await a
|
|
|
|
self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
|
|
|
|
self.assertEqual(cm.exception.__cause__.args, (42,))
|
|
|
|
return 'end'
|
|
|
|
self.assertEqual(run_async(run_gen()), ([], 'end'))
|
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
class CoroAsyncIOCompatTest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_asyncio_1(self):
|
2015-10-11 05:10:31 -03:00
|
|
|
# asyncio cannot be imported when Python is compiled without thread
|
|
|
|
# support
|
2015-10-11 05:53:15 -03:00
|
|
|
asyncio = support.import_module('asyncio')
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
class MyException(Exception):
|
|
|
|
pass
|
|
|
|
|
|
|
|
buffer = []
|
|
|
|
|
|
|
|
class CM:
|
|
|
|
async def __aenter__(self):
|
|
|
|
buffer.append(1)
|
|
|
|
await asyncio.sleep(0.01)
|
|
|
|
buffer.append(2)
|
|
|
|
return self
|
|
|
|
|
|
|
|
async def __aexit__(self, exc_type, exc_val, exc_tb):
|
|
|
|
await asyncio.sleep(0.01)
|
|
|
|
buffer.append(exc_type.__name__)
|
|
|
|
|
|
|
|
async def f():
|
|
|
|
async with CM() as c:
|
|
|
|
await asyncio.sleep(0.01)
|
|
|
|
raise MyException
|
|
|
|
buffer.append('unreachable')
|
|
|
|
|
2015-05-12 15:28:08 -03:00
|
|
|
loop = asyncio.new_event_loop()
|
|
|
|
asyncio.set_event_loop(loop)
|
2015-05-11 23:57:16 -03:00
|
|
|
try:
|
|
|
|
loop.run_until_complete(f())
|
|
|
|
except MyException:
|
|
|
|
pass
|
|
|
|
finally:
|
|
|
|
loop.close()
|
2018-06-02 00:34:09 -03:00
|
|
|
asyncio.set_event_loop_policy(None)
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
self.assertEqual(buffer, [1, 2, 'MyException'])
|
|
|
|
|
|
|
|
|
|
|
|
class SysSetCoroWrapperTest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_set_wrapper_1(self):
|
|
|
|
async def foo():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
wrapped = None
|
|
|
|
def wrap(gen):
|
|
|
|
nonlocal wrapped
|
|
|
|
wrapped = gen
|
|
|
|
return gen
|
|
|
|
|
2018-01-21 10:44:07 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
self.assertIsNone(sys.get_coroutine_wrapper())
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-21 10:44:07 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(wrap)
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
self.assertIs(sys.get_coroutine_wrapper(), wrap)
|
2015-05-11 23:57:16 -03:00
|
|
|
try:
|
|
|
|
f = foo()
|
|
|
|
self.assertTrue(wrapped)
|
|
|
|
|
|
|
|
self.assertEqual(run_async(f), ([], 'spam'))
|
|
|
|
finally:
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(None)
|
2018-01-29 15:31:47 -04:00
|
|
|
f.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
self.assertIsNone(sys.get_coroutine_wrapper())
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
wrapped = None
|
2018-01-29 15:31:47 -04:00
|
|
|
coro = foo()
|
2015-05-11 23:57:16 -03:00
|
|
|
self.assertFalse(wrapped)
|
2018-01-29 15:31:47 -04:00
|
|
|
coro.close()
|
2015-05-11 23:57:16 -03:00
|
|
|
|
|
|
|
def test_set_wrapper_2(self):
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
self.assertIsNone(sys.get_coroutine_wrapper())
|
2015-05-11 23:57:16 -03:00
|
|
|
with self.assertRaisesRegex(TypeError, "callable expected, got int"):
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(1)
|
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
self.assertIsNone(sys.get_coroutine_wrapper())
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2015-06-02 19:43:51 -03:00
|
|
|
def test_set_wrapper_3(self):
|
|
|
|
async def foo():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
def wrapper(coro):
|
|
|
|
async def wrap(coro):
|
|
|
|
return await coro
|
|
|
|
return wrap(coro)
|
|
|
|
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(wrapper)
|
2015-06-02 19:43:51 -03:00
|
|
|
try:
|
2015-06-04 11:16:51 -03:00
|
|
|
with silence_coro_gc(), self.assertRaisesRegex(
|
2018-01-29 15:31:47 -04:00
|
|
|
RuntimeError,
|
|
|
|
r"coroutine wrapper.*\.wrapper at 0x.*attempted to "
|
|
|
|
r"recursively wrap .* wrap .*"):
|
2015-06-02 19:43:51 -03:00
|
|
|
|
|
|
|
foo()
|
2018-01-29 15:31:47 -04:00
|
|
|
|
2015-06-02 19:43:51 -03:00
|
|
|
finally:
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(None)
|
2015-06-02 19:43:51 -03:00
|
|
|
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
def test_set_wrapper_4(self):
|
|
|
|
@types.coroutine
|
|
|
|
def foo():
|
|
|
|
return 'spam'
|
|
|
|
|
|
|
|
wrapped = None
|
|
|
|
def wrap(gen):
|
|
|
|
nonlocal wrapped
|
|
|
|
wrapped = gen
|
|
|
|
return gen
|
|
|
|
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(wrap)
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
try:
|
|
|
|
foo()
|
|
|
|
self.assertIs(
|
|
|
|
wrapped, None,
|
|
|
|
"generator-based coroutine was wrapped via "
|
|
|
|
"sys.set_coroutine_wrapper")
|
|
|
|
finally:
|
2018-01-29 03:34:26 -04:00
|
|
|
with self.assertWarns(DeprecationWarning):
|
|
|
|
sys.set_coroutine_wrapper(None)
|
Issue #24400: Introduce a distinct type for 'async def' coroutines.
Summary of changes:
1. Coroutines now have a distinct, separate from generators
type at the C level: PyGen_Type, and a new typedef PyCoroObject.
PyCoroObject shares the initial segment of struct layout with
PyGenObject, making it possible to reuse existing generators
machinery. The new type is exposed as 'types.CoroutineType'.
As a consequence of having a new type, CO_GENERATOR flag is
no longer applied to coroutines.
2. Having a separate type for coroutines made it possible to add
an __await__ method to the type. Although it is not used by the
interpreter (see details on that below), it makes coroutines
naturally (without using __instancecheck__) conform to
collections.abc.Coroutine and collections.abc.Awaitable ABCs.
[The __instancecheck__ is still used for generator-based
coroutines, as we don't want to add __await__ for generators.]
3. Add new opcode: GET_YIELD_FROM_ITER. The opcode is needed to
allow passing native coroutines to the YIELD_FROM opcode.
Before this change, 'yield from o' expression was compiled to:
(o)
GET_ITER
LOAD_CONST
YIELD_FROM
Now, we use GET_YIELD_FROM_ITER instead of GET_ITER.
The reason for adding a new opcode is that GET_ITER is used
in some contexts (such as 'for .. in' loops) where passing
a coroutine object is invalid.
4. Add two new introspection functions to the inspec module:
getcoroutinestate(c) and getcoroutinelocals(c).
5. inspect.iscoroutine(o) is updated to test if 'o' is a native
coroutine object. Before this commit it used abc.Coroutine,
and it was requested to update inspect.isgenerator(o) to use
abc.Generator; it was decided, however, that inspect functions
should really be tailored for checking for native types.
6. sys.set_coroutine_wrapper(w) API is updated to work with only
native coroutines. Since types.coroutine decorator supports
any type of callables now, it would be confusing that it does
not work for all types of coroutines.
7. Exceptions logic in generators C implementation was updated
to raise clearer messages for coroutines:
Before: TypeError("generator raised StopIteration")
After: TypeError("coroutine raised StopIteration")
2015-06-22 13:19:30 -03:00
|
|
|
|
2015-05-11 23:57:16 -03:00
|
|
|
|
2018-01-21 10:44:07 -04:00
|
|
|
class OriginTrackingTest(unittest.TestCase):
|
|
|
|
def here(self):
|
|
|
|
info = inspect.getframeinfo(inspect.currentframe().f_back)
|
|
|
|
return (info.filename, info.lineno)
|
|
|
|
|
|
|
|
def test_origin_tracking(self):
|
|
|
|
orig_depth = sys.get_coroutine_origin_tracking_depth()
|
|
|
|
try:
|
|
|
|
async def corofn():
|
|
|
|
pass
|
|
|
|
|
|
|
|
sys.set_coroutine_origin_tracking_depth(0)
|
|
|
|
self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 0)
|
|
|
|
|
|
|
|
with contextlib.closing(corofn()) as coro:
|
|
|
|
self.assertIsNone(coro.cr_origin)
|
|
|
|
|
|
|
|
sys.set_coroutine_origin_tracking_depth(1)
|
|
|
|
self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1)
|
|
|
|
|
|
|
|
fname, lineno = self.here()
|
|
|
|
with contextlib.closing(corofn()) as coro:
|
|
|
|
self.assertEqual(coro.cr_origin,
|
|
|
|
((fname, lineno + 1, "test_origin_tracking"),))
|
|
|
|
|
|
|
|
sys.set_coroutine_origin_tracking_depth(2)
|
|
|
|
self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 2)
|
|
|
|
|
|
|
|
def nested():
|
|
|
|
return (self.here(), corofn())
|
|
|
|
fname, lineno = self.here()
|
|
|
|
((nested_fname, nested_lineno), coro) = nested()
|
|
|
|
with contextlib.closing(coro):
|
|
|
|
self.assertEqual(coro.cr_origin,
|
|
|
|
((nested_fname, nested_lineno, "nested"),
|
|
|
|
(fname, lineno + 1, "test_origin_tracking")))
|
|
|
|
|
|
|
|
# Check we handle running out of frames correctly
|
|
|
|
sys.set_coroutine_origin_tracking_depth(1000)
|
|
|
|
with contextlib.closing(corofn()) as coro:
|
|
|
|
self.assertTrue(2 < len(coro.cr_origin) < 1000)
|
|
|
|
|
|
|
|
# We can't set depth negative
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
sys.set_coroutine_origin_tracking_depth(-1)
|
|
|
|
# And trying leaves it unchanged
|
|
|
|
self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1000)
|
|
|
|
|
|
|
|
finally:
|
|
|
|
sys.set_coroutine_origin_tracking_depth(orig_depth)
|
|
|
|
|
|
|
|
def test_origin_tracking_warning(self):
|
|
|
|
async def corofn():
|
|
|
|
pass
|
|
|
|
|
|
|
|
a1_filename, a1_lineno = self.here()
|
|
|
|
def a1():
|
|
|
|
return corofn() # comment in a1
|
|
|
|
a1_lineno += 2
|
|
|
|
|
|
|
|
a2_filename, a2_lineno = self.here()
|
|
|
|
def a2():
|
|
|
|
return a1() # comment in a2
|
|
|
|
a2_lineno += 2
|
|
|
|
|
|
|
|
def check(depth, msg):
|
|
|
|
sys.set_coroutine_origin_tracking_depth(depth)
|
2018-02-02 00:55:55 -04:00
|
|
|
with self.assertWarns(RuntimeWarning) as cm:
|
2018-01-21 10:44:07 -04:00
|
|
|
a2()
|
|
|
|
support.gc_collect()
|
2018-02-02 00:55:55 -04:00
|
|
|
self.assertEqual(msg, str(cm.warning))
|
2018-01-21 10:44:07 -04:00
|
|
|
|
|
|
|
orig_depth = sys.get_coroutine_origin_tracking_depth()
|
|
|
|
try:
|
|
|
|
msg = check(0, f"coroutine '{corofn.__qualname__}' was never awaited")
|
|
|
|
check(1, "".join([
|
|
|
|
f"coroutine '{corofn.__qualname__}' was never awaited\n",
|
|
|
|
"Coroutine created at (most recent call last)\n",
|
|
|
|
f' File "{a1_filename}", line {a1_lineno}, in a1\n',
|
|
|
|
f' return corofn() # comment in a1',
|
|
|
|
]))
|
|
|
|
check(2, "".join([
|
|
|
|
f"coroutine '{corofn.__qualname__}' was never awaited\n",
|
|
|
|
"Coroutine created at (most recent call last)\n",
|
|
|
|
f' File "{a2_filename}", line {a2_lineno}, in a2\n',
|
|
|
|
f' return a1() # comment in a2\n',
|
|
|
|
f' File "{a1_filename}", line {a1_lineno}, in a1\n',
|
|
|
|
f' return corofn() # comment in a1',
|
|
|
|
]))
|
|
|
|
|
|
|
|
finally:
|
|
|
|
sys.set_coroutine_origin_tracking_depth(orig_depth)
|
|
|
|
|
|
|
|
def test_unawaited_warning_when_module_broken(self):
|
|
|
|
# Make sure we don't blow up too bad if
|
|
|
|
# warnings._warn_unawaited_coroutine is broken somehow (e.g. because
|
|
|
|
# of shutdown problems)
|
|
|
|
async def corofn():
|
|
|
|
pass
|
|
|
|
|
|
|
|
orig_wuc = warnings._warn_unawaited_coroutine
|
|
|
|
try:
|
|
|
|
warnings._warn_unawaited_coroutine = lambda coro: 1/0
|
|
|
|
with support.captured_stderr() as stream:
|
|
|
|
corofn()
|
|
|
|
support.gc_collect()
|
|
|
|
self.assertIn("Exception ignored in", stream.getvalue())
|
|
|
|
self.assertIn("ZeroDivisionError", stream.getvalue())
|
|
|
|
self.assertIn("was never awaited", stream.getvalue())
|
|
|
|
|
|
|
|
del warnings._warn_unawaited_coroutine
|
|
|
|
with support.captured_stderr() as stream:
|
|
|
|
corofn()
|
|
|
|
support.gc_collect()
|
|
|
|
self.assertIn("was never awaited", stream.getvalue())
|
|
|
|
|
|
|
|
finally:
|
|
|
|
warnings._warn_unawaited_coroutine = orig_wuc
|
|
|
|
|
2018-01-26 15:28:31 -04:00
|
|
|
|
|
|
|
class UnawaitedWarningDuringShutdownTest(unittest.TestCase):
|
|
|
|
# https://bugs.python.org/issue32591#msg310726
|
|
|
|
def test_unawaited_warning_during_shutdown(self):
|
|
|
|
code = ("import asyncio\n"
|
|
|
|
"async def f(): pass\n"
|
|
|
|
"asyncio.gather(f())\n")
|
|
|
|
assert_python_ok("-c", code)
|
|
|
|
|
|
|
|
code = ("import sys\n"
|
|
|
|
"async def f(): pass\n"
|
|
|
|
"sys.coro = f()\n")
|
|
|
|
assert_python_ok("-c", code)
|
|
|
|
|
|
|
|
code = ("import sys\n"
|
|
|
|
"async def f(): pass\n"
|
|
|
|
"sys.corocycle = [f()]\n"
|
|
|
|
"sys.corocycle.append(sys.corocycle)\n")
|
|
|
|
assert_python_ok("-c", code)
|
|
|
|
|
|
|
|
|
2017-03-19 15:20:10 -03:00
|
|
|
@support.cpython_only
|
2015-05-11 23:57:16 -03:00
|
|
|
class CAPITest(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_tp_await_1(self):
|
|
|
|
from _testcapi import awaitType as at
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
future = at(iter([1]))
|
|
|
|
return (await future)
|
|
|
|
|
|
|
|
self.assertEqual(foo().send(None), 1)
|
|
|
|
|
|
|
|
def test_tp_await_2(self):
|
|
|
|
# Test tp_await to __await__ mapping
|
|
|
|
from _testcapi import awaitType as at
|
|
|
|
future = at(iter([1]))
|
|
|
|
self.assertEqual(next(future.__await__()), 1)
|
|
|
|
|
|
|
|
def test_tp_await_3(self):
|
|
|
|
from _testcapi import awaitType as at
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
future = at(1)
|
|
|
|
return (await future)
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
TypeError, "__await__.*returned non-iterator of type 'int'"):
|
|
|
|
self.assertEqual(foo().send(None), 1)
|
|
|
|
|
|
|
|
|
|
|
|
if __name__=="__main__":
|
2015-05-13 03:03:06 -03:00
|
|
|
unittest.main()
|