Remove implicit creation of loop from `asyncio.get_event_loop`. This is a step forward of deprecating the policy system of asyncio.
instead of using these lower level functions to manually create and close an
event loop.
- .. deprecated:: 3.12
- Deprecation warning is emitted if there is no current event loop.
- In some future Python release this will become an error.
+ .. versionchanged:: 3.14
+ Raises a :exc:`RuntimeError` if there is no current event loop.
.. function:: set_event_loop(loop)
On Windows, :class:`ProactorEventLoop` is now used by default.
- .. deprecated:: 3.12
- The :meth:`get_event_loop` method of the default asyncio policy now emits
- a :exc:`DeprecationWarning` if there is no current event loop set and it
- decides to create one.
- In some future Python release this will become an error.
+ .. versionchanged:: 3.14
+ The :meth:`get_event_loop` method of the default asyncio policy now
+ raises a :exc:`RuntimeError` if there is no set event loop.
.. class:: WindowsSelectorEventLoopPolicy
(Contributed by Kumar Aditya in :gh:`120804`.)
+* Removed implicit creation of event loop by :func:`asyncio.get_event_loop`.
+ It now raises a :exc:`RuntimeError` if there is no current event loop.
+ (Contributed by Kumar Aditya in :gh:`126353`.)
+
+
collections.abc
---------------
class _Local(threading.local):
_loop = None
- _set_called = False
def __init__(self):
self._local = self._Local()
Returns an instance of EventLoop or raises an exception.
"""
- 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:
- # Move up the call stack so that the warning is attached
- # to the line outside asyncio itself.
- 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:
raise RuntimeError('There is no current event loop in thread %r.'
% threading.current_thread().name)
def set_event_loop(self, loop):
"""Set the event loop."""
- self._local._set_called = True
if loop is not None and not isinstance(loop, AbstractEventLoop):
raise TypeError(f"loop must be an instance of AbstractEventLoop or None, not '{type(loop).__name__}'")
self._local._loop = loop
def test_get_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
self.assertIsNone(policy._local._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)
- self.assertIs(loop, policy.get_event_loop())
- loop.close()
+ with self.assertRaises(RuntimeError):
+ loop = policy.get_event_loop()
+ self.assertIsNone(policy._local._loop)
- def test_get_event_loop_calls_set_event_loop(self):
+ def test_get_event_loop_does_not_call_set_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
with mock.patch.object(
policy, "set_event_loop",
wraps=policy.set_event_loop) as m_set_event_loop:
- with self.assertWarns(DeprecationWarning) as cm:
+ with self.assertRaises(RuntimeError):
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
- # the child watcher correctly)
- m_set_event_loop.assert_called_with(loop)
-
- loop.close()
+ m_set_event_loop.assert_not_called()
def test_get_event_loop_after_set_none(self):
policy = asyncio.DefaultEventLoopPolicy()
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)
- with self.assertWarns(DeprecationWarning) as cm:
- loop2 = asyncio.get_event_loop()
- self.addCleanup(loop2.close)
- self.assertEqual(cm.filename, __file__)
- asyncio.set_event_loop(None)
with self.assertRaisesRegex(RuntimeError, 'no current'):
asyncio.get_event_loop()
- with self.assertRaisesRegex(RuntimeError, 'no running'):
- asyncio.get_running_loop()
- self.assertIs(asyncio._get_running_loop(), None)
+ asyncio.set_event_loop(None)
+ with self.assertRaisesRegex(RuntimeError, 'no current'):
+ asyncio.get_event_loop()
async def func():
self.assertIs(asyncio.get_event_loop(), loop)
if pid == 0:
# child
try:
- with self.assertWarns(DeprecationWarning):
- loop = asyncio.get_event_loop_policy().get_event_loop()
+ loop = asyncio.get_event_loop()
os.write(w, b'LOOP:' + str(id(loop)).encode())
except RuntimeError:
os.write(w, b'NO LOOP')
else:
# parent
result = os.read(r, 100)
- self.assertEqual(result[:5], b'LOOP:', result)
- self.assertNotEqual(int(result[5:]), id(loop))
+ self.assertEqual(result, b'NO LOOP')
wait_process(pid, exitcode=0)
@hashlib_helper.requires_hashdigest('md5')
self.assertEqual(proc.stderr, '')
def test_python_asyncio_debug(self):
- code = "import asyncio; print(asyncio.get_event_loop().get_debug())"
+ code = "import asyncio; print(asyncio.new_event_loop().get_debug())"
rc, out, err = assert_python_ok('-c', code, PYTHONASYNCIODEBUG='1')
self.assertIn(b'True', out)
--- /dev/null
+:func:`asyncio.get_event_loop` now does not implicitly creates an event loop.
+It now raises a :exc:`RuntimeError` if there is no set event loop. Patch by Kumar Aditya.
projects / thirdparty / Python / cpython.git / commitdiff
