Import the module a lazy import a.b as c names

`import a.b as c` compiles to `IMPORT_NAME a.b` followed by `IMPORT_FROM b`.
Lazily, IMPORT_NAME leaves a placeholder holding "a.b", and IMPORT_FROM
rewrote it into the placeholder `lazy from a import b` produces.  Reification
then imported `a` alone and read `b` off it, so the module `a.b` was never
imported under its own name: an attribute of the package shadowing it answered
instead, and `math.pi`, which no module backs, bound the float where the eager
statement raises ModuleNotFoundError.

Mark the dotted import on the placeholder and keep the whole name on it.
Reification imports that name and then walks its components with IMPORT_FROM,
which is what the eager statement does.

The test pinning `lazy import math.pi as pi` as working is inverted, since the
eager statement raises.

Author: brittanyrey

Include/internal/pycore_lazyimportobject.h

@@ -22,12 +22,15 @@ typedef struct {
     // Frame information for the original import location.
     PyCodeObject *lz_code;     // Code object where the lazy import was created.
     int lz_instr_offset;       // Instruction offset where the lazy import was created.
+    int lz_submodule;          // True for `import a.b as c`, which binds `a.b`
+                               // where `import a.b` binds `a`.
 } PyLazyImportObject;
 
 
 PyAPI_FUNC(PyObject *) _PyLazyImport_GetName(PyObject *lazy_import);
 PyAPI_FUNC(PyObject *) _PyLazyImport_New(
-    struct _PyInterpreterFrame *frame, PyObject *import_func, PyObject *from, PyObject *attr);
+    struct _PyInterpreterFrame *frame, PyObject *import_func, PyObject *from,
+    PyObject *attr, int submodule);
 
 #ifdef __cplusplus
 }

Lib/test/test_lazy_import/__init__.py

@@ -724,10 +724,18 @@ def test_non_package_lazily_imported(self):
         assert_python_ok("-c", code)
 
     def test_non_package_lazily_imported_as(self):
-        """Doing a dotted lazy import as still works"""
+        """A dotted lazy import as raises when the name is not a module."""
+        # gh-157757: the eager statement raises ModuleNotFoundError, so the
+        # lazy one raises it at first use rather than binding math.pi.
         code = textwrap.dedent("""
             lazy import math.pi as pi
-            pi
+
+            try:
+                pi
+            except ModuleNotFoundError:
+                pass
+            else:
+                raise AssertionError("ModuleNotFoundError was not raised")
         """)
         assert_python_ok("-c", code)
 
@@ -2209,6 +2217,25 @@ def test_import_after_variable_wins(self):
         ]
         self.assertIs(module_same_name_var_order2.bar, bar_mod)
 
+    def test_lazy_import_as_wins_over_variable(self):
+        """A dotted lazy import as imports the submodule the variable hides."""
+        # gh-157757: the eager statement imports pkg.b, which rebinds pkg.b to
+        # the module, so the lazy one must import it too rather than read the
+        # variable off pkg.
+        code = textwrap.dedent("""
+            import sys
+            import test.test_lazy_import.data.pkg as pkg
+            pkg.b = "hides the b submodule"
+
+            lazy import test.test_lazy_import.data.pkg.b as b
+            lazy import test.test_lazy_import.data.metasyntactic.foo.bar as bar
+
+            assert b is sys.modules["test.test_lazy_import.data.pkg.b"], b
+            assert bar is sys.modules[
+                "test.test_lazy_import.data.metasyntactic.foo.bar"], bar
+        """)
+        assert_python_ok("-c", code)
+
 
 class DeletedModuleReimportTests(unittest.TestCase):
     """Tests for reimporting after module deletion from sys.modules."""

Misc/NEWS.d/next/Core_and_Builtins/2026-09-18-15-20-00.gh-issue-157757.Kq3Lm7.rst

@@ -0,0 +1,3 @@
+Fix a lazy ``import a.b as c`` reading ``b`` off ``a`` instead of importing
+the module ``a.b``.  It now binds the submodule, and raises
+:exc:`ModuleNotFoundError` when no module backs the name.

Objects/lazyimportobject.c

@@ -11,7 +11,8 @@
 #define PyLazyImportObject_CAST(op) ((PyLazyImportObject *)(op))
 
 PyObject *
