Merge branch 'master' into micro-optimization

Author: asvetlov

.github/workflows/ci.yml

@@ -57,7 +57,7 @@ jobs:
     needs: lint
     strategy:
       matrix:
-        pyver: [3.6, 3.7, 3.8, 3.9]
+        pyver: ["3.6", "3.7", "3.8", "3.9", "3.10"]
         os: [ubuntu, macos, windows]
         include:
           - pyver: pypy3

.pre-commit-config.yaml

@@ -5,15 +5,15 @@ repos:
   - id: check-merge-conflict
     exclude: "rst$"
 - repo: https://github.com/asottile/yesqa
-  rev: v1.2.3
+  rev: v1.3.0
   hooks:
   - id: yesqa
-- repo: https://github.com/pre-commit/mirrors-isort
-  rev: 'v5.9.3'
+- repo: https://github.com/PyCQA/isort
+  rev: '5.9.3'
   hooks:
   - id: isort
 - repo: https://github.com/psf/black
-  rev: '21.8b0'
+  rev: '21.9b0'
   hooks:
     - id: black
       language_version: python3 # Should be a command that runs python3.6+
@@ -41,11 +41,11 @@ repos:
     files: |
       .gitignore
 - repo: https://github.com/asottile/pyupgrade
-  rev: 'v2.25.0'
+  rev: 'v2.29.0'
   hooks:
   - id: pyupgrade
     args: ['--py36-plus']
-- repo: https://gitlab.com/pycqa/flake8
-  rev: '3.9.2'
+- repo: https://github.com/PyCQA/flake8
+  rev: '4.0.1'
   hooks:
   - id: flake8

requirements.txt

@@ -1,10 +1,10 @@
 -e .
-black==21.8b0; implementation_name=="cpython"
-docutils==0.17.1
-flake8==3.9.2
+black==21.10b0; implementation_name=="cpython"
+docutils==0.18
+flake8==4.0.1
 isort==5.9.3
 mypy==0.910; implementation_name=="cpython"
 pre-commit==2.15
 pytest==6.2.5
-pytest-asyncio==0.15.1
-pytest-cov==2.12.1
+pytest-asyncio==0.16.0
+pytest-cov==3.0.0

setup.py

@@ -35,11 +35,13 @@ def read(name):
         "License :: OSI Approved :: Apache Software License",
         "Intended Audience :: Developers",
         "Programming Language :: Python",
+        "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
         "Topic :: Internet :: WWW/HTTP",
         "Framework :: AsyncIO",
     ],

tests/test_timeout.py

@@ -1,12 +1,28 @@
 import asyncio
 import sys
 import time
+from functools import wraps
+from typing import Any, Callable, List, TypeVar
 
 import pytest
 
 from async_timeout import Timeout, timeout, timeout_at
 
 
+_Func = TypeVar("_Func", bound=Callable[..., Any])
+
+
+def log_func(func: _Func, msg: str, call_order: List[str]) -> _Func:
+    """Simple wrapper to add a log to call_order when the function is called."""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:  # type: ignore[misc]
+        call_order.append(msg)
+        return func(*args, **kwargs)
+
+    return wrapper  # type: ignore[return-value]
+
+
 @pytest.mark.asyncio
 async def test_timeout() -> None:
     canceled_raised = False
@@ -347,15 +363,8 @@ async def test_deprecated_with() -> None:
             await asyncio.sleep(0)
 
 
-@pytest.mark.skipif(sys.version_info < (3, 7), reason="Not supported in 3.6")
-@pytest.mark.asyncio
-async def test_race_condition_cancel_before() -> None:
-    """Test race condition when cancelling before timeout.
-
-    If cancel happens immediately before the timeout, then
-    the timeout may overrule the cancellation, making it
-    impossible to cancel some tasks.
-    """
+async def race_condition(offset: float = 0) -> List[str]:
+    """Common code for below race condition tests."""
 
     async def test_task(deadline: float, loop: asyncio.AbstractEventLoop) -> None:
         # We need the internal Timeout class to specify the deadline (not delay).
@@ -364,39 +373,51 @@ async def test_task(deadline: float, loop: asyncio.AbstractEventLoop) -> None:
             with Timeout(deadline, loop):
                 await asyncio.sleep(10)
 
+    call_order: List[str] = []
+    f_exit = log_func(Timeout._do_exit, "exit", call_order)
+    Timeout._do_exit = f_exit  # type: ignore[assignment]
+    f_timeout = log_func(Timeout._on_timeout, "timeout", call_order)
+    Timeout._on_timeout = f_timeout  # type: ignore[assignment]
+
     loop = asyncio.get_running_loop()
     deadline = loop.time() + 1
     t = asyncio.create_task(test_task(deadline, loop))
-    loop.call_at(deadline, t.cancel)
+    loop.call_at(deadline + offset, log_func(t.cancel, "cancel", call_order))
     # If we get a TimeoutError, then the code is broken.
     with pytest.raises(asyncio.CancelledError):
         await t
 
+    return call_order
+
 
-@pytest.mark.xfail(
-    reason="The test is CPU performance sensitive, might fail on slow CI box"
-)
 @pytest.mark.skipif(sys.version_info < (3, 7), reason="Not supported in 3.6")
 @pytest.mark.asyncio
+async def test_race_condition_cancel_before() -> None:
+    """Test race condition when cancelling before timeout.
+
+    If cancel happens immediately before the timeout, then
+    the timeout may overrule the cancellation, making it
+    impossible to cancel some tasks.
+    """
+    call_order = await race_condition()
+
+    # This test is very timing dependant, so we check the order that calls
+    # happened to be sure the test itself ran correctly.
+    assert call_order == ["cancel", "timeout", "exit"]
+
+
+@pytest.mark.xfail(reason="Can't see a way to fix this currently.")
+@pytest.mark.skipif(sys.version_info < (3, 9), reason="Can't be fixed in <3.9.")
+@pytest.mark.asyncio
 async def test_race_condition_cancel_after() -> None:
     """Test race condition when cancelling after timeout.
 
     Similarly to the previous test, if a cancel happens
     immediately after the timeout (but before the __exit__),
     then the explicit cancel can get overruled again.
     """
+    call_order = await race_condition(0.000001)
 
-    async def test_task(deadline: float, loop: asyncio.AbstractEventLoop) -> None:
-        # We need the internal Timeout class to specify the deadline (not delay).
-        # This is needed to create the precise timing to reproduce the race condition.
-        with pytest.warns(DeprecationWarning):
-            with Timeout(deadline, loop):
-                await asyncio.sleep(10)
-
-    loop = asyncio.get_running_loop()
-    deadline = loop.time() + 1
-    t = asyncio.create_task(test_task(deadline, loop))
-    loop.call_at(deadline + 0.0000000000001, t.cancel)
-    # If we get a TimeoutError, then the code is broken.
-    with pytest.raises(asyncio.CancelledError):
-        await t
+    # This test is very timing dependant, so we check the order that calls
+    # happened to be sure the test itself ran correctly.
+    assert call_order == ["timeout", "cancel", "exit"]