PEP 810: Explicit lazy imports

brettcannon · October 3, 2025, 9:27pm

I was ~~told~~ asked at the core dev sprints to comment due to spending way too much time thinking about this as the author of importlib and importlib.util.LazyLoader. Basically I like it and support it!

I honestly only have a couple of comments about flow in the PEP and one misunderstanding.

it is useful to provide a mechanism to activate or deactivate lazy imports at a global level.

This is the first mention of the global on/off mechanism, and it’s after emphasizing how lazy import is local. It probably could either use more details or just a “more later” comment.

will check the global lazy imports flag

First mention of the flag with no context.

the lazy imports filter

First mention of the filter with no context.

ImportError: deferred import

This is a terminology flip from “lazy” to “deferred”. For consistency it’s probably best to use the same term as the keyword in the exception message (I leave it to the PEP authors which term to choose ).

No ongoing performance penalty unlike importlib.util.LazyLoader.

This assertion is made twice in the PEP and it’s actually incorrect. LazyLoader replaces __class__ for the module so that __getattribute__ gets changed to ModuleType (or whatever loader.create_module() returns so there is no perpetual performance penalty:

github.com/python/cpython

Lib/importlib/util.py

1ae925036


      
          """A subclass of the module type which triggers loading upon attribute access."""
          
          def __getattribute__(self, attr):
              """Trigger the load of the module and return the attribute."""
              __spec__ = object.__getattribute__(self, '__spec__')
              loader_state = __spec__.loader_state
              with loader_state['lock']:
                  # Only the first thread to get the lock should trigger the load
                  # and reset the module's class. The rest can now getattr().
                  if object.__getattribute__(self, '__class__') is _LazyModule:
                      __class__ = loader_state['__class__']
          
                      # Reentrant calls from the same thread must be allowed to proceed without
                      # triggering the load again.
                      # exec_module() and self-referential imports are the primary ways this can
                      # happen, but in any case we must return something to avoid deadlock.
                      if loader_state['is_loading']:
                          return __class__.__getattribute__(self, attr)
                      loader_state['is_loading'] = True
          
                      __dict__ = __class__.__getattribute__(self, '__dict__')

The key benefit of this PEP over LazyLoader is:

It doesn’t require wrapping import machinery to make it work.
It makes finding the module lazy (LazyLoader is eager in finding the module but lazy for loading).
It works on submodules.