options:

--enable-incomplete-feature {InlineTypedDict,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

-O FORMAT, --output FORMAT

Set a custom output format

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)

--warn-unused-configs

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.

--no-namespace-packages

Disable support for namespace packages (PEP 420, __init__.py-less) (inverse: --namespace-packages)

--ignore-missing-imports

Silently ignore imports of missing modules

--follow-untyped-imports

Typecheck modules without stubs or py.typed marker

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

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

--disallow-any-unimported

Disallow Any types resulting from unfollowed imports (inverse: --allow-any-unimported)

--disallow-subclassing-any

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

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-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 (while still allowing entirely unannotated definitions) (inverse: --allowincomplete-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: https://mypy.readthedocs.io/en/stable/kinds_of_types.html#no-strictoptional

--implicit-optional

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

--no-strict-optional

Disable strict Optional checks (inverse: --strictoptional)

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

--warn-unreachable

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

--report-deprecated-as-note

Report importing or using deprecated features as notes instead of errors (inverse: --no-reportdeprecated-as-note)

Miscellaneous strictness flags:

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

--no-implicit-reexport

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

--strict-equality

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

--strict-bytes

Disable treating bytearray and memoryview as subtypes of bytes (inverse: --no-strict-bytes)

--extra-checks

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

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.

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

--show-error-end

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

--hide-error-codes

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

--show-error-code-links

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

--pretty

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

--no-color-output

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

--no-error-summary

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

--show-absolute-path

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

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

--skip-cache-mtime-checks

Skip cache internal consistency checks based on mtime

Advanced options:

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 MODULE

Use a custom typing module

--old-type-inference

Disable new experimental type inference algorithm

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

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

Miscellaneous:

--junit-xml JUNIT_XML

Write junit.xml to the given file

--find-occurrences CLASS.MEMBER

Print out all usages of a class member (experimental)

--scripts-are-modules

Script x becomes module x instead of __main__

--install-types

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

--non-interactive

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

--explicit-package-bases

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 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. Define MYPY_CACHE_DIR to override configuration cache_dir path.