Use comments rather than docstrings for internal helpers

Author: gpshead

Lib/importlib/_bootstrap.py

@@ -1264,18 +1264,17 @@ def _find_and_load_unlocked(name, import_, *, lazy_submodule=False):
 _NEEDS_LOADING = object()
 
 
+# Return whether module (a sys.modules value) is still executing.
 def _is_initializing(module):
-    """Return whether *module* (a sys.modules value) is still executing."""
     return getattr(getattr(module, '__spec__', None), '_initializing', False)
 
 
+# Import, or wait for, the parent packages of name.
+#
+# _find_and_load() calls this before taking name's module lock, so that no
+# thread holds a submodule's lock while waiting for its parent.  This avoids
+# the deadlocks and import errors of gh-83065 and gh-159963.
 def _resolve_parents(name, import_):
-    """Import, or wait for, the parent packages of *name*.
-
-    _find_and_load() calls this before taking name's module lock, so that no
-    thread holds a submodule's lock while waiting for its parent.  This avoids
-    the deadlocks and import errors of gh-83065 and gh-159963.
-    """
     # Wait for each ancestor package that another thread is still
     # initializing, outermost first.  Importing beneath a package while its
     # __init__ is part way through its own imports could give one of the two

Lib/test/test_importlib/test_threaded_import.py

@@ -531,14 +531,13 @@ def _join_import_threads(self, threads):
 
     def _run_two_first_imports(self, files, stmt1, stmt2, *,
                                sync_name, t2_waits_for):
-        """Thread 1 runs *stmt1*.  Something it executes calls
-        ``<sync_name>.hold()``, which starts thread 2 on *stmt2* and returns
-        only once thread 2 is blocked on the module lock of *t2_waits_for*
-        (any module lock if None).  Module code may also call
-        ``<sync_name>.join_t2()`` to wait for thread 2 to finish.
-        Returns a list of (what, problem) pairs; empty means both imports
-        succeeded and no module body ran more than once.
-        """
+        # Thread 1 runs stmt1.  Something it executes calls
+        # <sync_name>.hold(), which starts thread 2 on stmt2 and returns
+        # only once thread 2 is blocked on the module lock of t2_waits_for
+        # (any module lock if None).  Module code may also call
+        # <sync_name>.join_t2() to wait for thread 2 to finish.
+        # Returns a list of (what, problem) pairs; empty means both imports
+        # succeeded and no module body ran more than once.
         # list.append() is atomic, on free-threaded builds too.
         count = f"import {sync_name}; {sync_name}.executed.append(__name__)\n"
         self._setup_package_tree({relpath: count + source