Fix warning about asyncio.get_event_loop() in Python 3.12 (#1071)

mhucka · web-flow · commit a941cfba0b3b · 2025-06-05T20:16:12.000Z
In Python 3.12, the code in `shell_tools.py` produces the following warnings when running `check/pytest`: ``` dev_tools/shell_tools_test.py::test_run_cmd_raise_on_fail dev_tools/shell_tools.py:185: DeprecationWarning: There is no current event loop result = asyncio.get_event_loop().run_until_complete( ``` The fix involves managing the event loop. The updated functions now try to get the current running event loop; if no loop is running, they create a new one, use it, and then close it. Note: commit [c3ab0fa](c3ab0fa) has the actual code changes. Commit [ba775f5](ba775f5) contains purely formatting changes from applying `check/format-incremental`.
diff --git a/dev_tools/shell_tools.py b/dev_tools/shell_tools.py
@@ -15,24 +15,13 @@
 import asyncio
 import subprocess
 import sys
-from typing import (
-    List,
-    Optional,
-    Tuple,
-    Union,
-    IO,
-    Any,
-    cast,
-    NamedTuple,
-)
+from typing import List, Optional, Tuple, Union, IO, Any, cast, NamedTuple
 
 from collections.abc import AsyncIterable
 
-CommandOutput = NamedTuple("CommandOutput", [
-    ('out', Optional[str]),
-    ('err', Optional[str]),
-    ('exit_code', int),
-])
+CommandOutput = NamedTuple(
+    "CommandOutput", [('out', Optional[str]), ('err', Optional[str]), ('exit_code', int)]
+)
 
 BOLD = 1
 DIM = 2
@@ -52,11 +41,7 @@ def highlight(text: str, color_code: int, bold: bool = False) -> str:
     Returns:
         The highlighted string.
     """
-    return '{}\033[{}m{}\033[0m'.format(
-        '\033[1m' if bold else '',
-        color_code,
-        text,
-    )
+    return '{}\033[{}m{}\033[0m'.format('\033[1m' if bold else '', color_code, text)
 
 
 class TeeCapture:
@@ -70,9 +55,9 @@ def __init__(self, out_pipe: Optional[IO[str]] = None) -> None:
         self.out_pipe = out_pipe
 
 
-async def _async_forward(async_chunks: AsyncIterable,
-                         out: Optional[Union[TeeCapture, IO[str]]]
-                        ) -> Optional[str]:
+async def _async_forward(
+    async_chunks: AsyncIterable, out: Optional[Union[TeeCapture, IO[str]]]
+) -> Optional[str]:
     """Prints/captures output from the given asynchronous iterable.
 
     Args:
@@ -99,9 +84,9 @@ async def _async_forward(async_chunks: AsyncIterable,
 
 
 async def _async_wait_for_process(
-        future_process: Any,
-        out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
-        err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr
+    future_process: Any,
+    out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
+    err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr,
 ) -> CommandOutput:
     """Awaits the creation and completion of an asynchronous process.
 
@@ -122,8 +107,7 @@ async def _async_wait_for_process(
     return CommandOutput(output, err_output, process.returncode)
 
 
-def abbreviate_command_arguments_after_switches(cmd: Tuple[str, ...]
-                                               ) -> Tuple[str, ...]:
+def abbreviate_command_arguments_after_switches(cmd: Tuple[str, ...]) -> Tuple[str, ...]:
     result = [cmd[0]]
     for i in range(1, len(cmd)):
         if not cmd[i].startswith('-'):
@@ -133,13 +117,15 @@ def abbreviate_command_arguments_after_switches(cmd: Tuple[str, ...]
     return tuple(result)
 
 
-def run_cmd(*cmd: Optional[str],
-            out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
-            err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr,
-            raise_on_fail: bool = True,
-            log_run_to_stderr: bool = True,
-            abbreviate_non_option_arguments: bool = False,
-            **kwargs) -> CommandOutput:
+def run_cmd(
+    *cmd: Optional[str],
+    out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
+    err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr,
+    raise_on_fail: bool = True,
+    log_run_to_stderr: bool = True,
+    abbreviate_non_option_arguments: bool = False,
+    **kwargs,
+) -> CommandOutput:
     """Invokes a subprocess and waits for it to finish.
 
     Args:
@@ -182,23 +168,44 @@ def run_cmd(*cmd: Optional[str],
         if abbreviate_non_option_arguments:
             cmd_desc = abbreviate_command_arguments_after_switches(cmd_desc)
         print('run:', cmd_desc, file=sys.stderr)
-    result = asyncio.get_event_loop().run_until_complete(
-        _async_wait_for_process(
-            asyncio.create_subprocess_exec(*kept_cmd,
-                                           stdout=asyncio.subprocess.PIPE,
-                                           stderr=asyncio.subprocess.PIPE,
-                                           **kwargs), out, err))
+
+    loop = None
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    try:
+        result = loop.run_until_complete(
+            _async_wait_for_process(
+                asyncio.create_subprocess_exec(
+                    *kept_cmd,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    **kwargs,
+                ),
+                out,
+                err,
+            )
+        )
+    finally:
+        if loop != None:
+            loop.close()
+
     if raise_on_fail and result[2]:
         raise subprocess.CalledProcessError(result[2], kept_cmd)
     return result
 
 
-def run_shell(cmd: str,
-              out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
-              err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr,
-              raise_on_fail: bool = True,
-              log_run_to_stderr: bool = True,
-              **kwargs) -> CommandOutput:
+def run_shell(
+    cmd: str,
+    out: Optional[Union[TeeCapture, IO[str]]] = sys.stdout,
+    err: Optional[Union[TeeCapture, IO[str]]] = sys.stderr,
+    raise_on_fail: bool = True,
+    log_run_to_stderr: bool = True,
+    **kwargs,
+) -> CommandOutput:
     """Invokes a shell command and waits for it to finish.
 
     Args:
@@ -233,12 +240,28 @@ def run_shell(cmd: str,
     """
     if log_run_to_stderr:
         print('shell:', cmd, file=sys.stderr)
-    result = asyncio.get_event_loop().run_until_complete(
-        _async_wait_for_process(
-            asyncio.create_subprocess_shell(cmd,
-                                            stdout=asyncio.subprocess.PIPE,
-                                            stderr=asyncio.subprocess.PIPE,
-                                            **kwargs), out, err))
+
+    loop = None
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    try:
+        result = loop.run_until_complete(
+            _async_wait_for_process(
+                asyncio.create_subprocess_shell(
+                    cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, **kwargs
+                ),
+                out,
+                err,
+            )
+        )
+    finally:
+        if loop != None:
+            loop.close()
+
     if raise_on_fail and result[2]:
         raise subprocess.CalledProcessError(result[2], cmd)
     return result
@@ -261,9 +284,7 @@ def output_of(*cmd: Optional[str], **kwargs) -> str:
          subprocess.CalledProcessError: The process returned a non-zero error
             code and raise_on_fail was set.
     """
-    result = cast(
-        str,
-        run_cmd(*cmd, log_run_to_stderr=False, out=TeeCapture(), **kwargs).out)
+    result = cast(str, run_cmd(*cmd, log_run_to_stderr=False, out=TeeCapture(), **kwargs).out)
 
     # Strip final newline.
     if result.endswith('\n'):
