Your company here — click to reach over 10,000 unique daily visitors

mypy - Man Page

manual page for mypy 1.10.1-dev

Examples (TL;DR)


usage: mypy [-h] [-v] [-V] [more options; see below]

[-m MODULE] [-p PACKAGE] [-c PROGRAM_TEXT] [files ...]

Mypy is a program that will type check your Python code.

Pass in any files or folders you want to type check. Mypy will recursively traverse any provided folders to find .py files:

$ mypy my_program.py my_src_folder

For more information on getting started, see:

- https://mypy.readthedocs.io/en/stable/getting_started.html

For more details on both running mypy and using the flags below, see:

- https://mypy.readthedocs.io/en/stable/running_mypy.html - https://mypy.readthedocs.io/en/stable/command_line.html

You can also use a config file to configure mypy instead of using command line flags. For more details, see:

- https://mypy.readthedocs.io/en/stable/config_file.html


--enable-incomplete-feature {PreciseTupleTypes}

Enable support of incomplete/experimental features for early preview

Optional arguments

-h,  --help

Show this help message and exit

-v,  --verbose

More verbose messages

-V,  --version

Show program's version number and exit

Config file

Use a config file instead of command line arguments. This is useful if you are using many flags or want to set different options per each module.

--config-file CONFIG_FILE

Configuration file, must have a [mypy] section (defaults to mypy.ini, .mypy.ini, pyproject.toml, setup.cfg, ~/.config/mypy/config, ~/.mypy.ini)


Warn about unused '[mypy-<pattern>]' or '[[tool.mypy.overrides]]' config sections (inverse: --no-warn-unused-configs)

Import discovery

Configure how imports are discovered and followed.


Support namespace packages (PEP 420, __init__.pyless) (inverse: --namespace-packages)


Silently ignore imports of missing modules

--follow-imports {normal,silent,skip,error}

How to treat imports (default normal)

--python-executable EXECUTABLE

Python executable used for finding PEP 561 compliant installed packages and stubs


Do not search for installed PEP 561 compliant packages


Do not silence errors in PEP 561 compliant installed packages

--junit-format {global,per_file}

If --junit-xml is set, specifies format. global: single test with all errors; per_file: one test entry per file with failures

Platform configuration

Type check code assuming it will be run under certain runtime conditions. By default, mypy assumes your code will be run using the same operating system and Python version you are using to run mypy itself.

--python-version x.y

Type check code assuming it will be running on Python x.y

--platform PLATFORM

Type check special-cased code for the given OS platform (defaults to sys.platform)

--always-true NAME

Additional variable to be considered True (may be repeated)

--always-false NAME

Additional variable to be considered False (may be repeated)

Disallow dynamic typing

Disallow the use of the dynamic 'Any' type under certain conditions.


Disallow Any types resulting from unfollowed imports


Disallow all expressions that have type Any


Disallow functions that have Any in their signature after decorator transformation


Disallow explicit Any in type positions


Disallow usage of generic types that do not specify explicit type parameters (inverse: --allow-any-generics)


Disallow subclassing values of type 'Any' when defining classes (inverse: --allow-subclassingany)

Untyped definitions and calls

Configure how untyped definitions and calls are handled. Note: by default, mypy ignores any untyped function definitions and assumes any calls to such functions have a return type of 'Any'.


Disallow calling functions without type annotations from functions with type annotations (inverse: --allow-untyped-calls)

--untyped-calls-exclude MODULE

Disable --disallow-untyped-calls for functions/methods coming from specific package, module, or class


Disallow defining functions without type annotations or with incomplete type annotations (inverse: --allow-untyped-defs)


Disallow defining functions with incomplete type annotations (while still allowing entirely unannotated definitions) (inverse: --allowincomplete-defs)


Type check the interior of functions without type annotations (inverse: --no-check-untyped-defs)


Disallow decorating typed functions with untyped decorators (inverse: --allow-untyped-decorators)

None and Optional handling

Adjust how values of type 'None' are handled. For more context on how mypy handles values of type 'None', see: https://mypy.readthedocs.io/en/stable/kinds_of_types.html#no-strictoptional


Assume arguments with default values of None are Optional (inverse: --no-implicit-optional)


Disable strict Optional checks (inverse: --strictoptional)

Configuring warnings

Detect code that is sound but redundant or problematic.


Warn about casting an expression to its inferred type (inverse: --no-warn-redundant-casts)


Warn about unneeded '# type: ignore' comments (inverse: --no-warn-unused-ignores)


Do not warn about functions that end without returning (inverse: --warn-no-return)


Warn about returning values of type Any from nonAny typed functions (inverse: --no-warn-returnany)


