mirror of
https://github.com/NixOS/nixpkgs.git
synced 2025-01-12 07:54:50 +00:00
9ee1d16c36
They brought significant regressions. Upstream is now discussing what to do, but we still want the security fixes from 3.10.9.
599 lines
23 KiB
Diff
599 lines
23 KiB
Diff
REVERT https://github.com/python/cpython/commit/300d812fd1c4d9244e71de0d228cc72439d312a7
|
|
--- b/Doc/library/asyncio-eventloop.rst
|
|
+++ a/Doc/library/asyncio-eventloop.rst
|
|
@@ -43,12 +43,10 @@
|
|
|
|
Get the current event loop.
|
|
|
|
+ If there is no current event loop set in the current OS thread,
|
|
+ the OS thread is main, and :func:`set_event_loop` has not yet
|
|
+ been called, asyncio will create a new event loop and set it as the
|
|
+ current one.
|
|
- When called from a coroutine or a callback (e.g. scheduled with
|
|
- call_soon or similar API), this function will always return the
|
|
- running event loop.
|
|
-
|
|
- If there is no running event loop set, the function will return
|
|
- the result of ``get_event_loop_policy().get_event_loop()`` call.
|
|
|
|
Because this function has rather complex behavior (especially
|
|
when custom event loop policies are in use), using the
|
|
@@ -60,14 +58,10 @@
|
|
event loop.
|
|
|
|
.. deprecated:: 3.10
|
|
+ Emits a deprecation warning if there is no running event loop.
|
|
+ In future Python releases, this function may become an alias of
|
|
+ :func:`get_running_loop` and will accordingly raise a
|
|
+ :exc:`RuntimeError` if there is no running event loop.
|
|
- Deprecation warning is emitted if there is no current event loop.
|
|
- In Python 3.12 it will be an error.
|
|
-
|
|
- .. note::
|
|
- In Python versions 3.10.0--3.10.8 this function
|
|
- (and other functions which used it implicitly) emitted a
|
|
- :exc:`DeprecationWarning` if there was no running event loop, even if
|
|
- the current loop was set.
|
|
|
|
.. function:: set_event_loop(loop)
|
|
|
|
reverted:
|
|
--- b/Doc/library/asyncio-llapi-index.rst
|
|
+++ a/Doc/library/asyncio-llapi-index.rst
|
|
@@ -19,7 +19,7 @@
|
|
- The **preferred** function to get the running event loop.
|
|
|
|
* - :func:`asyncio.get_event_loop`
|
|
+ - Get an event loop instance (current or via the policy).
|
|
- - Get an event loop instance (running or current via the current policy).
|
|
|
|
* - :func:`asyncio.set_event_loop`
|
|
- Set the event loop as current via the current policy.
|
|
reverted:
|
|
--- b/Doc/library/asyncio-policy.rst
|
|
+++ a/Doc/library/asyncio-policy.rst
|
|
@@ -112,11 +112,6 @@
|
|
|
|
On Windows, :class:`ProactorEventLoop` is now used by default.
|
|
|
|
- .. deprecated:: 3.10.9
|
|
- :meth:`get_event_loop` now emits a :exc:`DeprecationWarning` if there
|
|
- is no current event loop set and a new event loop has been implicitly
|
|
- created. In Python 3.12 it will be an error.
|
|
-
|
|
|
|
.. class:: WindowsSelectorEventLoopPolicy
|
|
|
|
reverted:
|
|
--- b/Lib/asyncio/events.py
|
|
+++ a/Lib/asyncio/events.py
|
|
@@ -650,21 +650,6 @@
|
|
if (self._local._loop is None and
|
|
not self._local._set_called and
|
|
threading.current_thread() is threading.main_thread()):
|
|
- stacklevel = 2
|
|
- try:
|
|
- f = sys._getframe(1)
|
|
- except AttributeError:
|
|
- pass
|
|
- else:
|
|
- while f:
|
|
- module = f.f_globals.get('__name__')
|
|
- if not (module == 'asyncio' or module.startswith('asyncio.')):
|
|
- break
|
|
- f = f.f_back
|
|
- stacklevel += 1
|
|
- import warnings
|
|
- warnings.warn('There is no current event loop',
|
|
- DeprecationWarning, stacklevel=stacklevel)
|
|
self.set_event_loop(self.new_event_loop())
|
|
|
|
if self._local._loop is None:
|
|
@@ -778,13 +763,12 @@
|
|
|
|
|
|
def _get_event_loop(stacklevel=3):
|
|
- # This internal method is going away in Python 3.12, left here only for
|
|
- # backwards compatibility with 3.10.0 - 3.10.8 and 3.11.0.
|
|
- # Similarly, this method's C equivalent in _asyncio is going away as well.
|
|
- # See GH-99949 for more details.
|
|
current_loop = _get_running_loop()
|
|
if current_loop is not None:
|
|
return current_loop
|
|
+ import warnings
|
|
+ warnings.warn('There is no current event loop',
|
|
+ DeprecationWarning, stacklevel=stacklevel)
|
|
return get_event_loop_policy().get_event_loop()
|
|
|
|
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_base_events.py
|
|
+++ a/Lib/test/test_asyncio/test_base_events.py
|
|
@@ -752,7 +752,7 @@
|
|
def test_env_var_debug(self):
|
|
code = '\n'.join((
|
|
'import asyncio',
|
|
+ 'loop = asyncio.get_event_loop()',
|
|
- 'loop = asyncio.new_event_loop()',
|
|
'print(loop.get_debug())'))
|
|
|
|
# Test with -E to not fail if the unit test was run with
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_events.py
|
|
+++ a/Lib/test/test_asyncio/test_events.py
|
|
@@ -2561,9 +2561,8 @@
|
|
def test_get_event_loop(self):
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
|
self.assertIsNone(policy._local._loop)
|
|
+
|
|
+ loop = policy.get_event_loop()
|
|
- with self.assertWarns(DeprecationWarning) as cm:
|
|
- loop = policy.get_event_loop()
|
|
- self.assertEqual(cm.filename, __file__)
|
|
self.assertIsInstance(loop, asyncio.AbstractEventLoop)
|
|
|
|
self.assertIs(policy._local._loop, loop)
|
|
@@ -2577,10 +2576,7 @@
|
|
policy, "set_event_loop",
|
|
wraps=policy.set_event_loop) as m_set_event_loop:
|
|
|
|
+ loop = policy.get_event_loop()
|
|
- with self.assertWarns(DeprecationWarning) as cm:
|
|
- loop = policy.get_event_loop()
|
|
- self.addCleanup(loop.close)
|
|
- self.assertEqual(cm.filename, __file__)
|
|
|
|
# policy._local._loop must be set through .set_event_loop()
|
|
# (the unix DefaultEventLoopPolicy needs this call to attach
|
|
@@ -2614,8 +2610,7 @@
|
|
|
|
def test_set_event_loop(self):
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
|
+ old_loop = policy.get_event_loop()
|
|
- old_loop = policy.new_event_loop()
|
|
- policy.set_event_loop(old_loop)
|
|
|
|
self.assertRaises(AssertionError, policy.set_event_loop, object())
|
|
|
|
@@ -2728,11 +2723,15 @@
|
|
asyncio.set_event_loop_policy(Policy())
|
|
loop = asyncio.new_event_loop()
|
|
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(TestError):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaises(TestError):
|
|
- asyncio.get_event_loop()
|
|
asyncio.set_event_loop(None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(TestError):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaises(TestError):
|
|
- asyncio.get_event_loop()
|
|
|
|
with self.assertRaisesRegex(RuntimeError, 'no running'):
|
|
asyncio.get_running_loop()
|
|
@@ -2746,11 +2745,16 @@
|
|
loop.run_until_complete(func())
|
|
|
|
asyncio.set_event_loop(loop)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(TestError):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
+
|
|
- with self.assertRaises(TestError):
|
|
- asyncio.get_event_loop()
|
|
asyncio.set_event_loop(None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(TestError):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaises(TestError):
|
|
- asyncio.get_event_loop()
|
|
|
|
finally:
|
|
asyncio.set_event_loop_policy(old_policy)
|
|
@@ -2774,8 +2778,10 @@
|
|
self.addCleanup(loop2.close)
|
|
self.assertEqual(cm.warnings[0].filename, __file__)
|
|
asyncio.set_event_loop(None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'no current'):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current'):
|
|
- asyncio.get_event_loop()
|
|
|
|
with self.assertRaisesRegex(RuntimeError, 'no running'):
|
|
asyncio.get_running_loop()
|
|
@@ -2789,11 +2795,15 @@
|
|
loop.run_until_complete(func())
|
|
|
|
asyncio.set_event_loop(loop)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ self.assertIs(asyncio.get_event_loop(), loop)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- self.assertIs(asyncio.get_event_loop(), loop)
|
|
|
|
asyncio.set_event_loop(None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'no current'):
|
|
+ asyncio.get_event_loop()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current'):
|
|
- asyncio.get_event_loop()
|
|
|
|
finally:
|
|
asyncio.set_event_loop_policy(old_policy)
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_futures.py
|
|
+++ a/Lib/test/test_asyncio/test_futures.py
|
|
@@ -145,8 +145,10 @@
|
|
self.assertTrue(f.cancelled())
|
|
|
|
def test_constructor_without_loop(self):
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ self._new_future()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- self._new_future()
|
|
|
|
def test_constructor_use_running_loop(self):
|
|
async def test():
|
|
@@ -156,10 +158,12 @@
|
|
self.assertIs(f.get_loop(), self.loop)
|
|
|
|
def test_constructor_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10, undeprecated in 3.11.1
|
|
asyncio.set_event_loop(self.loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ f = self._new_future()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- f = self._new_future()
|
|
self.assertIs(f._loop, self.loop)
|
|
self.assertIs(f.get_loop(), self.loop)
|
|
|
|
@@ -495,8 +499,10 @@
|
|
return (arg, threading.get_ident())
|
|
ex = concurrent.futures.ThreadPoolExecutor(1)
|
|
f1 = ex.submit(run, 'oi')
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(RuntimeError):
|
|
+ asyncio.wrap_future(f1)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.wrap_future(f1)
|
|
ex.shutdown(wait=True)
|
|
|
|
def test_wrap_future_use_running_loop(self):
|
|
@@ -511,14 +517,16 @@
|
|
ex.shutdown(wait=True)
|
|
|
|
def test_wrap_future_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10, undeprecated in 3.11.1
|
|
asyncio.set_event_loop(self.loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
def run(arg):
|
|
return (arg, threading.get_ident())
|
|
ex = concurrent.futures.ThreadPoolExecutor(1)
|
|
f1 = ex.submit(run, 'oi')
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ f2 = asyncio.wrap_future(f1)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- f2 = asyncio.wrap_future(f1)
|
|
self.assertIs(self.loop, f2._loop)
|
|
ex.shutdown(wait=True)
|
|
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_streams.py
|
|
+++ a/Lib/test/test_asyncio/test_streams.py
|
|
@@ -747,8 +747,10 @@
|
|
self.assertEqual(data, b'data')
|
|
|
|
def test_streamreader_constructor_without_loop(self):
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ asyncio.StreamReader()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.StreamReader()
|
|
|
|
def test_streamreader_constructor_use_running_loop(self):
|
|
# asyncio issue #184: Ensure that StreamReaderProtocol constructor
|
|
@@ -762,17 +764,21 @@
|
|
def test_streamreader_constructor_use_global_loop(self):
|
|
# asyncio issue #184: Ensure that StreamReaderProtocol constructor
|
|
# retrieves the current loop if the loop parameter is not set
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10, undeprecated in 3.11.1
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
asyncio.set_event_loop(self.loop)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ reader = asyncio.StreamReader()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- reader = asyncio.StreamReader()
|
|
self.assertIs(reader._loop, self.loop)
|
|
|
|
|
|
def test_streamreaderprotocol_constructor_without_loop(self):
|
|
reader = mock.Mock()
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ asyncio.StreamReaderProtocol(reader)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.StreamReaderProtocol(reader)
|
|
|
|
def test_streamreaderprotocol_constructor_use_running_loop(self):
|
|
# asyncio issue #184: Ensure that StreamReaderProtocol constructor
|
|
@@ -786,11 +792,13 @@
|
|
def test_streamreaderprotocol_constructor_use_global_loop(self):
|
|
# asyncio issue #184: Ensure that StreamReaderProtocol constructor
|
|
# retrieves the current loop if the loop parameter is not set
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10, undeprecated in 3.11.1
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
asyncio.set_event_loop(self.loop)
|
|
reader = mock.Mock()
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ protocol = asyncio.StreamReaderProtocol(reader)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- protocol = asyncio.StreamReaderProtocol(reader)
|
|
self.assertIs(protocol._loop, self.loop)
|
|
|
|
def test_multiple_drain(self):
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_tasks.py
|
|
+++ a/Lib/test/test_asyncio/test_tasks.py
|
|
@@ -210,8 +210,10 @@
|
|
|
|
a = notmuch()
|
|
self.addCleanup(a.close)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ asyncio.ensure_future(a)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.ensure_future(a)
|
|
|
|
async def test():
|
|
return asyncio.ensure_future(notmuch())
|
|
@@ -221,10 +223,12 @@
|
|
self.assertTrue(t.done())
|
|
self.assertEqual(t.result(), 'ok')
|
|
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
asyncio.set_event_loop(self.loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ t = asyncio.ensure_future(notmuch())
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- t = asyncio.ensure_future(notmuch())
|
|
self.assertIs(t._loop, self.loop)
|
|
self.loop.run_until_complete(t)
|
|
self.assertTrue(t.done())
|
|
@@ -243,8 +247,10 @@
|
|
|
|
a = notmuch()
|
|
self.addCleanup(a.close)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ asyncio.ensure_future(a)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
- asyncio.ensure_future(a)
|
|
|
|
async def test():
|
|
return asyncio.ensure_future(notmuch())
|
|
@@ -254,10 +260,12 @@
|
|
self.assertTrue(t.done())
|
|
self.assertEqual(t.result(), 'ok')
|
|
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
asyncio.set_event_loop(self.loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ t = asyncio.ensure_future(notmuch())
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- t = asyncio.ensure_future(notmuch())
|
|
self.assertIs(t._loop, self.loop)
|
|
self.loop.run_until_complete(t)
|
|
self.assertTrue(t.done())
|
|
@@ -1480,8 +1488,10 @@
|
|
self.addCleanup(a.close)
|
|
|
|
futs = asyncio.as_completed([a])
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ list(futs)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- list(futs)
|
|
|
|
def test_as_completed_coroutine_use_running_loop(self):
|
|
loop = self.new_test_loop()
|
|
@@ -1497,14 +1507,17 @@
|
|
loop.run_until_complete(test())
|
|
|
|
def test_as_completed_coroutine_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
async def coro():
|
|
return 42
|
|
|
|
loop = self.new_test_loop()
|
|
asyncio.set_event_loop(loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ futs = asyncio.as_completed([coro()])
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ futs = list(futs)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- futs = list(asyncio.as_completed([coro()]))
|
|
self.assertEqual(len(futs), 1)
|
|
self.assertEqual(loop.run_until_complete(futs[0]), 42)
|
|
|
|
@@ -1974,8 +1987,10 @@
|
|
|
|
inner = coro()
|
|
self.addCleanup(inner.close)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaisesRegex(RuntimeError, 'There is no current event loop'):
|
|
+ asyncio.shield(inner)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.shield(inner)
|
|
|
|
def test_shield_coroutine_use_running_loop(self):
|
|
async def coro():
|
|
@@ -1989,13 +2004,15 @@
|
|
self.assertEqual(res, 42)
|
|
|
|
def test_shield_coroutine_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
async def coro():
|
|
return 42
|
|
|
|
asyncio.set_event_loop(self.loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ outer = asyncio.shield(coro())
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- outer = asyncio.shield(coro())
|
|
self.assertEqual(outer._loop, self.loop)
|
|
res = self.loop.run_until_complete(outer)
|
|
self.assertEqual(res, 42)
|
|
@@ -2933,7 +2950,7 @@
|
|
self.assertIsNone(asyncio.current_task(loop=self.loop))
|
|
|
|
def test_current_task_no_running_loop_implicit(self):
|
|
+ with self.assertRaises(RuntimeError):
|
|
- with self.assertRaisesRegex(RuntimeError, 'no running event loop'):
|
|
asyncio.current_task()
|
|
|
|
def test_current_task_with_implicit_loop(self):
|
|
@@ -3097,8 +3114,10 @@
|
|
return asyncio.gather(*args, **kwargs)
|
|
|
|
def test_constructor_empty_sequence_without_loop(self):
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(RuntimeError):
|
|
+ asyncio.gather()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.gather()
|
|
|
|
def test_constructor_empty_sequence_use_running_loop(self):
|
|
async def gather():
|
|
@@ -3111,10 +3130,12 @@
|
|
self.assertEqual(fut.result(), [])
|
|
|
|
def test_constructor_empty_sequence_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
asyncio.set_event_loop(self.one_loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ fut = asyncio.gather()
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- fut = asyncio.gather()
|
|
self.assertIsInstance(fut, asyncio.Future)
|
|
self.assertIs(fut._loop, self.one_loop)
|
|
self._run_loop(self.one_loop)
|
|
@@ -3202,8 +3223,10 @@
|
|
self.addCleanup(gen1.close)
|
|
gen2 = coro()
|
|
self.addCleanup(gen2.close)
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ with self.assertRaises(RuntimeError):
|
|
+ asyncio.gather(gen1, gen2)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
|
|
- asyncio.gather(gen1, gen2)
|
|
|
|
def test_constructor_use_running_loop(self):
|
|
async def coro():
|
|
@@ -3217,14 +3240,16 @@
|
|
self.one_loop.run_until_complete(fut)
|
|
|
|
def test_constructor_use_global_loop(self):
|
|
+ # Deprecated in 3.10
|
|
- # Deprecated in 3.10.0, undeprecated in 3.10.9
|
|
async def coro():
|
|
return 'abc'
|
|
asyncio.set_event_loop(self.other_loop)
|
|
self.addCleanup(asyncio.set_event_loop, None)
|
|
gen1 = coro()
|
|
gen2 = coro()
|
|
+ with self.assertWarns(DeprecationWarning) as cm:
|
|
+ fut = asyncio.gather(gen1, gen2)
|
|
+ self.assertEqual(cm.warnings[0].filename, __file__)
|
|
- fut = asyncio.gather(gen1, gen2)
|
|
self.assertIs(fut._loop, self.other_loop)
|
|
self.other_loop.run_until_complete(fut)
|
|
|
|
reverted:
|
|
--- b/Lib/test/test_asyncio/test_unix_events.py
|
|
+++ a/Lib/test/test_asyncio/test_unix_events.py
|
|
@@ -1740,8 +1740,7 @@
|
|
|
|
def test_child_watcher_replace_mainloop_existing(self):
|
|
policy = self.create_policy()
|
|
+ loop = policy.get_event_loop()
|
|
- loop = policy.new_event_loop()
|
|
- policy.set_event_loop(loop)
|
|
|
|
# Explicitly setup SafeChildWatcher,
|
|
# default ThreadedChildWatcher has no _loop property
|
|
reverted:
|
|
--- b/Lib/test/test_coroutines.py
|
|
+++ a/Lib/test/test_coroutines.py
|
|
@@ -2319,8 +2319,7 @@
|
|
def test_unawaited_warning_during_shutdown(self):
|
|
code = ("import asyncio\n"
|
|
"async def f(): pass\n"
|
|
+ "asyncio.gather(f())\n")
|
|
- "async def t(): asyncio.gather(f())\n"
|
|
- "asyncio.run(t())\n")
|
|
assert_python_ok("-c", code)
|
|
|
|
code = ("import sys\n"
|
|
reverted:
|
|
--- b/Modules/_asynciomodule.c
|
|
+++ a/Modules/_asynciomodule.c
|
|
@@ -332,6 +332,13 @@
|
|
return loop;
|
|
}
|
|
|
|
+ if (PyErr_WarnEx(PyExc_DeprecationWarning,
|
|
+ "There is no current event loop",
|
|
+ stacklevel))
|
|
+ {
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
policy = PyObject_CallNoArgs(asyncio_get_event_loop_policy);
|
|
if (policy == NULL) {
|
|
return NULL;
|
|
@@ -3085,11 +3092,6 @@
|
|
return get_event_loop(1);
|
|
}
|
|
|
|
-// This internal method is going away in Python 3.12, left here only for
|
|
-// backwards compatibility with 3.10.0 - 3.10.8 and 3.11.0.
|
|
-// Similarly, this method's Python equivalent in asyncio.events is going
|
|
-// away as well.
|
|
-// See GH-99949 for more details.
|
|
/*[clinic input]
|
|
_asyncio._get_event_loop
|
|
stacklevel: int = 3
|