Star import reveals internal names when __all__ omits or misspells entries

Direct answer

CPython does not validate ``__all__`` when a module is loaded. If ``__all__`` lists a name that does not exist in the module namespace, the module imports successfully. The failure is deferred until a consumer runs ``from module import *`` and the import system resolves each listed name against the module namespace; an undefined entry then raises ``AttributeError``. There is no built-in import statement option that raises at module load time solely because ``__all__`` contains an unknown identifier.

Confirmed behavior and likely explanation

Confirmed: when a module defines ``__all__``, star import binds only the listed names, resolving each at consumer import time.

Confirmed: the language reference does not require the interpreter to audit ``__all__`` entries against defined names before finishing module execution.

Likely explanation: the delayed ``AttributeError`` occurs because name resolution is lazy relative to module definition. The typo exists in the module's public contract, but nothing forces the interpreter to check that contract at load time.

Mechanisms for early validation

• Static linting. Tools such as pylint, flake8-bugbear, or type checkers can compare ``__all__`` entries against defined symbols and report undefined or misspelled names before code runs. Rule names and coverage vary by tool version, so treat this as a development safeguard, not a runtime guarantee.
• Runtime self-validation. Add a check at the end of the module so the problem surfaces on the first import:

for _name in __all__:
    if _name not in globals():
        raise ImportError(f"__all__ contains undefined name: {_name!r}")

• Import hook or custom loader. An ``importlib`` loader can inspect ``__all__`` after module execution and raise ``ImportError`` for unknown entries. This applies globally but is more complex, and it can misfire on modules that use module-level ``__getattr__`` for lazy attributes.

Recommended steps for this case

1. Add the runtime self-validation loop to the module that defines ``__all__``.
2. Verify with a module containing one defined name and one misspelled entry.
3. Run ``python3 -c "from testmod import *"`` and confirm it raises ``ImportError`` immediately instead of succeeding and failing later.
4. Enable the corresponding lint rule in CI so typos are caught before deployment.

Assumptions and uncertainty

• Assumes CPython 3.8 or later; behavior is stable across recent 3.x releases.
• Module-level ``__getattr__`` can make names available only on access, so eager validation may flag intentionally lazy names.
• If ``__all__`` is built dynamically after the validation loop runs, the check misses those entries.
• Linter behavior depends on configuration and version; no specific warning code is guaranteed.

Verification

# testmod.py
__all__ = ["foo", "mis_spelled"]

def foo():
    return 1

for _name in __all__:
    if _name not in globals():
        raise ImportError(f"__all__ contains undefined name: {_name!r}")

python3 -c "from testmod import *"

Expected result: ``ImportError: __all__ contains undefined name: 'mis_spelled'`` at import time.

One missing detail changes the recommendation: do you control the module's source code, or are you consuming third-party modules? If you do not control the source, self-validation is not practical; rely on linting, CI checks, or a project-wide import hook instead.