gh-155695: Preserve import behavior in lazy module tracking

Read stored initialization flags without invoking spec callbacks or materializing dictionaries. Keep unsupported spec state conservatively tracked. Skip cached exports without changing their import context or clearing independently pending modules.

Author: pablogsal

Lib/test/test_lazy_import/__init__.py

@@ -1325,6 +1325,61 @@ def test_attribute_entry_removed_on_reification(self):
         """)
         assert_python_ok("-c", code)
 
+    def test_already_loaded_attribute_is_not_tracked(self):
+        code = textwrap.dedent("""
+            import sys
+            import math
+
+            lazy from math import pi
+            assert "math.pi" not in sys.lazy_modules, sys.lazy_modules
+            assert pi == math.pi
+        """)
+        assert_python_ok("-c", code)
+
+    def test_cached_lazy_attribute_keeps_its_import_context(self):
+        code = textwrap.dedent("""
+            import builtins
+            import sys
+            import test.test_lazy_import.data.basic_from_unused
+
+            holder = "test.test_lazy_import.data.basic_from_unused"
+            target = "test.test_lazy_import.data.basic2"
+            default_import = builtins.__import__
+
+            def import_hook(name, *args):
+                if name == holder:
+                    raise RuntimeError("cached placeholder imported its holder")
+                return default_import(name, *args)
+
+            namespace = {
+                "__builtins__": dict(builtins.__dict__, __import__=import_hook),
+                "__name__": "cached_import_test",
+            }
+            exec(f"lazy from {holder} import basic2", namespace)
+            assert holder + ".basic2" not in sys.lazy_modules, sys.lazy_modules
+            assert target in sys.lazy_modules, sys.lazy_modules
+            exec("assert basic2.x == 42", namespace)
+            assert target not in sys.lazy_modules, sys.lazy_modules
+        """)
+        assert_python_ok("-c", code)
+
+    def test_cached_attribute_keeps_pending_module_tracked(self):
+        code = textwrap.dedent("""
+            import sys
+            import test.test_lazy_import.data.pkg as pkg
+            pkg.b = 42
+
+            lazy import test.test_lazy_import.data.pkg.b as pending
+            lazy from test.test_lazy_import.data.pkg import b
+            name = "test.test_lazy_import.data.pkg.b"
+            assert b == 42, b
+            assert name not in sys.modules, sys.modules
+            assert name in sys.lazy_modules, sys.lazy_modules
+            assert pending.foo() == "foo"
+            assert name not in sys.lazy_modules, sys.lazy_modules
+        """)
+        assert_python_ok("-c", code)
+
     def test_failed_reification_stays_tracked(self):
         """A lazy import that fails to resolve must stay tracked."""
         code = textwrap.dedent("""
@@ -1391,6 +1446,83 @@ def __spec__(self):
         """)
         assert_python_ok("-c", code)
 
+    def test_spec_initializing_descriptor_is_not_run(self):
+        code = textwrap.dedent("""
+            import sys
+            import types
+
+            class Spec:
+                @property
+                def _initializing(self):
+                    raise RuntimeError("_initializing descriptor was run")
+
+                @property
+                def __dict__(self):
+                    raise RuntimeError("__dict__ descriptor was run")
+
+            class SlottedSpec:
+                __slots__ = ()
+
+                @property
+                def _initializing(self):
+                    raise RuntimeError("_initializing descriptor was run")
+
+            for spec in (Spec(), SlottedSpec()):
+                module = types.ModuleType("custom_spec")
+                module.__spec__ = spec
+                sys.modules["custom_spec"] = module
+                lazy import custom_spec
+        """)
+        assert_python_ok("-c", code)
+
+    def test_cached_attribute_does_not_check_spec_twice(self):
+        code = textwrap.dedent("""
+            import sys
+            import types
+
+            class Spec:
+                def __init__(self):
+                    self.calls = 0
+
+                @property
+                def _initializing(self):
+                    self.calls += 1
+                    if self.calls == 2:
+                        raise RuntimeError("_initializing was read twice")
+                    return False
+
+            module = types.ModuleType("cached_spec")
+            module.__spec__ = Spec()
+            module.attr = 1
+            sys.modules["cached_spec"] = module
+            lazy from cached_spec import attr
+            assert attr == 1, attr
+        """)
+        assert_python_ok("-c", code)
+
+    def test_spec_initializing_truth_conversion_is_not_run(self):
+        code = textwrap.dedent("""
+            import sys
+            import types
+            from importlib.machinery import ModuleSpec
+
+            class Flag:
+                def __bool__(self):
+                    raise RuntimeError("_initializing truth conversion was run")
+
+            released = memoryview(b"")
+            released.release()
+            for flag in (Flag(), released):
+                sys.lazy_modules.discard("custom_spec")
+                module = types.ModuleType("custom_spec")
+                module.__spec__ = ModuleSpec("custom_spec", None)
+                module.__spec__._initializing = flag
+                sys.modules["custom_spec"] = module
+                lazy import custom_spec
+                assert "custom_spec" in sys.lazy_modules, sys.lazy_modules
+        """)
+        assert_python_ok("-c", code)
+
     def test_pending_submodule_is_still_tracked(self):
         """`lazy from` a submodule that is not loaded must stay tracked."""
         code = textwrap.dedent("""

Python/import.c

