Provided by: mypy_0.670-2_all bug


       mypy - Optional Static Typing for Python


       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_src_folder

       For more information on getting started, see:


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

       -                        -

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


   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    about    unused    '[mypy-<pattern>]'     config     sections     (inverse:

   Import discovery:
              Configure how imports are discovered and followed.

              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

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

   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 types resulting from unfollowed imports

              Disallow  subclassing  values  of  type  'Any'  when  defining  classes   (inverse:

              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)

   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)

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

              Disallow  defining   functions   with   incomplete   type   annotations   (inverse:

              Type   check   the   interior  of  functions  without  type  annotations  (inverse:

              Disallow   decorating   typed   functions   with   untyped   decorators   (inverse:

   None and Optional handling:
              Adjust  how values of type 'None' are handled. For more context on how mypy handles
              values               of               type               'None',               see:

              Don't  assume  arguments  with  default  values  of  None  are  Optional  (inverse:

              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)

              Detect code that is sound but redundant or problematic.

              Warn    about    casting   an   expression   to   its   inferred   type   (inverse:

              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:

   Other strictness checks:
              Suppress    toplevel    errors    caused    by    missing   annotations   (inverse:

              Allow   unconditional   variable   redefinition   with   a   new   type   (inverse:

              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:

              Disable module cache (inverse: --incremental)

       --cache-dir DIR
              Store module cache info in the  given  folder  in  incremental  mode  (defaults  to

              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

   Mypy internals:
              Debug and customize mypy internals.

       --pdb  Invoke pdb on fatal error

       --show-traceback, --tb
              Show traceback on fatal error

              Raise exception on fatal error

       --custom-typing MODULE
              Use a custom typing module

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

       --shadow-file SOURCE_FILE SHADOW_FILE
              When  encountering  SOURCE_FILE,  read  and  type check the contents of SHADOW_FILE

   Error reporting:
              Adjust the amount of detail shown in error messages.

              Precede   errors   with   "note:"    messages    explaining    context    (inverse:

              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

       --junit-xml JUNIT_XML
              Write junit.xml to the given file

              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

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