def test_coherence(self): # We have to special case Options.BuildType because we're required to # set a target options = Options() options.build_type = BuildType.PROGRAM_TEXT _, parsed_options = process_options(['-c', 'cmd']) assert_equal(options, parsed_options)
def process_options( args: List[str], require_targets: bool = True, server_options: bool = False, ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments.""" parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=AugmentedHelpFormatter) strict_flag_names = [] # type: List[str] strict_flag_assignments = [] # type: List[Tuple[str, bool]] def add_invertible_flag(flag: str, *, inverse: Optional[str] = None, default: bool, dest: Optional[str] = None, help: str, strict_flag: bool = False) -> None: if inverse is None: inverse = invert_flag_name(flag) if help is not argparse.SUPPRESS: help += " (inverse: {})".format(inverse) arg = parser.add_argument( flag, # type: ignore # incorrect stub for add_argument action='store_false' if default else 'store_true', dest=dest, help=help) dest = arg.dest arg = parser.add_argument( inverse, # type: ignore # incorrect stub for add_argument action='store_true' if default else 'store_false', dest=dest, help=argparse.SUPPRESS) if strict_flag: assert dest is not None strict_flag_names.append(flag) strict_flag_assignments.append((dest, not default)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument( '--platform', action='store', metavar='PLATFORM', help="typecheck special-cased code for the given OS platform " "(defaults to sys.platform).") parser.add_argument('-2', '--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('--ignore-missing-imports', action='store_true', help="silently ignore imports of missing modules") parser.add_argument('--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="how to treat imports (default normal)") parser.add_argument( '--disallow-any-unimported', default=False, action='store_true', help="disallow Any types resulting from unfollowed imports") parser.add_argument('--disallow-any-expr', default=False, action='store_true', help='disallow all expressions that have type Any') parser.add_argument( '--disallow-any-decorated', default=False, action='store_true', help='disallow functions that have Any in their signature ' 'after decorator transformation') parser.add_argument('--disallow-any-explicit', default=False, action='store_true', help='disallow explicit Any in type positions') parser.add_argument( '--disallow-any-generics', default=False, action='store_true', help='disallow usage of generic types that do not specify explicit ' 'type parameters') add_invertible_flag( '--disallow-untyped-calls', default=False, strict_flag=True, help="disallow calling functions without type annotations" " from functions with type annotations") add_invertible_flag( '--disallow-untyped-defs', default=False, strict_flag=True, help="disallow defining functions without type annotations" " or with incomplete type annotations") add_invertible_flag( '--disallow-incomplete-defs', default=False, strict_flag=True, help="disallow defining functions with incomplete type annotations") add_invertible_flag( '--check-untyped-defs', default=False, strict_flag=True, help="type check the interior of functions without type annotations") add_invertible_flag( '--disallow-subclassing-any', default=False, strict_flag=True, help="disallow subclassing values of type 'Any' when defining classes") add_invertible_flag( '--warn-incomplete-stub', default=False, help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") add_invertible_flag( '--disallow-untyped-decorators', default=False, strict_flag=True, help="disallow decorating typed functions with untyped decorators") add_invertible_flag( '--warn-redundant-casts', default=False, strict_flag=True, help="warn about casting an expression to its inferred type") add_invertible_flag( '--no-warn-no-return', dest='warn_no_return', default=True, help="do not warn about functions that end without returning") add_invertible_flag('--warn-return-any', default=False, strict_flag=True, help="warn about returning values of type Any" " from non-Any typed functions") add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True, help="warn about unneeded '# type: ignore' comments") add_invertible_flag( '--warn-unused-configs', default=False, strict_flag=True, help="warn about unused '[mypy-<pattern>]' config sections") add_invertible_flag( '--show-error-context', default=False, dest='show_error_context', help='Precede errors with "note:" messages explaining context') add_invertible_flag( '--no-implicit-optional', default=False, strict_flag=True, help="don't assume arguments with default values of None are Optional") parser.add_argument( '-i', '--incremental', action='store_true', help="enable module cache, (inverse: --no-incremental)") parser.add_argument('--no-incremental', action='store_false', dest='incremental', help=argparse.SUPPRESS) parser.add_argument('--quick-and-dirty', action='store_true', help="use cache even if dependencies out of date " "(implies --incremental)") parser.add_argument( '--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) parser.add_argument( '--cache-fine-grained', action='store_true', help="include fine-grained dependency information in the cache") parser.add_argument('--skip-version-check', action='store_true', help="allow using cache written by older mypy version") add_invertible_flag('--strict-optional', default=False, strict_flag=True, help="enable experimental strict Optional checks") parser.add_argument( '--strict-optional-whitelist', metavar='GLOB', nargs='*', help="suppress strict Optional errors in all but the provided files " "(experimental -- read documentation before using!). " "Implies --strict-optional. Has the undesirable side-effect of " "suppressing other errors in non-whitelisted files.") parser.add_argument('--junit-xml', help="write junit.xml to the given file") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--show-traceback', '--tb', action='store_true', help="show traceback on fatal error") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") parser.add_argument('--custom-typeshed-dir', metavar='DIR', help="use the custom typeshed in DIR") parser.add_argument('--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") parser.add_argument('--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(defaults.CONFIG_FILE)) add_invertible_flag('--show-column-numbers', default=False, help="Show column numbers in error messages") parser.add_argument( '--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="print out all usages of a class member (experimental)") strict_help = "Strict mode. Enables the following flags: {}".format( ", ".join(strict_flag_names)) parser.add_argument('--strict', action='store_true', dest='special-opts:strict', help=strict_help) parser.add_argument('--shadow-file', nargs=2, metavar=('SOURCE_FILE', 'SHADOW_FILE'), dest='shadow_file', help='Typecheck SHADOW_FILE in place of SOURCE_FILE.') # hidden options # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-deps will dump all fine-grained dependencies to stdout parser.add_argument('--dump-deps', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) # --semantic-analysis-only does exactly that. parser.add_argument('--semantic-analysis-only', action='store_true', help=argparse.SUPPRESS) # --local-partial-types disallows partial types spanning module top level and a function # (implicitly defined in fine-grained incremental mode) parser.add_argument('--local-partial-types', action='store_true', help=argparse.SUPPRESS) # deprecated options parser.add_argument('--disallow-any', dest='special-opts:disallow_any', help=argparse.SUPPRESS) add_invertible_flag('--strict-boolean', default=False, help=argparse.SUPPRESS) parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) parser.add_argument('-s', '--silent-imports', action='store_true', dest='special-opts:silent_imports', help=argparse.SUPPRESS) parser.add_argument('--almost-silent', action='store_true', dest='special-opts:almost_silent', help=argparse.SUPPRESS) parser.add_argument('--fast-parser', action='store_true', dest='special-opts:fast_parser', help=argparse.SUPPRESS) parser.add_argument('--no-fast-parser', action='store_true', dest='special-opts:no_fast_parser', help=argparse.SUPPRESS) if server_options: parser.add_argument('--experimental', action='store_true', dest='fine_grained_incremental', help="enable fine-grained incremental mode") parser.add_argument( '--use-fine-grained-cache', action='store_true', help="use the cache in fine-grained incremental mode") report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') for report_type in sorted(reporter_classes): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) code_group = parser.add_argument_group( title='How to specify the code to type check') code_group.add_argument( '-m', '--module', action='append', metavar='MODULE', dest='special-opts:modules', help="type-check module; can repeat for more modules") # TODO: `mypy -p A -p B` currently silently ignores A # (last option wins). Perhaps -c, -m and -p could just be # command-line flags that modify how we interpret self.files? code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument('-p', '--package', metavar='PACKAGE', dest='special-opts:package', help="type-check all files in a directory") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file and know if the user requested all strict options. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file if config_file is not None and not os.path.exists(config_file): parser.error("Cannot find config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() parse_config_file(options, config_file) # Set strict flags before parsing (if strict mode enabled), so other command # line options can override. if getattr(dummy, 'special-opts:strict'): for dest, value in strict_flag_assignments: setattr(options, dest, value) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error( "Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # Process deprecated options if special_opts.disallow_any: print( "--disallow-any option was split up into multiple flags. " "See http://mypy.readthedocs.io/en/latest/command_line.html#disallow-any-flags" ) if options.strict_boolean: print( "Warning: --strict-boolean is deprecated; " "see https://github.com/python/mypy/issues/3195", file=sys.stderr) if special_opts.almost_silent: print( "Warning: --almost-silent has been replaced by " "--follow-imports=errors", file=sys.stderr) if options.follow_imports == 'normal': options.follow_imports = 'errors' elif special_opts.silent_imports: print( "Warning: --silent-imports has been replaced by " "--ignore-missing-imports --follow-imports=skip", file=sys.stderr) options.ignore_missing_imports = True if options.follow_imports == 'normal': options.follow_imports = 'skip' if special_opts.dirty_stubs: print( "Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) if special_opts.fast_parser: print("Warning: --fast-parser is now the default (and only) parser.") if special_opts.no_fast_parser: print( "Warning: --no-fast-parser no longer has any effect. The fast parser " "is now mypy's default and only parser.") # Check for invalid argument combinations. if require_targets: code_methods = sum( bool(c) for c in [ special_opts.modules, special_opts.command, special_opts.package, special_opts.files ]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error( "May only specify one of: module, package, files, or command.") # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if special_opts.find_occurrences: experiments.find_occurrences = special_opts.find_occurrences.split('.') assert experiments.find_occurrences is not None if len(experiments.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(experiments.find_occurrences) != 2: parser.error( "Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Let quick_and_dirty imply incremental. if options.quick_and_dirty: options.incremental = True # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it.".format( special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() # TODO: use the same cache as the BuildManager will targets = build.FindModuleCache().find_modules_recursive( special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT targets = [BuildSource(None, None, '\n'.join(special_opts.command))] return targets, options else: targets = create_source_list(special_opts.files, options) return targets, options
def process_options( args: List[str], stdout: Optional[TextIO] = None, stderr: Optional[TextIO] = None, require_targets: bool = True, server_options: bool = False, fscache: Optional[FileSystemCache] = None, program: str = 'mypy', header: str = HEADER, ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments. If a FileSystemCache is passed in, and package_root options are given, call fscache.set_package_root() to set the cache's package root. """ stdout = stdout or sys.stdout stderr = stderr or sys.stderr parser = argparse.ArgumentParser(prog=program, usage=header, description=DESCRIPTION, epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=AugmentedHelpFormatter, add_help=False) strict_flag_names = [] # type: List[str] strict_flag_assignments = [] # type: List[Tuple[str, bool]] def add_invertible_flag( flag: str, *, inverse: Optional[str] = None, default: bool, dest: Optional[str] = None, help: str, strict_flag: bool = False, group: Optional[argparse._ActionsContainer] = None) -> None: if inverse is None: inverse = invert_flag_name(flag) if group is None: group = parser if help is not argparse.SUPPRESS: help += " (inverse: {})".format(inverse) arg = group.add_argument( flag, action='store_false' if default else 'store_true', dest=dest, help=help) dest = arg.dest arg = group.add_argument( inverse, action='store_true' if default else 'store_false', dest=dest, help=argparse.SUPPRESS) if strict_flag: assert dest is not None strict_flag_names.append(flag) strict_flag_assignments.append((dest, not default)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. # Note: we have a style guide for formatting the mypy --help text. See # https://github.com/python/mypy/wiki/Documentation-Conventions general_group = parser.add_argument_group(title='Optional arguments') general_group.add_argument('-h', '--help', action='help', help="Show this help message and exit") general_group.add_argument('-v', '--verbose', action='count', dest='verbosity', help="More verbose messages") general_group.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__, help="Show program's version number and exit") config_group = parser.add_argument_group( title='Config file', description="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_group.add_argument( '--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(', '.join(defaults.CONFIG_FILES))) add_invertible_flag( '--warn-unused-configs', default=False, strict_flag=True, help="Warn about unused '[mypy-<pattern>]' config sections", group=config_group) imports_group = parser.add_argument_group( title='Import discovery', description="Configure how imports are discovered and followed.") imports_group.add_argument( '--ignore-missing-imports', action='store_true', help="Silently ignore imports of missing modules") imports_group.add_argument('--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="How to treat imports (default normal)") imports_group.add_argument( '--python-executable', action='store', metavar='EXECUTABLE', help="Python executable used for finding PEP 561 compliant installed" " packages and stubs", dest='special-opts:python_executable') imports_group.add_argument( '--no-site-packages', action='store_true', dest='special-opts:no_executable', help="Do not search for installed PEP 561 compliant packages") imports_group.add_argument( '--no-silence-site-packages', action='store_true', help="Do not silence errors in PEP 561 compliant installed packages") add_invertible_flag( '--namespace-packages', default=False, help="Support namespace packages (PEP 420, __init__.py-less)", group=imports_group) platform_group = parser.add_argument_group( title='Platform configuration', description="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.") platform_group.add_argument( '--python-version', type=parse_version, metavar='x.y', help='Type check code assuming it will be running on Python x.y', dest='special-opts:python_version') platform_group.add_argument( '-2', '--py2', dest='special-opts:python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="Use Python 2 mode (same as --python-version 2.7)") platform_group.add_argument( '--platform', action='store', metavar='PLATFORM', help="Type check special-cased code for the given OS platform " "(defaults to sys.platform)") platform_group.add_argument( '--always-true', metavar='NAME', action='append', default=[], help="Additional variable to be considered True (may be repeated)") platform_group.add_argument( '--always-false', metavar='NAME', action='append', default=[], help="Additional variable to be considered False (may be repeated)") disallow_any_group = parser.add_argument_group( title='Dynamic typing', description= "Disallow the use of the dynamic 'Any' type under certain conditions.") disallow_any_group.add_argument( '--disallow-any-unimported', default=False, action='store_true', help="Disallow Any types resulting from unfollowed imports") add_invertible_flag( '--disallow-subclassing-any', default=False, strict_flag=True, help="Disallow subclassing values of type 'Any' when defining classes", group=disallow_any_group) disallow_any_group.add_argument( '--disallow-any-expr', default=False, action='store_true', help='Disallow all expressions that have type Any') disallow_any_group.add_argument( '--disallow-any-decorated', default=False, action='store_true', help='Disallow functions that have Any in their signature ' 'after decorator transformation') disallow_any_group.add_argument( '--disallow-any-explicit', default=False, action='store_true', help='Disallow explicit Any in type positions') add_invertible_flag( '--disallow-any-generics', default=False, strict_flag=True, help='Disallow usage of generic types that do not specify explicit type ' 'parameters', group=disallow_any_group) untyped_group = parser.add_argument_group( title='Untyped definitions and calls', description="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'.") add_invertible_flag( '--disallow-untyped-calls', default=False, strict_flag=True, help="Disallow calling functions without type annotations" " from functions with type annotations", group=untyped_group) add_invertible_flag( '--disallow-untyped-defs', default=False, strict_flag=True, help="Disallow defining functions without type annotations" " or with incomplete type annotations", group=untyped_group) add_invertible_flag( '--disallow-incomplete-defs', default=False, strict_flag=True, help="Disallow defining functions with incomplete type annotations", group=untyped_group) add_invertible_flag( '--check-untyped-defs', default=False, strict_flag=True, help="Type check the interior of functions without type annotations", group=untyped_group) add_invertible_flag( '--disallow-untyped-decorators', default=False, strict_flag=True, help="Disallow decorating typed functions with untyped decorators", group=untyped_group) none_group = parser.add_argument_group( title='None and Optional handling', description= "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") add_invertible_flag( '--no-implicit-optional', default=False, strict_flag=True, help="Don't assume arguments with default values of None are Optional", group=none_group) none_group.add_argument('--strict-optional', action='store_true', help=argparse.SUPPRESS) none_group.add_argument( '--no-strict-optional', action='store_false', dest='strict_optional', help="Disable strict Optional checks (inverse: --strict-optional)") none_group.add_argument( '--strict-optional-whitelist', metavar='GLOB', nargs='*', help="Suppress strict Optional errors in all but the provided files; " "implies --strict-optional (may suppress certain other errors " "in non-whitelisted files)") lint_group = parser.add_argument_group( title='Warnings', description="Detect code that is sound but redundant or problematic.") add_invertible_flag( '--warn-redundant-casts', default=False, strict_flag=True, help="Warn about casting an expression to its inferred type", group=lint_group) add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True, help="Warn about unneeded '# type: ignore' comments", group=lint_group) add_invertible_flag( '--no-warn-no-return', dest='warn_no_return', default=True, help="Do not warn about functions that end without returning", group=lint_group) add_invertible_flag('--warn-return-any', default=False, strict_flag=True, help="Warn about returning values of type Any" " from non-Any typed functions", group=lint_group) # Note: this group is intentionally added here even though we don't add # --strict to this group near the end. # # That way, this group will appear after the various strictness groups # but before the remaining flags. # We add `--strict` near the end so we don't accidentally miss any strictness # flags that are added after this group. strictness_group = parser.add_argument_group( title='Other strictness checks') add_invertible_flag( '--allow-untyped-globals', default=False, strict_flag=False, help="Suppress toplevel errors caused by missing annotations", group=strictness_group) add_invertible_flag( '--allow-redefinition', default=False, strict_flag=False, help="Allow unconditional variable redefinition with a new type", group=strictness_group) add_invertible_flag( '--strict-equality', default=False, strict_flag=False, help="Prohibit equality, identity, and container checks for" " non-overlapping types", group=strictness_group) incremental_group = parser.add_argument_group( title='Incremental mode', description= "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") incremental_group.add_argument('-i', '--incremental', action='store_true', help=argparse.SUPPRESS) incremental_group.add_argument( '--no-incremental', action='store_false', dest='incremental', help="Disable module cache (inverse: --incremental)") incremental_group.add_argument( '--cache-dir', action='store', metavar='DIR', help="Store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) add_invertible_flag('--sqlite-cache', default=False, help="Use a sqlite database to store the cache", group=incremental_group) incremental_group.add_argument( '--cache-fine-grained', action='store_true', help= "Include fine-grained dependency information in the cache for the mypy daemon" ) incremental_group.add_argument( '--skip-version-check', action='store_true', help="Allow using cache written by older mypy version") incremental_group.add_argument( '--skip-cache-mtime-checks', action='store_true', help="Skip cache internal consistency checks based on mtime") internals_group = parser.add_argument_group( title='Mypy internals', description="Debug and customize mypy internals.") internals_group.add_argument('--pdb', action='store_true', help="Invoke pdb on fatal error") internals_group.add_argument('--show-traceback', '--tb', action='store_true', help="Show traceback on fatal error") internals_group.add_argument('--raise-exceptions', action='store_true', help="Raise exception on fatal error") internals_group.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="Use a custom typing module") internals_group.add_argument('--custom-typeshed-dir', metavar='DIR', help="Use the custom typeshed in DIR") add_invertible_flag( '--warn-incomplete-stub', default=False, help="Warn if missing type annotation in typeshed, only relevant with" " --disallow-untyped-defs or --disallow-incomplete-defs enabled", group=internals_group) internals_group.add_argument( '--shadow-file', nargs=2, metavar=('SOURCE_FILE', 'SHADOW_FILE'), dest='shadow_file', action='append', help="When encountering SOURCE_FILE, read and type check " "the contents of SHADOW_FILE instead.") add_invertible_flag('--fast-exit', default=False, help=argparse.SUPPRESS, group=internals_group) add_invertible_flag('--new-semantic-analyzer', default=False, help=argparse.SUPPRESS, group=internals_group) error_group = parser.add_argument_group( title='Error reporting', description="Adjust the amount of detail shown in error messages.") add_invertible_flag( '--show-error-context', default=False, dest='show_error_context', help='Precede errors with "note:" messages explaining context', group=error_group) add_invertible_flag('--show-column-numbers', default=False, help="Show column numbers in error messages", group=error_group) strict_help = "Strict mode; enables the following flags: {}".format( ", ".join(strict_flag_names)) strictness_group.add_argument('--strict', action='store_true', dest='special-opts:strict', help=strict_help) report_group = parser.add_argument_group( title='Report generation', description='Generate a report in the specified format.') for report_type in sorted(defaults.REPORTER_NAMES): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) other_group = parser.add_argument_group(title='Miscellaneous') other_group.add_argument('--quickstart-file', help=argparse.SUPPRESS) other_group.add_argument('--junit-xml', help="Write junit.xml to the given file") other_group.add_argument( '--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") other_group.add_argument( '--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="Print out all usages of a class member (experimental)") if server_options: # TODO: This flag is superfluous; remove after a short transition (2018-03-16) other_group.add_argument('--experimental', action='store_true', dest='fine_grained_incremental', help="Enable fine-grained incremental mode") other_group.add_argument( '--use-fine-grained-cache', action='store_true', help="Use the cache in fine-grained incremental mode") # hidden options parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help=argparse.SUPPRESS) parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help=argparse.SUPPRESS) # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-deps will dump all fine-grained dependencies to stdout parser.add_argument('--dump-deps', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) # --semantic-analysis-only does exactly that. parser.add_argument('--semantic-analysis-only', action='store_true', help=argparse.SUPPRESS) # --local-partial-types disallows partial types spanning module top level and a function # (implicitly defined in fine-grained incremental mode) parser.add_argument('--local-partial-types', action='store_true', help=argparse.SUPPRESS) # --logical-deps adds some more dependencies that are not semantically needed, but # may be helpful to determine relative importance of classes and functions for overall # type precision in a code base. It also _removes_ some deps, so this flag should be never # used except for generating code stats. This also automatically enables --cache-fine-grained. # NOTE: This is an experimental option that may be modified or removed at any time. parser.add_argument('--logical-deps', action='store_true', help=argparse.SUPPRESS) # --bazel changes some behaviors for use with Bazel (https://bazel.build). parser.add_argument('--bazel', action='store_true', help=argparse.SUPPRESS) # --package-root adds a directory below which directories are considered # packages even without __init__.py. May be repeated. parser.add_argument('--package-root', metavar='ROOT', action='append', default=[], help=argparse.SUPPRESS) # --cache-map FILE ... gives a mapping from source files to cache files. # Each triple of arguments is a source file, a cache meta file, and a cache data file. # Modules not mentioned in the file will go through cache_dir. # Must be followed by another flag or by '--' (and then only file args may follow). parser.add_argument('--cache-map', nargs='+', dest='special-opts:cache_map', help=argparse.SUPPRESS) # options specifying code to check code_group = parser.add_argument_group( title="Running code", description= "Specify the code you want to type check. For more details, see " "mypy.readthedocs.io/en/latest/running_mypy.html#running-mypy") code_group.add_argument( '-m', '--module', action='append', metavar='MODULE', default=[], dest='special-opts:modules', help="Type-check module; can repeat for more modules") code_group.add_argument( '-p', '--package', action='append', metavar='PACKAGE', default=[], dest='special-opts:packages', help="Type-check package recursively; can be repeated") code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="Type-check program passed in as string") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="Type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file and know if the user requested all strict options. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file # Don't explicitly test if "config_file is not None" for this check. # This lets `--config-file=` (an empty string) be used to disable all config files. if config_file and not os.path.exists(config_file): parser.error("Cannot find config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() parse_config_file(options, config_file, stdout, stderr) # Set strict flags before parsing (if strict mode enabled), so other command # line options can override. if getattr(dummy, 'special-opts:strict'): # noqa for dest, value in strict_flag_assignments: setattr(options, dest, value) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # The python_version is either the default, which can be overridden via a config file, # or stored in special_opts and is passed via the command line. options.python_version = special_opts.python_version or options.python_version try: infer_python_executable(options, special_opts) except PythonExecutableInferenceError as e: parser.error(str(e)) if special_opts.no_executable: options.python_executable = None # Paths listed in the config file will be ignored if any paths are passed on # the command line. if options.files and not special_opts.files: special_opts.files = options.files # Check for invalid argument combinations. if require_targets: code_methods = sum( bool(c) for c in [ special_opts.modules + special_opts.packages, special_opts.command, special_opts.files ]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error( "May only specify one of: module/package, files, or command.") # Check for overlapping `--always-true` and `--always-false` flags. overlap = set(options.always_true) & set(options.always_false) if overlap: parser.error( "You can't make a variable always true and always false (%s)" % ', '.join(sorted(overlap))) # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if special_opts.find_occurrences: state.find_occurrences = special_opts.find_occurrences.split('.') assert state.find_occurrences is not None if len(state.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(state.find_occurrences) != 2: parser.error( "Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Process --package-root. if options.package_root: process_package_roots(fscache, parser, options) # Process --cache-map. if special_opts.cache_map: if options.sqlite_cache: parser.error("--cache-map is incompatible with --sqlite-cache") process_cache_map(parser, special_opts, options) # Let logical_deps imply cache_fine_grained (otherwise the former is useless). if options.logical_deps: options.cache_fine_grained = True # Set target. if special_opts.modules + special_opts.packages: options.build_type = BuildType.MODULE search_paths = SearchPaths((os.getcwd(), ), tuple(mypy_path()), (), ()) targets = [] # TODO: use the same cache that the BuildManager will cache = FindModuleCache(search_paths, fscache) for p in special_opts.packages: if os.sep in p or os.altsep and os.altsep in p: fail("Package name '{}' cannot have a slash in it.".format(p), stderr) p_targets = cache.find_modules_recursive(p) if not p_targets: fail("Can't find package '{}'".format(p), stderr) targets.extend(p_targets) for m in special_opts.modules: targets.append(BuildSource(None, m, None)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT targets = [BuildSource(None, None, '\n'.join(special_opts.command))] return targets, options else: try: targets = create_source_list(special_opts.files, options, fscache) # Variable named e2 instead of e to work around mypyc bug #620 # which causes issues when using the same variable to catch # exceptions of different types. except InvalidSourceList as e2: fail(str(e2), stderr) return targets, options
def process_options(args: List[str], require_targets: bool = True, server_options: bool = False, fscache: Optional[FileSystemCache] = None, program: str = 'mypy', header: str = HEADER, ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments. If a FileSystemCache is passed in, and package_root options are given, call fscache.set_package_root() to set the cache's package root. """ parser = argparse.ArgumentParser(prog=program, usage=header, description=DESCRIPTION, epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=AugmentedHelpFormatter, add_help=False) strict_flag_names = [] # type: List[str] strict_flag_assignments = [] # type: List[Tuple[str, bool]] def add_invertible_flag(flag: str, *, inverse: Optional[str] = None, default: bool, dest: Optional[str] = None, help: str, strict_flag: bool = False, group: Optional[argparse._ActionsContainer] = None ) -> None: if inverse is None: inverse = invert_flag_name(flag) if group is None: group = parser if help is not argparse.SUPPRESS: help += " (inverse: {})".format(inverse) arg = group.add_argument(flag, action='store_false' if default else 'store_true', dest=dest, help=help) dest = arg.dest arg = group.add_argument(inverse, action='store_true' if default else 'store_false', dest=dest, help=argparse.SUPPRESS) if strict_flag: assert dest is not None strict_flag_names.append(flag) strict_flag_assignments.append((dest, not default)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. # Note: we have a style guide for formatting the mypy --help text. See # https://github.com/python/mypy/wiki/Documentation-Conventions general_group = parser.add_argument_group( title='Optional arguments') general_group.add_argument( '-h', '--help', action='help', help="Show this help message and exit") general_group.add_argument( '-v', '--verbose', action='count', dest='verbosity', help="More verbose messages") general_group.add_argument( '-V', '--version', action='version', version='%(prog)s ' + __version__, help="Show program's version number and exit") config_group = parser.add_argument_group( title='Config file', description="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_group.add_argument( '--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(', '.join(defaults.CONFIG_FILES))) add_invertible_flag('--warn-unused-configs', default=False, strict_flag=True, help="Warn about unused '[mypy-<pattern>]' config sections", group=config_group) imports_group = parser.add_argument_group( title='Import discovery', description="Configure how imports are discovered and followed.") imports_group.add_argument( '--ignore-missing-imports', action='store_true', help="Silently ignore imports of missing modules") imports_group.add_argument( '--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="How to treat imports (default normal)") imports_group.add_argument( '--python-executable', action='store', metavar='EXECUTABLE', help="Python executable used for finding PEP 561 compliant installed" " packages and stubs", dest='special-opts:python_executable') imports_group.add_argument( '--no-site-packages', action='store_true', dest='special-opts:no_executable', help="Do not search for installed PEP 561 compliant packages") imports_group.add_argument( '--no-silence-site-packages', action='store_true', help="Do not silence errors in PEP 561 compliant installed packages") add_invertible_flag( '--namespace-packages', default=False, help="Support namespace packages (PEP 420, __init__.py-less)", group=imports_group) platform_group = parser.add_argument_group( title='Platform configuration', description="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.") platform_group.add_argument( '--python-version', type=parse_version, metavar='x.y', help='Type check code assuming it will be running on Python x.y', dest='special-opts:python_version') platform_group.add_argument( '-2', '--py2', dest='special-opts:python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="Use Python 2 mode (same as --python-version 2.7)") platform_group.add_argument( '--platform', action='store', metavar='PLATFORM', help="Type check special-cased code for the given OS platform " "(defaults to sys.platform)") platform_group.add_argument( '--always-true', metavar='NAME', action='append', default=[], help="Additional variable to be considered True (may be repeated)") platform_group.add_argument( '--always-false', metavar='NAME', action='append', default=[], help="Additional variable to be considered False (may be repeated)") disallow_any_group = parser.add_argument_group( title='Dynamic typing', description="Disallow the use of the dynamic 'Any' type under certain conditions.") disallow_any_group.add_argument( '--disallow-any-unimported', default=False, action='store_true', help="Disallow Any types resulting from unfollowed imports") add_invertible_flag('--disallow-subclassing-any', default=False, strict_flag=True, help="Disallow subclassing values of type 'Any' when defining classes", group=disallow_any_group) disallow_any_group.add_argument( '--disallow-any-expr', default=False, action='store_true', help='Disallow all expressions that have type Any') disallow_any_group.add_argument( '--disallow-any-decorated', default=False, action='store_true', help='Disallow functions that have Any in their signature ' 'after decorator transformation') disallow_any_group.add_argument( '--disallow-any-explicit', default=False, action='store_true', help='Disallow explicit Any in type positions') add_invertible_flag('--disallow-any-generics', default=False, strict_flag=True, help='Disallow usage of generic types that do not specify explicit type ' 'parameters', group=disallow_any_group) untyped_group = parser.add_argument_group( title='Untyped definitions and calls', description="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'.") add_invertible_flag('--disallow-untyped-calls', default=False, strict_flag=True, help="Disallow calling functions without type annotations" " from functions with type annotations", group=untyped_group) add_invertible_flag('--disallow-untyped-defs', default=False, strict_flag=True, help="Disallow defining functions without type annotations" " or with incomplete type annotations", group=untyped_group) add_invertible_flag('--disallow-incomplete-defs', default=False, strict_flag=True, help="Disallow defining functions with incomplete type annotations", group=untyped_group) add_invertible_flag('--check-untyped-defs', default=False, strict_flag=True, help="Type check the interior of functions without type annotations", group=untyped_group) add_invertible_flag('--disallow-untyped-decorators', default=False, strict_flag=True, help="Disallow decorating typed functions with untyped decorators", group=untyped_group) none_group = parser.add_argument_group( title='None and Optional handling', description="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") add_invertible_flag('--no-implicit-optional', default=False, strict_flag=True, help="Don't assume arguments with default values of None are Optional", group=none_group) none_group.add_argument( '--strict-optional', action='store_true', help=argparse.SUPPRESS) none_group.add_argument( '--no-strict-optional', action='store_false', dest='strict_optional', help="Disable strict Optional checks (inverse: --strict-optional)") none_group.add_argument( '--strict-optional-whitelist', metavar='GLOB', nargs='*', help="Suppress strict Optional errors in all but the provided files; " "implies --strict-optional (may suppress certain other errors " "in non-whitelisted files)") lint_group = parser.add_argument_group( title='Warnings', description="Detect code that is sound but redundant or problematic.") add_invertible_flag('--warn-redundant-casts', default=False, strict_flag=True, help="Warn about casting an expression to its inferred type", group=lint_group) add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True, help="Warn about unneeded '# type: ignore' comments", group=lint_group) add_invertible_flag('--no-warn-no-return', dest='warn_no_return', default=True, help="Do not warn about functions that end without returning", group=lint_group) add_invertible_flag('--warn-return-any', default=False, strict_flag=True, help="Warn about returning values of type Any" " from non-Any typed functions", group=lint_group) # Note: this group is intentionally added here even though we don't add # --strict to this group near the end. # # That way, this group will appear after the various strictness groups # but before the remaining flags. # We add `--strict` near the end so we don't accidentally miss any strictness # flags that are added after this group. strictness_group = parser.add_argument_group( title='Other strictness checks') add_invertible_flag('--allow-untyped-globals', default=False, strict_flag=False, help="Suppress toplevel errors caused by missing annotations", group=strictness_group) add_invertible_flag('--allow-redefinition', default=False, strict_flag=False, help="Allow unconditional variable redefinition with a new type", group=strictness_group) add_invertible_flag('--strict-equality', default=False, strict_flag=False, help="Prohibit equality, identity, and container checks for" " non-overlapping types", group=strictness_group) incremental_group = parser.add_argument_group( title='Incremental mode', description="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") incremental_group.add_argument( '-i', '--incremental', action='store_true', help=argparse.SUPPRESS) incremental_group.add_argument( '--no-incremental', action='store_false', dest='incremental', help="Disable module cache (inverse: --incremental)") incremental_group.add_argument( '--cache-dir', action='store', metavar='DIR', help="Store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) add_invertible_flag('--sqlite-cache', default=False, help="Use a sqlite database to store the cache", group=incremental_group) incremental_group.add_argument( '--cache-fine-grained', action='store_true', help="Include fine-grained dependency information in the cache for the mypy daemon") incremental_group.add_argument( '--skip-version-check', action='store_true', help="Allow using cache written by older mypy version") incremental_group.add_argument( '--skip-cache-mtime-checks', action='store_true', help="Skip cache internal consistency checks based on mtime") internals_group = parser.add_argument_group( title='Mypy internals', description="Debug and customize mypy internals.") internals_group.add_argument( '--pdb', action='store_true', help="Invoke pdb on fatal error") internals_group.add_argument( '--show-traceback', '--tb', action='store_true', help="Show traceback on fatal error") internals_group.add_argument( '--raise-exceptions', action='store_true', help="Raise exception on fatal error" ) internals_group.add_argument( '--custom-typing', metavar='MODULE', dest='custom_typing_module', help="Use a custom typing module") internals_group.add_argument( '--custom-typeshed-dir', metavar='DIR', help="Use the custom typeshed in DIR") add_invertible_flag('--warn-incomplete-stub', default=False, help="Warn if missing type annotation in typeshed, only relevant with" " --disallow-untyped-defs or --disallow-incomplete-defs enabled", group=internals_group) internals_group.add_argument( '--shadow-file', nargs=2, metavar=('SOURCE_FILE', 'SHADOW_FILE'), dest='shadow_file', action='append', help="When encountering SOURCE_FILE, read and type check " "the contents of SHADOW_FILE instead.") add_invertible_flag('--fast-exit', default=False, help=argparse.SUPPRESS, group=internals_group) add_invertible_flag('--new-semantic-analyzer', default=False, help=argparse.SUPPRESS, group=internals_group) error_group = parser.add_argument_group( title='Error reporting', description="Adjust the amount of detail shown in error messages.") add_invertible_flag('--show-error-context', default=False, dest='show_error_context', help='Precede errors with "note:" messages explaining context', group=error_group) add_invertible_flag('--show-column-numbers', default=False, help="Show column numbers in error messages", group=error_group) strict_help = "Strict mode; enables the following flags: {}".format( ", ".join(strict_flag_names)) strictness_group.add_argument( '--strict', action='store_true', dest='special-opts:strict', help=strict_help) report_group = parser.add_argument_group( title='Report generation', description='Generate a report in the specified format.') for report_type in sorted(defaults.REPORTER_NAMES): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) other_group = parser.add_argument_group( title='Miscellaneous') other_group.add_argument( '--quickstart-file', help=argparse.SUPPRESS) other_group.add_argument( '--junit-xml', help="Write junit.xml to the given file") other_group.add_argument( '--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") other_group.add_argument( '--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="Print out all usages of a class member (experimental)") if server_options: # TODO: This flag is superfluous; remove after a short transition (2018-03-16) other_group.add_argument( '--experimental', action='store_true', dest='fine_grained_incremental', help="Enable fine-grained incremental mode") other_group.add_argument( '--use-fine-grained-cache', action='store_true', help="Use the cache in fine-grained incremental mode") # hidden options parser.add_argument( '--stats', action='store_true', dest='dump_type_stats', help=argparse.SUPPRESS) parser.add_argument( '--inferstats', action='store_true', dest='dump_inference_stats', help=argparse.SUPPRESS) # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-deps will dump all fine-grained dependencies to stdout parser.add_argument('--dump-deps', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) # --semantic-analysis-only does exactly that. parser.add_argument('--semantic-analysis-only', action='store_true', help=argparse.SUPPRESS) # --local-partial-types disallows partial types spanning module top level and a function # (implicitly defined in fine-grained incremental mode) parser.add_argument('--local-partial-types', action='store_true', help=argparse.SUPPRESS) # --logical-deps adds some more dependencies that are not semantically needed, but # may be helpful to determine relative importance of classes and functions for overall # type precision in a code base. It also _removes_ some deps, so this flag should be never # used except for generating code stats. This also automatically enables --cache-fine-grained. # NOTE: This is an experimental option that may be modified or removed at any time. parser.add_argument('--logical-deps', action='store_true', help=argparse.SUPPRESS) # --bazel changes some behaviors for use with Bazel (https://bazel.build). parser.add_argument('--bazel', action='store_true', help=argparse.SUPPRESS) # --package-root adds a directory below which directories are considered # packages even without __init__.py. May be repeated. parser.add_argument('--package-root', metavar='ROOT', action='append', default=[], help=argparse.SUPPRESS) # --cache-map FILE ... gives a mapping from source files to cache files. # Each triple of arguments is a source file, a cache meta file, and a cache data file. # Modules not mentioned in the file will go through cache_dir. # Must be followed by another flag or by '--' (and then only file args may follow). parser.add_argument('--cache-map', nargs='+', dest='special-opts:cache_map', help=argparse.SUPPRESS) # options specifying code to check code_group = parser.add_argument_group( title="Running code", description="Specify the code you want to type check. For more details, see " "mypy.readthedocs.io/en/latest/running_mypy.html#running-mypy") code_group.add_argument( '-m', '--module', action='append', metavar='MODULE', default=[], dest='special-opts:modules', help="Type-check module; can repeat for more modules") code_group.add_argument( '-p', '--package', action='append', metavar='PACKAGE', default=[], dest='special-opts:packages', help="Type-check package recursively; can be repeated") code_group.add_argument( '-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="Type-check program passed in as string") code_group.add_argument( metavar='files', nargs='*', dest='special-opts:files', help="Type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file and know if the user requested all strict options. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file # Don't explicitly test if "config_file is not None" for this check. # This lets `--config-file=` (an empty string) be used to disable all config files. if config_file and not os.path.exists(config_file): parser.error("Cannot find config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() parse_config_file(options, config_file) # Set strict flags before parsing (if strict mode enabled), so other command # line options can override. if getattr(dummy, 'special-opts:strict'): for dest, value in strict_flag_assignments: setattr(options, dest, value) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # The python_version is either the default, which can be overridden via a config file, # or stored in special_opts and is passed via the command line. options.python_version = special_opts.python_version or options.python_version try: infer_python_executable(options, special_opts) except PythonExecutableInferenceError as e: parser.error(str(e)) if special_opts.no_executable: options.python_executable = None # Paths listed in the config file will be ignored if any paths are passed on # the command line. if options.files and not special_opts.files: special_opts.files = options.files # Check for invalid argument combinations. if require_targets: code_methods = sum(bool(c) for c in [special_opts.modules + special_opts.packages, special_opts.command, special_opts.files]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module/package, files, or command.") # Check for overlapping `--always-true` and `--always-false` flags. overlap = set(options.always_true) & set(options.always_false) if overlap: parser.error("You can't make a variable always true and always false (%s)" % ', '.join(sorted(overlap))) # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if special_opts.find_occurrences: state.find_occurrences = special_opts.find_occurrences.split('.') assert state.find_occurrences is not None if len(state.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(state.find_occurrences) != 2: parser.error("Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Process --package-root. if options.package_root: process_package_roots(fscache, parser, options) # Process --cache-map. if special_opts.cache_map: if options.sqlite_cache: parser.error("--cache-map is incompatible with --sqlite-cache") process_cache_map(parser, special_opts, options) # Let logical_deps imply cache_fine_grained (otherwise the former is useless). if options.logical_deps: options.cache_fine_grained = True # Set target. if special_opts.modules + special_opts.packages: options.build_type = BuildType.MODULE search_paths = SearchPaths((os.getcwd(),), tuple(mypy_path()), (), ()) targets = [] # TODO: use the same cache that the BuildManager will cache = FindModuleCache(search_paths, fscache) for p in special_opts.packages: if os.sep in p or os.altsep and os.altsep in p: fail("Package name '{}' cannot have a slash in it.".format(p)) p_targets = cache.find_modules_recursive(p) if not p_targets: fail("Can't find package '{}'".format(p)) targets.extend(p_targets) for m in special_opts.modules: targets.append(BuildSource(None, m, None)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT targets = [BuildSource(None, None, '\n'.join(special_opts.command))] return targets, options else: try: targets = create_source_list(special_opts.files, options, fscache) except InvalidSourceList as e: fail(str(e)) return targets, options
def process_options( args: List[str], require_targets: bool = True) -> Tuple[List[BuildSource], Options]: """Parse command line arguments.""" # Make the help output a little less jarring. help_factory = (lambda prog: argparse.RawDescriptionHelpFormatter( prog=prog, max_help_position=28)) parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=help_factory) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument( '--platform', action='store', metavar='PLATFORM', help="typecheck special-cased code for the given OS platform " "(defaults to sys.platform).") parser.add_argument('-2', '--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('-s', '--silent-imports', action='store_true', help="don't follow imports to .py files") parser.add_argument( '--almost-silent', action='store_true', help="like --silent-imports but reports the imports as errors") parser.add_argument( '--disallow-untyped-calls', action='store_true', help="disallow calling functions without type annotations" " from functions with type annotations") parser.add_argument( '--disallow-untyped-defs', action='store_true', help="disallow defining functions without type annotations" " or with incomplete type annotations") parser.add_argument( '--check-untyped-defs', action='store_true', help="type check the interior of functions without type annotations") parser.add_argument( '--disallow-subclassing-any', action='store_true', help="disallow subclassing values of type 'Any' when defining classes") parser.add_argument( '--warn-incomplete-stub', action='store_true', help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") parser.add_argument( '--warn-redundant-casts', action='store_true', help="warn about casting an expression to its inferred type") parser.add_argument('--warn-no-return', action='store_true', help="warn about functions that end without returning") parser.add_argument('--warn-unused-ignores', action='store_true', help="warn about unneeded '# type: ignore' comments") parser.add_argument('--hide-error-context', action='store_true', dest='hide_error_context', help="Hide context notes before errors") parser.add_argument('--fast-parser', action='store_true', help="enable experimental fast parser") parser.add_argument('-i', '--incremental', action='store_true', help="enable experimental module cache") parser.add_argument( '--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) parser.add_argument('--strict-optional', action='store_true', dest='strict_optional', help="enable experimental strict Optional checks") parser.add_argument( '--strict-optional-whitelist', metavar='GLOB', nargs='*', help="suppress strict Optional errors in all but the provided files " "(experimental -- read documentation before using!). " "Implies --strict-optional. Has the undesirable side-effect of " "suppressing other errors in non-whitelisted files.") parser.add_argument('--junit-xml', help="write junit.xml to the given file") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--show-traceback', '--tb', action='store_true', help="show traceback on fatal error") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") parser.add_argument('--custom-typeshed-dir', metavar='DIR', help="use the custom typeshed in DIR") parser.add_argument('--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") parser.add_argument('--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(defaults.CONFIG_FILE)) parser.add_argument('--show-column-numbers', action='store_true', dest='show_column_numbers', help="Show column numbers in error messages") parser.add_argument( '--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="print out all usages of a class member (experimental)") # hidden options # --shadow-file a.py tmp.py will typecheck tmp.py in place of a.py. # Useful for tools to make transformations to a file to get more # information from a mypy run without having to change the file in-place # (e.g. by adding a call to reveal_type). parser.add_argument('--shadow-file', metavar='PATH', nargs=2, dest='shadow_file', help=argparse.SUPPRESS) # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # deprecated options parser.add_argument('--silent', action='store_true', dest='special-opts:silent', help=argparse.SUPPRESS) parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') for report_type in sorted(reporter_classes): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) code_group = parser.add_argument_group( title='How to specify the code to type check') code_group.add_argument( '-m', '--module', action='append', metavar='MODULE', dest='special-opts:modules', help="type-check module; can repeat for more modules") # TODO: `mypy -p A -p B` currently silently ignores ignores A # (last option wins). Perhaps -c, -m and -p could just be # command-line flags that modify how we interpret self.files? code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument('-p', '--package', metavar='PACKAGE', dest='special-opts:package', help="type-check all files in a directory") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file or defaults.CONFIG_FILE # Parse config file first, so command line can override. options = Options() if config_file and os.path.exists(config_file): parse_config_file(options, config_file) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error( "Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # warn about deprecated options if special_opts.silent: print("Warning: --silent is deprecated; use --silent-imports", file=sys.stderr) options.silent_imports = True if special_opts.dirty_stubs: print( "Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) # Check for invalid argument combinations. if require_targets: code_methods = sum( bool(c) for c in [ special_opts.modules, special_opts.command, special_opts.package, special_opts.files ]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error( "May only specify one of: module, package, files, or command.") # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if options.strict_optional: experiments.STRICT_OPTIONAL = True if special_opts.find_occurrences: experiments.find_occurrences = special_opts.find_occurrences.split('.') if len(experiments.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(experiments.find_occurrences) != 2: parser.error( "Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it.".format( special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = build.find_modules_recursive(special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT return [BuildSource(None, None, '\n'.join(special_opts.command))], options else: targets = [] for f in special_opts.files: if f.endswith(PY_EXTENSIONS): targets.append(BuildSource(f, crawl_up(f)[1], None)) elif os.path.isdir(f): sub_targets = expand_dir(f) if not sub_targets: fail("There are no .py[i] files in directory '{}'".format( f)) targets.extend(sub_targets) else: mod = os.path.basename( f) if options.scripts_are_modules else None targets.append(BuildSource(f, mod, None)) return targets, options
def process_options(args: List[str], require_targets: bool = True, server_options: bool = False, fscache: Optional[FileSystemCache] = None, ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments. If a FileSystemCache is passed in, and package_root options are given, call fscache.set_package_root() to set the cache's package root. """ parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=AugmentedHelpFormatter) strict_flag_names = [] # type: List[str] strict_flag_assignments = [] # type: List[Tuple[str, bool]] def add_invertible_flag(flag: str, *, inverse: Optional[str] = None, default: bool, dest: Optional[str] = None, help: str, strict_flag: bool = False, group: Optional[argparse._ActionsContainer] = None ) -> None: if inverse is None: inverse = invert_flag_name(flag) if group is None: group = parser if help is not argparse.SUPPRESS: help += " (inverse: {})".format(inverse) arg = group.add_argument(flag, action='store_false' if default else 'store_true', dest=dest, help=help) dest = arg.dest arg = group.add_argument(inverse, action='store_true' if default else 'store_false', dest=dest, help=argparse.SUPPRESS) if strict_flag: assert dest is not None strict_flag_names.append(flag) strict_flag_assignments.append((dest, not default)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__, help="show program's version number and exit") config_group = parser.add_argument_group( title='config file', description="Use a config file instead of command line arguments.") config_group.add_argument( '--config-file', help="configuration file, must have a [mypy] section " "(defaults to {})".format(', '.join(defaults.CONFIG_FILES))) add_invertible_flag('--warn-unused-configs', default=False, strict_flag=True, help="warn about unused '[mypy-<pattern>]' config sections", group=config_group) imports_group = parser.add_argument_group( title='import discovery', description="Configure how imports are discovered and followed.") imports_group.add_argument( '--ignore-missing-imports', action='store_true', help="silently ignore imports of missing modules") imports_group.add_argument( '--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="how to treat imports (default normal)") imports_group.add_argument( '--python-executable', action='store', metavar='EXECUTABLE', help="Python executable used for finding PEP 561 compliant installed" " packages and stubs", dest='special-opts:python_executable') imports_group.add_argument( '--no-site-packages', action='store_true', dest='special-opts:no_executable', help="do not search for installed PEP 561 compliant packages") platform_group = parser.add_argument_group( title='platform configuration', description="Type check code assuming certain runtime conditions.") platform_group.add_argument( '--python-version', type=parse_version, metavar='x.y', help='type check code assuming it will be running on Python x.y', dest='special-opts:python_version') platform_group.add_argument( '-2', '--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode (same as --python-version 2.7)") platform_group.add_argument( '--platform', action='store', metavar='PLATFORM', help="type check special-cased code for the given OS platform " "(defaults to sys.platform)") platform_group.add_argument( '--always-true', metavar='NAME', action='append', default=[], help="additional variable to be considered True (may be repeated)") platform_group.add_argument( '--always-false', metavar='NAME', action='append', default=[], help="additional variable to be considered False (may be repeated)") disallow_any_group = parser.add_argument_group( title='Any type restrictions', description="Disallow the use of the 'Any' type under certain conditions.") disallow_any_group.add_argument( '--disallow-any-unimported', default=False, action='store_true', help="disallow Any types resulting from unfollowed imports") add_invertible_flag('--disallow-subclassing-any', default=False, strict_flag=True, help="disallow subclassing values of type 'Any' when defining classes", group=disallow_any_group) disallow_any_group.add_argument( '--disallow-any-expr', default=False, action='store_true', help='disallow all expressions that have type Any') disallow_any_group.add_argument( '--disallow-any-decorated', default=False, action='store_true', help='disallow functions that have Any in their signature ' 'after decorator transformation') disallow_any_group.add_argument( '--disallow-any-explicit', default=False, action='store_true', help='disallow explicit Any in type positions') disallow_any_group.add_argument( '--disallow-any-generics', default=False, action='store_true', help='disallow usage of generic types that do not specify explicit ' 'type parameters') untyped_group = parser.add_argument_group( title='untyped definitions and calls', description="Configure how untyped definitions and calls are handled.") add_invertible_flag('--disallow-untyped-calls', default=False, strict_flag=True, help="disallow calling functions without type annotations" " from functions with type annotations", group=untyped_group) add_invertible_flag('--disallow-untyped-defs', default=False, strict_flag=True, help="disallow defining functions without type annotations" " or with incomplete type annotations", group=untyped_group) add_invertible_flag('--disallow-incomplete-defs', default=False, strict_flag=True, help="disallow defining functions with incomplete type annotations", group=untyped_group) add_invertible_flag('--check-untyped-defs', default=False, strict_flag=True, help="type check the interior of functions without type annotations", group=untyped_group) add_invertible_flag('--warn-incomplete-stub', default=False, help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled", group=untyped_group) none_group = parser.add_argument_group( title='None and Optional handling', description="Adjust how values of type 'None' are handled.") add_invertible_flag('--no-implicit-optional', default=False, strict_flag=True, help="don't assume arguments with default values of None are Optional", group=none_group) none_group.add_argument( '--strict-optional', action='store_true', help=argparse.SUPPRESS) none_group.add_argument( '--no-strict-optional', action='store_false', dest='strict_optional', help="disable strict Optional checks (inverse: --strict-optional)") none_group.add_argument( '--strict-optional-whitelist', metavar='GLOB', nargs='*', help="suppress strict Optional errors in all but the provided files; " "implies --strict-optional (may suppress certain other errors " "in non-whitelisted files)") lint_group = parser.add_argument_group( title='warnings', description="Detect code that is sound but redundant or problematic.") add_invertible_flag('--warn-redundant-casts', default=False, strict_flag=True, help="warn about casting an expression to its inferred type", group=lint_group) add_invertible_flag('--no-warn-no-return', dest='warn_no_return', default=True, help="do not warn about functions that end without returning", group=lint_group) add_invertible_flag('--warn-return-any', default=False, strict_flag=True, help="warn about returning values of type Any" " from non-Any typed functions", group=lint_group) add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True, help="warn about unneeded '# type: ignore' comments", group=lint_group) strictness_group = parser.add_argument_group( title='other strictness checks', description="Other miscellaneous strictness checks.") add_invertible_flag('--disallow-untyped-decorators', default=False, strict_flag=True, help="disallow decorating typed functions with untyped decorators", group=strictness_group) incremental_group = parser.add_argument_group( title='incremental mode', description="Adjust how mypy incrementally type checks and caches modules.") incremental_group.add_argument( '-i', '--incremental', action='store_true', help=argparse.SUPPRESS) incremental_group.add_argument( '--no-incremental', action='store_false', dest='incremental', help="disable module cache (inverse: --incremental)") incremental_group.add_argument( '--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) incremental_group.add_argument( '--cache-fine-grained', action='store_true', help="include fine-grained dependency information in the cache for the mypy daemon") incremental_group.add_argument( '--quick-and-dirty', action='store_true', help="use cache even if dependencies out of date (implies --incremental)") incremental_group.add_argument( '--skip-version-check', action='store_true', help="allow using cache written by older mypy version") internals_group = parser.add_argument_group( title='mypy internals', description="Debug and customize mypy internals.") internals_group.add_argument( '--pdb', action='store_true', help="invoke pdb on fatal error") internals_group.add_argument( '--show-traceback', '--tb', action='store_true', help="show traceback on fatal error") internals_group.add_argument( '--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") internals_group.add_argument( '--custom-typeshed-dir', metavar='DIR', help="use the custom typeshed in DIR") internals_group.add_argument( '--shadow-file', nargs=2, metavar=('SOURCE_FILE', 'SHADOW_FILE'), dest='shadow_file', action='append', help="when encountering SOURCE_FILE, read and type check " "the contents of SHADOW_FILE instead.") error_group = parser.add_argument_group( title='error reporting', description="Adjust the amount of detail shown in error messages.") add_invertible_flag('--show-error-context', default=False, dest='show_error_context', help='precede errors with "note:" messages explaining context', group=error_group) add_invertible_flag('--show-column-numbers', default=False, help="show column numbers in error messages", group=error_group) analysis_group = parser.add_argument_group( title='extra analysis', description="Extract additional information and analysis.") analysis_group.add_argument( '--stats', action='store_true', dest='dump_type_stats', help=argparse.SUPPRESS) analysis_group.add_argument( '--inferstats', action='store_true', dest='dump_inference_stats', help=argparse.SUPPRESS) analysis_group.add_argument( '--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="print out all usages of a class member (experimental)") strict_help = "strict mode; enables the following flags: {}".format( ", ".join(strict_flag_names)) strictness_group.add_argument( '--strict', action='store_true', dest='special-opts:strict', help=strict_help) report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') for report_type in sorted(reporter_classes): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) other_group = parser.add_argument_group( title='miscellaneous', description="Other miscellaneous flags.") other_group.add_argument( '--junit-xml', help="write junit.xml to the given file") other_group.add_argument( '--scripts-are-modules', action='store_true', help="script x becomes module x instead of __main__") if server_options: # TODO: This flag is superfluous; remove after a short transition (2018-03-16) other_group.add_argument( '--experimental', action='store_true', dest='fine_grained_incremental', help="enable fine-grained incremental mode") other_group.add_argument( '--use-fine-grained-cache', action='store_true', help="use the cache in fine-grained incremental mode") # hidden options # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-deps will dump all fine-grained dependencies to stdout parser.add_argument('--dump-deps', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) # --semantic-analysis-only does exactly that. parser.add_argument('--semantic-analysis-only', action='store_true', help=argparse.SUPPRESS) # --local-partial-types disallows partial types spanning module top level and a function # (implicitly defined in fine-grained incremental mode) parser.add_argument('--local-partial-types', action='store_true', help=argparse.SUPPRESS) # --bazel changes some behaviors for use with Bazel (https://bazel.build). parser.add_argument('--bazel', action='store_true', help=argparse.SUPPRESS) # --package-root adds a directory below which directories are considered # packages even without __init__.py. May be repeated. parser.add_argument('--package-root', metavar='ROOT', action='append', default=[], help=argparse.SUPPRESS) # --cache-map FILE ... gives a mapping from source files to cache files. # Each triple of arguments is a source file, a cache meta file, and a cache data file. # Modules not mentioned in the file will go through cache_dir. # Must be followed by another flag or by '--' (and then only file args may follow). parser.add_argument('--cache-map', nargs='+', dest='special-opts:cache_map', help=argparse.SUPPRESS) # deprecated options parser.add_argument('--disallow-any', dest='special-opts:disallow_any', help=argparse.SUPPRESS) add_invertible_flag('--strict-boolean', default=False, help=argparse.SUPPRESS) parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) parser.add_argument('-s', '--silent-imports', action='store_true', dest='special-opts:silent_imports', help=argparse.SUPPRESS) parser.add_argument('--almost-silent', action='store_true', dest='special-opts:almost_silent', help=argparse.SUPPRESS) parser.add_argument('--fast-parser', action='store_true', dest='special-opts:fast_parser', help=argparse.SUPPRESS) parser.add_argument('--no-fast-parser', action='store_true', dest='special-opts:no_fast_parser', help=argparse.SUPPRESS) code_group = parser.add_argument_group(title='specifying which code to type check') code_group.add_argument('-m', '--module', action='append', metavar='MODULE', default=[], dest='special-opts:modules', help="type-check module; can repeat for more modules") code_group.add_argument('-p', '--package', action='append', metavar='PACKAGE', default=[], dest='special-opts:packages', help="type-check package recursively; can be repeated") code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file and know if the user requested all strict options. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file if config_file is not None and not os.path.exists(config_file): parser.error("Cannot find config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() parse_config_file(options, config_file) # Set strict flags before parsing (if strict mode enabled), so other command # line options can override. if getattr(dummy, 'special-opts:strict'): for dest, value in strict_flag_assignments: setattr(options, dest, value) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error("Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # Process deprecated options if special_opts.disallow_any: print("--disallow-any option was split up into multiple flags. " "See http://mypy.readthedocs.io/en/latest/command_line.html#disallow-any-flags") if options.strict_boolean: print("Warning: --strict-boolean is deprecated; " "see https://github.com/python/mypy/issues/3195", file=sys.stderr) if special_opts.almost_silent: print("Warning: --almost-silent has been replaced by " "--follow-imports=errors", file=sys.stderr) if options.follow_imports == 'normal': options.follow_imports = 'errors' elif special_opts.silent_imports: print("Warning: --silent-imports has been replaced by " "--ignore-missing-imports --follow-imports=skip", file=sys.stderr) options.ignore_missing_imports = True if options.follow_imports == 'normal': options.follow_imports = 'skip' if special_opts.dirty_stubs: print("Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) if special_opts.fast_parser: print("Warning: --fast-parser is now the default (and only) parser.") if special_opts.no_fast_parser: print("Warning: --no-fast-parser no longer has any effect. The fast parser " "is now mypy's default and only parser.") try: infer_python_version_and_executable(options, special_opts) except PythonExecutableInferenceError as e: parser.error(str(e)) if special_opts.no_executable: options.python_executable = None # Check for invalid argument combinations. if require_targets: code_methods = sum(bool(c) for c in [special_opts.modules + special_opts.packages, special_opts.command, special_opts.files]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module/package, files, or command.") # Check for overlapping `--always-true` and `--always-false` flags. overlap = set(options.always_true) & set(options.always_false) if overlap: parser.error("You can't make a variable always true and always false (%s)" % ', '.join(sorted(overlap))) # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if special_opts.find_occurrences: experiments.find_occurrences = special_opts.find_occurrences.split('.') assert experiments.find_occurrences is not None if len(experiments.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(experiments.find_occurrences) != 2: parser.error("Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Process --package-root. if options.package_root: process_package_roots(fscache, parser, options) # Process --cache-map. if special_opts.cache_map: process_cache_map(parser, special_opts, options) # Let quick_and_dirty imply incremental. if options.quick_and_dirty: options.incremental = True # Set target. if special_opts.modules + special_opts.packages: options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = [] # TODO: use the same cache that the BuildManager will cache = build.FindModuleCache(fscache) for p in special_opts.packages: if os.sep in p or os.altsep and os.altsep in p: fail("Package name '{}' cannot have a slash in it.".format(p)) p_targets = cache.find_modules_recursive(p, tuple(lib_path), options.python_executable) if not p_targets: fail("Can't find package '{}'".format(p)) targets.extend(p_targets) for m in special_opts.modules: targets.append(BuildSource(None, m, None)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT targets = [BuildSource(None, None, '\n'.join(special_opts.command))] return targets, options else: try: targets = create_source_list(special_opts.files, options, fscache) except InvalidSourceList as e: fail(str(e)) return targets, options
def process_options(args: List[str], require_targets: bool = True ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments.""" # Make the help output a little less jarring. help_factory = (lambda prog: argparse.RawDescriptionHelpFormatter(prog=prog, max_help_position=28)) # type: Any parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=help_factory) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument('--platform', action='store', metavar='PLATFORM', help="typecheck special-cased code for the given OS platform " "(defaults to sys.platform).") parser.add_argument('-2', '--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('--ignore-missing-imports', action='store_true', help="silently ignore imports of missing modules") parser.add_argument('--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="how to treat imports (default normal)") parser.add_argument('--disallow-untyped-calls', action='store_true', help="disallow calling functions without type annotations" " from functions with type annotations") parser.add_argument('--disallow-untyped-defs', action='store_true', help="disallow defining functions without type annotations" " or with incomplete type annotations") parser.add_argument('--check-untyped-defs', action='store_true', help="type check the interior of functions without type annotations") parser.add_argument('--disallow-subclassing-any', action='store_true', help="disallow subclassing values of type 'Any' when defining classes") parser.add_argument('--warn-incomplete-stub', action='store_true', help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") parser.add_argument('--warn-redundant-casts', action='store_true', help="warn about casting an expression to its inferred type") parser.add_argument('--warn-no-return', action='store_true', help="warn about functions that end without returning") parser.add_argument('--warn-unused-ignores', action='store_true', help="warn about unneeded '# type: ignore' comments") parser.add_argument('--show-error-context', action='store_false', dest='hide_error_context', help='Precede errors with "note:" messages explaining context') parser.add_argument('--fast-parser', action='store_true', help="enable fast parser (recommended except on Windows)") parser.add_argument('-i', '--incremental', action='store_true', help="enable experimental module cache") parser.add_argument('--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) parser.add_argument('--strict-optional', action='store_true', dest='strict_optional', help="enable experimental strict Optional checks") parser.add_argument('--strict-optional-whitelist', metavar='GLOB', nargs='*', help="suppress strict Optional errors in all but the provided files " "(experimental -- read documentation before using!). " "Implies --strict-optional. Has the undesirable side-effect of " "suppressing other errors in non-whitelisted files.") parser.add_argument('--junit-xml', help="write junit.xml to the given file") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--show-traceback', '--tb', action='store_true', help="show traceback on fatal error") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") parser.add_argument('--custom-typeshed-dir', metavar='DIR', help="use the custom typeshed in DIR") parser.add_argument('--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") parser.add_argument('--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(defaults.CONFIG_FILE)) parser.add_argument('--show-column-numbers', action='store_true', dest='show_column_numbers', help="Show column numbers in error messages") parser.add_argument('--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="print out all usages of a class member (experimental)") # hidden options # --shadow-file a.py tmp.py will typecheck tmp.py in place of a.py. # Useful for tools to make transformations to a file to get more # information from a mypy run without having to change the file in-place # (e.g. by adding a call to reveal_type). parser.add_argument('--shadow-file', metavar='PATH', nargs=2, dest='shadow_file', help=argparse.SUPPRESS) # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) parser.add_argument('--hide-error-context', action='store_true', dest='hide_error_context', help=argparse.SUPPRESS) # deprecated options parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) parser.add_argument('-s', '--silent-imports', action='store_true', dest='special-opts:silent_imports', help=argparse.SUPPRESS) parser.add_argument('--almost-silent', action='store_true', dest='special-opts:almost_silent', help=argparse.SUPPRESS) report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') for report_type in sorted(reporter_classes): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) code_group = parser.add_argument_group(title='How to specify the code to type check') code_group.add_argument('-m', '--module', action='append', metavar='MODULE', dest='special-opts:modules', help="type-check module; can repeat for more modules") # TODO: `mypy -p A -p B` currently silently ignores ignores A # (last option wins). Perhaps -c, -m and -p could just be # command-line flags that modify how we interpret self.files? code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument('-p', '--package', metavar='PACKAGE', dest='special-opts:package', help="type-check all files in a directory") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = defaults.CONFIG_FILE if dummy.config_file: config_file = dummy.config_file if not os.path.exists(config_file): parser.error("Cannot file config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() if config_file and os.path.exists(config_file): parse_config_file(options, config_file) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error("Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # Process deprecated options if special_opts.almost_silent: print("Warning: --almost-silent has been replaced by " "--follow-imports=errors", file=sys.stderr) if options.follow_imports == 'normal': options.follow_imports = 'errors' elif special_opts.silent_imports: print("Warning: --silent-imports has been replaced by " "--ignore-missing-imports --follow-imports=skip", file=sys.stderr) options.ignore_missing_imports = True if options.follow_imports == 'normal': options.follow_imports = 'skip' if special_opts.dirty_stubs: print("Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) # Check for invalid argument combinations. if require_targets: code_methods = sum(bool(c) for c in [special_opts.modules, special_opts.command, special_opts.package, special_opts.files]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module, package, files, or command.") # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if options.strict_optional: experiments.STRICT_OPTIONAL = True if special_opts.find_occurrences: experiments.find_occurrences = special_opts.find_occurrences.split('.') if len(experiments.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(experiments.find_occurrences) != 2: parser.error("Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it." .format(special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = build.find_modules_recursive(special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT return [BuildSource(None, None, '\n'.join(special_opts.command))], options else: targets = [] for f in special_opts.files: if f.endswith(PY_EXTENSIONS): targets.append(BuildSource(f, crawl_up(f)[1], None)) elif os.path.isdir(f): sub_targets = expand_dir(f) if not sub_targets: fail("There are no .py[i] files in directory '{}'" .format(f)) targets.extend(sub_targets) else: mod = os.path.basename(f) if options.scripts_are_modules else None targets.append(BuildSource(f, mod, None)) return targets, options
def process_options(args: List[str], require_targets: bool = True) -> Tuple[List[BuildSource], Options]: """Parse command line arguments.""" # Make the help output a little less jarring. help_factory = lambda prog: argparse.RawDescriptionHelpFormatter(prog=prog, max_help_position=28) parser = argparse.ArgumentParser(prog="mypy", epilog=FOOTER, formatter_class=help_factory) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument("-v", "--verbose", action="count", dest="verbosity", help="more verbose messages") parser.add_argument("-V", "--version", action="version", version="%(prog)s " + __version__) parser.add_argument("--python-version", type=parse_version, metavar="x.y", help="use Python x.y") parser.add_argument( "--platform", action="store", metavar="PLATFORM", help="typecheck special-cased code for the given OS platform " "(defaults to sys.platform).", ) parser.add_argument( "-2", "--py2", dest="python_version", action="store_const", const=defaults.PYTHON2_VERSION, help="use Python 2 mode", ) parser.add_argument("-s", "--silent-imports", action="store_true", help="don't follow imports to .py files") parser.add_argument( "--almost-silent", action="store_true", help="like --silent-imports but reports the imports as errors" ) parser.add_argument( "--disallow-untyped-calls", action="store_true", help="disallow calling functions without type annotations" " from functions with type annotations", ) parser.add_argument( "--disallow-untyped-defs", action="store_true", help="disallow defining functions without type annotations" " or with incomplete type annotations", ) parser.add_argument( "--check-untyped-defs", action="store_true", help="type check the interior of functions without type annotations", ) parser.add_argument( "--disallow-subclassing-any", action="store_true", help="disallow subclassing values of type 'Any' when defining classes", ) parser.add_argument( "--warn-incomplete-stub", action="store_true", help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled", ) parser.add_argument( "--warn-redundant-casts", action="store_true", help="warn about casting an expression to its inferred type" ) parser.add_argument( "--warn-unused-ignores", action="store_true", help="warn about unneeded '# type: ignore' comments" ) parser.add_argument( "--suppress-error-context", action="store_true", dest="suppress_error_context", help="Suppress context notes before errors", ) parser.add_argument("--fast-parser", action="store_true", help="enable experimental fast parser") parser.add_argument("-i", "--incremental", action="store_true", help="enable experimental module cache") parser.add_argument( "--cache-dir", action="store", metavar="DIR", help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.MYPY_CACHE), ) parser.add_argument( "--strict-optional", action="store_true", dest="special-opts:strict_optional", help="enable experimental strict Optional checks", ) parser.add_argument( "--strict-optional-whitelist", metavar="GLOB", nargs="*", help="suppress strict Optional errors in all but the provided files " "(experimental -- read documentation before using!). " "Implies --strict-optional. Has the undesirable side-effect of " "suppressing other errors in non-whitelisted files.", ) parser.add_argument("--pdb", action="store_true", help="invoke pdb on fatal error") parser.add_argument("--show-traceback", "--tb", action="store_true", help="show traceback on fatal error") parser.add_argument("--stats", action="store_true", dest="dump_type_stats", help="dump stats") parser.add_argument( "--inferstats", action="store_true", dest="dump_inference_stats", help="dump type inference stats" ) parser.add_argument( "--custom-typing", metavar="MODULE", dest="custom_typing_module", help="use a custom typing module" ) # hidden options # --shadow-file a.py tmp.py will typecheck tmp.py in place of a.py. # Useful for tools to make transformations to a file to get more # information from a mypy run without having to change the file in-place # (e.g. by adding a call to reveal_type). parser.add_argument("--shadow-file", metavar="PATH", nargs=2, dest="shadow_file", help=argparse.SUPPRESS) # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument("--debug-cache", action="store_true", help=argparse.SUPPRESS) # deprecated options parser.add_argument("--silent", action="store_true", dest="special-opts:silent", help=argparse.SUPPRESS) parser.add_argument( "-f", "--dirty-stubs", action="store_true", dest="special-opts:dirty_stubs", help=argparse.SUPPRESS ) parser.add_argument( "--use-python-path", action="store_true", dest="special-opts:use_python_path", help=argparse.SUPPRESS ) report_group = parser.add_argument_group( title="report generation", description="Generate a report in the specified format." ) report_group.add_argument("--html-report", metavar="DIR", dest="special-opts:html_report") report_group.add_argument("--old-html-report", metavar="DIR", dest="special-opts:old_html_report") report_group.add_argument("--xslt-html-report", metavar="DIR", dest="special-opts:xslt_html_report") report_group.add_argument("--xml-report", metavar="DIR", dest="special-opts:xml_report") report_group.add_argument("--txt-report", metavar="DIR", dest="special-opts:txt_report") report_group.add_argument("--xslt-txt-report", metavar="DIR", dest="special-opts:xslt_txt_report") report_group.add_argument("--linecount-report", metavar="DIR", dest="special-opts:linecount_report") report_group.add_argument("--linecoverage-report", metavar="DIR", dest="special-opts:linecoverage_report") code_group = parser.add_argument_group(title="How to specify the code to type check") code_group.add_argument( "-m", "--module", action="append", metavar="MODULE", dest="special-opts:modules", help="type-check module; can repeat for more modules", ) # TODO: `mypy -c A -c B` and `mypy -p A -p B` currently silently # ignore A (last option wins). Perhaps -c, -m and -p could just # be command-line flags that modify how we interpret self.files? code_group.add_argument( "-c", "--command", action="append", metavar="PROGRAM_TEXT", dest="special-opts:command", help="type-check program passed in as string", ) code_group.add_argument( "-p", "--package", metavar="PACKAGE", dest="special-opts:package", help="type-check all files in a directory" ) code_group.add_argument( metavar="files", nargs="*", dest="special-opts:files", help="type-check given files or directories" ) options = Options() special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, "special-opts:")) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error( "Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # warn about deprecated options if special_opts.silent: print("Warning: --silent is deprecated; use --silent-imports", file=sys.stderr) options.silent_imports = True if special_opts.dirty_stubs: print( "Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr, ) # Check for invalid argument combinations. if require_targets: code_methods = sum( bool(c) for c in [special_opts.modules, special_opts.command, special_opts.package, special_opts.files] ) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module, package, files, or command.") # Set build flags. if special_opts.strict_optional or options.strict_optional_whitelist is not None: experiments.STRICT_OPTIONAL = True # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith("_report") and val is not None: report_type = flag[:-7].replace("_", "-") report_dir = val options.report_dirs[report_type] = report_dir # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it.".format(special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = build.find_modules_recursive(special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT return [BuildSource(None, None, "\n".join(special_opts.command))], options else: targets = [] for f in special_opts.files: if f.endswith(PY_EXTENSIONS): targets.append(BuildSource(f, crawl_up(f)[1], None)) elif os.path.isdir(f): sub_targets = expand_dir(f) if not sub_targets: fail("There are no .py[i] files in directory '{}'".format(f)) targets.extend(sub_targets) else: targets.append(BuildSource(f, None, None)) return targets, options
def process_options(args: List[str]) -> Tuple[List[BuildSource], Options]: """Process command line arguments. Return (mypy program path (or None), module to run as script (or None), parsed flags) """ # Make the help output a little less jarring. help_factory = (lambda prog: argparse.RawDescriptionHelpFormatter(prog=prog, max_help_position=28)) parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, formatter_class=help_factory) def parse_version(v: str) -> Tuple[int, int]: m = re.match(r'\A(\d)\.(\d+)\Z', v) if m: return int(m.group(1)), int(m.group(2)) else: raise argparse.ArgumentTypeError( "Invalid python version '{}' (expected format: 'x.y')".format(v)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument('--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('-s', '--silent-imports', action='store_true', help="don't follow imports to .py files") parser.add_argument('--almost-silent', action='store_true', help="like --silent-imports but reports the imports as errors") parser.add_argument('--disallow-untyped-calls', action='store_true', help="disallow calling functions without type annotations" " from functions with type annotations") parser.add_argument('--disallow-untyped-defs', action='store_true', help="disallow defining functions without type annotations" " or with incomplete type annotations") parser.add_argument('--check-untyped-defs', action='store_true', help="type check the interior of functions without type annotations") parser.add_argument('--warn-incomplete-stub', action='store_true', help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") parser.add_argument('--warn-redundant-casts', action='store_true', help="warn about casting an expression to its inferred type") parser.add_argument('--warn-unused-ignores', action='store_true', help="warn about unneeded '# type: ignore' comments") parser.add_argument('--suppress-error-context', action='store_true', dest='suppress_error_context', help="Suppress context notes before errors") parser.add_argument('--fast-parser', action='store_true', help="enable experimental fast parser") parser.add_argument('-i', '--incremental', action='store_true', help="enable experimental module cache") parser.add_argument('--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.MYPY_CACHE)) parser.add_argument('--strict-optional', action='store_true', dest='special-opts:strict_optional', help="enable experimental strict Optional checks") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") # deprecated options parser.add_argument('--silent', action='store_true', dest='special-opts:silent', help=argparse.SUPPRESS) parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') report_group.add_argument('--html-report', metavar='DIR', dest='special-opts:html_report') report_group.add_argument('--old-html-report', metavar='DIR', dest='special-opts:old_html_report') report_group.add_argument('--xslt-html-report', metavar='DIR', dest='special-opts:xslt_html_report') report_group.add_argument('--xml-report', metavar='DIR', dest='special-opts:xml_report') report_group.add_argument('--txt-report', metavar='DIR', dest='special-opts:txt_report') report_group.add_argument('--xslt-txt-report', metavar='DIR', dest='special-opts:xslt_txt_report') report_group.add_argument('--linecount-report', metavar='DIR', dest='special-opts:linecount_report') code_group = parser.add_argument_group(title='How to specify the code to type check') code_group.add_argument('-m', '--module', action='append', metavar='MODULE', dest='special-opts:modules', help="type-check module; can repeat for more modules") # TODO: `mypy -c A -c B` and `mypy -p A -p B` currently silently # ignore A (last option wins). Perhaps -c, -m and -p could just # be command-line flags that modify how we interpret self.files? code_group.add_argument('-c', '--command', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument('-p', '--package', metavar='PACKAGE', dest='special-opts:package', help="type-check all files in a directory") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") options = Options() special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error("Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # warn about deprecated options if special_opts.silent: print("Warning: --silent is deprecated; use --silent-imports", file=sys.stderr) options.silent_imports = True if special_opts.dirty_stubs: print("Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) # Check for invalid argument combinations. code_methods = sum(bool(c) for c in [special_opts.modules, special_opts.command, special_opts.package, special_opts.files]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module, package, files, or command.") # Set build flags. if special_opts.strict_optional: experiments.STRICT_OPTIONAL = True # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it." .format(special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = build.find_modules_recursive(special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT return [BuildSource(None, None, special_opts.command)], options else: targets = [] for f in special_opts.files: if f.endswith(PY_EXTENSIONS): targets.append(BuildSource(f, crawl_up(f)[1], None)) elif os.path.isdir(f): sub_targets = expand_dir(f) if not sub_targets: fail("There are no .py[i] files in directory '{}'" .format(f)) targets.extend(sub_targets) else: targets.append(BuildSource(f, None, None)) return targets, options
def process_options(args: List[str]) -> Tuple[List[BuildSource], Options]: """Process command line arguments. Return (mypy program path (or None), module to run as script (or None), parsed flags) """ # Make the help output a little less jarring. help_factory = (lambda prog: argparse.RawDescriptionHelpFormatter( prog=prog, max_help_position=28)) parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, formatter_class=help_factory) def parse_version(v: str) -> Tuple[int, int]: m = re.match(r'\A(\d)\.(\d+)\Z', v) if m: return int(m.group(1)), int(m.group(2)) else: raise argparse.ArgumentTypeError( "Invalid python version '{}' (expected format: 'x.y')".format( v)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument('--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('-s', '--silent-imports', action='store_true', help="don't follow imports to .py files") parser.add_argument('--silent', action='store_true', dest='special-opts:silent', help="deprecated name for --silent-imports") parser.add_argument( '--almost-silent', action='store_true', help="like --silent-imports but reports the imports as errors") parser.add_argument( '--disallow-untyped-calls', action='store_true', help="disallow calling functions without type annotations" " from functions with type annotations") parser.add_argument( '--disallow-untyped-defs', action='store_true', help="disallow defining functions without type annotations" " or with incomplete type annotations") parser.add_argument( '--check-untyped-defs', action='store_true', help="type check the interior of functions without type annotations") parser.add_argument( '--warn-incomplete-stub', action='store_true', help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") parser.add_argument( '--warn-redundant-casts', action='store_true', help="warn about casting an expression to its inferred type") parser.add_argument('--warn-unused-ignores', action='store_true', help="warn about unneeded '# type: ignore' comments") parser.add_argument('--fast-parser', action='store_true', help="enable experimental fast parser") parser.add_argument('-i', '--incremental', action='store_true', help="enable experimental module cache") parser.add_argument( '--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.MYPY_CACHE)) parser.add_argument('--strict-optional', action='store_true', dest='special-opts:strict_optional', help="enable experimental strict Optional checks") parser.add_argument('-f', '--dirty-stubs', action='store_true', help="don't warn if typeshed is out of sync") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help="an anti-pattern") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') report_group.add_argument('--html-report', metavar='DIR', dest='special-opts:html_report') report_group.add_argument('--old-html-report', metavar='DIR', dest='special-opts:old_html_report') report_group.add_argument('--xslt-html-report', metavar='DIR', dest='special-opts:xslt_html_report') report_group.add_argument('--xml-report', metavar='DIR', dest='special-opts:xml_report') report_group.add_argument('--txt-report', metavar='DIR', dest='special-opts:txt_report') report_group.add_argument('--xslt-txt-report', metavar='DIR', dest='special-opts:xslt_txt_report') report_group.add_argument('--linecount-report', metavar='DIR', dest='special-opts:linecount_report') code_group = parser.add_argument_group( title='How to specify the code to type check') code_group.add_argument( '-m', '--module', action='append', metavar='MODULE', dest='special-opts:modules', help="type-check module; can repeat for more modules") # TODO: `mypy -c A -c B` and `mypy -p A -p B` currently silently # ignore A (last option wins). Perhaps -c, -m and -p could just # be command-line flags that modify how we interpret self.files? code_group.add_argument('-c', '--command', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument('-p', '--package', metavar='PACKAGE', dest='special-opts:package', help="type-check all files in a directory") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") options = Options() special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error( "Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # --silent is deprecated; warn about this. if special_opts.silent: print("Warning: --silent is deprecated; use --silent-imports", file=sys.stderr) options.silent_imports = True # Check for invalid argument combinations. code_methods = sum( bool(c) for c in [ special_opts.modules, special_opts.command, special_opts.package, special_opts.files ]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error( "May only specify one of: module, package, files, or command.") # Set build flags. if special_opts.strict_optional: experiments.STRICT_OPTIONAL = True # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Set target. if special_opts.modules: options.build_type = BuildType.MODULE targets = [BuildSource(None, m, None) for m in special_opts.modules] return targets, options elif special_opts.package: if os.sep in special_opts.package or os.altsep and os.altsep in special_opts.package: fail("Package name '{}' cannot have a slash in it.".format( special_opts.package)) options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = build.find_modules_recursive(special_opts.package, lib_path) if not targets: fail("Can't find package '{}'".format(special_opts.package)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT return [BuildSource(None, None, special_opts.command)], options else: targets = [] for f in special_opts.files: if f.endswith(PY_EXTENSIONS): targets.append(BuildSource(f, crawl_up(f)[1], None)) elif os.path.isdir(f): sub_targets = expand_dir(f) if not sub_targets: fail("There are no .py[i] files in directory '{}'".format( f)) targets.extend(sub_targets) else: targets.append(BuildSource(f, None, None)) return targets, options
def process_options(args: List[str], require_targets: bool = True, server_options: bool = False, ) -> Tuple[List[BuildSource], Options]: """Parse command line arguments.""" parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER, fromfile_prefix_chars='@', formatter_class=AugmentedHelpFormatter) strict_flag_names = [] # type: List[str] strict_flag_assignments = [] # type: List[Tuple[str, bool]] def add_invertible_flag(flag: str, *, inverse: Optional[str] = None, default: bool, dest: Optional[str] = None, help: str, strict_flag: bool = False ) -> None: if inverse is None: inverse = invert_flag_name(flag) if help is not argparse.SUPPRESS: help += " (inverse: {})".format(inverse) arg = parser.add_argument(flag, # type: ignore # incorrect stub for add_argument action='store_false' if default else 'store_true', dest=dest, help=help) dest = arg.dest arg = parser.add_argument(inverse, # type: ignore # incorrect stub for add_argument action='store_true' if default else 'store_false', dest=dest, help=argparse.SUPPRESS) if strict_flag: assert dest is not None strict_flag_names.append(flag) strict_flag_assignments.append((dest, not default)) # Unless otherwise specified, arguments will be parsed directly onto an # Options object. Options that require further processing should have # their `dest` prefixed with `special-opts:`, which will cause them to be # parsed into the separate special_opts namespace object. parser.add_argument('-v', '--verbose', action='count', dest='verbosity', help="more verbose messages") parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument('--python-version', type=parse_version, metavar='x.y', help='use Python x.y') parser.add_argument('--platform', action='store', metavar='PLATFORM', help="typecheck special-cased code for the given OS platform " "(defaults to sys.platform).") parser.add_argument('-2', '--py2', dest='python_version', action='store_const', const=defaults.PYTHON2_VERSION, help="use Python 2 mode") parser.add_argument('--ignore-missing-imports', action='store_true', help="silently ignore imports of missing modules") parser.add_argument('--follow-imports', choices=['normal', 'silent', 'skip', 'error'], default='normal', help="how to treat imports (default normal)") parser.add_argument('--disallow-any-unimported', default=False, action='store_true', help="disallow Any types resulting from unfollowed imports") parser.add_argument('--disallow-any-expr', default=False, action='store_true', help='disallow all expressions that have type Any') parser.add_argument('--disallow-any-decorated', default=False, action='store_true', help='disallow functions that have Any in their signature ' 'after decorator transformation') parser.add_argument('--disallow-any-explicit', default=False, action='store_true', help='disallow explicit Any in type positions') parser.add_argument('--disallow-any-generics', default=False, action='store_true', help='disallow usage of generic types that do not specify explicit ' 'type parameters') add_invertible_flag('--disallow-untyped-calls', default=False, strict_flag=True, help="disallow calling functions without type annotations" " from functions with type annotations") add_invertible_flag('--disallow-untyped-defs', default=False, strict_flag=True, help="disallow defining functions without type annotations" " or with incomplete type annotations") add_invertible_flag('--disallow-incomplete-defs', default=False, strict_flag=True, help="disallow defining functions with incomplete type annotations") add_invertible_flag('--check-untyped-defs', default=False, strict_flag=True, help="type check the interior of functions without type annotations") add_invertible_flag('--disallow-subclassing-any', default=False, strict_flag=True, help="disallow subclassing values of type 'Any' when defining classes") add_invertible_flag('--warn-incomplete-stub', default=False, help="warn if missing type annotation in typeshed, only relevant with" " --check-untyped-defs enabled") add_invertible_flag('--disallow-untyped-decorators', default=False, strict_flag=True, help="disallow decorating typed functions with untyped decorators") add_invertible_flag('--warn-redundant-casts', default=False, strict_flag=True, help="warn about casting an expression to its inferred type") add_invertible_flag('--no-warn-no-return', dest='warn_no_return', default=True, help="do not warn about functions that end without returning") add_invertible_flag('--warn-return-any', default=False, strict_flag=True, help="warn about returning values of type Any" " from non-Any typed functions") add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True, help="warn about unneeded '# type: ignore' comments") add_invertible_flag('--warn-unused-configs', default=False, strict_flag=True, help="warn about unused '[mypy-<pattern>]' config sections") add_invertible_flag('--show-error-context', default=False, dest='show_error_context', help='Precede errors with "note:" messages explaining context') add_invertible_flag('--no-implicit-optional', default=False, strict_flag=True, help="don't assume arguments with default values of None are Optional") parser.add_argument('-i', '--incremental', action='store_true', help="enable module cache, (inverse: --no-incremental)") parser.add_argument('--no-incremental', action='store_false', dest='incremental', help=argparse.SUPPRESS) parser.add_argument('--quick-and-dirty', action='store_true', help="use cache even if dependencies out of date " "(implies --incremental)") parser.add_argument('--cache-dir', action='store', metavar='DIR', help="store module cache info in the given folder in incremental mode " "(defaults to '{}')".format(defaults.CACHE_DIR)) parser.add_argument('--cache-fine-grained', action='store_true', help="include fine-grained dependency information in the cache") parser.add_argument('--skip-version-check', action='store_true', help="allow using cache written by older mypy version") add_invertible_flag('--strict-optional', default=False, strict_flag=True, help="enable experimental strict Optional checks") parser.add_argument('--strict-optional-whitelist', metavar='GLOB', nargs='*', help="suppress strict Optional errors in all but the provided files " "(experimental -- read documentation before using!). " "Implies --strict-optional. Has the undesirable side-effect of " "suppressing other errors in non-whitelisted files.") parser.add_argument('--junit-xml', help="write junit.xml to the given file") parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error") parser.add_argument('--show-traceback', '--tb', action='store_true', help="show traceback on fatal error") parser.add_argument('--stats', action='store_true', dest='dump_type_stats', help="dump stats") parser.add_argument('--inferstats', action='store_true', dest='dump_inference_stats', help="dump type inference stats") parser.add_argument('--custom-typing', metavar='MODULE', dest='custom_typing_module', help="use a custom typing module") parser.add_argument('--custom-typeshed-dir', metavar='DIR', help="use the custom typeshed in DIR") parser.add_argument('--scripts-are-modules', action='store_true', help="Script x becomes module x instead of __main__") parser.add_argument('--config-file', help="Configuration file, must have a [mypy] section " "(defaults to {})".format(defaults.CONFIG_FILE)) add_invertible_flag('--show-column-numbers', default=False, help="Show column numbers in error messages") parser.add_argument('--find-occurrences', metavar='CLASS.MEMBER', dest='special-opts:find_occurrences', help="print out all usages of a class member (experimental)") strict_help = "Strict mode. Enables the following flags: {}".format( ", ".join(strict_flag_names)) parser.add_argument('--strict', action='store_true', dest='special-opts:strict', help=strict_help) parser.add_argument('--shadow-file', nargs=2, metavar=('SOURCE_FILE', 'SHADOW_FILE'), dest='shadow_file', help='Typecheck SHADOW_FILE in place of SOURCE_FILE.') # hidden options # --debug-cache will disable any cache-related compressions/optimizations, # which will make the cache writing process output pretty-printed JSON (which # is easier to debug). parser.add_argument('--debug-cache', action='store_true', help=argparse.SUPPRESS) # --dump-deps will dump all fine-grained dependencies to stdout parser.add_argument('--dump-deps', action='store_true', help=argparse.SUPPRESS) # --dump-graph will dump the contents of the graph of SCCs and exit. parser.add_argument('--dump-graph', action='store_true', help=argparse.SUPPRESS) # --semantic-analysis-only does exactly that. parser.add_argument('--semantic-analysis-only', action='store_true', help=argparse.SUPPRESS) # --local-partial-types disallows partial types spanning module top level and a function # (implicitly defined in fine-grained incremental mode) parser.add_argument('--local-partial-types', action='store_true', help=argparse.SUPPRESS) # deprecated options parser.add_argument('--disallow-any', dest='special-opts:disallow_any', help=argparse.SUPPRESS) add_invertible_flag('--strict-boolean', default=False, help=argparse.SUPPRESS) parser.add_argument('-f', '--dirty-stubs', action='store_true', dest='special-opts:dirty_stubs', help=argparse.SUPPRESS) parser.add_argument('--use-python-path', action='store_true', dest='special-opts:use_python_path', help=argparse.SUPPRESS) parser.add_argument('-s', '--silent-imports', action='store_true', dest='special-opts:silent_imports', help=argparse.SUPPRESS) parser.add_argument('--almost-silent', action='store_true', dest='special-opts:almost_silent', help=argparse.SUPPRESS) parser.add_argument('--fast-parser', action='store_true', dest='special-opts:fast_parser', help=argparse.SUPPRESS) parser.add_argument('--no-fast-parser', action='store_true', dest='special-opts:no_fast_parser', help=argparse.SUPPRESS) if server_options: # TODO: This flag is superfluous; remove after a short transition (2018-03-16) parser.add_argument('--experimental', action='store_true', dest='fine_grained_incremental', help="enable fine-grained incremental mode") parser.add_argument('--use-fine-grained-cache', action='store_true', help="use the cache in fine-grained incremental mode") report_group = parser.add_argument_group( title='report generation', description='Generate a report in the specified format.') for report_type in sorted(reporter_classes): report_group.add_argument('--%s-report' % report_type.replace('_', '-'), metavar='DIR', dest='special-opts:%s_report' % report_type) code_group = parser.add_argument_group(title='How to specify the code to type check') code_group.add_argument('-m', '--module', action='append', metavar='MODULE', default=[], dest='special-opts:modules', help="type-check module; can repeat for more modules") code_group.add_argument('-p', '--package', action='append', metavar='PACKAGE', default=[], dest='special-opts:packages', help="type-check package recursively; can be repeated") code_group.add_argument('-c', '--command', action='append', metavar='PROGRAM_TEXT', dest='special-opts:command', help="type-check program passed in as string") code_group.add_argument(metavar='files', nargs='*', dest='special-opts:files', help="type-check given files or directories") # Parse arguments once into a dummy namespace so we can get the # filename for the config file and know if the user requested all strict options. dummy = argparse.Namespace() parser.parse_args(args, dummy) config_file = dummy.config_file if config_file is not None and not os.path.exists(config_file): parser.error("Cannot find config file '%s'" % config_file) # Parse config file first, so command line can override. options = Options() parse_config_file(options, config_file) # Set strict flags before parsing (if strict mode enabled), so other command # line options can override. if getattr(dummy, 'special-opts:strict'): for dest, value in strict_flag_assignments: setattr(options, dest, value) # Parse command line for real, using a split namespace. special_opts = argparse.Namespace() parser.parse_args(args, SplitNamespace(options, special_opts, 'special-opts:')) # --use-python-path is no longer supported; explain why. if special_opts.use_python_path: parser.error("Sorry, --use-python-path is no longer supported.\n" "If you are trying this because your code depends on a library module,\n" "you should really investigate how to obtain stubs for that module.\n" "See https://github.com/python/mypy/issues/1411 for more discussion." ) # Process deprecated options if special_opts.disallow_any: print("--disallow-any option was split up into multiple flags. " "See http://mypy.readthedocs.io/en/latest/command_line.html#disallow-any-flags") if options.strict_boolean: print("Warning: --strict-boolean is deprecated; " "see https://github.com/python/mypy/issues/3195", file=sys.stderr) if special_opts.almost_silent: print("Warning: --almost-silent has been replaced by " "--follow-imports=errors", file=sys.stderr) if options.follow_imports == 'normal': options.follow_imports = 'errors' elif special_opts.silent_imports: print("Warning: --silent-imports has been replaced by " "--ignore-missing-imports --follow-imports=skip", file=sys.stderr) options.ignore_missing_imports = True if options.follow_imports == 'normal': options.follow_imports = 'skip' if special_opts.dirty_stubs: print("Warning: -f/--dirty-stubs is deprecated and no longer necessary. Mypy no longer " "checks the git status of stubs.", file=sys.stderr) if special_opts.fast_parser: print("Warning: --fast-parser is now the default (and only) parser.") if special_opts.no_fast_parser: print("Warning: --no-fast-parser no longer has any effect. The fast parser " "is now mypy's default and only parser.") # Check for invalid argument combinations. if require_targets: code_methods = sum(bool(c) for c in [special_opts.modules + special_opts.packages, special_opts.command, special_opts.files]) if code_methods == 0: parser.error("Missing target module, package, files, or command.") elif code_methods > 1: parser.error("May only specify one of: module/package, files, or command.") # Set build flags. if options.strict_optional_whitelist is not None: # TODO: Deprecate, then kill this flag options.strict_optional = True if special_opts.find_occurrences: experiments.find_occurrences = special_opts.find_occurrences.split('.') assert experiments.find_occurrences is not None if len(experiments.find_occurrences) < 2: parser.error("Can only find occurrences of class members.") if len(experiments.find_occurrences) != 2: parser.error("Can only find occurrences of non-nested class members.") # Set reports. for flag, val in vars(special_opts).items(): if flag.endswith('_report') and val is not None: report_type = flag[:-7].replace('_', '-') report_dir = val options.report_dirs[report_type] = report_dir # Let quick_and_dirty imply incremental. if options.quick_and_dirty: options.incremental = True # Set target. if special_opts.modules + special_opts.packages: options.build_type = BuildType.MODULE lib_path = [os.getcwd()] + build.mypy_path() targets = [] # TODO: use the same cache as the BuildManager will cache = build.FindModuleCache() for p in special_opts.packages: if os.sep in p or os.altsep and os.altsep in p: fail("Package name '{}' cannot have a slash in it.".format(p)) p_targets = cache.find_modules_recursive(p, lib_path) if not p_targets: fail("Can't find package '{}'".format(p)) targets.extend(p_targets) for m in special_opts.modules: targets.append(BuildSource(None, m, None)) return targets, options elif special_opts.command: options.build_type = BuildType.PROGRAM_TEXT targets = [BuildSource(None, None, '\n'.join(special_opts.command))] return targets, options else: try: targets = create_source_list(special_opts.files, options) except InvalidSourceList as e: fail(str(e)) return targets, options