.\" Man page generated from reStructuredText.
.
.TH "MYPY" "1" "Feb 20, 2021" "" "Mypy"
.SH NAME
mypy \- Optional static typing for Python
.
.nr rst2man-indent-level 0
.
.de1 rstReportMargin
\\$1 \\n[an-margin]
level \\n[rst2man-indent-level]
level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
-
\\n[rst2man-indent0]
\\n[rst2man-indent1]
\\n[rst2man-indent2]
..
.de1 INDENT
.\" .rstReportMargin pre:
. RS \\$1
. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
. nr rst2man-indent-level +1
.\" .rstReportMargin post:
..
.de UNINDENT
. RE
.\" indent \\n[an-margin]
.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
.nr rst2man-indent-level -1
.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
..
.SH SYNOPSIS
.sp
\fBmypy\fP [\-h] [\-v] [\-V] [\-m \fIMODULE\fP] [\-p \fIPACKAGE\fP] [\-c \fIPROGRAM_TEXT\fP] [\fIOPTIONS\fP\&...] [\fIFILES\fP ...]
.SH DESCRIPTION
.sp
Mypy is a static type checker for Python 3 and Python 2.7. If you sprinkle
your code with type annotations, mypy can type check your code and find
common bugs. As mypy is a static analyzer, or a lint\-like tool, the type
annotations are just hints for mypy and don’t interfere when running
your program. You run your program with a standard Python interpreter,
and the annotations are treated effectively as comments.
.sp
Using the Python 3 function annotation syntax (using the PEP 484 notation)
or a comment\-based annotation syntax for Python 2 code, you will be
able to efficiently annotate your code and use mypy to check the code
for common errors. Mypy has a powerful and easy\-to\-use type system with
modern features such as type inference, generics, callable types, tuple
types, union types, and structural subtyping.
.sp
Mypy is invoked with the paths the user needs to check:
.INDENT 0.0
.INDENT 3.5
.sp
.nf
.ft C
$ mypy foo.py bar.py some_directory
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
The directories are checked recursively to find Python source files.
.SH OPTIONS
.sp
This section documents mypy\(aqs command line interface. You can view
a quick summary of the available flags by running \fBmypy \-\-help\fP\&.
.sp
\fBNOTE:\fP
.INDENT 0.0
.INDENT 3.5
Command line flags are liable to change between releases.
.UNINDENT
.UNINDENT
.SS Specifying what to type check
.sp
By default, you can specify what code you want mypy to type check
by passing in the paths to what you want to have type checked:
.INDENT 0.0
.INDENT 3.5
.sp
.nf
.ft C
$ mypy foo.py bar.py some_directory
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
Note that directories are checked recursively.
.sp
Mypy also lets you specify what code to type check in several other
ways. A short summary of the relevant flags is included below:
for full details, see running\-mypy\&.
.INDENT 0.0
.TP
.B \-m MODULE, \-\-module MODULE
Asks mypy to type check the provided module. This flag may be
repeated multiple times.
.sp
Mypy \fIwill not\fP recursively type check any submodules of the provided
module.
.UNINDENT
.INDENT 0.0
.TP
.B \-p PACKAGE, \-\-package PACKAGE
Asks mypy to type check the provided package. This flag may be
repeated multiple times.
.sp
Mypy \fIwill\fP recursively type check any submodules of the provided
package. This flag is identical to \fB\-\-module\fP apart from this
behavior.
.UNINDENT
.INDENT 0.0
.TP
.B \-c PROGRAM_TEXT, \-\-command PROGRAM_TEXT
Asks mypy to type check the provided string as a program.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-exclude
A regular expression that matches file names, directory names and paths
which mypy should ignore while recursively discovering files to check.
Use forward slashes on all platforms.
.sp
For instance, to avoid discovering any files named \fIsetup.py\fP you could
pass \fB\-\-exclude \(aq/setup\e.py$\(aq\fP\&. Similarly, you can ignore discovering
directories with a given name by e.g. \fB\-\-exclude /build/\fP or
those matching a subpath with \fB\-\-exclude /project/vendor/\fP\&.
.sp
Note that this flag only affects recursive discovery, that is, when mypy is
discovering files within a directory tree or submodules of a package to
check. If you pass a file or module explicitly it will still be checked. For
instance, \fBmypy \-\-exclude \(aq/setup.py$\(aq but_still_check/setup.py\fP\&.
.sp
Note that mypy will never recursively discover files and directories named
"site\-packages", "node_modules" or "__pycache__", or those whose name starts
with a period, exactly as \fB\-\-exclude
\(aq/(site\-packages|node_modules|__pycache__|\e..*)/$\(aq\fP would. Mypy will also
never recursively discover files with extensions other than \fB\&.py\fP or
\fB\&.pyi\fP\&.
.UNINDENT
.SS Optional arguments
.INDENT 0.0
.TP
.B \-h, \-\-help
Show help message and exit.
.UNINDENT
.INDENT 0.0
.TP
.B \-v, \-\-verbose
More verbose messages.
.UNINDENT
.INDENT 0.0
.TP
.B \-V, \-\-version
Show program\(aqs version number and exit.
.UNINDENT
.SS Config file
.INDENT 0.0
.TP
.B \-\-config\-file CONFIG_FILE
This flag makes mypy read configuration settings from the given file.
.sp
By default settings are read from \fBmypy.ini\fP, \fB\&.mypy.ini\fP, or \fBsetup.cfg\fP
in the current directory. Settings override mypy\(aqs built\-in defaults and
command line flags can override settings.
.sp
Specifying \fB\-\-config\-file=\fP (with no filename) will ignore \fIall\fP
config files.
.sp
See config\-file for the syntax of configuration files.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-warn\-unused\-configs
This flag makes mypy warn about unused \fB[mypy\-<pattern>]\fP config
file sections.
(This requires turning off incremental mode using \fB\-\-no\-incremental\fP\&.)
.UNINDENT
.SS Import discovery
.sp
The following flags customize how exactly mypy discovers and follows
imports.
.INDENT 0.0
.TP
.B \-\-namespace\-packages
This flag enables import discovery to use namespace packages (see
\fI\%PEP 420\fP).  In particular, this allows discovery of imported
packages that don\(aqt have an \fB__init__.py\fP (or \fB__init__.pyi\fP)
file.
.sp
Namespace packages are found (using the PEP 420 rules, which
prefers "classic" packages over namespace packages) along the
module search path \-\- this is primarily set from the source files
passed on the command line, the \fBMYPYPATH\fP environment variable,
and the 
.nf
:confval:\(gamypy_path\(ga
.fi
 config option.
.sp
This flag affects how mypy finds modules and packages explicitly passed on
the command line. It also affects how mypy determines fully qualified module
names for files passed on the command line. See Mapping file paths to
modules for details.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-explicit\-package\-bases
This flag tells mypy that top\-level packages will be based in either the
current directory, or a member of the \fBMYPYPATH\fP environment variable or

.nf
:confval:\(gamypy_path\(ga
.fi
 config option. This option is only useful in
conjunction with \fB\-\-namespace\-packages\fP\&. See Mapping file
paths to modules for details.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-ignore\-missing\-imports
This flag makes mypy ignore all missing imports. It is equivalent
to adding \fB# type: ignore\fP comments to all unresolved imports
within your codebase.
.sp
Note that this flag does \fInot\fP suppress errors about missing names
in successfully resolved modules. For example, if one has the
following files:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
package/__init__.py
package/mod.py
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
Then mypy will generate the following errors with \fB\-\-ignore\-missing\-imports\fP:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
import package.unknown      # No error, ignored
x = package.unknown.func()  # OK. \(aqfunc\(aq is assumed to be of type \(aqAny\(aq

from package import unknown          # No error, ignored
from package.mod import NonExisting  # Error: Module has no attribute \(aqNonExisting\(aq
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
For more details, see ignore\-missing\-imports\&.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-follow\-imports {normal,silent,skip,error}
This flag adjusts how mypy follows imported modules that were not
explicitly passed in via the command line.
.sp
The default option is \fBnormal\fP: mypy will follow and type check
all modules. For more information on what the other options do,
see Following imports\&.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-python\-executable EXECUTABLE
This flag will have mypy collect type information from \fI\%PEP 561\fP
compliant packages installed for the Python executable \fBEXECUTABLE\fP\&.
If not provided, mypy will use PEP 561 compliant packages installed for
the Python executable running mypy.
.sp
See installed\-packages for more on making PEP 561 compliant packages.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-site\-packages
This flag will disable searching for \fI\%PEP 561\fP compliant packages. This
will also disable searching for a usable Python executable.
.sp
Use this  flag if mypy cannot find a Python executable for the version of
Python being checked, and you don\(aqt need to use PEP 561 typed packages.
Otherwise, use \fB\-\-python\-executable\fP\&.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-silence\-site\-packages
By default, mypy will suppress any error messages generated within \fI\%PEP 561\fP
compliant packages. Adding this flag will disable this behavior.
.UNINDENT
.SS Platform configuration
.sp
By default, mypy will assume that you intend to run your code using the same
operating system and Python version you are using to run mypy itself. The
following flags let you modify this behavior.
.sp
For more information on how to use these flags, see version_and_platform_checks\&.
.INDENT 0.0
.TP
.B \-\-python\-version X.Y
This flag will make mypy type check your code as if it were
run under Python version X.Y. Without this option, mypy will default to using
whatever version of Python is running mypy. Note that the \fB\-2\fP and
\fB\-\-py2\fP flags are aliases for \fB\-\-python\-version 2.7\fP\&.
.sp
This flag will attempt to find a Python executable of the corresponding
version to search for \fI\%PEP 561\fP compliant packages. If you\(aqd like to
disable this, use the \fB\-\-no\-site\-packages\fP flag (see
import\-discovery for more details).
.UNINDENT
.INDENT 0.0
.TP
.B \-2, \-\-py2
Equivalent to running \fB\-\-python\-version 2.7\fP\&.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-platform PLATFORM
This flag will make mypy type check your code as if it were
run under the given operating system. Without this option, mypy will
default to using whatever operating system you are currently using.
.sp
The \fBPLATFORM\fP parameter may be any string supported by
\fBsys.platform\fP\&.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-always\-true NAME
This flag will treat all variables named \fBNAME\fP as
compile\-time constants that are always true.  This flag may
be repeated.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-always\-false NAME
This flag will treat all variables named \fBNAME\fP as
compile\-time constants that are always false.  This flag may
be repeated.
.UNINDENT
.SS Disallow dynamic typing
.sp
The \fBAny\fP type is used represent a value that has a dynamic type\&.
The \fB\-\-disallow\-any\fP family of flags will disallow various uses of the \fBAny\fP type in
a module \-\- this lets us strategically disallow the use of dynamic typing in a controlled way.
.sp
The following options are available:
.INDENT 0.0
.TP
.B \-\-disallow\-any\-unimported
This flag disallows usage of types that come from unfollowed imports
(such types become aliases for \fBAny\fP). Unfollowed imports occur either
when the imported module does not exist or when \fB\-\-follow\-imports=skip\fP
is set.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-any\-expr
This flag disallows all expressions in the module that have type \fBAny\fP\&.
If an expression of type \fBAny\fP appears anywhere in the module
mypy will output an error unless the expression is immediately
used as an argument to \fBcast()\fP or assigned to a variable with an
explicit type annotation.
.sp
In addition, declaring a variable of type \fBAny\fP
or casting to type \fBAny\fP is not allowed. Note that calling functions
that take parameters of type \fBAny\fP is still allowed.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-any\-decorated
This flag disallows functions that have \fBAny\fP in their signature
after decorator transformation.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-any\-explicit
This flag disallows explicit \fBAny\fP in type positions such as type
annotations and generic type parameters.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-any\-generics
This flag disallows usage of generic types that do not specify explicit
type parameters. Moreover, built\-in collections (such as \fBlist\fP and
\fBdict\fP) become disallowed as you should use their aliases from the \fBtyping\fP
module (such as \fBList[int]\fP and \fBDict[str, str]\fP).
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-subclassing\-any
This flag reports an error whenever a class subclasses a value of
type \fBAny\fP\&.  This may occur when the base class is imported from
a module that doesn\(aqt exist (when using
\fB\-\-ignore\-missing\-imports\fP) or is
ignored due to \fB\-\-follow\-imports=skip\fP or a
\fB# type: ignore\fP comment on the \fBimport\fP statement.
.sp
Since the module is silenced, the imported class is given a type of \fBAny\fP\&.
By default mypy will assume that the subclass correctly inherited
the base class even though that may not actually be the case.  This
flag makes mypy raise an error instead.
.UNINDENT
.SS Untyped definitions and calls
.sp
The following flags configure how mypy handles untyped function
definitions or calls.
.INDENT 0.0
.TP
.B \-\-disallow\-untyped\-calls
This flag reports an error whenever a function with type annotations
calls a function defined without annotations.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-untyped\-defs
This flag reports an error whenever it encounters a function definition
without type annotations.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-incomplete\-defs
This flag reports an error whenever it encounters a partly annotated
function definition.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-check\-untyped\-defs
This flag is less severe than the previous two options \-\- it type checks
the body of every function, regardless of whether it has type annotations.
(By default the bodies of functions without annotations are not type
checked.)
.sp
It will assume all arguments have type \fBAny\fP and always infer \fBAny\fP
as the return type.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disallow\-untyped\-decorators
This flag reports an error whenever a function with type annotations
is decorated with a decorator without annotations.
.UNINDENT
.SS None and Optional handling
.sp
The following flags adjust how mypy handles values of type \fBNone\fP\&.
For more details, see no_strict_optional\&.
.INDENT 0.0
.TP
.B \-\-no\-implicit\-optional
This flag causes mypy to stop treating arguments with a \fBNone\fP
default value as having an implicit \fBOptional\fP type.
.sp
For example, by default mypy will assume that the \fBx\fP parameter
is of type \fBOptional[int]\fP in the code snippet below since
the default parameter is \fBNone\fP:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
def foo(x: int = None) \-> None:
    print(x)
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
If this flag is set, the above snippet will no longer type check:
we must now explicitly indicate that the type is \fBOptional[int]\fP:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
def foo(x: Optional[int] = None) \-> None:
    print(x)
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-strict\-optional
This flag disables strict checking of \fBOptional\fP
types and \fBNone\fP values. With this option, mypy doesn\(aqt
generally check the use of \fBNone\fP values \-\- they are valid
everywhere. See no_strict_optional for more about this feature.
.sp
\fBNote:\fP Strict optional checking was enabled by default starting in
mypy 0.600, and in previous versions it had to be explicitly enabled
using \fB\-\-strict\-optional\fP (which is still accepted).
.UNINDENT
.SS Configuring warnings
.sp
The follow flags enable warnings for code that is sound but is
potentially problematic or redundant in some way.
.INDENT 0.0
.TP
.B \-\-warn\-redundant\-casts
This flag will make mypy report an error whenever your code uses
an unnecessary cast that can safely be removed.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-warn\-unused\-ignores
This flag will make mypy report an error whenever your code uses
a \fB# type: ignore\fP comment on a line that is not actually
generating an error message.
.sp
This flag, along with the \fB\-\-warn\-redundant\-casts\fP flag, are both
particularly useful when you are upgrading mypy. Previously,
you may have needed to add casts or \fB# type: ignore\fP annotations
to work around bugs in mypy or missing stubs for 3rd party libraries.
.sp
These two flags let you discover cases where either workarounds are
no longer necessary.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-warn\-no\-return
By default, mypy will generate errors when a function is missing
return statements in some execution paths. The only exceptions
are when:
.INDENT 7.0
.IP \(bu 2
The function has a \fBNone\fP or \fBAny\fP return type
.IP \(bu 2
The function has an empty body or a body that is just
ellipsis (\fB\&...\fP). Empty functions are often used for
abstract methods.
.UNINDENT
.sp
Passing in \fB\-\-no\-warn\-no\-return\fP will disable these error
messages in all cases.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-warn\-return\-any
This flag causes mypy to generate a warning when returning a value
with type \fBAny\fP from a function declared with a non\-\fBAny\fP return type.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-warn\-unreachable
This flag will make mypy report an error whenever it encounters
code determined to be unreachable or redundant after performing type analysis.
This can be a helpful way of detecting certain kinds of bugs in your code.
.sp
For example, enabling this flag will make mypy report that the \fBx > 7\fP
check is redundant and that the \fBelse\fP block below is unreachable.
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
def process(x: int) \-> None:
    # Error: Right operand of \(aqor\(aq is never evaluated
    if isinstance(x, int) or x > 7:
        # Error: Unsupported operand types for + ("int" and "str")
        print(x + "bad")
    else:
        # Error: \(aqStatement is unreachable\(aq error
        print(x + "bad")
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
To help prevent mypy from generating spurious warnings, the "Statement is
unreachable" warning will be silenced in exactly two cases:
.INDENT 7.0
.IP 1. 3
When the unreachable statement is a \fBraise\fP statement, is an
\fBassert False\fP statement, or calls a function that has the \fBNoReturn\fP
return type hint. In other words, when the unreachable statement
throws an error or terminates the program in some way.
.IP 2. 3
When the unreachable statement was \fIintentionally\fP marked as unreachable
using version_and_platform_checks\&.
.UNINDENT
.sp
\fBNOTE:\fP
.INDENT 7.0
.INDENT 3.5
Mypy currently cannot detect and report unreachable or redundant code
inside any functions using type\-variable\-value\-restriction\&.
.sp
This limitation will be removed in future releases of mypy.
.UNINDENT
.UNINDENT
.UNINDENT
.SS Miscellaneous strictness flags
.sp
This section documents any other flags that do not neatly fall under any
of the above sections.
.INDENT 0.0
.TP
.B \-\-allow\-untyped\-globals
This flag causes mypy to suppress errors caused by not being able to fully
infer the types of global and class variables.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-allow\-redefinition
By default, mypy won\(aqt allow a variable to be redefined with an
unrelated type. This flag enables redefinition of a variable with an
arbitrary type \fIin some contexts\fP: only redefinitions within the
same block and nesting depth as the original definition are allowed.
Example where this can be useful:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
def process(items: List[str]) \-> None:
    # \(aqitems\(aq has type List[str]
    items = [item.split() for item in items]
    # \(aqitems\(aq now has type List[List[str]]
    ...
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-local\-partial\-types
In mypy, the most common cases for partial types are variables initialized using \fBNone\fP,
but without explicit \fBOptional\fP annotations. By default, mypy won\(aqt check partial types
spanning module top level or class top level. This flag changes the behavior to only allow
partial types at local level, therefore it disallows inferring variable type for \fBNone\fP
from two assignments in different scopes. For example:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
from typing import Optional

a = None  # Need type annotation here if using \-\-local\-partial\-types
b = None  # type: Optional[int]

class Foo:
    bar = None  # Need type annotation here if using \-\-local\-partial\-types
    baz = None  # type: Optional[int]

    def __init__(self) \-> None:
        self.bar = 1

reveal_type(Foo().bar)  # Union[int, None] without \-\-local\-partial\-types
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
Note: this option is always implicitly enabled in mypy daemon and will become
enabled by default for mypy in a future release.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-implicit\-reexport
By default, imported values to a module are treated as exported and mypy allows
other modules to import them. This flag changes the behavior to not re\-export unless
the item is imported using from\-as or is included in \fB__all__\fP\&. Note this is
always treated as enabled for stub files. For example:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
# This won\(aqt re\-export the value
from foo import bar
# This will re\-export it as bar and allow other modules to import it
from foo import bar as bar
# This will also re\-export bar
from foo import bar
__all__ = [\(aqbar\(aq]
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-strict\-equality
By default, mypy allows always\-false comparisons like \fB42 == \(aqno\(aq\fP\&.
Use this flag to prohibit such comparisons of non\-overlapping types, and
similar identity and container checks:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
from typing import List, Text

items: List[int]
if \(aqsome string\(aq in items:  # Error: non\-overlapping container check!
    ...

text: Text
if text != b\(aqother bytes\(aq:  # Error: non\-overlapping equality check!
    ...

assert text is not None  # OK, check against None is allowed as a special case.
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-strict
This flag mode enables all optional error checking flags.  You can see the
list of flags enabled by strict mode in the full \fBmypy \-\-help\fP output.
.sp
Note: the exact list of flags enabled by running \fB\-\-strict\fP may change
over time.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-disable\-error\-code
This flag allows disabling one or multiple error codes globally.
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
# no flag
x = \(aqa string\(aq
x.trim()  # error: "str" has no attribute "trim"  [attr\-defined]

# \-\-disable\-error\-code attr\-defined
x = \(aqa string\(aq
x.trim()
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-enable\-error\-code
This flag allows enabling one or multiple error codes globally.
.sp
Note: This flag will override disabled error codes from the \-\-disable\-error\-code
flag
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
# \-\-disable\-error\-code attr\-defined
x = \(aqa string\(aq
x.trim()

# \-\-disable\-error\-code attr\-defined \-\-enable\-error\-code attr\-defined
x = \(aqa string\(aq
x.trim()  # error: "str" has no attribute "trim"  [attr\-defined]
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.SS Configuring error messages
.sp
The following flags let you adjust how much detail mypy displays
in error messages.
.INDENT 0.0
.TP
.B \-\-show\-error\-context
This flag will precede all errors with "note" messages explaining the
context of the error. For example, consider the following program:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
class Test:
    def foo(self, x: int) \-> int:
        return x + "bar"
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
Mypy normally displays an error message that looks like this:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
main.py:3: error: Unsupported operand types for + ("int" and "str")
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
If we enable this flag, the error message now looks like this:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
main.py: note: In member "foo" of class "Test":
main.py:3: error: Unsupported operand types for + ("int" and "str")
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-show\-column\-numbers
This flag will add column offsets to error messages.
For example, the following indicates an error in line 12, column 9
(note that column offsets are 0\-based):
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
main.py:12:9: error: Unsupported operand types for / ("int" and "str")
.ft P
.fi
.UNINDENT
.UNINDENT
.UNINDENT
.INDENT 0.0
.TP
.B \-\-show\-error\-codes
This flag will add an error code \fB[<code>]\fP to error messages. The error
code is shown after each error message:
.INDENT 7.0
.INDENT 3.5
.sp
.nf
.ft C
prog.py:1: error: "str" has no attribute "trim"  [attr\-defined]
.ft P
.fi
.UNINDENT
.UNINDENT
.sp
See error\-codes for more information.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-pretty
Use visually nicer output in error messages: use soft word wrap,
show source code snippets, and show error location markers.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-color\-output
This flag will disable color output in error messages, enabled by default.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-no\-error\-summary
This flag will disable error summary. By default mypy shows a summary line
including total number of errors, number of files with errors, and number
of files checked.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-show\-absolute\-path
Show absolute paths to files.
.UNINDENT
.SS Incremental mode
.sp
By default, mypy will store type information into a cache. Mypy
will use this information to avoid unnecessary recomputation when
it type checks your code again.  This can help speed up the type
checking process, especially when most parts of your program have
not changed since the previous mypy run.
.sp
If you want to speed up how long it takes to recheck your code
beyond what incremental mode can offer, try running mypy in
daemon mode\&.
.INDENT 0.0
.TP
.B \-\-no\-incremental
This flag disables incremental mode: mypy will no longer reference
the cache when re\-run.
.sp
Note that mypy will still write out to the cache even when
incremental mode is disabled: see the \fB\-\-cache\-dir\fP flag below
for more details.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-cache\-dir DIR
By default, mypy stores all cache data inside of a folder named
\fB\&.mypy_cache\fP in the current directory. This flag lets you
change this folder. This flag can also be useful for controlling
cache use when using remote caching\&.
.sp
This setting will override the \fBMYPY_CACHE_DIR\fP environment
variable if it is set.
.sp
Mypy will also always write to the cache even when incremental
mode is disabled so it can "warm up" the cache. To disable
writing to the cache, use \fB\-\-cache\-dir=/dev/null\fP (UNIX)
or \fB\-\-cache\-dir=nul\fP (Windows).
.UNINDENT
.INDENT 0.0
.TP
.B \-\-sqlite\-cache
Use an \fI\%SQLite\fP database to store the cache.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-cache\-fine\-grained
Include fine\-grained dependency information in the cache for the mypy daemon.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-skip\-version\-check
By default, mypy will ignore cache data generated by a different
version of mypy. This flag disables that behavior.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-skip\-cache\-mtime\-checks
Skip cache internal consistency checks based on mtime.
.UNINDENT
.SS Advanced options
.sp
The following flags are useful mostly for people who are interested
in developing or debugging mypy internals.
.INDENT 0.0
.TP
.B \-\-pdb
This flag will invoke the Python debugger when mypy encounters
a fatal error.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-show\-traceback, \-\-tb
If set, this flag will display a full traceback when mypy
encounters a fatal error.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-raise\-exceptions
Raise exception on fatal error.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-custom\-typing\-module MODULE
This flag lets you use a custom module as a substitute for the
\fBtyping\fP module.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-custom\-typeshed\-dir DIR
This flag specifies the directory where mypy looks for typeshed
stubs, instead of the typeshed that ships with mypy.  This is
primarily intended to make it easier to test typeshed changes before
submitting them upstream, but also allows you to use a forked version of
typeshed.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-warn\-incomplete\-stub
This flag modifies both the \fB\-\-disallow\-untyped\-defs\fP and
\fB\-\-disallow\-incomplete\-defs\fP flags so they also report errors
if stubs in typeshed are missing type annotations or has incomplete
annotations. If both flags are missing, \fB\-\-warn\-incomplete\-stub\fP
also does nothing.
.sp
This flag is mainly intended to be used by people who want contribute
to typeshed and would like a convenient way to find gaps and omissions.
.sp
If you want mypy to report an error when your codebase \fIuses\fP an untyped
function, whether that function is defined in typeshed or not, use the
\fB\-\-disallow\-untyped\-calls\fP flag. See untyped\-definitions\-and\-calls
for more details.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-shadow\-file SOURCE_FILE SHADOW_FILE
When mypy is asked to type check \fBSOURCE_FILE\fP, this flag makes mypy
read from and type check the contents of \fBSHADOW_FILE\fP instead. However,
diagnostics will continue to refer to \fBSOURCE_FILE\fP\&.
.sp
Specifying this argument multiple times (\fB\-\-shadow\-file X1 Y1 \-\-shadow\-file X2 Y2\fP)
will allow mypy to perform multiple substitutions.
.sp
This allows tooling to create temporary files with helpful modifications
without having to change the source file in place. For example, suppose we
have a pipeline that adds \fBreveal_type\fP for certain variables.
This pipeline is run on \fBoriginal.py\fP to produce \fBtemp.py\fP\&.
Running \fBmypy \-\-shadow\-file original.py temp.py original.py\fP will then
cause mypy to type check the contents of \fBtemp.py\fP instead of  \fBoriginal.py\fP,
but error messages will still reference \fBoriginal.py\fP\&.
.UNINDENT
.SS Report generation
.sp
If these flags are set, mypy will generate a report in the specified
format into the specified directory.
.INDENT 0.0
.TP
.B \-\-any\-exprs\-report DIR
Causes mypy to generate a text file report documenting how many
expressions of type \fBAny\fP are present within your codebase.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-cobertura\-xml\-report DIR
Causes mypy to generate a Cobertura XML type checking coverage report.
.sp
You must install the \fI\%lxml\fP library to generate this report.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-html\-report / \-\-xslt\-html\-report DIR
Causes mypy to generate an HTML type checking coverage report.
.sp
You must install the \fI\%lxml\fP library to generate this report.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-linecount\-report DIR
Causes mypy to generate a text file report documenting the functions
and lines that are typed and untyped within your codebase.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-linecoverage\-report DIR
Causes mypy to generate a JSON file that maps each source file\(aqs
absolute filename to a list of line numbers that belong to typed
functions in that file.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-lineprecision\-report DIR
Causes mypy to generate a flat text file report with per\-module
statistics of how many lines are typechecked etc.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-txt\-report / \-\-xslt\-txt\-report DIR
Causes mypy to generate a text file type checking coverage report.
.sp
You must install the \fI\%lxml\fP library to generate this report.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-xml\-report DIR
Causes mypy to generate an XML type checking coverage report.
.sp
You must install the \fI\%lxml\fP library to generate this report.
.UNINDENT
.SS Miscellaneous
.INDENT 0.0
.TP
.B \-\-junit\-xml JUNIT_XML
Causes mypy to generate a JUnit XML test result document with
type checking results. This can make it easier to integrate mypy
with continuous integration (CI) tools.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-find\-occurrences CLASS.MEMBER
This flag will make mypy print out all usages of a class member
based on static type information. This feature is experimental.
.UNINDENT
.INDENT 0.0
.TP
.B \-\-scripts\-are\-modules
This flag will give command line arguments that appear to be
scripts (i.e. files whose name does not end in \fB\&.py\fP)
a module name derived from the script name rather than the fixed
name \fB__main__\fP\&.
.sp
This lets you check more than one script in a single mypy invocation.
(The default \fB__main__\fP is technically more correct, but if you
have many scripts that import a large package, the behavior enabled
by this flag is often more convenient.)
.UNINDENT
.SH ENVIRONMENT
.INDENT 0.0
.TP
\fBMYPYPATH\fP
Additional module search path entries. The format is the same as the shell\(aqs \fI$PATH\fP: one or more directory pathnames separated by colons.
.UNINDENT
.SH SEE ALSO
.sp
\fBdmypy\fP(1)
.sp
Full documentation is available online at: \fI\%http://mypy.readthedocs.io/en/latest/getting_started.html\fP
or locally at: \fI\%/usr/share/doc/mypy/html\fP (requires \fImypy\-doc\fP package).
.SH AUTHOR
Jukka Lehtosalo and contributors
.\" Generated by docutils manpage writer.
.