gh-152298: Preserve lazy submodule sentinel errors

Author: 1sgtpepper

Lib/test/test_lazy_import/__init__.py

@@ -515,6 +515,47 @@ def __getitem__(self, name):
         self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}")
         self.assertIn("OK", result.stdout)
 
+    @support.requires_subprocess()
+    def test_lazy_submodule_sys_modules_none_sentinel_raises(self):
+        """The sys.modules None sentinel should preserve import failure."""
+        code = textwrap.dedent("""
+            import os
+            import sys
+            import tempfile
+
+            with tempfile.TemporaryDirectory() as tmpdir:
+                pkg_dir = os.path.join(tmpdir, "lazy_sentinel_pkg")
+                os.mkdir(pkg_dir)
+                with open(os.path.join(pkg_dir, "__init__.py"), "w", encoding="utf-8") as f:
+                    f.write("")
+                with open(os.path.join(pkg_dir, "sub.py"), "w", encoding="utf-8") as f:
+                    f.write("VALUE = 42\\n")
+
+                sys.path.insert(0, tmpdir)
+                lazy import lazy_sentinel_pkg.sub
+                try:
+                    sys.modules["lazy_sentinel_pkg.sub"] = None
+                    try:
+                        lazy_sentinel_pkg.sub
+                    except ModuleNotFoundError as exc:
+                        assert exc.name == "lazy_sentinel_pkg.sub", exc
+                    else:
+                        raise AssertionError("ModuleNotFoundError was not raised")
+                finally:
+                    sys.path.remove(tmpdir)
+                    for name in ("lazy_sentinel_pkg", "lazy_sentinel_pkg.sub"):
+                        sys.modules.pop(name, None)
+
+            print("OK")
+        """)
+        result = subprocess.run(
+            [sys.executable, "-c", code],
+            capture_output=True,
+            text=True
+        )
+        self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}")
+        self.assertIn("OK", result.stdout)
+
     def test_lazy_import_pkg_cross_import(self):
         """Cross-imports within package should preserve lazy imports."""
         import test.test_lazy_import.data.pkg.c

Misc/NEWS.d/next/Core_and_Builtins/2026-06-29-03-18-22.gh-issue-152298.X3zQpA.rst

@@ -1,2 +1,5 @@
 Fix :meth:`!types.LazyImportType.resolve` so resolving a module-level lazy
 import replaces the original lazy proxy in the module globals.
+Lazy submodule attribute access now also preserves importlib's
+``sys.modules[name] is None`` sentinel behavior while treating absent requested
+lazy submodules as normal attribute misses.

Python/import.c

@@ -4101,7 +4101,7 @@ _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
     }
     else if (obj != NULL) {
         // Cache the result and update the original global before releasing
-        // the import lock, so competing reification cannot import again.
+        // the import lock, so later reification through this proxy reuses it.
         if (_PyLazyImport_FinishResolve(lazy_import, obj) < 0) {
             Py_CLEAR(obj);
         }
@@ -4455,8 +4455,10 @@ register_from_lazy_on_parent(PyThreadState *tstate, PyObject *abs_name,
 static int
 is_module_not_found_for_name(PyThreadState *tstate, PyObject *name)
 {
-    // Return true only for "name itself was not found", consuming the current
-    // exception so callers can continue normal attribute fallback.
+    // Return true only for the importlib._handle_fromlist() compatibility
+    // case where "name itself was not found" and sys.modules[name] is not the
+    // None sentinel. Consume the current exception so callers can continue
+    // normal attribute fallback.
     if (!_PyErr_ExceptionMatches(tstate, PyExc_ModuleNotFoundError)) {
         return 0;
     }
@@ -4479,6 +4481,18 @@ is_module_not_found_for_name(PyThreadState *tstate, PyObject *name)
         return 0;
     }
 
+    PyObject *mod = import_get_module(tstate, name);
+    if (mod == Py_None) {
+        Py_DECREF(mod);
+        _PyErr_SetRaisedException(tstate, exc);
+        return 0;
+    }
+    if (mod == NULL && _PyErr_Occurred(tstate)) {
+        PyErr_Clear();
+        _PyErr_SetRaisedException(tstate, exc);
+        return 0;
+    }
+    Py_XDECREF(mod);
     Py_DECREF(exc);
     return 1;
 }
@@ -4554,7 +4568,12 @@ _PyImport_TryLoadLazySubmodule(PyObject *mod_name, PyObject *attr_name,
         return -1;
     }
 
-    if (PySet_Discard(pending_set, attr_name) < 0) {
+    // This completes the successful lazy-submodule publish. pending_set is an
+    // internal set and attr_name is a Unicode attribute name, so discard is not
+    // expected to fail after the parent dict has been updated.
+    int discard_rc = PySet_Discard(pending_set, attr_name);
+    assert(discard_rc >= 0);
+    if (discard_rc < 0) {
         Py_DECREF(pending_set);
         Py_DECREF(submod);
         return -1;