thread 1  wants       a
thread 1  has (1)     a
thread 1  wants       a.leaf
thread 1  has (1)     a.leaf
thread 1  wants       a
thread 1  has (2)     a
thread 2  wants       b
thread 2  has (1)     b
thread 2  wants       b.leaf
thread 2  has (1)     b.leaf
thread 2  wants       b
thread 2  has (2)     b
thread 2  wants       a
thread 1  gives back (1) a
thread 1  wants       b
thread 1  DEADLOCK    b
thread 1  wants       b.leaf
thread 1  DEADLOCK    b.leaf
thread 1  gives back (0) a.leaf
thread 1  gives back (0) a
thread 2  has (1)     a
thread 2  gives back (0) a
thread 2  gives back (1) b
thread 2  gives back (0) b.leaf
thread 2  gives back (0) b

"""Two threads make first imports in two packages.  No import cycle, and either
order works in one thread, yet thread 1 fails on 3.15 (passes on 3.11 to 3.14).

    python repro_error.py           -> _DeadlockError
    python repro_error.py partial   -> ImportError: cannot import name 'X' from
                                       partially initialized module 'b'
"""
import importlib._bootstrap as bootstrap
import os, shutil, sys, tempfile, threading, time, traceback, types

CASES = {
    # Needs: a.leaf -> b.leaf -> b -> a.  "a" imports nothing, so there is no cycle.
    "deadlock": ("import a.leaf", "import b.leaf", {
        "a/__init__.py": "import sync; sync.slow_init()",
        "a/leaf.py":     "from b.leaf import X",
        "b/__init__.py": "import a",
        "b/leaf.py":     "X = 1"}),
    # Needs: a.leaf -> b -> a.  No cycle either.
    "partial": ("import a.leaf", "import b", {
        "a/__init__.py": "import sync; sync.slow_init()",
        "a/leaf.py":     "from b import X",
        "b.py":          "import a; X = 1"}),
}
stmt1, stmt2, files = CASES[sys.argv[1] if len(sys.argv) > 1 else "deadlock"]

sys.dont_write_bytecode = True
root = tempfile.mkdtemp()
sys.path.insert(0, root)
for path, text in files.items():
    os.makedirs(os.path.dirname(os.path.join(root, path)), exist_ok=True)
    with open(os.path.join(root, path), "w") as f:
        f.write(text + "\n")

# "sync" is not a file: it lets a/__init__.py call back into this script.
sync = sys.modules["sync"] = types.ModuleType("sync")

# Control: one thread, both orders.
sync.slow_init = lambda: None
for order in ((stmt1, stmt2), (stmt2, stmt1)):
    for stmt in order:
        exec(stmt)
    for name in [n for n in sys.modules if n.split(".")[0] in ("a", "b")]:
        del sys.modules[name]
print("one thread, both orders: ok")

# Two threads.  a/__init__.py stands for any package whose __init__ takes a while:
# it returns once thread 2 has got as far as waiting for the module lock of "a".
# No sleep decides the order; the private _blocking_on is only read, to see that moment.
in_a = threading.Event()
failed = []

def slow_init():
    in_a.set()
    while "_ModuleLock('a')" not in repr(bootstrap._blocking_on.get(t2.ident)):
        time.sleep(0.001)
sync.slow_init = slow_init

def run(stmt, start_after=None):
    if start_after:
        start_after.wait()
    try:
        exec(stmt)
    except BaseException:
        failed.append(stmt)
        print(f"{threading.current_thread().name}, {stmt!r}:")
        traceback.print_exc(file=sys.stdout)

t1 = threading.Thread(target=run, args=(stmt1,), name="thread 1", daemon=True)
t2 = threading.Thread(target=run, args=(stmt2, in_a), name="thread 2", daemon=True)
t2.start(); t1.start()
t1.join(30); t2.join(30)
if t1.is_alive() or t2.is_alive():
    failed.append("still running after 30 s")
shutil.rmtree(root, ignore_errors=True)
print("two threads:", f"FAILED {failed}" if failed else "ok", "on", sys.version.split()[0])
sys.exit(1 if failed else 0)

