Datasets:

lolbench26
/

LoLBench

You are working in `/workspace/cpython`, a source tree checked out at
the base commit for this task. Implement the requested behavior in the source
tree, then run:

```bash
lolbench-submit
```

Do not stop after editing files, running tests, or describing the solution. The
task is complete only when `lolbench-submit` has created
`/logs/artifacts/solution.patch`. If that file does not exist, continue
working and run `lolbench-submit` again.

That command writes your implementation diff to
`/logs/artifacts/solution.patch`, which is the artifact the Harbor verifier
will grade. Before running `lolbench-submit`, clean or revert any test files
you created or modified; test files must not be included in the final
`solution.patch`.

This environment has no outbound internet access — `curl`/`wget`, `git fetch`/`clone`, package installs, and web fetch/search will all fail. Implement the requirements using only the code already in the workspace and your own knowledge; do not attempt to fetch or search external resources.

Now please implement the following requirements in the source tree:

---

## Abstract
This PEP introduces syntax for lazy imports as an explicit language feature:

```python
lazy import json
lazy from json import dumps
```
Lazy imports defer the loading and execution of a module until the first time
the imported name is used, in contrast to 'normal' imports, which eagerly load
and execute a module at the point of the import statement.

By allowing developers to mark individual imports as lazy with explicit
syntax, Python programs can reduce startup time, memory usage, and unnecessary
work. This is particularly beneficial for command-line tools, test suites, and
applications with large dependency graphs.

This proposal preserves full backwards compatibility: normal import statements
remain unchanged, and lazy imports are enabled only where explicitly
requested.

## Motivation
The dominant convention in Python code is to place all imports at the module
level, typically at the beginning of the file. This avoids repetition, makes
import dependencies clear and minimizes runtime overhead by only evaluating an
import statement once per module.

A major drawback with this approach is that importing the first module for an
execution of Python (the "main" module) often triggers an immediate cascade of
imports, and optimistically loads many dependencies that may never be used.
The effect is especially costly for command-line tools with multiple
subcommands, where even running the command with `--help` can load dozens of
unnecessary modules and take several seconds. This basic example demonstrates
what must be loaded just to get helpful feedback to the user on how to run the
program at all. Inefficiently, the user incurs this overhead again when they
figure out the command they want and invoke the program "for real."

A somewhat common way to delay imports is to move the imports into functions
(inline imports), but this practice requires more work to implement and
maintain, and can be subverted by a single inadvertent top-level import.
Additionally, it obfuscates the full set of dependencies for a module.
Analysis of the Python standard library shows that approximately 17% of all
imports outside tests (nearly 3500 total imports across 730 files) are already
placed inside functions or methods specifically to defer their execution. This
demonstrates that developers are already manually implementing lazy imports in
performance-sensitive code, but doing so requires scattering imports
throughout the codebase and makes the full dependency graph harder to
understand at a glance.

