Fix Python 3.6 compatibility issues []

Author: wchilders-nvidia

dev_tools/bin/edg-docker-shell

@@ -103,7 +103,7 @@ def _resolve_working_directory(args: argparse.Namespace,
     # Otherwise, calculate a working directory maintaining the same
     # relativity to the root project source directory.
     cwd = Path.cwd()
-    if cwd.is_relative_to(src_dir):
+    if edgutil.is_path_relative_to(cwd, src_dir):
       result_path = result_path.joinpath(cwd.relative_to(src_dir))
 
   return result_path

dev_tools/bin/edg-docker-test-bisect

@@ -100,7 +100,7 @@ def _resolve_test_path(mono_repo_dir: Path, test_path: Path) -> Optional[str]:
     return None
 
   mono_repo_tests_dir = mono_repo_dir / 'tests' / 'tests'
-  if not test_path.is_relative_to(mono_repo_dir):
+  if not edgutil.is_path_relative_to(test_path, mono_repo_dir):
     return None
 
   return str(test_path.relative_to(mono_repo_tests_dir).as_posix())

dev_tools/bin/edg-rematerialize-test-run

@@ -126,7 +126,7 @@ def collect_affected_tests(test_home: Path,
   for diff_file in diff_files:
     file_path = test_home.parent.joinpath(PurePosixPath(diff_file.file_name))
 
-    if file_path.is_relative_to(tests_dir):
+    if edgutil.is_path_relative_to(file_path, tests_dir):
       # A file in a test suite.
       orig_file_path = file_path
 
@@ -166,7 +166,7 @@ def collect_affected_tests(test_home: Path,
                 test_file_found = True
         # File not found, move on to the parent.
         file_path = file_path.parent
-    elif (file_path.is_relative_to(expectations_dir) and
+    elif (edgutil.is_path_relative_to(file_path, expectations_dir) and
           file_path.suffix == '.log'):
       config_name = file_path.parent.name
       suite_name = file_path.stem
@@ -511,7 +511,7 @@ async def simulate_test(test_home: Path, config_run_dir: Path,
     if len(rt_metadata_cases) > 0:
       # relative_test_path is already suite/... (relative to test_home/tests),
       # matching live runs that use path relative to top_dir.parent.
-      await asyncio.to_thread(
+      await edgutil.async_to_thread(
         edgtest.runtest.finalize_rt_tar,
         rt_contents,
         rt_metadata_cases,

dev_tools/pylibs/edgacknowledg/client/bench/__init__.py

@@ -34,7 +34,7 @@
   trunc_display_content,
 )
 import edgutil
-from edgutil import eprint, get_running_event_loop
+from edgutil import eprint
 
 TOOL_PATH_CG_ANNOTATE = edgutil.RequiredToolPath('cg_annotate')
 
@@ -289,10 +289,8 @@ async def run_bench_source_handler(channel: Channel,
       run_path = session.run_dir / metadata.rel_benchmark_path
 
       async def annotate_job() -> str:
-        loop = get_running_event_loop()
-        return await loop.run_in_executor(
-          None,
-          lambda: get_cg_annotate_output(baseline_path, run_path)
+        return await edgutil.async_to_thread(
+          get_cg_annotate_output, baseline_path, run_path
         )
 
       annotate_text = await worker_pool.submit(annotate_job)

dev_tools/pylibs/edgdocker/__init__.py

@@ -428,16 +428,7 @@ def exec_docker_cmd(image_name: str, workspace_dir: Path,
   if 'EDG_BASE' in os.environ:
     container_workspace_dir = PurePosixPath('/', 'edg', 'workspace')
     host_base_path = Path(os.environ['EDG_BASE'])
-    # Path.is_relative_to is 3.9+.
-    if sys.version_info >= (3, 9):
-      base_is_relative = host_base_path.is_relative_to(workspace_dir)
-    else:
-      try:
-        host_base_path.relative_to(workspace_dir)
-        base_is_relative = True
-      except ValueError:
-        base_is_relative = False
-    if base_is_relative:
+    if edgutil.is_path_relative_to(host_base_path, workspace_dir):
       rel_base_path = host_base_path.relative_to(workspace_dir)
       base_path = container_workspace_dir.joinpath(rel_base_path)
       _add_env_value(docker_args, 'EDG_BASE', str(base_path))

dev_tools/pylibs/edgtest/exec/__init__.py

@@ -490,7 +490,7 @@ def background_process_lines():
               # If UTF decoding fails, revert to a binary line write.
               output_file_handle.write(line)
 
-        await asyncio.to_thread(background_process_lines)
+        await edgutil.async_to_thread(background_process_lines)
 
   return tested_process.returncode
 
@@ -925,7 +925,7 @@ async def run_executed_process(
     # isn't fully blocked.  In free-threaded Python builds, this should also
     # be significantly more performant for test suites with heavy regex use.
     matches_file = case_artifact_dir / 'matches' / 'output.txt'
-    missing_matches = await asyncio.to_thread(
+    missing_matches = await edgutil.async_to_thread(
       verify_regex_matches,
       command_body_files,
       test_descript.match_regex,
@@ -1221,7 +1221,7 @@ async def run_test(test_path: Path, *, top_dir: Path, output_dir: Path,
       if len(rt_metadata_cases) > 0:
         # Metadata path is relative to top_dir's parent so the top directory
         # name (e.g. the suite) remains the first path component.
-        await asyncio.to_thread(
+        await edgutil.async_to_thread(
           edgtest.runtest.finalize_rt_tar,
           rt_contents,
           rt_metadata_cases,

dev_tools/pylibs/edgtest/runtest/__init__.py

@@ -1258,7 +1258,7 @@ def finalize_rt_tar(contents: RtTarContents,
   per-case matches diff_hash values.
 
   Callers that need to keep an asyncio event loop responsive should run this
-  via ``asyncio.to_thread``.
+  via ``edgutil.async_to_thread``.
   '''
   diff_hashes: List[str] = []
   for case in cases:

dev_tools/pylibs/edgutil/__init__.py

@@ -312,23 +312,63 @@ class AsyncLoopFatalError(Exception):
   '''Raised to ask ``run_asyncio_loop`` to cancel remaining tasks and stop.'''
   pass
 
-def get_running_event_loop() -> asyncio.AbstractEventLoop:
-  # asyncio.get_running_loop is 3.7+.
-  if sys.version_info >= (3, 7):
+# The helpers below depend on the Python version, which cannot change at run
+# time, so each is declared once per supported API and selected at import.
+
+if sys.version_info >= (3, 7):
+  def get_running_event_loop() -> asyncio.AbstractEventLoop:
+    '''Return the running event loop (asyncio.get_running_loop is 3.7+).'''
     return asyncio.get_running_loop()
-  return asyncio.get_event_loop()
-
-def _active_asyncio_tasks(
-    loop: asyncio.AbstractEventLoop) -> Set[asyncio.Task]:
-  # In Python 3.7 asyncio.Task.all_tasks was deprecated in favor of
-  # asyncio.all_tasks. This was later removed in 3.9.
-  #
-  # To provide compatibility for both check to see if our python version is
-  # greater than or equal to 3.7, and conditionally enable the new API,
-  # otherwise fallback to the original API.
-  if sys.version_info >= (3, 7):
+else:
+  def get_running_event_loop() -> asyncio.AbstractEventLoop:
+    '''Return the running event loop (asyncio.get_running_loop is 3.7+).'''
+    return asyncio.get_event_loop()
+
+if sys.version_info >= (3, 9):
+  def is_path_relative_to(path: Path, other: Path) -> bool:
+    '''Return whether path is equal to or located under other.'''
+    return path.is_relative_to(other)
+else:
+  def is_path_relative_to(path: Path, other: Path) -> bool:
+    '''Return whether path is equal to or located under other.
+
+    Path.is_relative_to is only available in Python 3.9+.
+    '''
+    try:
+      result = Path(os.path.commonpath([str(path), str(other)])) == other
+    except ValueError:
+      # Mixing absolute and relative paths (or differing drives).
+      result = False
+    return result
+
+if sys.version_info >= (3, 9):
+  async def async_to_thread(func: Callable[..., Any],
+                            *args: Any,
+                            **kwargs: Any) -> Any:
+    '''Run func(*args, **kwargs) in a worker thread and await its result.'''
+    return await asyncio.to_thread(func, *args, **kwargs)
+else:
+  async def async_to_thread(func: Callable[..., Any],
+                            *args: Any,
+                            **kwargs: Any) -> Any:
+    '''Run func(*args, **kwargs) in a worker thread and await its result.
+
+    asyncio.to_thread is only available in Python 3.9+.
+    '''
+    return await get_running_event_loop().run_in_executor(
+      None, functools.partial(func, *args, **kwargs)
+    )
+
+if sys.version_info >= (3, 7):
+  def _active_asyncio_tasks(
+      loop: asyncio.AbstractEventLoop) -> Set[asyncio.Task]:
+    # asyncio.Task.all_tasks was deprecated in 3.7 in favor of
+    # asyncio.all_tasks, and removed in 3.9.
     return asyncio.all_tasks(loop)
-  return asyncio.Task.all_tasks(loop)  # type: ignore[attr-defined]
+else:
+  def _active_asyncio_tasks(
+      loop: asyncio.AbstractEventLoop) -> Set[asyncio.Task]:
+    return asyncio.Task.all_tasks(loop)  # type: ignore[attr-defined]
 
 def _stop_asyncio_loop(loop: asyncio.AbstractEventLoop) -> None:
   for task in _active_asyncio_tasks(loop):
@@ -671,29 +711,14 @@ async def __aenter__(self) -> Optional[BinaryIO]:
     self._out_handle = open(self._temp_dir / 'diff', 'w+b')
 
     if _DIFF_CMD is None:
-      # asyncio.to_thread is 3.9+.
-      if sys.version_info >= (3, 9):
-        has_diff = await asyncio.to_thread(
-          _write_unified_diff_with_difflib,
-          self._from_file,
-          self._to_file,
-          self._out_handle,
-          self._from_label,
-          self._to_label
-        )
-      else:
-        loop = get_running_event_loop()
-        has_diff = await loop.run_in_executor(
-          None,
-          functools.partial(
-            _write_unified_diff_with_difflib,
-            self._from_file,
-            self._to_file,
-            self._out_handle,
-            self._from_label,
-            self._to_label
-          )
-        )
+      has_diff = await async_to_thread(
+        _write_unified_diff_with_difflib,
+        self._from_file,
+        self._to_file,
+        self._out_handle,
+        self._from_label,
+        self._to_label
+      )
     else:
       has_diff = await _write_unified_diff_with_diff_cmd(
         self._from_file,