Python Enhancement Proposal Introduces New Export Keyword to Streamline Module API Management

The Python steering committee and core developers are currently evaluating a transformative proposal aimed at refining how large-scale libraries manage their public interfaces. Authored by Neil Girdhar and sponsored by Peter Bierma, the draft proposal—formally categorized as a Standards Track PEP for Python 3.16—seeks to introduce a dedicated export keyword. This new syntax is designed to bridge the gap between a library’s internal implementation and its public-facing API, effectively solving a long-standing redundancy issue that has plagued maintainers of major packages like NumPy, pandas, and FastAPI.

The Evolution of the Hub-and-Internals Pattern

In the contemporary Python ecosystem, the architecture of a professional-grade library typically follows what is known as the "hub-and-internals" pattern. Under this model, maintainers organize code into a complex, multi-layered tree of submodules for ease of development. However, to provide a user-friendly experience, they present a "flattened" public layout. For example, while a specific function might be defined deep within library._internal.submodule.core, it is re-exported in the top-level library/__init__.py so that users can simply call library.function().

Currently, Python provides two primary methods for this re-exporting process, both of which are considered suboptimal. The first involves the use of the __all__ list. Maintainers must import a name and then manually add that name as a string to the __all__ variable. This violates the "Don’t Repeat Yourself" (DRY) principle, as every exported name must be written twice. In massive libraries like pandas or polars, this results in hundreds of lines of duplicated code where the import list and the __all__ list must be kept in sync by hand.

The second method is the "reflexive-alias" idiom: from x import y as y. While this signals to type checkers that an import is intended for re-export, it is often confusing to junior developers and can be accidentally "cleaned up" by automated linting tools that perceive the redundant alias as a mistake. The proposed export keyword aims to unify these concerns into a single, authoritative statement.

Chronology and Development of the Proposal

The conceptual framework for the export keyword began gaining significant traction in mid-2026. According to the proposal’s documentation, the draft was officially created on August 5, 2026, following preliminary discussions within the Python community regarding the limitations of module-level exports.

On August 21, 2026, the proposal entered a more rigorous phase of revision following a series of threads on the Python Discourse forum. During this period, the authors refined the relationship between this proposal and PEP 842. While PEP 842 attempted a broader overhaul of module exports—including the introduction of an ExportError for unauthorized access—the current proposal (often referred to in discussions as PEP 844) takes a more focused approach. It concentrates specifically on the syntax of re-exports to ensure maximum compatibility and minimal friction for adoption.

The discussion history reveals that the proposal was born out of a shared discomfort among library maintainers regarding the fragility of __all__. By late August, the consensus among the proponents was that a "soft keyword" approach—similar to the implementation of match and case in Python 3.10—would be the most effective way to introduce the feature without breaking existing codebases that might use "export" as a variable name.

Technical Specification: How the Export Keyword Functions

The proposed syntax introduces export as a soft keyword that replaces import in a from ... import statement. The standard form would appear as:

from ._internal.core export PublicAPI

Under the hood, this statement performs two simultaneous actions. First, it binds the name PublicAPI in the current module’s namespace, just as a standard import would. Second, it automatically appends the string "PublicAPI" to the module’s __all__ list. If __all__ does not exist, the interpreter creates it; if it exists as a tuple or other iterable, it is normalized into a list to allow for the append operation.

The proposal also includes support for aliases and wildcard exports:

1. Aliasing: from ._internal.widgets export Widget as PublicWidget binds the name and adds "PublicWidget" to __all__.
2. Wildcards: from ._internal.core export * imports all public names from the submodule and extends the current module’s __all__ with those names.

Crucially, the proposal restricts the use of export to the module level. Attempting to use the export keyword inside a function or class definition would result in a SyntaxError. This restriction ensures that export is only used to define the public API of a module, rather than local scopes where __all__ has no semantic meaning.

Integration with Lazy Loading (PEP 810)

One of the most significant technical advantages of the export proposal is its synergy with PEP 810, which introduces explicit lazy imports. For high-performance libraries like NumPy, startup time is a critical metric. Currently, many libraries use complex __getattr__ hacks to defer the loading of submodules until they are actually accessed.

With the combination of PEP 810 and the new export syntax, a maintainer could write:

lazy from . export linalg

This statement would immediately add "linalg" to __all__, ensuring that dir(library) and IDE auto-completion work perfectly from the moment of import. However, the actual linalg submodule would not be loaded into memory until a user attempts to access an attribute on it. This "eager export, lazy import" behavior provides a massive boost to developer experience and system performance, removing the need for manual __dir__ overrides and boilerplate-heavy __getattr__ logic.

Analysis of Ecosystem Impact and Supporting Data

The necessity of this change is underscored by the sheer volume of boilerplate in current top-tier Python libraries. An analysis of the pandas/__init__.py file reveals over 300 lines of code dedicated solely to the dual-maintenance of imports and __all__ entries. Similarly, the polars library features a massive block of reflexive aliases to satisfy type checkers.

Data gathered from the Discourse threads suggests that the current "manual" system is a frequent source of "silent drift." This occurs when a maintainer adds a new feature to a submodule and imports it into the hub but forgets to update the __all__ list. The result is a feature that is technically available but invisible to documentation generators (like Sphinx) and "star imports."

By folding these two actions into a single statement, the export keyword makes the public API "correct by construction." Industry experts suggest that this will lead to:

• Reduced Maintenance Burden: Fewer lines of code to manage in hub modules.
• Improved Tooling Accuracy: Linters and IDEs can unambiguously identify which imports are intended for public consumption.
• Better Onboarding: New contributors can more easily understand the package structure without deciphering the import as idiom.

Official Responses and Community Debate

While the proposal has seen strong support from the maintainers of FastAPI and Typer, it has not been without its critics. Some members of the Python community have questioned whether adding a new keyword is necessary when decorators or functional calls could achieve similar results.

The authors addressed these concerns in the "Rejected Ideas" section of the proposal. They argued that decorators like @public do not compose well with imports, as there is no object to decorate when a name is simply being passed through a hub module. Furthermore, functional approaches like public(name) still require the name to be written twice, failing to solve the primary DRY violation.

Another point of contention involves runtime enforcement. Some developers expressed a desire for Python to raise an error if a user accesses a name not listed in __all__. However, the authors of this PEP have explicitly designated runtime enforcement as a "non-goal." They argue that Python’s long-standing convention of using underscores for internal names is sufficient and that policing access would introduce unnecessary performance overhead and break existing patterns used by tools like pip.

Future Outlook

As of late 2026, the proposal remains in the "Draft" status, undergoing active discussion. If accepted, it is slated for inclusion in Python 3.16. The next steps involve the development of a reference implementation in CPython and a potential source-to-source transform prototype to allow library authors to test the syntax in real-world environments.

The introduction of export represents a shift in Python’s philosophy toward more explicit architectural declarations. As the language continues to dominate the data science and web development landscapes, features that support the maintenance of large, complex codebases are becoming increasingly prioritized. Should this PEP pass, it will likely mark the end of the "double-list" era in Python library design, ushering in a more streamlined and error-resistant method of API management.