The standard library provides the `~importlib.util.LazyLoader` class to
solve some of these inefficiency problems. It permits imports at the module
level to work *mostly* like inline imports do. Many scientific Python
libraries have adopted a similar pattern, formalized in
[SPEC 1](https://scientific-python.org/specs/spec-0001/).
There's also the third-party `lazy_loader` package, yet another
implementation of lazy imports. Imports used solely for static type checking
are another source of potentially unneeded imports, and there are similarly
disparate approaches to minimizing the overhead. The various approaches used
here to defer or remove eager imports do not cover all potential use-cases for
a general lazy import mechanism. There is no clear standard, and there are
several drawbacks including runtime overhead in unexpected places, or worse
runtime introspection.

This proposal introduces syntax for lazy imports with a design that is local,
explicit, controlled, and granular. Each of these qualities is essential to
making the feature predictable and safe to use in practice.

The behavior is **local**: laziness applies only to the specific import marked
with the `lazy` keyword, and it does not cascade recursively into other
imports. This ensures that developers can reason about the effect of laziness
by looking only at the line of code in front of them, without worrying about
whether imported modules will themselves behave differently. A `lazy import`
is an isolated decision each time it is used, not a global shift in semantics.

The semantics are **explicit**. When a name is imported lazily, the binding is
created in the importing module immediately, but the target module is not
loaded until the first time the name is accessed. After this point, the
binding is indistinguishable from one created by a normal import. This clarity
reduces surprises and makes the feature accessible to developers who may not
be deeply familiar with Python’s import machinery.

Lazy imports are **controlled**, in the sense that lazy loading is only
triggered by the importing code itself. In the general case, a library will
only experience lazy imports if its own authors choose to mark them as such.
This avoids shifting responsibility onto downstream users and prevents
accidental surprises in library behavior. Since library authors typically
manage their own import subgraphs, they retain predictable control over when
and how laziness is applied.

The mechanism is also **granular**. It is introduced through explicit syntax
on individual imports, rather than a global flag or implicit setting. This
allows developers to adopt it incrementally, starting with the most
performance-sensitive areas of a codebase. As this feature is introduced to
the community, we want to make the experience of onboarding optional,
progressive, and adaptable to the needs of each project.

Lazy imports provide several concrete advantages:

* Command-line tools are often invoked directly by a user, so latency -- in
  particular startup latency -- is quite noticeable. These programs are also
  typically short-lived processes (contrasted with, e.g., a web server). With
  lazy imports, only the code paths actually reached will import a module.
  This can reduce startup time by 50-70% in practice, providing a significant
  improvement to a common user experience and improving Python's
  competitiveness in domains where fast startup matters most.

* Type annotations frequently require imports that are never used at runtime.
  The common workaround is to wrap them in `if TYPE_CHECKING:` blocks
  [#f1]_. With lazy imports, annotation-only imports impose no runtime
  penalty, eliminating the need for such guards and making annotated codebases
  cleaner.
* Large applications often import thousands of modules, and each module
  creates function and type objects, incurring memory costs. In long-lived
  processes, this noticeably raises baseline memory usage. Lazy imports defer
  these costs until a module is needed, keeping unused subsystems unloaded.
  Memory savings of 30-40% have been observed in real workloads.
## Rationale
The design of this proposal is centered on clarity, predictability, and ease
of adoption. Each decision was made to ensure that lazy imports provide
tangible benefits without introducing unnecessary complexity into the language
or its runtime.
It is also worth noting that while this PEP outlines one specific approach, we
list alternate implementation strategies for some of the core aspects and
semantics of the proposal. If the community expresses a strong preference for
a different technical path that still preserves the same core semantics or
there is fundamental disagreement over the specific option, we have included
the brainstorming we have already completed in preparation for this proposal
as reference.
The choice to introduce a new `lazy` keyword reflects the need for explicit
syntax. Lazy imports have different semantics from normal imports: errors and
side effects occur at first use rather than at the import statement. This
semantic difference makes it critical that laziness is visible at the import
site itself, not hidden in global configuration or distant module-level
declarations. The `lazy` keyword provides local reasoning about import
behavior, avoiding the need to search elsewhere in the code to understand
whether an import is deferred. The rest of the import semantics remain
unchanged: the same import machinery, module finding, and loading mechanisms
are used.
Another important decision is to represent lazy imports with proxy objects in
the module's namespace, rather than by modifying dictionary lookup. Earlier
approaches experimented with embedding laziness into dictionaries, but this
blurred abstractions and risked affecting unrelated parts of the runtime. The
dictionary is a fundamental data structure in Python -- literally every object
is built on top of dicts -- and adding hooks to dictionaries would prevent
critical optimizations and complicate the entire runtime. The proxy approach
is simpler: it behaves like a placeholder until first use, at which point it
resolves the import and rebinds the name. From then on, the binding is
indistinguishable from a normal import. This makes the mechanism easy to
explain and keeps the rest of the interpreter unchanged.
Compatibility for library authors was also a key concern. Many maintainers
need a migration path that allows them to support both new and old versions of
Python at once. For this reason, the proposal includes the
`!__lazy_modules__` global as a transitional mechanism. A module can
declare which imports should be treated as lazy (by listing the module names
as strings), and on Python 3.15 or later those imports will become lazy
automatically, as if they were imported with the `lazy` keyword. On earlier
versions the declaration is ignored, leaving imports eager. This gives authors
a practical bridge until they can rely on the keyword as the canonical syntax.
Finally, the feature is designed to be adopted incrementally. Nothing changes
unless a developer explicitly opts in, and adoption can begin with just a few
imports in performance-sensitive areas. This mirrors the experience of gradual
typing in Python: a mechanism that can be introduced progressively, without
forcing projects to commit globally from day one. Notably, the adoption can
also be done from the "outside in", permitting CLI authors to introduce lazy
imports and speed up user-facing tools, without requiring changes to every
library the tool might use.
### Other design decisions
* The scope of laziness is deliberately local and non-recursive. A lazy import
  only affects the specific statement where it appears; it does not cascade
  into other modules or submodules. This choice is crucial for predictability.
  When developers read code, they can reason about import behavior line by
  line, without worrying about hidden laziness deeper in the dependency graph.
  The result is a feature that is powerful but still easy to understand in
  context.
* In addition, it is useful to provide a mechanism to activate or deactivate
  lazy imports for all code running in the interpreter
  (referred to in this PEP as the 'global lazy imports flag').
  While the primary design centers the explicit `lazy import` syntax,
  there are scenarios -- such as large applications, testing environments,
  or frameworks -- where enabling laziness consistently across
  many modules provides the most benefit. A global switch makes it easy to
  experiment with or enforce consistent behavior, while still working in
  combination with the filtering API to respect exclusions or tool-specific
  configuration. This ensures that global adoption can be practical without
  reducing flexibility or control.
## Specification
### Grammar
A new soft keyword `lazy` is added. A soft keyword is a context-sensitive
keyword that only has special meaning in specific grammatical contexts;
elsewhere it can be used as a regular identifier (e.g., as a variable name).
The `lazy` keyword only has special meaning when it appears before import
statements:
```text
import_name:
    | 'lazy'? 'import' dotted_as_names
import_from:
    | 'lazy'? 'from' ('.' | '...')* dotted_name 'import' import_from_targets
    | 'lazy'? 'from' ('.' | '...')+ 'import' import_from_targets
```
#### Syntax restrictions
The soft keyword is only allowed at the global (module) level, **not** inside
functions, class bodies, `try` blocks, or `import *`. Import
statements that use the soft keyword are *potentially lazy*. Imports that
can't be lazy are unaffected by the global lazy imports flag, and instead are
always eager. Additionally, `from __future__ import` statements cannot be
lazy.
Examples of syntax errors:

```python
## SyntaxError: lazy import not allowed inside functions
def foo():
    lazy import json
## SyntaxError: lazy import not allowed inside classes
class Bar:
    lazy import json
## SyntaxError: lazy import not allowed inside try/except blocks
try:
    lazy import json
except ImportError:
    pass
## SyntaxError: lazy from ... import * is not allowed
lazy from json import *
## SyntaxError: lazy from __future__ import is not allowed
lazy from __future__ import annotations
```
### Semantics
When the `lazy` keyword is used, the import becomes *potentially lazy*
(see `Lazy imports filter`_ for advanced override mechanisms). The module is not
loaded immediately at the import statement; instead, a lazy proxy object is
created and bound to the name. The actual module is loaded on first use of
that name.

When using `lazy from ... import`, **each imported name** is bound to a lazy
proxy object. The first access to **any** of these names triggers loading of
the entire module and reifies **only that specific name** to its actual value.
Other names remain as lazy proxies until they are accessed. The interpreter's
adaptive specialization will optimize away the lazy checks after a few accesses.

Example with `lazy import`:

```python
import sys
lazy import json
print('json' in sys.modules)  # False - module not loaded yet
## First use triggers loading
result = json.dumps({"hello": "world"})
print('json' in sys.modules)  # True - now loaded
```
Example with `lazy from ... import`:

```python
import sys
lazy from json import dumps, loads
print('json' in sys.modules)           # False - module not loaded yet
## First use of 'dumps' triggers loading json and reifies ONLY 'dumps'
result = dumps({"hello": "world"})
print('json' in sys.modules)           # True - module now loaded
## Accessing 'loads' now reifies it (json already loaded, no re-import)
data = loads(result)
```
A module may define a `!__lazy_modules__` variable in its global scope,
which specifies which module names should be made *potentially lazy* (as if the
`lazy` keyword was used). This variable is checked on each `import`
statement to determine whether the import should be made *potentially lazy*.
The check is performed by calling `__contains__` on the
`!__lazy_modules__` object with a string containing the fully qualified
module name being imported. Typically, `!__lazy_modules__` is a set of
fully qualified module name strings. When a module is made lazy this way,
from-imports using that module are also lazy, but not necessarily imports of
sub-modules.

The normal (non-lazy) import statement will check the global lazy imports
flag. If it is "all", all imports are *potentially lazy* (except for
imports that can't be lazy, as mentioned above.)

Example:

```python
__lazy_modules__ = ["json"]
import json
print('json' in sys.modules)  # False
result = json.dumps({"hello": "world"})
print('json' in sys.modules)  # True
```
If the global lazy imports flag is set to "none", no *potentially lazy*
import is ever imported lazily, and the behavior is equivalent to a regular
import statement: the import is *eager* (as if the lazy keyword was not used).

Finally, the application may use a custom filter function on all *potentially
lazy* imports to determine if they should be lazy or not (this is an advanced
feature, see `Lazy imports filter`_). If a filter function is set, it will be
called with the name of the module doing the import, the name of the module
being imported, and (if applicable) the fromlist. An import remains lazy only
if the filter function returns `True`. If no lazy import filter is set, all
*potentially lazy* imports are lazy.
#### Note on .pth files
The lazy import mechanism does not apply to .pth files processed by the
`site` module. While .pth files have special handling for lines that begin
with `import` followed by a space or tab, this special handling will not be
adapted to support lazy imports. Imports specified in .pth files remain eager
as they always have been.
### Lazy objects
Lazy modules, as well as names lazy imported from modules, are represented
by `!types.LazyImportType` instances, which are resolved to the real
object (reified) before they can be used. This reification is usually done
automatically (see below), but can also be done by calling the lazy object's
`resolve` method.
### Lazy import mechanism
When an import is lazy, `__lazy_import__` is called instead of
`__import__`. `__lazy_import__` has the same function signature as
`__import__`. It adds the module name to `sys.lazy_modules`, a dict
mapping the fully-qualified name of the importing (parent) module to the
set of names that were lazily imported from it (primarily for diagnostics
and introspection), and returns a
`!types.LazyImportType` object for the module.

The implementation of `from ... import` (the `IMPORT_FROM` bytecode
implementation) checks if the module it's fetching from is a lazy module
object, and if so, returns a `!types.LazyImportType` for each name
instead.

The end result of this process is that lazy imports (regardless of how they
are enabled) result in lazy objects being assigned to global variables.

Lazy module objects do not appear in `sys.modules`, they're recorded in
the `sys.lazy_modules` dict (keyed by the importing module, with the set
of lazily-imported names as the value). Under normal operation lazy objects
should only
end up stored in global variables, and the common ways to access those
variables (regular variable access, module attributes) will resolve lazy
imports (reify) and replace them when they're accessed.

It is still possible to expose lazy objects through other means, like
debuggers. This is not considered a problem.

### Reification
When a lazy object is used, it needs to be reified. This means resolving the
import at that point in the program and replacing the lazy object with the
concrete one. Reification imports the module at that point in the program.
Notably, reification still calls `__import__` to resolve the import, which
uses the state of the import system (e.g. `sys.path`, `sys.meta_path`,
`sys.path_hooks` and `__import__`) at **reification** time, **not** the
state when the `lazy import` statement was evaluated.

When the module is reified, it's removed from `sys.lazy_modules` (even if
there are still other unreified lazy references to it). When a package is
reified and submodules in the package were also previously lazily imported,
those submodules are *not* automatically reified but they *are* added to the
reified package's globals (unless the package already assigned something
else to the name of the submodule).

If reification fails (e.g., due to an `ImportError`), the lazy object is
*not* reified or replaced. Subsequent uses of the lazy object will re-try
the reification. Exceptions that happen during reification are raised as
normal, but the exception is enhanced with chaining to show both where the
lazy import was defined and where it was accessed (even though it propagates
from the code that triggered reification). This provides clear debugging
information:

```python
## app.py - has a typo in the import
lazy from json import dumsp  # Typo: should be 'dumps'
print("App started successfully")
print("Processing data...")
## Error occurs here on first use
result = dumsp({"key": "value"})
```
The traceback shows both locations:

```pytb
App started successfully
Processing data...
Traceback (most recent call last):
  File "app.py", line 2, in <module>
    lazy from json import dumsp
ImportError: deferred import of 'json.dumsp' raised an exception during resolution
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
  File "app.py", line 8, in <module>
    result = dumsp({"key": "value"})
             ^^^^^
ImportError: cannot import name 'dumsp' from 'json'. Did you mean: 'dump'?
```
This exception chaining clearly shows:

(1) where the lazy import was defined,
(2) that the module was not eagerly imported, and
(3) where the actual access happened that triggered the error.

Reification does **not** automatically occur when a module that was previously
lazily imported is subsequently eagerly imported. Reification does **not**
immediately resolve all lazy objects (e.g. `lazy from` statements) that
referenced the module. It **only** resolves the lazy object being accessed.

Accessing a lazy object (from a global variable or a module attribute) reifies
the object.

However, calling `globals()` or accessing a module's `__dict__` does
**not** trigger reification -- they return the module's dictionary, and
accessing lazy objects through that dictionary still returns lazy proxy
objects that need to be manually reified upon use. A lazy object can be
resolved explicitly by calling the `resolve` method. Calling `dir()` at
the global scope will not reify the globals, nor will calling `dir(mod)`
(through special-casing in `mod.__dir__`.) Other, more indirect ways of
accessing arbitrary globals (e.g. inspecting `frame.f_globals`) also do
**not** reify all the objects.

Example using `globals()` and `__dict__`:

```python
## my_module.py
import sys
lazy import json
## Calling globals() does NOT trigger reification
g = globals()
print('json' in sys.modules)  # False - still lazy
print(type(g['json']))  # <class 'lazy_import'>
## Accessing __dict__ also does NOT trigger reification
d = __dict__
print(type(d['json']))  # <class 'lazy_import'>
## Explicitly reify using the resolve() method
resolved = g['json'].resolve()
print(type(resolved))  # <class 'module'>
print('json' in sys.modules)  # True - now loaded
```
## Install the filter
sys.set_lazy_imports_filter(exclude_side_effect_modules)

## These imports are checked by the filter
lazy import data_processor        # Filter returns True -> stays lazy
lazy import legacy_plugin_system  # Filter returns False -> imported eagerly
print('data_processor' in sys.modules)       # False - still lazy
print('legacy_plugin_system' in sys.modules) # True - loaded eagerly

## First use of data_processor triggers loading
result = data_processor.transform(data)
print('data_processor' in sys.modules)       # True - now loaded
```
### Global lazy imports control
*Note: This is an advanced feature. This is intended for application developers
and framework authors who need to control lazy imports across their entire
application. Library developers are discouraged from using the global activation
mechanism as it can affect the runtime execution of applications (similar to
`sys.setrecursionlimit()`, `sys.setswitchinterval()`, or
`gc.set_threshold()`).*

The global lazy imports flag can be controlled through:

* The `-X lazy_imports=<mode>` command-line option
* The `PYTHON_LAZY_IMPORTS=<mode>` environment variable
* The `sys.set_lazy_imports(mode)` function (primarily for testing)

The precedence order for setting the lazy imports mode follows the standard
Python pattern: `sys.set_lazy_imports()` takes highest precedence, followed
by `-X lazy_imports=<mode>`, then `PYTHON_LAZY_IMPORTS=<mode>`. If none
are specified, the mode defaults to `"normal"`.

Where `<mode>` can be:

* `"normal"` (or unset): Only explicitly marked lazy imports are lazy

* `"all"`: All module-level imports (except in `try`
  blocks and `import *`) become *potentially lazy*

* `"none"`: No imports are lazy, even those explicitly marked with
  `lazy` keyword

When the global flag is set to `"all"`, all imports at the global level
of all modules are *potentially lazy* **except** for those inside a `try`
block or any wild card (`from ... import *`) import.

If the global lazy imports flag is set to `"none"`, no *potentially
lazy* import is ever imported lazily, the import filter is never called, and
the behavior is equivalent to a regular `import` statement: the import is
*eager* (as if the lazy keyword was not used).

Python code can run the `!sys.set_lazy_imports` function to override
the state of the global lazy imports flag inherited from the environment or CLI.
This is especially useful if an application needs to ensure that all imports
are evaluated eagerly, via `sys.set_lazy_imports("none")`.

## Backwards Compatibility
Lazy imports are **opt-in**. Existing programs continue to run unchanged
unless a project explicitly enables laziness (via `lazy` syntax,
`!__lazy_modules__`, or an interpreter-wide switch).

### Unchanged semantics
* Regular `import` and `from ... import ...` statements remain eager
  unless explicitly made *potentially lazy* by the local or global mechanisms
  provided.
* Dynamic import APIs remain eager and unchanged: `__import__()` and
  `importlib.import_module()`.
* Import hooks and loaders continue to run under the standard import protocol
  when a lazy object is reified.

### Observable behavioral shifts (opt-in only)
These changes are limited to bindings explicitly made lazy:

* **Error timing.** Exceptions that would have occurred during an eager import
  (for example `ImportError` or `AttributeError` for a missing member) now
  occur at the *use* of the lazy name.

  ```python
  # With eager import - error at import statement
  import broken_module  # ImportError raised here
  # With lazy import - error deferred
  lazy import broken_module
  print("Import succeeded")
  broken_module.foo()  # ImportError raised here on use
  ```

* **Side-effect timing.** Import-time side effects in lazily imported modules
  occur at first use of the binding, not at module import time.
* **Import order.** Because modules are imported on first use, the order in
  which modules are imported may differ from how they appear in code.
* **Presence in `sys.modules`.** A lazily imported module does not appear in
  `sys.modules` until first use. After reification, it must appear in
  `sys.modules`. If some other code eagerly imports the same module before
  first use, the lazy binding resolves to that existing (lazy) module object
  when it is first used.
* **Proxy visibility.** Before first use, the bound name refers to a lazy
  proxy. Indirect introspection that touches the value may observe a proxy
  lazy object representation. After first use (provided the module was
  imported successfully), the name is rebound to the real object and becomes
  indistinguishable from an eager import.

### Thread-safety and reification
Reification follows the existing import-lock discipline. Exactly one thread
performs the import and **atomically rebinds** the importing module's global
to the resolved object. Concurrent readers thereafter observe the real
object.

Lazy imports are thread-safe and have no special considerations for
free-threading. A module that would normally be imported in the main thread
may be imported in a different thread if that thread triggers the first access
to the lazy import. This is not a problem: the import lock ensures thread
safety regardless of which thread performs the import.

Subinterpreters are supported. Each subinterpreter maintains its own
`sys.lazy_modules` and import state, so lazy imports in one subinterpreter
do not affect others.

### Performance
Lazy imports have **no measurable performance overhead**. The implementation
is designed to be performance-neutral for both code that uses lazy imports and
code that doesn't.

#### Runtime performance
After reification (provided the import was successful), lazy imports have
**zero overhead**. The adaptive interpreter specializes the bytecode
(typically after 2-3 accesses), eliminating any checks. For example,
`LOAD_GLOBAL` becomes `LOAD_GLOBAL_MODULE`, which directly accesses the
module identically to normal imports.

The `pyperformance suite`_ confirms the implementation is performance-neutral.

.. _pyperformance suite: https://github.com/facebookexperimental/
    free-threading-benchmarking/blob/main/results/bm-20250922-3.15.0a0-27836e5/
    bm-20250922-vultr-x86_64-DinoV-lazy_imports-3.15.0a0-27836e5-vs-base.svg
#### Filter function performance
The filter function (set via `sys.set_lazy_imports_filter()`) is called for
every *potentially lazy* import to determine whether it should actually be
lazy. When no filter is set, this is simply a NULL check (testing whether a
filter function has been registered), which is a highly predictable branch that
adds essentially no overhead. When a filter is installed, it is called for each
potentially lazy import, but this still has **almost no measurable performance
cost**. To measure this, we benchmarked importing all 278 top-level importable
modules from the Python standard library (which transitively loads 392 total
modules including all submodules and dependencies), then forced reification of
every loaded module to ensure everything was fully materialized.

Note that these measurements establish the baseline overhead of the filter
mechanism itself. Of course, any user-defined filter function that performs
additional work beyond a trivial check will add overhead proportional to the
complexity of that work. However, we expect that in practice this overhead
will be dwarfed by the performance benefits gained from avoiding unnecessary
imports. The benchmarks below measure the minimal cost of the filter dispatch
mechanism when the filter function does essentially nothing.

We compared four different configurations:

| Configuration | Mean ± Std Dev (ms) | Overhead vs Baseline |
|---|---|---|
| **Eager imports** (baseline) | 161.2 ± 4.3 | 0% |
| **Lazy + filter forcing eager** | 161.7 ± 4.2 | +0.3% ± 3.7% |
| **Lazy + filter allowing lazy + reification** | 162.0 ± 4.0 | +0.5% ± 3.7% |
| **Lazy + no filter + reification** | 161.4 ± 4.3 | +0.1% ± 3.8% |

The four configurations:

1. **Eager imports (baseline)**: Normal Python imports with no lazy machinery.
   Standard Python behavior.

2. **Lazy + filter forcing eager**: Filter function returns `False` for all
   imports, forcing eager execution, then all imports are reified at script
   end. Measures pure filter calling overhead since every import goes through
   the filter but executes eagerly.

3. **Lazy + filter allowing lazy + reification**: Filter function returns
   `True` for all imports, allowing lazy execution. All imports are reified
   at script end. Measures filter overhead when imports are actually lazy.

4. **Lazy + no filter + reification**: No filter installed, imports are lazy
   and reified at script end. Baseline for lazy behavior without filter.

The benchmarks used [hyperfine](https://github.com/sharkdp/hyperfine),
testing 278 standard library modules. Each ran in a fresh Python process.
All configurations force the import of exactly the same set of modules
(all modules loaded by the eager baseline) to ensure a fair comparison.

The benchmark environment used CPU isolation with 32 logical CPUs (0-15 at
3200 MHz, 16-31 at 2400 MHz), the performance scaling governor, Turbo Boost
disabled, and full ASLR randomization. The overhead error bars are computed
using standard error propagation for the formula ``(value - baseline) /
baseline``, accounting for uncertainties in both the measured value and the
baseline.

#### Startup time improvements
The primary performance benefit of lazy imports is reduced startup time by
loading only the modules actually used at runtime, rather than optimistically
loading entire dependency trees at startup.

Real-world deployments at scale have demonstrated that the benefits can be
massive, though of course this depends on the specific codebase and usage
patterns. Organizations with large, interconnected codebases have reported
substantial reductions in server reload times, ML training initialization,
command-line tool startup, and Jupyter notebook loading. Memory usage
improvements have also been observed as unused modules remain unloaded.

For detailed case studies and performance data from production deployments,
see:

- [Python Lazy Imports With Cinder](https://developers.facebook.com/blog/post/2022/06/15/python-lazy-imports-with-cinder/)
  (Meta Instagram Server)
- [Lazy is the new fast: How Lazy Imports and Cinder accelerate machine learning at Meta](https://engineering.fb.com/2024/01/18/developer-tools/lazy-imports-cinder-machine-learning-meta/)
  (Meta ML Workloads)
- [Inside HRT's Python Fork](https://www.hudsonrivertrading.com/hrtbeat/inside-hrts-python-fork/)
  (Hudson River Trading)
- [Create an On-Demand Initializer for PySide](https://bugreports.qt.io/browse/PYSIDE-2404)
  (Qt for Python/PySide) - Christian Tismer's implementation of lazy
  initialization for PySide6 based on ideas from PEP 690, showing 10-20%
  startup time improvement for PySide applications. This demonstrates the
  particular value of lazy imports for frameworks with extensive
  initialization at import time.

The benefits scale with codebase complexity: the larger and more
interconnected the codebase, the more dramatic the improvements. The
PySide implementation particularly highlights how frameworks with heavy
initialization overhead can benefit significantly from opt-in lazy loading.

### Typing and tools
Type checkers and static analyzers may treat `lazy` imports as ordinary
imports for name resolution. At runtime, annotation-only imports can be marked
`lazy` to avoid startup overhead. IDEs and debuggers should be prepared to
display lazy proxies before first use and the real objects thereafter.

## Security Implications
Tools that install packages while performing imports from that the same
environment should ensure all modules are imported eagerly, or reified, before
the installation step, to avoid newly installed distributions from shadowing
them.

Such tools can use `!sys.set_lazy_imports` with `"none"` to
force eager evaluation, or provide a `!sys.set_lazy_imports_filter` function for
fine-grained control.

## How to Teach This
The new `lazy` keyword will be documented as part of the language standard.

As this feature is opt-in, new Python users should be able to continue using
the language as they are used to. For experienced developers, we expect them
to leverage lazy imports for the variety of benefits listed above (decreased
latency, decreased memory usage, etc) on a case-by-case basis. Developers
interested in the performance of their Python binary will likely leverage
profiling to understand the import time overhead in their codebase and mark
the necessary imports as `lazy`. In addition, developers can mark imports
that will only be used for type annotations as `lazy`.

Additional documentation will be added to the Python documentation, including
guidance, a dedicated how-to guide, and updates to the import system
documentation covering: identifying slow-loading modules with profiling tools
(such as `-X importtime`), migration strategies for existing codebases, best
practices for avoiding common pitfalls with import-time side effects, and
patterns for using lazy imports effectively with type annotations and circular
imports.

Below is guidance on how to best take advantage of lazy imports and how to
avoid incompatibilities:

* When adopting lazy imports, users should be aware that eliding an import
  until it is used will result in side effects not being executed. In turn,
  users should be wary of modules that rely on import time side effects.
  Perhaps the most common reliance on import side effects is the registry
  pattern, where population of some external registry happens implicitly
  during the importing of modules, often via decorators but sometimes
  implemented via metaclasses or `__init_subclass__`. Instead, registries of
  objects should be constructed via explicit discovery processes (e.g. a
  well-known function to call).

  ```python
  # Problematic: Plugin registers itself on import
  # my_plugin.py
  from plugin_registry import register_plugin
  @register_plugin("MyPlugin")
  class MyPlugin:
      pass
  # In main code:
  lazy import my_plugin
  # Plugin NOT registered yet - module not loaded!
  # Better: Explicit discovery
  # plugin_registry.py
  def discover_plugins():
      from my_plugin import MyPlugin
      register_plugin(MyPlugin)
  # In main code:
  plugin_registry.discover_plugins()  # Explicit loading
  ```

* Always import needed submodules explicitly. It is not enough to rely on a
  different import to ensure a module has its submodules as attributes.
  Plainly, unless there is an explicit `from . import bar` in
  `foo/__init__.py`, always use `import foo.bar; foo.bar.Baz`, not
  `import foo; foo.bar.Baz`. The latter only works (unreliably) because the
  attribute `foo.bar` is added as a side effect of `foo.bar` being
  imported somewhere else.

* Users who are moving imports into functions to improve startup time, should
  instead consider keeping them where they are but adding the `lazy`
  keyword. This allows them to keep dependencies clear and avoid the overhead
  of repeatedly re-resolving the import but will still speed up the program.

  ```python
  # Before: Inline import (repeated overhead)
  def process_data(data):
      import json  # Re-resolved on every call
      return json.dumps(data)
  # After: Lazy import at module level
  lazy import json
  def process_data(data):
      return json.dumps(data)  # Loaded once on first call
  ```

* Avoid using wild card (star) imports, as those are always eager.

## FAQ
### How does this differ from the rejected PEP 690?
PEP 810 takes an explicit, opt-in approach instead of PEP 690's implicit
global approach. The key differences are:

- **Explicit syntax**: `lazy import foo` clearly marks which imports are
  lazy.
- **Local scope**: Laziness only affects the specific import statement, not
  cascading to dependencies.
- **Simpler implementation**: Uses proxy objects instead of modifying core
  dictionary behavior.

### What changes at reification time? What stays the same?
**What changes (the timing):**

* **When** the module is imported - deferred to first use instead of at the
  import statement
* **When** import errors occur - at first use rather than at import time
* **When** module-level side effects execute - at first use rather than at
  import time

**What stays the same (everything else):**

* The import machinery used - same `__import__`, same hooks, same loaders
* The module object created - identical to an eagerly imported module
* Import state consulted - `sys.path`, `sys.meta_path`, etc. at
  **reification time** (not at import statement time)
* Module attributes and behavior - completely indistinguishable after
  reification
* Thread safety - same import lock discipline as normal imports

In other words: lazy imports only change **when** something happens, not
**what** happens. After reification, a lazy-imported module is
indistinguishable from an eagerly imported one.

### What happens when lazy imports encounter errors?
Import errors (`ImportError`, `ModuleNotFoundError`, syntax errors) are
deferred until first use of the lazy name. This is similar to moving an import
into a function. The error will occur with a clear traceback pointing to the
first access of the lazy object.

The implementation provides enhanced error reporting through exception
chaining. When a lazy import fails during reification, the original exception
is preserved and chained, showing both where the import was defined and where
it was first used:

```pytb
Traceback (most recent call last):
  File "test.py", line 1, in <module>
    lazy import broken_module
ImportError: deferred import of 'broken_module' raised an exception during resolution
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    broken_module.foo()
    ^^^^^^^^^^^^^
  File "broken_module.py", line 2, in <module>
    1/0
ZeroDivisionError: division by zero
```
Exceptions during reification prevent the replacement of the lazy object,
and subsequent uses of the lazy object will retry the whole reification.

### How do lazy imports affect modules with import-time side effects?
Side effects are deferred until first use. This is generally desirable for
performance, but may require code changes for modules that rely on import-time
registration patterns. We recommend:

- Use explicit initialization functions instead of import-time side effects
- Call initialization functions explicitly when needed
- Avoid relying on import order for side effects

### Can I use lazy imports with `from ... import ...` statements?
Yes, as long as you don't use `from ... import *`. Both ``lazy import
foo` and `lazy from foo import bar` are supported. The `bar`` name will be
bound to a lazy object that resolves to `foo.bar` on first use.

### Does `lazy from module import Class` load the entire module or just the class?
It loads the **entire module**, not just the class. This is because
Python's import system always executes the complete module file -- there's no
mechanism to execute only part of a `.py` file. When you first access
`Class`, Python:

1. Loads and executes the entire `module.py` file
2. Extracts the `Class` attribute from the resulting module object
3. Binds `Class` to the name in your namespace

This is identical to eager `from module import Class` behavior. The only
difference with lazy imports is that steps 1-3 happen on first use instead of
at the import statement.

```python
## heavy_module.py
print("Loading heavy_module")  # This ALWAYS runs when module loads
class MyClass:
    pass
class UnusedClass:
    pass  # Also gets defined, even though we don't import it
## app.py
lazy from heavy_module import MyClass
print("Import statement done")  # heavy_module not loaded yet
obj = MyClass()                  # NOW "Loading heavy_module" prints
                                 # (and UnusedClass gets defined too)
```
**Key point**: Lazy imports defer *when* a module loads, not *what* gets
loaded. You cannot selectively load only parts of a module -- Python's import
system doesn't support partial module execution.

### What about type annotations and `TYPE_CHECKING` imports?
Lazy imports eliminate the common need for `TYPE_CHECKING` guards. You
can write:

```python
lazy from collections.abc import Sequence, Mapping  # No runtime cost
def process(items: Sequence[str]) -> Mapping[str, int]:
    ...
```
Instead of:

```python
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from collections.abc import Sequence, Mapping
def process(items: Sequence[str]) -> Mapping[str, int]:
    ...
```
### What's the performance overhead of lazy imports?
The overhead is minimal:

- Zero overhead after first use (provided the import doesn't fail) thanks to
  the adaptive interpreter optimizing the slow path away.
- Small one-time cost to create the proxy object.
- Reification (first use) has the same cost as a regular import.
- No ongoing performance penalty.

Benchmarking with the `pyperformance suite`_ shows the implementation is
performance neutral when lazy imports are not used.

.. _pyperformance suite: https://github.com/facebookexperimental/
    free-threading-benchmarking/blob/main/results/bm-20250922-3.15.0a0-27836e5/
    bm-20250922-vultr-x86_64-DinoV-lazy_imports-3.15.0a0-27836e5-vs-base.svg
### Can I mix lazy and eager imports of the same module?
Yes. If module `foo` is imported both lazily and eagerly in the same
program, the eager import takes precedence and both bindings resolve to the
same module object.
### How do I migrate existing code to use lazy imports?
Migration is incremental:
1. Identify slow-loading modules using profiling tools.
2. Add `lazy` keyword to imports that aren't needed immediately.
3. Test that side-effect timing changes don't break functionality.
4. Use `!__lazy_modules__` for compatibility with older Python versions.
### What about star imports (`from module import *`)?
Wild card (star) imports cannot be lazy - they remain eager. This is
because the set of names being imported cannot be determined without loading
the module. Using the `lazy` keyword with star imports will be a syntax
error. If lazy imports are globally enabled, star imports will still be eager.
### How do lazy imports interact with import hooks and custom loaders?
Import hooks and loaders work normally. When a lazy object is used,
the standard import protocol runs, including any custom hooks or loaders that
were in place at reification time.
### What happens in multi-threaded environments?
Lazy import reification is thread-safe. Only one thread will perform the
actual import, and the binding is atomically updated. Other threads will see
either the lazy proxy or the final resolved object.
### Can I force reification of a lazy import without using it?
Yes, individual lazy objects can be resolved by calling their `resolve()`
method.
### Why not use `importlib.util.LazyLoader` instead?
The standard library's `~importlib.util.LazyLoader` was designed for
specific use cases but has fundamental limitations as a general-purpose lazy
import mechanism.
Most critically, `LazyLoader` does not support `from ... import` statements.
There is no straightforward mechanism to lazily import specific attributes from
a module - users would need to manually wrap and proxy individual attributes,
which is both error-prone and defeats the performance benefits.
Additionally, `LazyLoader` must resolve the module spec before creating the
lazy loader, which introduces overhead that reduces the performance benefits of
lazy loading. The spec resolution involves filesystem operations and path
searching that this PEP's approach defers until actual module use.
`LazyLoader` also operates at the import machinery level rather than providing
language-level syntax, which means there's no canonical way for tools like
linters and type checkers to recognize lazy imports. A dedicated syntax enables
ecosystem-wide standardization and allows compiler and runtime optimizations
that would be impossible with a purely library-based approach.
Finally, `LazyLoader` requires significant boilerplate, involving manual
manipulation of module specs, loaders, and `sys.modules`, making it impractical
for common use cases where multiple modules need to be lazily imported.
### Will this break tools like `isort` or `black`?
Linters, formatters, and other tools will need updates to recognize
the `lazy` keyword, but the changes should be minimal since the import
structure remains the same. The keyword appears at the beginning,
making it easy to parse.
### How do I know if a library is compatible with lazy imports?
Most libraries should work fine with lazy imports. Libraries that might
have issues:
- Those with essential import-time side effects (registration,
  monkey-patching).
- Those that expect specific import ordering.
- Those that modify global state during import.
When in doubt, test lazy imports with your specific use cases.
### What happens if I globally enable lazy imports mode and a library doesn't work correctly?
*Note: This is an advanced feature.* You can use the lazy imports filter to
exclude specific modules that are known to have problematic side effects:
```python
import sys
def my_filter(importer, name, fromlist):
    # Don't lazily import modules known to have side effects
    if name in {'problematic_module', 'another_module'}:
        return False  # Import eagerly
    return True  # Allow lazy import
sys.set_lazy_imports_filter(my_filter)
```
The filter function receives the importer module name, the module being
imported, and the fromlist (if using `from ... import`). Returning `False`
forces an eager import.
Alternatively, set the global mode to `"none"` via ``-X
lazy_imports=none`` to turn off all lazy imports for debugging.
### Can I use lazy imports inside functions?
No, the `lazy` keyword is only allowed at module level. For
function-level lazy loading, use traditional inline imports or move the import
to module level with `lazy`.
### What about forwards compatibility with older Python versions?
Use the `!__lazy_modules__` global for compatibility:
```python
## Works on Python 3.15+ as lazy, eager on older versions
__lazy_modules__ = ['expensive_module', 'expensive_module_2']
import expensive_module
from expensive_module_2 import MyClass
```
The `!__lazy_modules__` attribute is a list of module name strings. When
an import statement is executed, Python checks if the module name being
imported appears in `!__lazy_modules__`. If it does, the import is
treated as if it had the `lazy` keyword (becoming *potentially lazy*). On
Python versions before 3.15 that don't support lazy imports, the
`!__lazy_modules__` attribute is simply ignored and imports proceed
eagerly as normal.
This provides a migration path until you can rely on the `lazy` keyword. For
maximum predictability, it's recommended to define `!__lazy_modules__`
once, before any imports. But as it is checked on each import, it can be
modified between `import` statements.
### How do explicit lazy imports interact with PEP 649 and PEP 749?
Python 3.14 implemented deferred evaluation of annotations,
as specified by PEP 649 and PEP 749.
If an annotation is not stringified, it is an expression that is evaluated
at a later time. It will only be resolved if the annotation is accessed. In
the example below, the `fake_typing` module is only loaded when the user
inspects the `__annotations__` dictionary. The `fake_typing` module would
also be loaded if the user uses `annotationlib.get_annotations()` or
`getattr` to access the annotations.
```python
lazy from fake_typing import MyFakeType
def foo(x: MyFakeType):
  pass
print(foo.__annotations__)  # Triggers loading the fake_typing module
```
### How do lazy imports interact with `dir()`, `getattr()`, and module introspection?
Accessing lazy imports through normal attribute access or `getattr()`
will trigger reification of the accessed attribute. Calling `dir()` on a
module will be special cased in `mod.__dir__` to avoid reification.
```python
lazy import json
## Before any access
## json not in sys.modules
## Any of these trigger reification:
dumps_func = json.dumps
dumps_func = getattr(json, 'dumps')
## Now json is in sys.modules
```
### Do lazy imports work with circular imports?
Lazy imports don't automatically solve circular import problems. If two
modules have a circular dependency, making the imports lazy might help **only
if** the circular reference isn't accessed during module initialization.
However, if either module accesses the other during import time, you'll still
get an error.
**Example that works** (deferred access in functions):
```python
## user_model.py
lazy import post_model
class User:
    def get_posts(self):
        # OK - post_model accessed inside function, not during import
        return post_model.Post.get_by_user(self.name)
## post_model.py
lazy import user_model
class Post:
    @staticmethod
    def get_by_user(username):
        return f"Posts by {username}"
```
This works because neither module accesses the other at module level -- the
access happens later when `get_posts()` is called.
**Example that fails** (access during import):
```python
## module_a.py
lazy import module_b
result = module_b.get_value()  # Error! Accessing during import
def func():
    return "A"
## module_b.py
lazy import module_a
result = module_a.func()  # Circular dependency error here
def get_value():
    return "B"
```
This fails because `module_a` tries to access `module_b` at import time,
which then tries to access `module_a` before it's fully initialized.
The best practice is still to avoid circular imports in your code design.
### Will lazy imports affect the performance of my hot paths?
After first use (provided the import succeed), lazy imports have **zero
overhead** thanks to the adaptive interpreter. The interpreter specializes
the bytecode (e.g., `LOAD_GLOBAL` becomes `LOAD_GLOBAL_MODULE`) which
eliminates the lazy check on subsequent accesses. This means once a lazy
import is reified, accessing it is just as fast as a normal import.
```python
lazy import json
def use_json():
    return json.dumps({"test": 1})
## First call triggers reification
use_json()
## After 2-3 calls, bytecode is specialized
use_json()
use_json()
```
You can observe the specialization using `dis.dis(use_json, adaptive=True)`:
```text
=== Before specialization ===
LOAD_GLOBAL              0 (json)
LOAD_ATTR                2 (dumps)
=== After 3 calls (specialized) ===
LOAD_GLOBAL_MODULE       0 (json)
LOAD_ATTR_MODULE         2 (dumps)
```
The specialized `LOAD_GLOBAL_MODULE` and `LOAD_ATTR_MODULE` instructions
are optimized fast paths with no overhead for checking lazy imports.
### What about `sys.modules`? When does a lazy import appear there?
A lazily imported module does **not** appear in `sys.modules` until it's
reified (first used). Once reified, it appears in `sys.modules` just like
any eager import.
```python
import sys
lazy import json
print('json' in sys.modules)  # False
result = json.dumps({"key": "value"})  # First use
print('json' in sys.modules)  # True
```
### Does `lazy from __future__ import feature` work?
No, future imports can't be lazy because they're parser/compiler directives.
It's technically possible for the runtime behavior to be lazy but there's no
real value in it.

### Why did you choose `lazy` as the keyword name?
Not "why"... memorize! :)

## Deferred Ideas
The following ideas have been considered but are deliberately deferred to focus
on delivering a stable, usable core feature first. These may be considered for
future enhancements once we have real-world experience with lazy imports.

### Alternative syntax and ergonomic improvements
Several alternative syntax forms have been suggested to improve ergonomics:

* **Type-only imports**: A specialized syntax for imports used exclusively in
  type annotations (similar to the `type` keyword in other contexts) could be
  added, such as `type from collections.abc import Sequence`. This would make
  the intent clearer than using `lazy` for type-only imports and would signal
  to readers that the import is never used at runtime. However, since `lazy`
  imports already solve the runtime cost problem for type annotations, we prefer
  to start with the simpler, more general mechanism and evaluate whether
  specialized syntax adds sufficient value after gathering usage data.

* **Block-based syntax**: Grouping multiple lazy imports in a block, such as:

  ```python
  as lazy:
      import foo
      from bar import baz
  ```

  This could reduce repetition when marking many imports as lazy. However, it
  would require introducing an entirely new statement form (`as lazy:` blocks)
  that doesn't fit into Python's existing grammar patterns. It's unclear how
  this would interact with other language features or what the precedent would
  be for similar block-level modifiers. This approach also makes it less clear
  when scanning code whether a particular import is lazy, since you must look at
  the surrounding context rather than the import line itself.

While these alternatives could provide different ergonomics in certain contexts,
they share similar drawbacks: they would require introducing new statement
forms or overloading existing syntax in non-obvious ways, and they open the
door to many other potential uses of similar syntax patterns that would
significantly expand the language. We prefer to start with the explicit
`lazy import` syntax and gather real-world feedback before considering
additional syntax variations. Any future ergonomic improvements should be
evaluated based on actual usage patterns rather than speculative benefits.

### Automatic lazy imports for `if TYPE_CHECKING` blocks
A future enhancement could automatically treat all imports inside
`if TYPE_CHECKING:` blocks as lazy:

```python
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from foo import Bar  # Could be automatically lazy
```
However, this would require significant changes to make this work at compile
time, since `TYPE_CHECKING` is currently just a runtime variable. The
compiler would need special knowledge of this pattern, similar to how
`from __future__ import` statements are handled. Additionally, making
`TYPE_CHECKING` a built-in would be required for this to work reliably.
Since `lazy` imports already solve the runtime cost problem for type-only
imports, we prefer to start with the explicit syntax and evaluate whether
this optimization adds sufficient value.

### Module-level lazy import mode
A module-level declaration to make all imports in that module lazy by default:

```python
from __future__ import lazy_imports
import foo  # Automatically lazy
```
This was discussed but deferred because it raises several questions. Using
`from __future__ import` implies this would become the default behavior in a
future Python version, which is unclear and not currently planned. It also
raises questions about how such a mode would interact with the global flag and
what the transition path would look like. The current explicit syntax and
`__lazy_modules__` provide sufficient control for initial adoption.

### Package metadata for lazy-safe declarations
Future enhancements could allow packages to declare in their metadata whether
they are safe for lazy importing (e.g., no import-time side effects). This
could be used by the filter mechanism or by static analysis tools. The current
filter API is designed to accommodate such future additions without requiring
changes to the core language specification.

### C API for lazy imports
No C API is provided for *creating or resolving individual* lazy imports: that
mechanism stays purely Python-facing, and existing C API functions like
`PyImport_ImportModule()` are unchanged and continue to perform eager imports,
since C extensions typically need immediate access to modules and cannot
benefit from deferred loading. The global mode and filter controls, on the
other hand, are mirrored at the C level so that embedders and the runtime can
configure lazy importing directly: `Include/import.h` defines a
`PyImport_LazyImportsMode` enum (`PyImport_LAZY_NORMAL`, `PyImport_LAZY_ALL`,
`PyImport_LAZY_NONE`) alongside `PyImport_SetLazyImportsMode()` and
`PyImport_GetLazyImportsMode()`, the C-level counterparts of
`sys.set_lazy_imports()` and `sys.get_lazy_imports()`, and
`PyImport_SetLazyImportsFilter()` and `PyImport_GetLazyImportsFilter()`, which
back `sys.set_lazy_imports_filter()` and `sys.get_lazy_imports_filter()` and
raise `ValueError` when given a non-callable filter. These are the same entry
points exercised from Python through the standard `_testcapi` adapter. If
compelling use cases emerge for a lower-level lazy-import C API, that could be
revisited in future versions.

## Alternate Implementation Ideas
Here are some alternative design decisions that were considered during the
development of this PEP. While the current proposal represents what we believe
to be the best balance of simplicity, performance, and maintainability, these
alternatives offer different trade-offs that may be valuable for implementers
to consider or for future refinements.

### Leveraging a subclass of dict
Instead of updating the internal dict object to directly add the fields needed
to support lazy imports, we could create a subclass of the dict object to be
used specifically for Lazy Import enablement. This would still be a leaky
abstraction though - methods can be called directly such as
`dict.__getitem__` and it would impact the performance of globals lookup in
the interpreter.

### Alternate keyword names
For this PEP, we decided to propose `lazy` for the explicit keyword as it
felt the most familiar to those already focused on optimizing import overhead.
We also considered a variety of other options to support explicit lazy
imports. The most compelling alternates were `defer` and `delay`.

## Rejected Ideas
### Making the new behavior the default
Changing `import` to be lazy by default is outside of the scope of this PEP.
From the discussion on PEP 690 it is clear that this is a fairly
contentious idea, although perhaps once we have wide-spread use of lazy
imports this can be reconsidered.

### Supporting `__lazy_modules__ = ["*"]` as built-in syntax
The suggestion to support `__lazy_modules__ = ["*"]` as a convenient way to
make all imports in a module lazy without explicit enumeration has been
considered. This approach was rejected because `!__lazy_modules__` already
represents implicit action-at-a-distance behavior that is tolerated solely as a
backwards compatibility mechanism. Extending support to wildcard patterns would
significantly increase implementation complexity and invite scope creep into
pattern matching and globbing functionality. As `!__lazy_modules__` is a
permanent language feature that cannot be removed in future versions, the design
prioritizes minimalism and restricts its scope to serving as a transitional tool
for backwards compatibility.
It is worth noting that the implementation performs membership checks by calling
`__contains__` on the `!__lazy_modules__` object. Consequently, users
requiring wildcard behavior may provide a custom object implementing
`__contains__` to return `True` for all queries or other desired patterns.
This design provides the necessary flexibility for advanced use cases while
maintaining a simple, focused specification for the primary mechanism. If this PEP is accepted, adding
such helper objects to the standard library can be discussed in a future issue. Presently, it is out of scope for this PEP.
### Disallowing lazy imports inside `with` blocks
An earlier version of this PEP proposed disallowing `lazy import` statements
inside `with` blocks, similar to the restriction on `try` blocks. The
concern was that certain context managers (like `contextlib.suppress(ImportError)`)
could suppress import errors in confusing ways when combined with lazy imports.
However, this restriction was rejected because `with` statements have much
broader semantics than `try/except` blocks. While `try/except` is explicitly
about catching exceptions, `with` blocks are commonly used for resource
management, temporary state changes, or scoping -- contexts where lazy imports
work perfectly fine. The `lazy import` syntax is explicit enough that
developers who write it inside a `with` block are making an intentional choice,
aligning with Python's "consenting adults" philosophy. For genuinely problematic
cases like `with suppress(ImportError): lazy import foo`, static analysis
tools and linters are better suited to catch these patterns than hard language
restrictions.
### Forcing eager imports in `with` blocks under the global flag
Another rejected idea was to make imports inside `with` blocks remain eager
even when the global lazy imports flag is set to `"all"`. The rationale was
to be conservative: since `with` statements can affect how imports behave
(e.g., by modifying `sys.path` or suppressing exceptions), forcing imports to
remain eager could prevent subtle bugs. However, this would create inconsistent
behavior where `lazy import` is allowed explicitly in `with` blocks, but
normal imports remain eager when the global flag is enabled. This inconsistency
between explicit and implicit laziness is confusing and hard to explain.
The simpler, more consistent rule is that the global flag affects imports
everywhere that explicit `lazy import` syntax is allowed. This avoids having
three different sets of rules (explicit syntax, global flag behavior, and filter
mechanism) and instead provides two: explicit syntax rules match what the global
flag affects, and the filter mechanism provides escape hatches for edge cases.
For users who need fine-grained control, the filter mechanism
(`sys.set_lazy_imports_filter()`) already provides a way to exclude specific
imports or patterns. Additionally, there's no inverse operation: if the global
flag forces imports eager in `with` blocks but a user wants them lazy, there's
no way to override it, creating an asymmetry.
In summary: imports in `with` blocks behave consistently whether marked
explicitly with `lazy import` or implicitly via the global flag, creating a
simple rule that's easy to explain and reason about.
### Modification of the dict object
The initial PEP for lazy imports (PEP 690) relied heavily on the modification
of the internal dict object to support lazy imports. We recognize that this
data structure is highly tuned, heavily used across the codebase, and very
performance sensitive. Because of the importance of this data structure and
the desire to keep the implementation of lazy imports encapsulated from users
who may have no interest in the feature, we've decided to invest in an
alternate approach.
The dictionary is the foundational data structure in Python. Every object's
attributes are stored in a dict, and dicts are used throughout the runtime for
namespaces, keyword arguments, and more. Adding any kind of hook or special
behavior to dicts to support lazy imports would:
1. Prevent critical interpreter optimizations including future JIT
   compilation.
2. Add complexity to a data structure that must remain simple and fast.
3. Affect every part of Python, not just import behavior.
4. Violate separation of concerns -- the hash table shouldn't know about the
   import system.
Past decisions that violated this principle of keeping core abstractions clean
have caused significant pain in the CPython ecosystem, making optimization
difficult and introducing subtle bugs.
### Transforming lazy objects via `__class__` mutation
An alternative implementation approach was proposed where lazy import objects
would be transformed into their final form by mutating their internal state,
rather than replacing the object entirely. Under this approach, a lazy object
would be transformed in-place after the actual import completes.
This approach was rejected for several reasons:
1. This technique could potentially work for module objects, but breaks down
   completely for arbitrary objects imported via `from` statements. When a
   user writes `lazy from foo import bar`, the object `bar` could be any
   Python object (a function, class, constant, etc.), not just a module. Any
   transformation approach would require that the lazy proxy object have
   compatible memory layout and other considerations with the target object,
   which is impossible to know before loading the module. This creates a
   fundamental asymmetry where `lazy import x` and `lazy from x import y`
   would require completely different implementation strategies, with the latter
   still needing the proxy replacement mechanism.
2. Even for module objects, the approach has fundamental limitations. Some
   implementations substitute custom classes in `sys.modules` that inherit
   from or replace the standard module type. These custom module classes can
   have different memory layouts and sizes than `PyModuleObject`. The
   transformation approach cannot work with such generic custom module
   implementations, creating fragility and maintenance burden across the
   ecosystem.
3. While the transformation approach might appear simpler in some respects, this
   is somewhat subjective. It introduces a bifurcated implementation: one path
   for modules and a completely different path for non-module objects. Whether
   this is simpler than a unified proxy mechanism depends on perspective and
   implementation details.
4. Any code holding a reference to the object before transformation will see a
   different type after transformation. This can break code that checks object
   types or relies on type stability, particularly C extensions that cache type
   pointers or use `PyObject_TypeCheck`. The transformation also requires
   careful coordination between the lazy import machinery and the type system to
   ensure that the object remains valid throughout the transformation process.
   The current proxy-based design avoids these issues by maintaining clear
   boundaries between the lazy proxy and the actual imported object.
The current design, which uses object replacement through the `LazyImportType`
proxy pattern, provides a consistent mechanism that works uniformly for both
`import` and `from ... import` statements while maintaining cleaner
separation between the lazy import machinery and Python's core object model.
### Making `lazy` imports find the module without loading it
The Python `import` machinery separates out finding a module and loading
it, and the lazy import implementation could technically defer only the
loading part. However, this approach was rejected for several critical reasons.
A significant part of the performance win comes from skipping the finding phase.
The issue is particularly acute on NFS-backed filesystems and distributed
storage, where each `stat()` call incurs network latency. In these kinds of
environments, `stat()` calls can take tens to hundreds of milliseconds
depending on network conditions. With dozens of imports each doing multiple
filesystem checks traversing `sys.path`, the time spent finding modules
before executing any Python code can become substantial. In some measurements,
spec finding accounts for the majority of total import time. Skipping only the
loading phase would leave most of the performance problem unsolved.
More critically, separating finding from loading creates the worst of both
worlds for error handling. Some exceptions from the import machinery (e.g.,
`ImportError` from a missing module, path resolution failures,
`ModuleNotFoundError`) would be raised at the `lazy import` statement, while
others (e.g., `SyntaxError`, `ImportError` from circular imports, attribute
errors from `from module import name`) would be raised later at first use.
This split is both confusing and unpredictable: developers would need to
understand the internal import machinery to know which errors happen when. The
current design is simpler: with full lazy imports, all import-related errors
occur at first use, making the behavior consistent and predictable.
Additionally, there are technical limitations: finding the module does not
guarantee the import will succeed, nor even that it will not raise ImportError.
Finding modules in packages requires that those packages are loaded, so it
would only help with lazy loading one level of a package hierarchy. Since
"finding" attributes in modules *requires* loading them, this would create a
hard to explain difference between `from package import module` and
`from module import function`.
### Placing the `lazy` keyword in the middle of from imports
While we found `from foo lazy import bar` to be a really intuitive placement
for the new explicit syntax, we quickly learned that placing the `lazy`
keyword here is already syntactically allowed in Python. This is because
`from . lazy import bar` is legal syntax (because whitespace does not
matter.)
### Placing the `lazy` keyword at the end of import statements
We discussed appending lazy to the end of import statements like such ``import
foo lazy` or `from foo import bar, baz lazy`` but ultimately decided that
this approach provided less clarity. For example, if multiple modules are
imported in a single statement, it is unclear if the lazy binding applies to
all of the imported objects or just a subset of the items.
### Adding an explicit `eager` keyword
Since we're not changing the default behavior, and we don't want to
encourage use of the global flags, it's too early to consider adding
superfluous syntax for the common, default case. It would create too much
confusion about what the default is, or when the `eager` keyword would be
necessary, or whether it affects lazy imports *in* the explicitly eagerly
imported module.
### Allowing the filter to force lazy imports even when globally disabled
As lazy imports allow some forms of circular imports that would otherwise
fail, as an intentional and desirable thing (especially for typing-related
imports), there was a suggestion to add a way to override the global disable
and force particular imports to be lazy, for instance by calling the lazy
imports filter even if lazy imports are globally disabled.
This approach could introduce a complex hierarchy of the different "override"
systems, making it much harder to analyze and reason about the code.
Additionally, this may require additional complexity to introduce finer-grained
systems to enable or disable particular imports as the use of lazy imports
evolves. The global disable is not expected to see commonplace use, but be more
of a debugging and selective testing tool for those who want to tightly control
their dependency on lazy imports. We think it's reasonable for package
maintainers, as they update packages to adopt lazy imports, to decide to
*not* support running with lazy imports globally disabled.
It may be that this means that in time, as more and more packages embrace
both typing and lazy imports, the global disable becomes mostly unused and
unusable. Similar things have happened in the past with other global flags,
and given the low cost of the flag this seems acceptable. It's also easier
to add more specific re-enabling mechanisms later, when we have a clearer
picture of real-world use and patterns, than it is to remove a hastily added
mechanism that isn't quite right.
### Using underscore-prefixed names for advanced features
The global activation and filter functions (`sys.set_lazy_imports`,
`sys.set_lazy_imports_filter`, `sys.get_lazy_imports_filter`) could be
marked as "private" or "advanced" by using underscore prefixes (e.g.,
`sys._set_lazy_imports_filter`). This was rejected because branding as
advanced features through documentation is sufficient. These functions have
legitimate use cases for advanced users, particularly operators of large
deployments. Providing an official mechanism prevents divergence from upstream
CPython. The global mode is intentionally documented as an advanced feature for
operators running huge fleets, not for day-to-day users or libraries. Python
has precedent for advanced features that remain public APIs without underscore
prefixes - for example, `gc.disable()`, `gc.get_objects()`, and
`gc.set_threshold()` are advanced features that can cause issues if misused,
yet they are not underscore-prefixed.
### Using a decorator syntax for lazy imports
A decorator-based syntax could mark imports as lazy:
```python
@lazy
import json
@lazy
from foo import bar
```
This approach was rejected because it introduces too many open questions and
complications. Decorators in Python are designed to wrap and transform callable
objects (functions, classes, methods), not statements. Allowing decorators on
import statements would open the door to many other potential statement
decorators (`@cached`, `@traced`, `@deprecated`, etc.), significantly
expanding the language's syntax in ways we don't want to explore. Furthermore,
this raises the question of where such decorators would come from: they would
need to be either imported or built-in, creating a bootstrapping problem for
import-related decorators. This is far more speculative and generic than the
focused `lazy import` syntax.
### Using a context manager instead of a new soft keyword
A backward compatible syntax, for example in the form of a context manager,
has been proposed:
```python
with lazy_imports(...):
    import json
```
This would replace the need for `!__lazy_modules__`, and allow
libraries to use one of the existing lazy imports implementations in older
Python versions. However, adding magic `with` statements with that kind of
effect would be a significant change to Python and `with` statements in
general, and it would not be easy to combine with the implementation for
lazy imports in this proposal. Adding standard library support for existing
lazy importers *without* changes to the implementation amounts to the status
quo, and does not solve the performance and usability issues with those
existing solutions.
### Returning a proxy dict from `globals()`
An alternative to reifying on `globals()` or exposing lazy objects would be
to return a proxy dictionary that automatically reifies lazy objects when
they're accessed through the proxy. This would seemingly give the best of both
worlds: `globals()` returns immediately without reification cost, but
accessing items through the result would automatically resolve lazy imports.
However, this approach is fundamentally incompatible with how `globals()` is
used in practice. Many standard library functions and built-ins expect
`globals()` to return a real `dict` object, not a proxy:
- `exec(code, globals())` requires a real dict.
- `eval(expr, globals())` requires a real dict.
- Functions that check `type(globals()) is dict` would break.
- Dictionary methods like `.update()` would need special handling.
- Performance would suffer from the indirection on every access.
The proxy would need to be so transparent that it would be indistinguishable
from a real dict in almost all cases, which is extremely difficult to achieve
correctly. Any deviation from true dict behavior would be a source of subtle
bugs.
### Automatically reifying on `__dict__` or `globals()` access
Three options were considered for how `globals()` and `mod.__dict__` should
behave with lazy imports:
1. Calling `globals()` or `mod.__dict__` traverses and resolves all lazy
   objects before returning.
2. Calling `globals()` or `mod.__dict__` returns the dictionary with lazy
   objects present (chosen).
3. Calling `globals()` returns the dictionary with lazy objects, but
   `mod.__dict__` reifies everything.
We chose option 2: both `globals()` and `__dict__` return the raw
namespace dictionary without triggering reification. This provides a clean,
predictable model where low-level introspection APIs don't trigger side
effects.
Having `globals()` and `__dict__` behave identically creates symmetry and
a simple mental model: both expose the raw namespace view. Low-level
introspection APIs should not automatically trigger imports, which would be
surprising and potentially expensive. Real-world experience implementing lazy
imports in the standard library (such as the traceback module) showed that
automatic reification on `__dict__` access was cumbersome and forced
introspection code to load modules it was only examining.
Option 1 (always reifying) was rejected because it would make `globals()`
and `__dict__` access surprisingly expensive and prevent introspecting the
lazy state of a module. Option 3 was initially considered to "protect" external
code from seeing lazy objects, but real-world usage showed this created more
problems than it solved, particularly for stdlib code that needs to introspect
modules without triggering side effects.