[gentoo-commits] repo/gentoo:master commit in: dev-python/async_timeout/, dev-python/async_timeout/files/

[Michał Górny]

commit:     0edc81fb7529ec388c628266d9584d6fb3464467
Author:     Arthur Zamarin <arthurzam <AT> gmail <DOT> com>
AuthorDate: Sat Jul 24 16:14:32 2021 +0000
Commit:     Michał Górny <mgorny <AT> gentoo <DOT> org>
CommitDate: Thu Jul 29 18:46:51 2021 +0000
URL:        https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=0edc81fb

dev-python/async_timeout: enable py3.10

needed to import from upstream fixes for tests
patch doesn't change other parts outside tests

Signed-off-by: Arthur Zamarin <arthurzam <AT> gmail.com>
Signed-off-by: Michał Górny <mgorny <AT> gentoo.org>

 .../async_timeout/async_timeout-3.0.1.ebuild       |   6 +-
 .../files/async_timeout-3.0.1-fix-py3.10.patch     | 387 +++++++++++++++++++++
 2 files changed, 392 insertions(+), 1 deletion(-)

diff --git a/dev-python/async_timeout/async_timeout-3.0.1.ebuild b/dev-python/async_timeout/async_timeout-3.0.1.ebuild
index f4022958304..33755ac4a21 100644
--- a/dev-python/async_timeout/async_timeout-3.0.1.ebuild
+++ b/dev-python/async_timeout/async_timeout-3.0.1.ebuild
@@ -2,7 +2,8 @@
 # Distributed under the terms of the GNU General Public License v2
 
 EAPI=7
-PYTHON_COMPAT=( python3_{8..9} )
+
+PYTHON_COMPAT=( python3_{8..10} )
 
 inherit distutils-r1
 
@@ -20,8 +21,11 @@ BDEPEND="
 	dev-python/setuptools_scm[${PYTHON_USEDEP}]
 	test? (
 		dev-python/pytest-aiohttp[${PYTHON_USEDEP}]
+		dev-python/pytest-asyncio[${PYTHON_USEDEP}]
 	)"
 
