Provided by: mypy_0.670-2_all bug

NAME

       mypy - Optional Static Typing for Python

DESCRIPTION

       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:

       - http://mypy.readthedocs.io/en/latest/getting_started.html

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

       -                 http://mypy.readthedocs.io/en/latest/running_mypy.html                 -
       http://mypy.readthedocs.io/en/latest/command_line.html

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

       - http://mypy.readthedocs.io/en/latest/config_file.html

   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.