@@ -3917,20 +3917,6 @@ lazy_import_replay_from(PyThreadState *tstate, PyObject *mod,
     return obj;
 }
 
-// The import machinery only discards module names, so this is what removes
-// the "pkg.attr" entry left by `lazy from pkg import attr`, submodule or not.
-static int
-discard_reified_lazy_import(PyInterpreterState *interp, PyObject *lazy_import)
-{
-    PyObject *name = _PyLazyImport_GetName(lazy_import);
-    if (name == NULL) {
-        return -1;
-    }
-    int res = PySet_Discard(LAZY_MODULES(interp), name);
-    Py_DECREF(name);
-    return res < 0 ? -1 : 0;
-}
-
 PyObject *
 _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
 {
@@ -4114,8 +4100,12 @@ _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
     }
 
 ok:
-    if (obj != NULL && discard_reified_lazy_import(interp, lazy_import) < 0) {
-        Py_CLEAR(obj);
+    if (obj != NULL) {
+        PyObject *name = _PyLazyImport_GetName(lazy_import);
+        if (name == NULL || PySet_Discard(LAZY_MODULES(interp), name) < 0) {
+            Py_CLEAR(obj);
+        }
+        Py_XDECREF(name);
     }
 
     if (PySet_Discard(importing, lazy_import) < 0) {
@@ -4376,41 +4366,35 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
     return final_mod;
 }
 
-// Check if a module is already loaded before adding it to sys.lazy_modules
 static int
 lazy_modules_add(PyThreadState *tstate, PyObject *name)
 {
-    PyObject *modules = get_modules_dict(tstate, false);
-    if (modules == NULL) {
+    PyObject *mod = import_get_module(tstate, name);
+    if (mod == NULL && PyErr_Occurred()) {
         return -1;
     }
-    PyObject *existing;
-    if (PyDict_GetItemRef(modules, name, &existing) < 0) {
-        return -1;
-    }
-    // A None entry blocks the import rather than satisfying it.
-    int loaded = (existing != NULL && existing != Py_None);
-    if (loaded && PyModule_Check(existing)) {
-        // Check if the module is still initializing.  Read __spec__ from the
-        // module dict so that a descriptor on a module subclass is not run.
+    int loaded = mod != NULL && mod != Py_None;
+    if (loaded && PyModule_Check(mod)) {
         PyObject *spec;
-        int rc = PyDict_GetItemRef(_PyModule_GetDict(existing),
-                                   &_Py_ID(__spec__), &spec);
-        if (rc > 0) {
-            rc = _PyModuleSpec_IsInitializing(spec);
-            Py_DECREF(spec);
-        }
-        if (rc < 0) {
-            Py_DECREF(existing);
+        if (PyDict_GetItemRef(_PyModule_GetDict(mod), &_Py_ID(__spec__), &spec) < 0) {
+            Py_DECREF(mod);
             return -1;
         }
-        loaded = !rc;
-    }
-    Py_XDECREF(existing);
-    if (loaded) {
-        return 0;
+        loaded = spec == NULL || spec == Py_None;
+        if (!loaded) {
+            // Read the usual flag without callbacks or dictionary allocation.
+            // Unsupported spec representations stay conservatively tracked.
+            PyObject *initializing = NULL;
+            if ((Py_TYPE(spec)->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+                _PyObject_TryGetInstanceAttribute(spec, &_Py_ID(_initializing), &initializing)) {
+                loaded = initializing == NULL || initializing == Py_False;
+            }
+            Py_XDECREF(initializing);
+        }
+        Py_XDECREF(spec);
     }
-    return PySet_Add(LAZY_MODULES(tstate->interp), name);
+    Py_XDECREF(mod);
+    return loaded ? 0 : PySet_Add(LAZY_MODULES(tstate->interp), name);
 }
 
 // ensure we have the set for the parent module name in sys.lazy_modules.
@@ -4501,19 +4485,32 @@ static int
 register_from_lazy_on_parent(PyThreadState *tstate, PyObject *abs_name,
                              PyObject *from)
 {
-    PyObject *fromname = PyUnicode_FromFormat("%U.%U", abs_name, from);
-    if (fromname == NULL) {
+    // IMPORT_FROM returns stored attributes directly.  Their imports are
+    // already resolved or tracked by their own placeholders, so skip the alias.
+    PyObject *mod = import_get_module(tstate, abs_name);
+    if (mod == NULL && PyErr_Occurred()) {
         return -1;
     }
+    int rc = 0;
+    if (mod != NULL && PyModule_Check(mod)) {
+        rc = PyDict_Contains(_PyModule_GetDict(mod), from);
+    }
+    Py_XDECREF(mod);
+    if (rc != 0) {
+        return rc < 0 ? -1 : 0;
+    }
 
-    if (lazy_modules_add(tstate, fromname) < 0) {
-        Py_DECREF(fromname);
+    PyObject *fromname = PyUnicode_FromFormat("%U.%U", abs_name, from);
+    if (fromname == NULL) {
         return -1;
     }
 
-    int res = register_lazy_on_parent(tstate, fromname);
+    rc = lazy_modules_add(tstate, fromname);
+    if (rc == 0) {
+        rc = register_lazy_on_parent(tstate, fromname);
+    }
     Py_DECREF(fromname);
-    return res;
+    return rc;
 }
 
 _PyLazySubmoduleImportResult