GeezerVison

Copy link

Copy Markdown

Contributor

brittanyrey requested review from DinoV, FFY00, Yhg1s, brettcannon, ericsnowcurrently, kumaraditya303, markshannon, ncoghlan, pablogsal and warsaw as code owners September 24, 2026 14:38

johnslavik requested review from encukou and johnslavik September 24, 2026 14:59

brettcannon removed their request for review September 24, 2026 20:00

pablogsal reviewed Sep 25, 2026

View reviewed changes

pablogsal force-pushed the b-gh157757-lazy-dotted-as branch from c10339c to 48244f1 Compare September 26, 2026 19:46

pablogsal approved these changes Sep 26, 2026

View reviewed changes

pablogsal enabled auto-merge (squash) September 26, 2026 19:46

66 checks passed

cherry_picker 1e8ff18a1215b711136b4377282e392583847d62 3.15

…e `a.b` (GH-158092) (#158257)

gh-157757: Fix to make `lazy import a.b as c` import the module `a.b` (#158092)

* 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.

* Stop excluding test_trace from the lazy-imports-all run

It passes now that a lazy `import a.b as c` imports the module: the
KeyError on 'test.tracedmodules.testmod' came from the submodule never
being imported under its own name.

* Rename lz_submodule to lz_dotted_as and trim the comments

The flag means "bind the whole dotted name, not the root", which the old
name did not say, and import.c already has unrelated lazy_pending_submodules
machinery to be confused with.

* Chain lazy IMPORT_FROM placeholders instead of flagging dotted imports

Each deferred IMPORT_FROM off a placeholder without a fromlist now keeps
the previous placeholder in lz_from and the attribute name in lz_attr.
Reification walks back to the placeholder IMPORT_NAME left, runs that
import, and replays the lookups in order with _PyEval_ImportFrom, which
is what the eager bytecode does.  This drops the lz_dotted_as flag and
also follows a custom __lazy_import__ that returns a placeholder for a
different module name.

* Chain every deferred IMPORT_FROM onto the previous placeholder

`lazy from a import b` now records its lookup the same way as `import
a.b as c`, so a placeholder holds either the module name and fromlist or
the previous placeholder and an attribute name, and reification has a
single path.  The import passes only the name being resolved as the
fromlist, so accessing b still does not import the other names'
submodules.

* Treat an empty fromlist on a lazy import placeholder as no fromlist

__import__("a.b", fromlist=()) returns the top-level package `a`, the same
as fromlist=None, but the placeholder kept the empty tuple.  Every consumer
of lz_attr then read it as a real fromlist: reification narrowed it to the
chained attribute and replayed the lookups on `a.b`, _PyEval_LazyImportFrom
took the attribute off sys.modules["a.b"], and the repr named `a.b.attr`.

_PyLazyImport_New already collapses None to NULL for exactly this reason,
so collapse an empty tuple there too and every site follows.

* gh-157757: Preserve empty fromlists for custom import hooks

---------


(cherry picked from commit 1e8ff18)

Co-authored-by: Brittany Reynoso <[email protected]>

… module `a.b` (pythonGH-158092) (python#158257)

pythongh-157757: Fix to make `lazy import a.b as c` import the module `a.b` (python#158092)

* 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.

* Stop excluding test_trace from the lazy-imports-all run

It passes now that a lazy `import a.b as c` imports the module: the
KeyError on 'test.tracedmodules.testmod' came from the submodule never
being imported under its own name.

* Rename lz_submodule to lz_dotted_as and trim the comments

The flag means "bind the whole dotted name, not the root", which the old
name did not say, and import.c already has unrelated lazy_pending_submodules
machinery to be confused with.

* Chain lazy IMPORT_FROM placeholders instead of flagging dotted imports

Each deferred IMPORT_FROM off a placeholder without a fromlist now keeps
the previous placeholder in lz_from and the attribute name in lz_attr.
Reification walks back to the placeholder IMPORT_NAME left, runs that
import, and replays the lookups in order with _PyEval_ImportFrom, which
is what the eager bytecode does.  This drops the lz_dotted_as flag and
also follows a custom __lazy_import__ that returns a placeholder for a
different module name.

* Chain every deferred IMPORT_FROM onto the previous placeholder

`lazy from a import b` now records its lookup the same way as `import
a.b as c`, so a placeholder holds either the module name and fromlist or
the previous placeholder and an attribute name, and reification has a
single path.  The import passes only the name being resolved as the
fromlist, so accessing b still does not import the other names'
submodules.

* Treat an empty fromlist on a lazy import placeholder as no fromlist

__import__("a.b", fromlist=()) returns the top-level package `a`, the same
as fromlist=None, but the placeholder kept the empty tuple.  Every consumer
of lz_attr then read it as a real fromlist: reification narrowed it to the
chained attribute and replayed the lookups on `a.b`, _PyEval_LazyImportFrom
took the attribute off sys.modules["a.b"], and the repr named `a.b.attr`.

_PyLazyImport_New already collapses None to NULL for exactly this reason,
so collapse an empty tuple there too and every site follows.

* pythongh-157757: Preserve empty fromlists for custom import hooks

---------

(cherry picked from commit 1e8ff18)

Co-authored-by: Brittany Reynoso <[email protected]>
(cherry picked from commit 1a2d24e)

The nested-placeholder replay path in _PyImport_LoadLazyImportTstate
called PyTuple_GET_SIZE(root->lz_attr) without a PyTuple_Check, while the
sibling _PyEval_LazyImportFrom path added in the same upstream change
(pythongh-157757 / pythonGH-158092) guards the identical access with PyTuple_Check,
as does the fromlist handling a few lines below. _PyLazyImport_New
accepts a Unicode fromlist by design, so the tuple invariant on lz_attr
is maintained only by callers; match the sibling guard to harden the
reifier for a fleet-wide patch.

No reachable Python path currently builds a root placeholder with a
Unicode lz_attr (the builtin __lazy_import__ normalizes a str fromlist
to a tuple before storing), so this is defense-in-depth and a
consistency fix rather than a live crash. Behaviour of normal dotted
lazy imports is unchanged; upstream test_lazy_import (133) and the
LinkedIn local lazy suite pass.

brittanyrey deleted the b-gh157757-lazy-dotted-as branch October 1, 2026 21:36

… module `a.b` (pythonGH-158092) (python#158257)

pythongh-157757: Fix to make `lazy import a.b as c` import the module `a.b` (python#158092)

* 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.

* Stop excluding test_trace from the lazy-imports-all run

It passes now that a lazy `import a.b as c` imports the module: the
KeyError on 'test.tracedmodules.testmod' came from the submodule never
being imported under its own name.

* Rename lz_submodule to lz_dotted_as and trim the comments

The flag means "bind the whole dotted name, not the root", which the old
name did not say, and import.c already has unrelated lazy_pending_submodules
machinery to be confused with.

* Chain lazy IMPORT_FROM placeholders instead of flagging dotted imports

Each deferred IMPORT_FROM off a placeholder without a fromlist now keeps
the previous placeholder in lz_from and the attribute name in lz_attr.
Reification walks back to the placeholder IMPORT_NAME left, runs that
import, and replays the lookups in order with _PyEval_ImportFrom, which
is what the eager bytecode does.  This drops the lz_dotted_as flag and
also follows a custom __lazy_import__ that returns a placeholder for a
different module name.

* Chain every deferred IMPORT_FROM onto the previous placeholder

`lazy from a import b` now records its lookup the same way as `import
a.b as c`, so a placeholder holds either the module name and fromlist or
the previous placeholder and an attribute name, and reification has a
single path.  The import passes only the name being resolved as the
fromlist, so accessing b still does not import the other names'
submodules.

* Treat an empty fromlist on a lazy import placeholder as no fromlist

__import__("a.b", fromlist=()) returns the top-level package `a`, the same
as fromlist=None, but the placeholder kept the empty tuple.  Every consumer
of lz_attr then read it as a real fromlist: reification narrowed it to the
chained attribute and replayed the lookups on `a.b`, _PyEval_LazyImportFrom
took the attribute off sys.modules["a.b"], and the repr named `a.b.attr`.

_PyLazyImport_New already collapses None to NULL for exactly this reason,
so collapse an empty tuple there too and every site follows.

* pythongh-157757: Preserve empty fromlists for custom import hooks

---------

(cherry picked from commit 1e8ff18)

Co-authored-by: Brittany Reynoso <[email protected]>
(cherry picked from commit 1a2d24e)

The nested-placeholder replay path in _PyImport_LoadLazyImportTstate
called PyTuple_GET_SIZE(root->lz_attr) without a PyTuple_Check, while the
sibling _PyEval_LazyImportFrom path added in the same upstream change
(pythongh-157757 / pythonGH-158092) guards the identical access with PyTuple_Check,
as does the fromlist handling a few lines below. _PyLazyImport_New
accepts a Unicode fromlist by design, so the tuple invariant on lz_attr
is maintained only by callers; match the sibling guard to harden the
reifier for a fleet-wide patch.

No reachable Python path currently builds a root placeholder with a
Unicode lz_attr (the builtin __lazy_import__ normalizes a str fromlist
to a tuple before storing), so this is defense-in-depth and a
consistency fix rather than a live crash. Behaviour of normal dotted
lazy imports is unchanged; upstream test_lazy_import (133) and the
LinkedIn local lazy suite pass.