-_PyLazyImport_New(_PyInterpreterFrame *frame, PyObject *builtins, PyObject *name, PyObject *fromlist)
+_PyLazyImport_New(_PyInterpreterFrame *frame, PyObject *builtins,
+                  PyObject *name, PyObject *fromlist, int submodule)
 {
     PyLazyImportObject *m;
     if (!name || !PyUnicode_Check(name)) {
@@ -33,6 +34,7 @@ _PyLazyImport_New(_PyInterpreterFrame *frame, PyObject *builtins, PyObject *name
     m->lz_builtins = Py_XNewRef(builtins);
     m->lz_from = Py_NewRef(name);
     m->lz_attr = Py_XNewRef(fromlist);
+    m->lz_submodule = submodule;
 
     // Capture frame information for the original import location.
     m->lz_code = NULL;

Python/ceval.c

@@ -3333,6 +3333,15 @@ _PyEval_LazyImportFrom(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObje
     assert(PyUnicode_Check(name));
     PyObject *ret;
     PyLazyImportObject *d = (PyLazyImportObject *)v;
+
+    if (d->lz_attr == NULL) {
+        // `import a.b as x` binds `a.b`, not an attribute of `a` (gh-157757).
+        if (d->lz_submodule) {
+            return Py_NewRef(v);  // a later component of the same name
+        }
+        return _PyLazyImport_New(frame, d->lz_builtins, d->lz_from, NULL, 1);
+    }
+
     PyObject *mod = PyImport_GetModule(d->lz_from);
     if (mod != NULL) {
         // Check if the module already has the attribute, if so, resolve it
@@ -3353,34 +3362,8 @@ _PyEval_LazyImportFrom(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObje
         Py_DECREF(mod);
     }
 
-    if (d->lz_attr != NULL) {
-        if (PyUnicode_Check(d->lz_attr)) {
-            PyObject *from = PyUnicode_FromFormat(
-                "%U.%U", d->lz_from, d->lz_attr);
-            if (from == NULL) {
-                return NULL;
-            }
-            ret = _PyLazyImport_New(frame, d->lz_builtins, from, name);
-            Py_DECREF(from);
-            return ret;
-        }
-    }
-    else {
-        Py_ssize_t dot = PyUnicode_FindChar(
-            d->lz_from, '.', 0, PyUnicode_GET_LENGTH(d->lz_from), 1
-        );
-        if (dot >= 0) {
-            PyObject *from = PyUnicode_Substring(d->lz_from, 0, dot);
-            if (from == NULL) {
-                return NULL;
-            }
-            ret = _PyLazyImport_New(frame, d->lz_builtins, from, name);
-            Py_DECREF(from);
-            return ret;
-        }
-    }
-    ret = _PyLazyImport_New(frame, d->lz_builtins, d->lz_from, name);
-    return ret;
+    assert(!PyUnicode_Check(d->lz_attr));  // a fromlist, not a taken name
+    return _PyLazyImport_New(frame, d->lz_builtins, d->lz_from, name, 0);
 }
 
 #define CANNOT_CATCH_MSG "catching classes that do not inherit from "\

Python/import.c

@@ -3898,6 +3898,27 @@ _PyImport_ResolveName(PyThreadState *tstate, PyObject *name,
   return resolve_name(tstate, name, globals, level);
 }
 
+// Repeat IMPORT_FROM over the components of `name` after the first, taking
+// `a.b.c` off the `a` that importing "a.b.c" returns.
+static PyObject *
+import_from_dotted_name(PyThreadState *tstate, PyObject *mod, PyObject *name)
+{
+    PyObject *parts = PyUnicode_Split(name, _Py_LATIN1_CHR('.'), -1);
+    if (parts == NULL) {
+        return NULL;
+    }
+    PyObject *obj = Py_NewRef(mod);
+    for (Py_ssize_t i = 1; i < PyList_GET_SIZE(parts); i++) {
+        Py_SETREF(obj, _PyEval_ImportFrom(tstate, obj,
+                                          PyList_GET_ITEM(parts, i)));
+        if (obj == NULL) {
+            break;
+        }
+    }
+    Py_DECREF(parts);
+    return obj;
+}
+
 PyObject *
 _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
 {
@@ -3989,7 +4010,15 @@ _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
         goto error;
     }
 
-    if (lz->lz_attr != NULL && PyUnicode_Check(lz->lz_attr)) {
+    if (lz->lz_submodule) {
+        PyObject *top = obj;
+        obj = import_from_dotted_name(tstate, top, lz->lz_from);
+        Py_DECREF(top);
+        if (obj == NULL) {
+            goto error;
+        }
+    }
+    else if (lz->lz_attr != NULL && PyUnicode_Check(lz->lz_attr)) {
         PyObject *from = obj;
         obj = _PyEval_ImportFrom(tstate, from, lz->lz_attr);
         Py_DECREF(from);
@@ -4600,7 +4629,7 @@ _PyImport_LazyImportModuleLevelObject(PyThreadState *tstate,
     else {
         Py_XINCREF(fromlist);
     }
-    PyObject *res = _PyLazyImport_New(frame, builtins, abs_name, fromlist);
+    PyObject *res = _PyLazyImport_New(frame, builtins, abs_name, fromlist, 0);
     if (res == NULL) {
         Py_XDECREF(fromlist);
         Py_DECREF(abs_name);