Warn about statements or expressions inferred to be unreachable (inverse: --no-warn-unreachable)

Miscellaneous strictness flags


Suppress toplevel errors caused by missing annotations (inverse: --disallow-untyped-globals)


Allow unconditional variable redefinition with a new type (inverse: --disallow-redefinition)


Treat imports as private unless aliased (inverse: --implicit-reexport)


Prohibit equality, identity, and container checks for non-overlapping types (inverse: --no-strictequality)


Enable additional checks that are technically correct but may be impractical in real code. For example, this prohibits partial overlap in TypedDict updates, and makes arguments prepended via Concatenate positional-only (inverse: --noextra-checks)


Strict mode; enables the following flags: --warnunused-configs, --disallow-any-generics, --disallow-subclassing-any, --disallow-untypedcalls, --disallow-untyped-defs, --disallowincomplete-defs, --check-untyped-defs, --disallowuntyped-decorators, --warn-redundant-casts, --warn-unused-ignores, --warn-return-any, --noimplicit-reexport, --strict-equality, --extrachecks

--disable-error-code NAME

Disable a specific error code

--enable-error-code NAME

Enable a specific error code

Configuring error messages

Adjust the amount of detail shown in error messages.


Precede errors with "note:" messages explaining context (inverse: --hide-error-context)


Show column numbers in error messages (inverse: --hide-column-numbers)


Show end line/end column numbers in error messages. This implies --show-column-numbers (inverse: --hide-error-end)


Hide error codes in error messages (inverse: --show-error-codes)


Show links to error code documentation (inverse: --hide-error-code-links)


Use visually nicer output in error messages: Use soft word wrap, show source code snippets, and show error location markers (inverse: --no-pretty)


Do not colorize error messages (inverse: --coloroutput)


Do not show error stats summary (inverse: --errorsummary)


Show absolute paths to files (inverse: --hideabsolute-path)

Incremental mode

Adjust how mypy incrementally type checks and caches modules. Mypy caches type information about modules into a cache to let you speed up future invocations of mypy. Also see mypy's daemon mode: mypy.readthedocs.io/en/stable/mypy_daemon.html#mypy-daemon


Disable module cache (inverse: --incremental)

--cache-dir DIR

Store module cache info in the given folder in incremental mode (defaults to '.mypy_cache')


Use a sqlite database to store the cache (inverse: --no-sqlite-cache)


Include fine-grained dependency information in the cache for the mypy daemon


Allow using cache written by older mypy version


Skip cache internal consistency checks based on mtime

Advanced options

Debug and customize mypy internals.


Invoke pdb on fatal error

--show-traceback,  --tb

Show traceback on fatal error


Raise exception on fatal error

--custom-typing-module MODULE

Use a custom typing module


Disable new experimental type inference algorithm

--custom-typeshed-dir DIR

Use the custom typeshed in DIR


Warn if missing type annotation in typeshed, only relevant with --disallow-untyped-defs or --disallow-incomplete-defs enabled (inverse: --nowarn-incomplete-stub)


When encountering SOURCE_FILE, read and type check the contents of SHADOW_FILE instead.

Report generation

Generate a report in the specified format.

--any-exprs-report DIR

--cobertura-xml-report DIR

--html-report DIR

--linecount-report DIR

--linecoverage-report DIR

--lineprecision-report DIR

--txt-report DIR

--xml-report DIR

--xslt-html-report DIR

--xslt-txt-report DIR


--junit-xml JUNIT_XML

Write junit.xml to the given file

--find-occurrences CLASS.MEMBER

Print out all usages of a class member (experimental)


Script x becomes module x instead of __main__


Install detected missing library stub packages using pip (inverse: --no-install-types)


Install stubs without asking for confirmation and hide errors, with --install-types (inverse: --interactive)

Running code

Specify the code you want to type check. For more details, see mypy.readthedocs.io/en/stable/running_mypy.html#running-mypy


Use current directory and MYPYPATH to determine module names of files passed (inverse: --noexplicit-package-bases)

--exclude PATTERN

Regular expression to match file names, directory names or paths which mypy should ignore while recursively discovering files to check, e.g. --exclude '/setup\.py$'. May be specified more than once, eg. --exclude a --exclude b

-m, --module MODULE

Type-check module; can repeat for more modules

-p, --package PACKAGE

Type-check package recursively; can be repeated

-c, --command PROGRAM_TEXT

Type-check program passed in as string


Type-check given files or directories

Environment variables

Define MYPYPATH for additional module search path entries. Define MYPY_CACHE_DIR to override configuration cache_dir path.


June 2024 mypy 1.10.1-dev