gh-93896: allow enabling asyncio.Runner calls to asyncio.set_event_loop independantly to loop_factory

Lib/asyncio/runners.py

@@ -1,5 +1,6 @@
 __all__ = ('Runner', 'run')
 
+import sys
 import contextvars
 import enum
 import functools
@@ -17,6 +18,12 @@ class _State(enum.Enum):
  CLOSED = "closed"
 
 
+if sys.platform == "win32":
+ from .windows_events import ProactorEventLoop as _new_event_loop
+else:
+ from .unix_events import SelectorEventLoop as _new_event_loop
+
+
 class Runner:
  """A context manager that controls event loop life cycle.
 
@@ -25,7 +32,11 @@ class Runner:
  and properly finalizes the loop at the context manager exit.
 
  If debug is True, the event loop will be run in debug mode.
- If loop_factory is passed, it is used for new event loop creation.
+ If loop_factory is passed, it is used for new event loop creation, otherwise
+ a ProactorEventLoop will be started on Windows or a SelectorEventLoop will
+ be started on unix
+ If set_policy_loop is True, the event loop in the default policy will be
+ set.
 
  asyncio.run(main(), debug=True)
 
@@ -45,14 +56,18 @@ class Runner:
 
  # Note: the class is final, it is not intended for inheritance.
 
- def __init__(self, *, debug=None, loop_factory=None):
+ def __init__(self, *, debug=None, loop_factory=None, set_policy_loop=None):
  self._state = _State.CREATED
  self._debug = debug
  self._loop_factory = loop_factory
  self._loop = None
  self._context = None
  self._interrupt_count = 0
- self._set_event_loop = False
+ if set_policy_loop is None and loop_factory is None:
+ # default to setting the policy loop, if the loop_factory is not set
+ self._set_policy_loop = True
+ else:
+ self._set_policy_loop = set_policy_loop
 
  def __enter__(self):
  self._lazy_init()
@@ -67,11 +82,13 @@ def close(self):
  return
  try:
  loop = self._loop
+ if self._set_policy_loop:
+ events.set_event_loop(loop)
  _cancel_all_tasks(loop)
  loop.run_until_complete(loop.shutdown_asyncgens())
  loop.run_until_complete(loop.shutdown_default_executor())
  finally:
- if self._set_event_loop:
+ if self._set_policy_loop:
  events.set_event_loop(None)
  loop.close()
  self._loop = None
@@ -93,10 +110,11 @@ def run(self, coro, *, context=None):
  "Runner.run() cannot be called from a running event loop")
 
  self._lazy_init()
+ loop = self._loop
 
  if context is None:
  context = self._context
- task = self._loop.create_task(coro, context=context)
+ task = loop.create_task(coro, context=context)
 
  if (threading.current_thread() is threading.main_thread()
  and signal.getsignal(signal.SIGINT) is signal.default_int_handler
@@ -114,15 +132,17 @@ def run(self, coro, *, context=None):
 
  self._interrupt_count = 0
  try:
- if self._set_event_loop:
- events.set_event_loop(self._loop)
- return self._loop.run_until_complete(task)
+ if self._set_policy_loop:
+ events.set_event_loop(loop)
+ return loop.run_until_complete(task)
  except exceptions.CancelledError:
  if self._interrupt_count > 0 and task.uncancel() == 0:
  raise KeyboardInterrupt()
  else:
  raise # CancelledError
  finally:
+ if self._set_policy_loop:
+ events.set_event_loop(None)
  if (sigint_handler is not None
  and signal.getsignal(signal.SIGINT) is sigint_handler
  ):
@@ -134,8 +154,7 @@ def _lazy_init(self):
  if self._state is _State.INITIALIZED:
  return
  if self._loop_factory is None:
- self._loop = events.new_event_loop()
- self._set_event_loop = True
+ self._loop = _new_event_loop()
  else:
  self._loop = self._loop_factory()
  if self._debug is not None:
@@ -165,7 +184,9 @@ def run(main, *, debug=None):
 
  If debug is True, the event loop will be run in debug mode.
 
- This function always creates a new event loop and closes it at the end.
+ This function always creates a new event loop from the default policy sets
+ it in the event loop policy and closes it at the end and sets the policy
+ loop to None.
  It should be used as a main entry point for asyncio programs, and should
  ideally only be called once.
 
@@ -182,7 +203,11 @@ async def main():
  raise RuntimeError(
  "asyncio.run() cannot be called from a running event loop")
 
- with Runner(debug=debug) as runner:
+ with Runner(
+ debug=debug,
+ loop_factory=events.new_event_loop,
+ set_policy_loop=True,
+ ) as runner:
  return runner.run(main)
 
 

Lib/test/test_asyncio/test_runners.py

@@ -39,6 +39,19 @@ def set_event_loop(self, loop):
  self.loop = loop
 
 
+class NullPolicy(asyncio.AbstractEventLoopPolicy):
+
+ def get_event_loop(self):
+ # shouldn't ever be called by asyncio.run()
+ raise RuntimeError
+
+ def new_event_loop(self):
+ raise RuntimeError
+
+ def set_event_loop(self, loop):
+ raise RuntimeError
+
+
 class BaseTest(unittest.TestCase):
 
  def new_loop(self):
@@ -57,6 +70,19 @@ async def shutdown_asyncgens():
 
  return loop
 
+ def setUp(self):
+ super().setUp()
+
+ policy = NullPolicy()
+ asyncio.set_event_loop_policy(policy)
+
+ def tearDown(self):
+ asyncio.set_event_loop_policy(None)
+ super().tearDown()
+
+
+class RunTests(BaseTest):
+
  def setUp(self):
  super().setUp()
 
@@ -69,12 +95,9 @@ def tearDown(self):
  self.assertTrue(policy.loop.is_closed())
  self.assertTrue(policy.loop.shutdown_ag_run)
 
- asyncio.set_event_loop_policy(None)
  super().tearDown()
 
 
-class RunTests(BaseTest):
-
  def test_asyncio_run_return(self):
  async def main():
  await asyncio.sleep(0)

Lib/unittest/async_case.py

@@ -114,7 +114,11 @@ def _callMaybeAsync(self, func, /, *args, **kwargs):
 
  def _setupAsyncioRunner(self):
  assert self._asyncioRunner is None, 'asyncio runner is already initialized'
- runner = asyncio.Runner(debug=True)
+ runner = asyncio.Runner(
+ debug=True,
+ loop_factory=asyncio.new_event_loop,
+ set_policy_loop=True,
+ )
  self._asyncioRunner = runner
 
  def _tearDownAsyncioRunner(self):

Misc/NEWS.d/next/Library/2022-06-21-13-08-46.gh-issue-93896.2BsYCX.rst

@@ -0,0 +1 @@
+Restored missing ``set_event_loop()`` calls in ``asyncio.run()`` and ``AsyncTestCase`` accidentally removed in the 3.11 betas.