https://github.com/python/cpython/commit/aef4a1203c06efde8505aefc9cf994e9a23f398d
commit: aef4a1203c06efde8505aefc9cf994e9a23f398d
branch: main
author: Serhiy Storchaka <storch...@gmail.com>
committer: serhiy-storchaka <storch...@gmail.com>
date: 2024-01-10T12:50:31+02:00
summary:
gh-96037: Always insert TimeoutError when exit an expired asyncio.timeout()
block (GH-113819)
If other exception was raised during exiting an expired
asyncio.timeout() block, insert TimeoutError in the exception context
just above the CancelledError.
files:
A Misc/NEWS.d/next/Library/2024-01-08-19-38-42.gh-issue-96037.Yr2Y1C.rst
M Lib/asyncio/timeouts.py
M Lib/test/test_asyncio/test_timeouts.py
diff --git a/Lib/asyncio/timeouts.py b/Lib/asyncio/timeouts.py
index 2c5dd295ff5ade..e6f5100691d362 100644
--- a/Lib/asyncio/timeouts.py
+++ b/Lib/asyncio/timeouts.py
@@ -110,10 +110,15 @@ async def __aexit__(
self._state = _State.EXPIRED
if self._task.uncancel() <= self._cancelling and exc_type is not
None:
+ # Since there are no new cancel requests, we're
+ # handling this.
if issubclass(exc_type, exceptions.CancelledError):
- # Since there are no new cancel requests, we're
- # handling this.
raise TimeoutError from exc_val
+ elif exc_val is not None:
+ self._insert_timeout_error(exc_val)
+ if isinstance(exc_val, ExceptionGroup):
+ for exc in exc_val.exceptions:
+ self._insert_timeout_error(exc)
elif self._state is _State.ENTERED:
self._state = _State.EXITED
@@ -126,6 +131,16 @@ def _on_timeout(self) -> None:
# drop the reference early
self._timeout_handler = None
+ @staticmethod
+ def _insert_timeout_error(exc_val: BaseException) -> None:
+ while exc_val.__context__ is not None:
+ if isinstance(exc_val.__context__, exceptions.CancelledError):
+ te = TimeoutError()
+ te.__context__ = te.__cause__ = exc_val.__context__
+ exc_val.__context__ = te
+ break
+ exc_val = exc_val.__context__
+
def timeout(delay: Optional[float]) -> Timeout:
"""Timeout async context manager.
diff --git a/Lib/test/test_asyncio/test_timeouts.py
b/Lib/test/test_asyncio/test_timeouts.py
index f54e79e4d8e600..1f7f9ee696a525 100644
--- a/Lib/test/test_asyncio/test_timeouts.py
+++ b/Lib/test/test_asyncio/test_timeouts.py
@@ -116,15 +116,68 @@ async def test_foreign_exception_passed(self):
raise KeyError
self.assertFalse(cm.expired())
+ async def test_timeout_exception_context(self):
+ with self.assertRaises(TimeoutError) as cm:
+ async with asyncio.timeout(0.01):
+ try:
+ 1/0
+ finally:
+ await asyncio.sleep(1)
+ e = cm.exception
+ # Expect TimeoutError caused by CancelledError raised during handling
+ # of ZeroDivisionError.
+ e2 = e.__cause__
+ self.assertIsInstance(e2, asyncio.CancelledError)
+ self.assertIs(e.__context__, e2)
+ self.assertIsNone(e2.__cause__)
+ self.assertIsInstance(e2.__context__, ZeroDivisionError)
+
async def test_foreign_exception_on_timeout(self):
async def crash():
try:
await asyncio.sleep(1)
finally:
1/0
- with self.assertRaises(ZeroDivisionError):
+ with self.assertRaises(ZeroDivisionError) as cm:
async with asyncio.timeout(0.01):
await crash()
+ e = cm.exception
+ # Expect ZeroDivisionError raised during handling of TimeoutError
+ # caused by CancelledError.
+ self.assertIsNone(e.__cause__)
+ e2 = e.__context__
+ self.assertIsInstance(e2, TimeoutError)
+ e3 = e2.__cause__
+ self.assertIsInstance(e3, asyncio.CancelledError)
+ self.assertIs(e2.__context__, e3)
+
+ async def test_foreign_exception_on_timeout_2(self):
+ with self.assertRaises(ZeroDivisionError) as cm:
+ async with asyncio.timeout(0.01):
+ try:
+ try:
+ raise ValueError
+ finally:
+ await asyncio.sleep(1)
+ finally:
+ try:
+ raise KeyError
+ finally:
+ 1/0
+ e = cm.exception
+ # Expect ZeroDivisionError raised during handling of KeyError
+ # raised during handling of TimeoutError caused by CancelledError.
+ self.assertIsNone(e.__cause__)
+ e2 = e.__context__
+ self.assertIsInstance(e2, KeyError)
+ self.assertIsNone(e2.__cause__)
+ e3 = e2.__context__
+ self.assertIsInstance(e3, TimeoutError)
+ e4 = e3.__cause__
+ self.assertIsInstance(e4, asyncio.CancelledError)
+ self.assertIsNone(e4.__cause__)
+ self.assertIsInstance(e4.__context__, ValueError)
+ self.assertIs(e3.__context__, e4)
async def test_foreign_cancel_doesnt_timeout_if_not_expired(self):
with self.assertRaises(asyncio.CancelledError):
@@ -219,14 +272,30 @@ async def test_repr_disabled(self):
self.assertEqual(repr(cm), r"<Timeout [active] when=None>")
async def test_nested_timeout_in_finally(self):
- with self.assertRaises(TimeoutError):
+ with self.assertRaises(TimeoutError) as cm1:
async with asyncio.timeout(0.01):
try:
await asyncio.sleep(1)
finally:
- with self.assertRaises(TimeoutError):
+ with self.assertRaises(TimeoutError) as cm2:
async with asyncio.timeout(0.01):
await asyncio.sleep(10)
+ e1 = cm1.exception
+ # Expect TimeoutError caused by CancelledError.
+ e12 = e1.__cause__
+ self.assertIsInstance(e12, asyncio.CancelledError)
+ self.assertIsNone(e12.__cause__)
+ self.assertIsNone(e12.__context__)
+ self.assertIs(e1.__context__, e12)
+ e2 = cm2.exception
+ # Expect TimeoutError caused by CancelledError raised during
+ # handling of other CancelledError (which is the same as in
+ # the above chain).
+ e22 = e2.__cause__
+ self.assertIsInstance(e22, asyncio.CancelledError)
+ self.assertIsNone(e22.__cause__)
+ self.assertIs(e22.__context__, e12)
+ self.assertIs(e2.__context__, e22)
async def test_timeout_after_cancellation(self):
try:
@@ -235,7 +304,7 @@ async def test_timeout_after_cancellation(self):
except asyncio.CancelledError:
pass
finally:
- with self.assertRaises(TimeoutError):
+ with self.assertRaises(TimeoutError) as cm:
async with asyncio.timeout(0.0):
await asyncio.sleep(1) # some cleanup
@@ -251,13 +320,6 @@ async def test_cancel_in_timeout_after_cancellation(self):
asyncio.current_task().cancel()
await asyncio.sleep(2) # some cleanup
- async def test_timeout_exception_cause (self):
- with self.assertRaises(asyncio.TimeoutError) as exc:
- async with asyncio.timeout(0):
- await asyncio.sleep(1)
- cause = exc.exception.__cause__
- assert isinstance(cause, asyncio.CancelledError)
-
async def test_timeout_already_entered(self):
async with asyncio.timeout(0.01) as cm:
with self.assertRaisesRegex(RuntimeError, "has already been
entered"):
@@ -303,6 +365,47 @@ async def test_timeout_without_task(self):
with self.assertRaisesRegex(RuntimeError, "has not been entered"):
cm.reschedule(0.02)
+ async def test_timeout_taskgroup(self):
+ async def task():
+ try:
+ await asyncio.sleep(2) # Will be interrupted after 0.01 second
+ finally:
+ 1/0 # Crash in cleanup
+
+ with self.assertRaises(ExceptionGroup) as cm:
+ async with asyncio.timeout(0.01):
+ async with asyncio.TaskGroup() as tg:
+ tg.create_task(task())
+ try:
+ raise ValueError
+ finally:
+ await asyncio.sleep(1)
+ eg = cm.exception
+ # Expect ExceptionGroup raised during handling of TimeoutError caused
+ # by CancelledError raised during handling of ValueError.
+ self.assertIsNone(eg.__cause__)
+ e_1 = eg.__context__
+ self.assertIsInstance(e_1, TimeoutError)
+ e_2 = e_1.__cause__
+ self.assertIsInstance(e_2, asyncio.CancelledError)
+ self.assertIsNone(e_2.__cause__)
+ self.assertIsInstance(e_2.__context__, ValueError)
+ self.assertIs(e_1.__context__, e_2)
+
+ self.assertEqual(len(eg.exceptions), 1, eg)
+ e1 = eg.exceptions[0]
+ # Expect ZeroDivisionError raised during handling of TimeoutError
+ # caused by CancelledError (it is a different CancelledError).
+ self.assertIsInstance(e1, ZeroDivisionError)
+ self.assertIsNone(e1.__cause__)
+ e2 = e1.__context__
+ self.assertIsInstance(e2, TimeoutError)
+ e3 = e2.__cause__
+ self.assertIsInstance(e3, asyncio.CancelledError)
+ self.assertIsNone(e3.__context__)
+ self.assertIsNone(e3.__cause__)
+ self.assertIs(e2.__context__, e3)
+
if __name__ == '__main__':
unittest.main()
diff --git
a/Misc/NEWS.d/next/Library/2024-01-08-19-38-42.gh-issue-96037.Yr2Y1C.rst
b/Misc/NEWS.d/next/Library/2024-01-08-19-38-42.gh-issue-96037.Yr2Y1C.rst
new file mode 100644
index 00000000000000..525925b08230ed
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2024-01-08-19-38-42.gh-issue-96037.Yr2Y1C.rst
@@ -0,0 +1,2 @@
+Insert :exc:`TimeoutError` in the context of the exception that was raised
+during exiting an expired :func:`asyncio.timeout` block.
_______________________________________________
Python-checkins mailing list -- python-checkins@python.org
To unsubscribe send an email to python-checkins-le...@python.org
https://mail.python.org/mailman3/lists/python-checkins.python.org/
Member address: arch...@mail-archive.com