$ python repro_error.py
one thread, both orders: ok
thread 1, 'import a.leaf':
Traceback (most recent call last):
  File "repro_error.py", line 62, in run
    exec(stmt)
    ~~~~^^^^^^
  File "<string>", line 1, in <module>
  File "a/leaf.py", line 1, in <module>
    from b.leaf import X
  File "<frozen importlib._bootstrap>", line 1347, in _find_and_load
  File "<frozen importlib._bootstrap>", line 458, in __enter__
  File "<frozen importlib._bootstrap>", line 346, in acquire
_frozen_importlib._DeadlockError: deadlock detected by _ModuleLock('b.leaf') at 139688739099088
two threads: FAILED ['import a.leaf'] on 3.15.0
$ python repro_error.py partial
one thread, both orders: ok
thread 1, 'import a.leaf':
Traceback (most recent call last):
  File "repro_error.py", line 62, in run
    exec(stmt)
    ~~~~^^^^^^
  File "<string>", line 1, in <module>
  File "a/leaf.py", line 1, in <module>
    from b import X
ImportError: cannot import name 'X' from partially initialized module 'b' (most likely due to a circular import) (b.py)
two threads: FAILED ['import a.leaf'] on 3.15.0

"""Thread 1 makes the first import of w.main.  Thread 2 imports w.other, and starts
while w/__init__.py is still running.  On 3.15 thread 2 then has to wait until the
BODY of w.main has ended, though "w" was complete long before.  Here that body waits
for thread 2, so both would hang forever; no _DeadlockError is raised.  The wait is
cut off after 5 s so that the script ends.  Passes on 3.11 to 3.14.
"""
import importlib._bootstrap as bootstrap
import os, shutil, sys, tempfile, threading, time, traceback, types

files = {
    "w/__init__.py": "import sync; sync.slow_init()",
    "w/main.py":     "import sync; sync.wait_for_thread_2()",
    "w/other.py":    "",
}
sys.dont_write_bytecode = True
root = tempfile.mkdtemp()
sys.path.insert(0, root)
os.mkdir(os.path.join(root, "w"))
for path, text in files.items():
    with open(os.path.join(root, path), "w") as f:
        f.write(text + "\n")

in_w = threading.Event()
thread_2_done = threading.Event()
hung = []

def slow_init():
    # Stands for any __init__ that takes a while: returns once thread 2 waits for
    # the module lock of "w" (or is done: before gh-130094 it doesn't wait at all).
    in_w.set()
    while not (thread_2_done.is_set() or
               "_ModuleLock('w')" in repr(bootstrap._blocking_on.get(t2.ident))):
        time.sleep(0.001)

def wait_for_thread_2():
    w = sys.modules["w"]
    print("w.main's body runs; w.__spec__._initializing =", w.__spec__._initializing)
    if not thread_2_done.wait(5):
        hung.append(True)
        print("after 5 s thread 2 is still here:")
        traceback.print_stack(sys._current_frames()[t2.ident], limit=4, file=sys.stdout)

# "sync" is not a file: it lets the modules call back into this script.
sync = sys.modules["sync"] = types.ModuleType("sync")
sync.slow_init, sync.wait_for_thread_2 = slow_init, wait_for_thread_2

def thread_1():
    import w.main

def thread_2():
    in_w.wait()
    t0 = time.monotonic()
    import w.other
    thread_2_done.set()
    print(f"thread 2: 'import w.other' took {time.monotonic() - t0:.1f} s")

t1 = threading.Thread(target=thread_1, daemon=True)
t2 = threading.Thread(target=thread_2, daemon=True)
t2.start(); t1.start()
t1.join(30); t2.join(30)
shutil.rmtree(root, ignore_errors=True)
print("HANG (cut off by the script)" if hung else "ok", "on", sys.version.split()[0])
sys.exit(1 if hung else 0)

$ python repro_hang.py
w.main's body runs; w.__spec__._initializing = False
after 5 s thread 2 is still here:
  File "repro_hang.py", line 53, in thread_2
    import w.other
  File "<frozen importlib._bootstrap>", line 1347, in _find_and_load
  File "<frozen importlib._bootstrap>", line 458, in __enter__
  File "<frozen importlib._bootstrap>", line 365, in acquire
thread 2: 'import w.other' took 5.1 s
HANG (cut off by the script) on 3.15.0

w.main's body runs; w.__spec__._initializing = False
thread 2: 'import w.other' took 0.0 s
ok on 3.14.7