gh-100160: Restore and deprecate implicit creation of an event loop

Doc/library/asyncio-eventloop.rst

@@ -48,7 +48,7 @@ an event loop:
  running event loop.
 
  If there is no running event loop set, the function will return
- the result of calling ``get_event_loop_policy().get_event_loop()``.
+ the result of the ``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
@@ -59,11 +59,9 @@ an event loop:
  instead of using these lower level functions to manually create and close an
  event loop.
 
- .. note::
- In Python versions 3.10.0--3.10.8 and 3.11.0 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.
+ .. deprecated:: 3.12
+ Deprecation warning is emitted if there is no current event loop.
+ In some future Python release this will become an error.
 
 .. function:: set_event_loop(loop)
 

Doc/library/asyncio-policy.rst

@@ -116,9 +116,11 @@ asyncio ships with the following built-in policies:
 
  On Windows, :class:`ProactorEventLoop` is now used by default.
 
- .. versionchanged:: 3.12
-:meth:`get_event_loop` now raises a :exc:`RuntimeError` if there is no
- current event loop set.
+ .. 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.
 
 
 .. class:: WindowsSelectorEventLoopPolicy

Doc/whatsnew/3.10.rst

@@ -1709,19 +1709,6 @@ Deprecated
  scheduled for removal in Python 3.12.
  (Contributed by Erlend E. Aasland in :issue:`42264`.)
 
-* :func:`asyncio.get_event_loop` now emits a deprecation warning if there is
- no running event loop. In the future it will be an alias of
- :func:`~asyncio.get_running_loop`.
- :mod:`asyncio` functions which implicitly create :class:`~asyncio.Future`
- or :class:`~asyncio.Task` objects now emit
- a deprecation warning if there is no running event loop and no explicit
- *loop* argument is passed: :func:`~asyncio.ensure_future`,
- :func:`~asyncio.wrap_future`, :func:`~asyncio.gather`,
- :func:`~asyncio.shield`, :func:`~asyncio.as_completed` and constructors of
- :class:`~asyncio.Future`, :class:`~asyncio.Task`,
- :class:`~asyncio.StreamReader`, :class:`~asyncio.StreamReaderProtocol`.
- (Contributed by Serhiy Storchaka in :issue:`39529`.)
-
 * The undocumented built-in function ``sqlite3.enable_shared_cache`` is now
  deprecated, scheduled for removal in Python 3.12. Its use is strongly
  discouraged by the SQLite3 documentation. See `the SQLite3 docs

Doc/whatsnew/3.12.rst

@@ -408,6 +408,11 @@ Deprecated
  :exc:`ImportWarning`).
  (Contributed by Brett Cannon in :gh:`65961`.)
 
+* The :meth:`~asyncio.DefaultEventLoopPolicy.get_event_loop` method of the
+ default event loop policy now emits a :exc:`DeprecationWarning` if there
+ is no current event loop set and it decides to create one.
+ (Contributed by Serhiy Storchaka and Guido van Rossum in :gh:`100160`.)
+
 
 Pending Removal in Python 3.13
 ------------------------------
@@ -710,18 +715,6 @@ Changes in the Python API
  around process-global resources, which are best managed from the main interpreter.
  (Contributed by Dong-hee Na in :gh:`99127`.)
 
-* :func:`asyncio.get_event_loop` and many other :mod:`asyncio` functions like
- :func:`~asyncio.ensure_future`, :func:`~asyncio.shield` or
- :func:`~asyncio.gather`, and also the
- :meth:`~asyncio.BaseDefaultEventLoopPolicy.get_event_loop` method of
- :class:`~asyncio.BaseDefaultEventLoopPolicy` now raise a :exc:`RuntimeError`
- if called when there is no running event loop and the current event loop was
- not set.
- Previously they implicitly created and set a new current event loop.
- :exc:`DeprecationWarning` is no longer emitted if there is no running
- event loop but the current event loop is set in the policy.
- (Contributed by Serhiy Storchaka in :gh:`93453`.)
-
 
 Build Changes
 =============

Lib/asyncio/events.py

@@ -619,7 +619,7 @@ def get_event_loop(self):
 
  Returns an event loop object implementing the BaseEventLoop interface,
  or raises an exception in case no event loop has been set for the
- current context.
+ current context and the current policy does not specify to create one.
 
  It should never return None."""
  raise NotImplementedError
@@ -672,6 +672,28 @@ def get_event_loop(self):
 
  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)

Lib/test/test_asyncio/test_events.py

@@ -2614,8 +2614,33 @@ def test_event_loop_policy(self):
  def test_get_event_loop(self):
  policy = asyncio.DefaultEventLoopPolicy()
  self.assertIsNone(policy._local._loop)
- with self.assertRaisesRegex(RuntimeError, 'no current event 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)
+ self.assertIs(loop, policy.get_event_loop())
+ loop.close()
+
+ def test_get_event_loop_calls_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:
+ 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()
 
  def test_get_event_loop_after_set_none(self):
  policy = asyncio.DefaultEventLoopPolicy()
@@ -2801,8 +2826,10 @@ def test_get_event_loop_returns_running_loop2(self):
  loop = asyncio.new_event_loop()
  self.addCleanup(loop.close)
 
- with self.assertRaisesRegex(RuntimeError, 'no current'):
- asyncio.get_event_loop()
+ 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()

Lib/test/test_asyncio/test_unix_events.py

@@ -1884,7 +1884,9 @@ async def test_fork_not_share_event_loop(self):
  if pid == 0:
  # child
  try:
- loop = asyncio.get_event_loop_policy().get_event_loop()
+ with self.assertWarns(DeprecationWarning):
+ loop = asyncio.get_event_loop_policy().get_event_loop()
+ os.write(w, b'LOOP:' + str(id(loop)).encode())
  except RuntimeError:
  os.write(w, b'NO LOOP')
  except:
@@ -1893,7 +1895,9 @@ async def test_fork_not_share_event_loop(self):
  os._exit(0)
  else:
  # parent
- self.assertEqual(os.read(r, 100), b'NO LOOP')
+ result = os.read(r, 100)
+ self.assertEqual(result[:5], b'LOOP:', result)
+ self.assertNotEqual(int(result[5:]), id(loop))
  wait_process(pid, exitcode=0)
 
  @hashlib_helper.requires_hashdigest('md5')

Misc/NEWS.d/next/Library/2022-12-21-17-49-50.gh-issue-100160.N0NHRj.rst

@@ -0,0 +1,3 @@
+Emit a deprecation warning in
+:meth:`asyncio.DefaultEventLoopPolicy.get_event_loop` if there is no current
+event loop set and it decides to create one.