Typing Stubs for Mypy Extensions

1.1.0.20260408 · active · verified Thu Apr 16

This package provides static type checking stubs for the `mypy-extensions` library. It enables type checkers like Mypy to understand the types defined in `mypy-extensions`, such as `LiteralString`, `TypedDict`, and `NoReturn`, particularly when those features are not yet available in the standard `typing` module for the target Python version. The current version is 1.1.0.20260408, released as part of the `typeshed` project, with releases generally aligned with `typeshed` updates.

Common errors

```
ModuleNotFoundError: No module named 'mypy_extensions'
```
cause You have installed 'types-mypy-extensions' (the stub package) but not the actual runtime library 'mypy-extensions'. Stubs do not provide runtime functionality.

fix Install the runtime package: `pip install mypy-extensions`.
```
ModuleNotFoundError: No module named 'types_mypy_extensions'
```
cause Stub packages like 'types-mypy-extensions' are not meant for direct import in Python code. They are consumed by type checkers.

fix Import symbols from the actual runtime library, e.g., `from mypy_extensions import LiteralString`. The `types-mypy-extensions` package is solely for type checking tools like Mypy.

Warnings

gotcha This is a stub-only package. It provides type annotations for type checkers but does not contain any runtime code. You must install the actual 'mypy-extensions' package separately for your code to run successfully.
Fix: To use the functionality, install the runtime package: `pip install mypy-extensions`.
gotcha The 'types-mypy-extensions' package itself requires Python >= 3.10 to install and use. This means your development/type-checking environment must run Python 3.10 or newer, even if your target runtime environment uses an older Python version with 'mypy-extensions'.
Fix: Ensure your environment for running type checkers (e.g., `mypy`) is Python 3.10 or newer.
gotcha Many features provided by 'mypy-extensions' (e.g., TypedDict, NoReturn, LiteralString) are now part of the standard `typing` module in modern Python versions (e.g., TypedDict in 3.8+, NoReturn in 3.6+, LiteralString in 3.11+). Using `mypy-extensions` might be unnecessary or lead to confusion if your project primarily targets these newer Python versions.
Fix: Consider using imports from the standard `typing` module if your target Python version supports it. For example, `from typing import LiteralString` instead of `from mypy_extensions import LiteralString` for Python 3.11+.

Install

pip install types-mypy-extensions Install types-mypy-extensions

Imports

LiteralString
wrong:
```
from types_mypy_extensions import LiteralString
```
correct:
```
from mypy_extensions import LiteralString
```
Symbols are imported from the runtime library 'mypy_extensions'. The 'types-mypy-extensions' package provides only the type hints for these symbols, it is not meant for direct import.
TypedDict
wrong:
```
from types_mypy_extensions import TypedDict
```
correct:
```
from mypy_extensions import TypedDict
```
TypedDict from mypy_extensions was used for Python versions before 3.8. For modern Python, use 'from typing import TypedDict'.

Quickstart

This example demonstrates how to use `LiteralString` from `mypy_extensions` to enforce type safety against non-literal strings. The `types-mypy-extensions` package provides the necessary type stubs for a type checker like Mypy to correctly analyze these type hints.

from mypy_extensions import LiteralString

def process_query(query: LiteralString) -> None:
    print(f"Executing safe query: {query}")

def get_user_input() -> str:
    # Simulate user input which is not guaranteed to be a literal string
    return 'SELECT * FROM users; DROP TABLE users;' # Malicious input

# This is a safe literal string
safe_query: LiteralString = "SELECT id, name FROM users WHERE active = TRUE;"
process_query(safe_query)

# If type checked by mypy (with types-mypy-extensions installed),
# the following line is expected to fail because get_user_input() returns 'str', not 'LiteralString'.
# mypy will detect the type mismatch, preventing potential SQL injection if 'query' was used directly.
# Uncommenting the line below and running mypy should show a type error.
# process_query(get_user_input())

print("Run 'mypy your_file.py' to see type checking results.")

view raw JSON →