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, setup.cfg, ~/.config/mypy/config, ~/.mypy.ini)

--warn-unused-configs

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

Import discovery:

Configure how imports are discovered and followed.

--ignore-missing-imports

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

--no-site-packages

Do not search for installed PEP 561 compliant packages

--no-silence-site-packages

Do not silence errors in PEP 561 compliant installed packages

--namespace-packages

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

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

-2, --py2

Use Python 2 mode (same as --python-version 2.7)

--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)

Dynamic typing:

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

--disallow-any-unimported

Disallow Any types resulting from unfollowed imports

--disallow-subclassing-any

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

--disallow-any-expr

Disallow all expressions that have type Any

--disallow-any-decorated

Disallow functions that have Any in their signature after decorator transformation

--disallow-any-explicit

Disallow explicit Any in type positions

--disallow-any-generics

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

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-untyped-calls

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

--disallow-untyped-defs

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

--disallow-incomplete-defs

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

--check-untyped-defs

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

--disallow-untyped-decorators

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: mypy.readthedocs.io/en/latest/kinds_of_types.html#no-strict-optional

--no-implicit-optional

Don't assume arguments with default values of None are Optional (inverse: --implicit-optional)

--no-strict-optional

Disable strict Optional checks (inverse: --strictoptional)

--strict-optional-whitelist [GLOB [GLOB ...]]

Suppress strict Optional errors in all but the provided files; implies --strict-optional (may suppress certain other errors in non-whitelisted files)

Warnings:

Detect code that is sound but redundant or problematic.

--warn-redundant-casts

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

--warn-unused-ignores

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

--no-warn-no-return

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

--warn-return-any

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

Other strictness checks:

--allow-untyped-globals

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

--allow-redefinition

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

--strict

Strict mode; enables the following flags: --warnunused-configs, --disallow-subclassing-any, --disallow-any-generics, --disallow-untyped-calls, --disallow-untyped-defs, --disallow-incompletedefs, --check-untyped-defs, --disallow-untypeddecorators, --no-implicit-optional, --warnredundant-casts, --warn-unused-ignores, --warnreturn-any

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/latest/mypy_daemon.html#mypy-daemon

--no-incremental

Disable module cache (inverse: --incremental)

--cache-dir DIR

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

--sqlite-cache

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

--cache-fine-grained

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

--skip-version-check

Allow using cache written by older mypy version

Mypy internals:

Debug and customize mypy internals.

--pdb

Invoke pdb on fatal error

--show-traceback, --tb

Show traceback on fatal error

--raise-exceptions

Raise exception on fatal error

--custom-typing MODULE

Use a custom typing module

--custom-typeshed-dir DIR

Use the custom typeshed in DIR

--warn-incomplete-stub

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

--shadow-file SOURCE_FILE SHADOW_FILE

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

Error reporting:

Adjust the amount of detail shown in error messages.

--show-error-context

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

--show-column-numbers

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

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

--memory-xml-report DIR

--txt-report DIR

--xml-report DIR

--xslt-html-report DIR

--xslt-txt-report DIR

Miscellaneous:

--junit-xml JUNIT_XML

Write junit.xml to the given file

--scripts-are-modules

Script x becomes module x instead of __main__

--find-occurrences CLASS.MEMBER

Print out all usages of a class member (experimental)

Running code:

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

-m MODULE, --module MODULE

Type-check module; can repeat for more modules

-p PACKAGE, --package PACKAGE

Type-check package recursively; can be repeated

-c PROGRAM_TEXT, --command PROGRAM_TEXT

Type-check program passed in as string

files

Type-check given files or directories

Environment variables:

Define MYPYPATH for additional module search path entries.