+PATCHES=( "${FILESDIR}/${P}-fix-py3.10.patch" )
+
 distutils_enable_tests pytest
 
 python_prepare_all() {

diff --git a/dev-python/async_timeout/files/async_timeout-3.0.1-fix-py3.10.patch b/dev-python/async_timeout/files/async_timeout-3.0.1-fix-py3.10.patch
new file mode 100644
index 00000000000..5bfdcf2e6da
--- /dev/null
+++ b/dev-python/async_timeout/files/async_timeout-3.0.1-fix-py3.10.patch
@@ -0,0 +1,387 @@
+diff --git a/tests/test_py35.py b/tests/test_py35.py
+index 00bb7f0..7d88d99 100644
+--- a/tests/test_py35.py
++++ b/tests/test_py35.py
+@@ -4,30 +4,32 @@ import pytest
+ 
+ from async_timeout import timeout
+ 
+-pytestmark = pytest.mark.asyncio
+ 
+-
+-async def test_async_timeout(loop):
++@×××××××××××.asyncio
++async def test_async_timeout():
+     with pytest.raises(asyncio.TimeoutError):
+-        async with timeout(0.01, loop=loop) as cm:
+-            await asyncio.sleep(10, loop=loop)
++        async with timeout(0.01) as cm:
++            await asyncio.sleep(10)
+     assert cm.expired
+ 
+ 
+-async def test_async_no_timeout(loop):
+-    async with timeout(1, loop=loop) as cm:
+-        await asyncio.sleep(0, loop=loop)
++@×××××××××××.asyncio
++async def test_async_no_timeout():
++    async with timeout(1) as cm:
++        await asyncio.sleep(0)
+     assert not cm.expired
+ 
+ 
+-async def test_async_zero(loop):
++@×××××××××××.asyncio
++async def test_async_zero():
+     with pytest.raises(asyncio.TimeoutError):
+-        async with timeout(0, loop=loop) as cm:
+-            await asyncio.sleep(10, loop=loop)
++        async with timeout(0) as cm:
++            await asyncio.sleep(10)
+     assert cm.expired
+ 
+ 
+-async def test_async_zero_coro_not_started(loop):
++@×××××××××××.asyncio
++async def test_async_zero_coro_not_started():
+     coro_started = False
+ 
+     async def coro():
+@@ -35,8 +37,8 @@ async def test_async_zero_coro_not_started(loop):
+         coro_started = True
+ 
+     with pytest.raises(asyncio.TimeoutError):
+-        async with timeout(0, loop=loop) as cm:
+-            await asyncio.sleep(0, loop=loop)
++        async with timeout(0) as cm:
++            await asyncio.sleep(0)
+             await coro()
+ 
+     assert cm.expired
+diff --git a/tests/test_timeout.py b/tests/test_timeout.py
+index 8915546..b1cb3c7 100644
+--- a/tests/test_timeout.py
++++ b/tests/test_timeout.py
+@@ -6,89 +6,69 @@ import pytest
+ 
+ from async_timeout import timeout
+ 
+-from asyncio import ensure_future
+-
+-
+-def create_future(loop):
+-    """Compatibility wrapper for the loop.create_future() call introduced in
+-    3.5.2."""
+-    if hasattr(loop, 'create_future'):
+-        return loop.create_future()
+-    else:
+-        return asyncio.Future(loop=loop)
+-
+ 
+ @pytest.mark.asyncio
+-async def test_timeout(loop):
++async def test_timeout():
+     canceled_raised = False
+ 
+     async def long_running_task():
+         try:
+-            await asyncio.sleep(10, loop=loop)
++            await asyncio.sleep(10)
+         except asyncio.CancelledError:
+             nonlocal canceled_raised
+             canceled_raised = True
+             raise
+ 
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0.01, loop=loop) as t:
++        with timeout(0.01) as t:
+             await long_running_task()
+-            assert t._loop is loop
++            assert t._loop is asyncio.get_event_loop()
+     assert canceled_raised, 'CancelledError was not raised'
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_finish_in_time(loop):
++async def test_timeout_finish_in_time():
+     async def long_running_task():
+-        await asyncio.sleep(0.01, loop=loop)
++        await asyncio.sleep(0.01)
+         return 'done'
+ 
+-    with timeout(0.1, loop=loop):
++    with timeout(0.1):
+         resp = await long_running_task()
+     assert resp == 'done'
+ 
+ 
+-def test_timeout_global_loop(loop):
+-    asyncio.set_event_loop(loop)
+-
+-    async def run():
+-        with timeout(10) as t:
+-            await asyncio.sleep(0.01)
+-            assert t._loop is loop
+-
+-    loop.run_until_complete(run())
+-
+-
+ @pytest.mark.asyncio
+-async def test_timeout_disable(loop):
++async def test_timeout_disable():
+     async def long_running_task():
+-        await asyncio.sleep(0.1, loop=loop)
++        await asyncio.sleep(0.1)
+         return 'done'
+ 
++    loop = asyncio.get_event_loop()
+     t0 = loop.time()
+-    with timeout(None, loop=loop):
++    with timeout(None):
+         resp = await long_running_task()
+     assert resp == 'done'
+     dt = loop.time() - t0
+     assert 0.09 < dt < 0.13, dt
+ 
+ 
+-def test_timeout_is_none_no_task(loop):
++def test_timeout_is_none_no_task():
++    loop = asyncio.get_event_loop()
+     with timeout(None, loop=loop) as cm:
+         assert cm._task is None
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_enable_zero(loop):
++async def test_timeout_enable_zero():
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0, loop=loop) as cm:
+-            await asyncio.sleep(0.1, loop=loop)
++        with timeout(0) as cm:
++            await asyncio.sleep(0.1)
+ 
+     assert cm.expired
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_enable_zero_coro_not_started(loop):
++async def test_timeout_enable_zero_coro_not_started():
+     coro_started = False
+ 
+     async def coro():
+@@ -96,8 +76,8 @@ async def test_timeout_enable_zero_coro_not_started(loop):
+         coro_started = True
+ 
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0, loop=loop) as cm:
+-            await asyncio.sleep(0, loop=loop)
++        with timeout(0) as cm:
++            await asyncio.sleep(0)
+             await coro()
+ 
+     assert cm.expired
+@@ -105,51 +85,52 @@ async def test_timeout_enable_zero_coro_not_started(loop):
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_not_relevant_exception(loop):
+-    await asyncio.sleep(0, loop=loop)
++async def test_timeout_not_relevant_exception():
++    await asyncio.sleep(0)
+     with pytest.raises(KeyError):
+-        with timeout(0.1, loop=loop):
++        with timeout(0.1):
+             raise KeyError
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_canceled_error_is_not_converted_to_timeout(loop):
+-    await asyncio.sleep(0, loop=loop)
++async def test_timeout_canceled_error_is_not_converted_to_timeout():
++    await asyncio.sleep(0)
+     with pytest.raises(asyncio.CancelledError):
+-        with timeout(0.001, loop=loop):
++        with timeout(0.001):
+             raise asyncio.CancelledError
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_blocking_loop(loop):
++async def test_timeout_blocking_loop():
+     async def long_running_task():
+         time.sleep(0.1)
+         return 'done'
+ 
+-    with timeout(0.01, loop=loop):
++    with timeout(0.01):
+         result = await long_running_task()
+     assert result == 'done'
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_for_race_conditions(loop):
+-    fut = create_future(loop)
++async def test_for_race_conditions():
++    loop = asyncio.get_event_loop()
++    fut = loop.create_future()
+     loop.call_later(0.1, fut.set_result('done'))
+-    with timeout(0.2, loop=loop):
++    with timeout(0.2):
+         resp = await fut
+     assert resp == 'done'
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_time(loop):
++async def test_timeout_time():
+     foo_running = None
+-
++    loop = asyncio.get_event_loop()
+     start = loop.time()
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0.1, loop=loop):
++        with timeout(0.1):
+             foo_running = True
+             try:
+-                await asyncio.sleep(0.2, loop=loop)
++                await asyncio.sleep(0.2)
+             finally:
+                 foo_running = False
+ 
+@@ -160,26 +141,26 @@ async def test_timeout_time(loop):
+     assert not foo_running
+ 
+ 
+-def test_raise_runtimeerror_if_no_task(loop):
++def test_raise_runtimeerror_if_no_task():
+     with pytest.raises(RuntimeError):
+-        with timeout(0.1, loop=loop):
++        with timeout(0.1):
+             pass
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_outer_coro_is_not_cancelled(loop):
++async def test_outer_coro_is_not_cancelled():
+ 
+     has_timeout = False
+ 
+     async def outer():
+         nonlocal has_timeout
+         try:
+-            with timeout(0.001, loop=loop):
+-                await asyncio.sleep(1, loop=loop)
++            with timeout(0.001):
++                await asyncio.sleep(1)
+         except asyncio.TimeoutError:
+             has_timeout = True
+ 
+-    task = ensure_future(outer(), loop=loop)
++    task = asyncio.ensure_future(outer())
+     await task
+     assert has_timeout
+     assert not task.cancelled()
+@@ -187,14 +168,15 @@ async def test_outer_coro_is_not_cancelled(loop):
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_cancel_outer_coro(loop):
+-    fut = create_future(loop)
++async def test_cancel_outer_coro():
++    loop = asyncio.get_event_loop()
++    fut = loop.create_future()
+ 
+     async def outer():
+         fut.set_result(None)
+-        await asyncio.sleep(1, loop=loop)
++        await asyncio.sleep(1)
+ 
+-    task = ensure_future(outer(), loop=loop)
++    task = asyncio.ensure_future(outer())
+     await fut
+     task.cancel()
+     with pytest.raises(asyncio.CancelledError):
+@@ -204,57 +186,64 @@ async def test_cancel_outer_coro(loop):
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_suppress_exception_chain(loop):
++async def test_timeout_suppress_exception_chain():
+     with pytest.raises(asyncio.TimeoutError) as ctx:
+-        with timeout(0.01, loop=loop):
+-            await asyncio.sleep(10, loop=loop)
++        with timeout(0.01):
++            await asyncio.sleep(10)
+     assert not ctx.value.__suppress_context__
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_expired(loop):
++async def test_timeout_expired():
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0.01, loop=loop) as cm:
+-            await asyncio.sleep(10, loop=loop)
++        with timeout(0.01) as cm:
++            await asyncio.sleep(10)
+     assert cm.expired
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_inner_timeout_error(loop):
++async def test_timeout_inner_timeout_error():
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0.01, loop=loop) as cm:
++        with timeout(0.01) as cm:
+             raise asyncio.TimeoutError
+     assert not cm.expired
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_inner_other_error(loop):
++async def test_timeout_inner_other_error():
+     with pytest.raises(RuntimeError):
+-        with timeout(0.01, loop=loop) as cm:
++        with timeout(0.01) as cm:
+             raise RuntimeError
+     assert not cm.expired
+ 
+ 
+ @pytest.mark.asyncio
+-async def test_timeout_remaining(loop):
+-    with timeout(None, loop=loop) as cm:
++async def test_timeout_remaining():
++    with timeout(None) as cm:
+         assert cm.remaining is None
++    assert cm.remaining is None
++
++    t = timeout(None)
++    assert t.remaining is None
+ 
+-    t = timeout(1.0, loop=loop)
++    t = timeout(1.0)
+     assert t.remaining is None
+ 
+-    with timeout(1.0, loop=loop) as cm:
+-        await asyncio.sleep(0.1, loop=loop)
++    with timeout(1.0) as cm:
++        await asyncio.sleep(0.1)
+         assert cm.remaining < 1.0
++    r = cm.remaining
++    time.sleep(0.1)
++    assert abs(r - cm.remaining) < 1.0
+ 
+     with pytest.raises(asyncio.TimeoutError):
+-        with timeout(0.1, loop=loop) as cm:
+-            await asyncio.sleep(0.5, loop=loop)
++        with timeout(0.1) as cm:
++            await asyncio.sleep(0.5)
+ 
+     assert cm.remaining == 0.0
+ 
+ 
+-def test_cancel_without_starting(loop):
+-    tm = timeout(1, loop=loop)
++def test_cancel_without_starting():
++    tm = timeout(1)
+     tm._cancel_task()
+     tm._cancel_task()  # double call should success