gh-155695: Track cached exports without invoking spec callbacks

Inspect stored spec flags without invoking descriptors or user-defined truth conversions. Built-in false values still mark a module as loaded.

Skip registration for attributes already stored on loaded modules. Their existing placeholders keep their original import context, and pending modules with the same name remain tracked.

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,93 @@ 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 "custom_spec" in sys.lazy_modules, sys.lazy_modules
+        """)
+        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_builtin_false_initializing_is_not_tracked(self):
+        code = textwrap.dedent("""
+            import sys
+            import types
+
+            for flag in (False, None, 0, 0.0, 0j, "", b"", bytearray(),
+                         (), [], {}, set(), frozenset(), range(0), memoryview(b"")):
+                module = types.ModuleType("custom_spec")
+                module.__spec__ = types.SimpleNamespace(_initializing=flag)
+                sys.modules["custom_spec"] = module
+                lazy import custom_spec
+                assert "custom_spec" not in sys.lazy_modules, (flag, sys.lazy_modules)
+        """)
+        assert_python_ok("-c", code)
+
+    def test_spec_initializing_truth_conversion_is_not_run(self):
+        code = textwrap.dedent("""
+            import sys
+            import types
+
+            class Flag(int):
+                def __bool__(self):
+                    raise RuntimeError("_initializing truth conversion was run")
+
+            module = types.ModuleType("custom_spec")
+            module.__spec__ = types.SimpleNamespace(_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

@@ -4376,6 +4376,50 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
     return final_mod;
 }
 
+// Inspect stored initialization state without running spec descriptors or
+// converting user-defined values to bool.  Unknown state stays pending.
+static int
+lazy_import_spec_is_initializing(PyObject *spec)
+{
+    if (spec == Py_None) {
+        return 0;
+    }
+    PyObject *dict = PyObject_GenericGetDict(spec, NULL);
+    if (dict == NULL) {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            return 1;
+        }
+        return -1;
+    }
+    PyObject *initializing;
+    int rc = PyDict_GetItemRef(dict, &_Py_ID(_initializing), &initializing);
+    Py_DECREF(dict);
+    if (rc < 0) {
+        return -1;
+    }
+    if (rc == 0) {
+        initializing = _PyType_LookupRef(Py_TYPE(spec), &_Py_ID(_initializing));
+    }
+    if (initializing == NULL || initializing == Py_None) {
+        rc = 0;
+    }
+    else if (PyBool_Check(initializing) || PyLong_CheckExact(initializing) ||
+             PyFloat_CheckExact(initializing) || PyComplex_CheckExact(initializing) ||
+             PyUnicode_CheckExact(initializing) || PyBytes_CheckExact(initializing) ||
+             PyByteArray_CheckExact(initializing) || PyTuple_CheckExact(initializing) ||
+             PyList_CheckExact(initializing) || PyDict_CheckExact(initializing) ||
+             PyAnySet_CheckExact(initializing) || PyMemoryView_Check(initializing) ||
+             Py_IS_TYPE(initializing, &PyRange_Type)) {
+        rc = PyObject_IsTrue(initializing);
+    }
+    else {
+        rc = 1;
+    }
+    Py_XDECREF(initializing);
+    return rc;
+}
+
 // Check if a module is already loaded before adding it to sys.lazy_modules
 static int
 lazy_modules_add(PyThreadState *tstate, PyObject *name)
@@ -4397,7 +4441,7 @@ lazy_modules_add(PyThreadState *tstate, PyObject *name)
         int rc = PyDict_GetItemRef(_PyModule_GetDict(existing),
                                    &_Py_ID(__spec__), &spec);
         if (rc > 0) {
-            rc = _PyModuleSpec_IsInitializing(spec);
+            rc = lazy_import_spec_is_initializing(spec);
             Py_DECREF(spec);
         }
         if (rc < 0) {
@@ -4501,6 +4545,23 @@ static int
 register_from_lazy_on_parent(PyThreadState *tstate, PyObject *abs_name,
                              PyObject *from)
 {
+    // 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;
+    }
+    if (mod != NULL && PyModule_Check(mod)) {
+        int rc = PyDict_Contains(_PyModule_GetDict(mod), from);
+        Py_DECREF(mod);
+        if (rc != 0) {
+            return rc < 0 ? -1 : 0;
+        }
+    }
+    else {
+        Py_XDECREF(mod);
+    }
+
     PyObject *fromname = PyUnicode_FromFormat("%U.%U", abs_name, from);
     if (fromname == NULL) {
         return -1;