"""Mypy type checker command line tool."""

from __future__ import annotations

import argparse

import os

import platform

import subprocess

import sys

import time

from collections import defaultdict

from collections.abc import Sequence

from gettext import gettext

from io import TextIOWrapper

from typing import IO, TYPE_CHECKING, Any, Final, NoReturn, TextIO

if platform.python_implementation() == "PyPy":

sys.stderr.write(

"ERROR: Running mypy on PyPy is not supported yet.\n"

"To type-check a PyPy library please use an equivalent CPython version,\n"

"see https://github.com/mypyc/librt/issues/16 for possible workarounds.\n"

)

sys.exit(2)

from mypy import build, defaults, state, util

from mypy.config_parser import parse_config_file, parse_version, validate_package_allow_list

from mypy.defaults import RECURSION_LIMIT

from mypy.error_formatter import OUTPUT_CHOICES

from mypy.errors import CompileError

from mypy.find_sources import InvalidSourceList, create_source_list

from mypy.fscache import FileSystemCache

from mypy.modulefinder import (

BuildSource,

FindModuleCache,

ModuleNotFoundReason,

SearchPaths,

get_search_dirs,

mypy_path,

)

from mypy.options import INCOMPLETE_FEATURES, BuildType, Options

from mypy.split_namespace import SplitNamespace

from mypy.version import __version__

if TYPE_CHECKING:

from _typeshed import SupportsWrite

orig_stat: Final = os.stat

MEM_PROFILE: Final = False # If True, dump memory profile

def stat_proxy(path: str) -> os.stat_result:

try:

st = orig_stat(path)

except OSError as err:

print(f"stat({path!r}) -> {err}")

raise

else:

print(

"stat(%r) -> (st_mode=%o, st_mtime=%d, st_size=%d)"

% (path, st.st_mode, st.st_mtime, st.st_size)

)

return st

def main(

*,

args: list[str] | None = None,

stdout: TextIO = sys.stdout,

stderr: TextIO = sys.stderr,

clean_exit: bool = False,

) -> None:

"""Main entry point to the type checker.

Args:

args: Custom command-line arguments. If not given, sys.argv[1:] will

be used.

clean_exit: Don't hard kill the process on exit. This allows catching

SystemExit.

"""

util.check_python_version("mypy")

t0 = time.time()

# To log stat() calls: os.stat = stat_proxy

sys.setrecursionlimit(RECURSION_LIMIT)

if args is None:

args = sys.argv[1:]

# Write an escape sequence instead of raising an exception on encoding errors.

if isinstance(stdout, TextIOWrapper) and stdout.errors == "strict":

stdout.reconfigure(errors="backslashreplace")

fscache = FileSystemCache()

sources, options = process_options(args, stdout=stdout, stderr=stderr, fscache=fscache)

if clean_exit:

options.fast_exit = False

formatter = util.FancyFormatter(

stdout, stderr, options.hide_error_codes, hide_success=bool(options.output)

)

if options.num_workers:

# Supporting both parsers would be really tricky, so just support the new one.

options.native_parser = True

if options.cache_dir == os.devnull:

fail("error: cache must be enabled in parallel mode", stderr, options)

if options.allow_redefinition_new and not options.local_partial_types:

fail(

"error: --local-partial-types must be enabled if using --allow-redefinition-new",

stderr,

options,

)

if options.allow_redefinition_new and options.allow_redefinition_old:

fail(

"--allow-redefinition-old and --allow-redefinition-new should not be used together",

stderr,

options,

)

if options.install_types and (stdout is not sys.stdout or stderr is not sys.stderr):

# Since --install-types performs user input, we want regular stdout and stderr.

fail("error: --install-types not supported in this mode of running mypy", stderr, options)

if options.non_interactive and not options.install_types:

fail("error: --non-interactive is only supported with --install-types", stderr, options)

if options.install_types and not options.incremental:

fail(

"error: --install-types not supported with incremental mode disabled", stderr, options

)

if options.install_types and options.python_executable is None:

fail(

"error: --install-types not supported without python executable or site packages",

stderr,

options,

)

if options.install_types and not sources:

install_types(formatter, options, non_interactive=options.non_interactive)

return

res, messages, blockers = run_build(sources, options, fscache, t0, stdout, stderr)

if options.non_interactive:

missing_pkgs = read_types_packages_to_install(options.cache_dir, after_run=True)

if missing_pkgs:

# Install missing type packages and rerun build.

install_types(formatter, options, after_run=True, non_interactive=True)

fscache.flush()

print()

res, messages, blockers = run_build(sources, options, fscache, t0, stdout, stderr)

show_messages(messages, stderr, formatter, options)

if MEM_PROFILE:

from mypy.memprofile import print_memory_profile

print_memory_profile()

code = 0

n_errors, n_notes, n_files = util.count_stats(messages)

if messages and n_notes < len(messages):

code = 2 if blockers else 1

if options.error_summary:

if n_errors:

summary = formatter.format_error(

n_errors, n_files, len(sources), blockers=blockers, use_color=options.color_output

)

stdout.write(summary + "\n")

# Only notes should also output success

elif not messages or n_notes == len(messages):

stdout.write(formatter.format_success(len(sources), options.color_output) + "\n")

stdout.flush()

if options.install_types and not options.non_interactive:

result = install_types(formatter, options, after_run=True, non_interactive=False)

if result:

print()

print("note: Run mypy again for up-to-date results with installed types")

code = 2

if options.fast_exit:

# Exit without freeing objects -- it's faster.

#

# NOTE: We don't flush all open files on exit (or run other destructors)!

util.hard_exit(code)

elif code:

sys.exit(code)

# HACK: keep res alive so that mypyc won't free it before the hard_exit

list([res]) # noqa: C410

class BuildResultThunk:

# We pass this around so that we avoid freeing memory, which is slow

def __init__(self, build_result: build.BuildResult | None) -> None:

self._result = build_result

def run_build(

sources: list[BuildSource],

options: Options,

fscache: FileSystemCache,

t0: float,

stdout: TextIO,

stderr: TextIO,

) -> tuple[BuildResultThunk | None, list[str], bool]:

formatter = util.FancyFormatter(

stdout, stderr, options.hide_error_codes, hide_success=bool(options.output)

)

messages = []

messages_by_file = defaultdict(list)

def flush_errors(filename: str | None, new_messages: list[str], serious: bool) -> None:

if options.pretty:

new_messages = formatter.fit_in_terminal(new_messages)

messages.extend(new_messages)

if new_messages:

messages_by_file[filename].extend(new_messages)

if options.non_interactive:

# Collect messages and possibly show them later.

return

f = stderr if serious else stdout

show_messages(new_messages, f, formatter, options)

serious = False

blockers = False

res = None

try:

# Keep a dummy reference (res) for memory profiling afterwards, as otherwise

# the result could be freed.

res = build.build(sources, options, None, flush_errors, fscache, stdout, stderr)

except CompileError as e:

blockers = True

if not e.use_stdout:

serious = True

if res:

res.manager.metastore.close()

maybe_write_junit_xml(time.time() - t0, serious, messages, messages_by_file, options)

return BuildResultThunk(res), messages, blockers

def show_messages(

messages: list[str], f: TextIO, formatter: util.FancyFormatter, options: Options

) -> None:

for msg in messages:

if options.color_output:

msg = formatter.colorize(msg)

f.write(msg + "\n")

f.flush()

# Make the help output a little less jarring.

class AugmentedHelpFormatter(argparse.RawDescriptionHelpFormatter):

def __init__(self, prog: str, **kwargs: Any) -> None:

super().__init__(prog=prog, max_help_position=28, **kwargs)

def _fill_text(self, text: str, width: int, indent: str) -> str:

if "\n" in text:

# Assume we want to manually format the text

return super()._fill_text(text, width, indent)

# Format the text like argparse, but overflow rather than

# breaking long words (like URLs)

text = self._whitespace_matcher.sub(" ", text).strip()

import textwrap

return textwrap.fill(

text,

width,

initial_indent=indent,

subsequent_indent=indent,

break_on_hyphens=False,

break_long_words=False,

)

# Define pairs of flag prefixes with inverse meaning.

flag_prefix_pairs: Final = [("allow", "disallow"), ("show", "hide")]

flag_prefix_map: Final[dict[str, str]] = {}

for a, b in flag_prefix_pairs:

flag_prefix_map[a] = b

flag_prefix_map[b] = a

def invert_flag_name(flag: str) -> str:

split = flag[2:].split("-", 1)

if len(split) == 2:

prefix, rest = split

if prefix in flag_prefix_map:

return f"--{flag_prefix_map[prefix]}-{rest}"

elif prefix == "no":

return f"--{rest}"

return f"--no-{flag[2:]}"

class PythonExecutableInferenceError(Exception):

"""Represents a failure to infer the version or executable while searching."""

def python_executable_prefix(v: str) -> list[str]:

if sys.platform == "win32":

# on Windows, all Python executables are named `python`. To handle this, there

# is the `py` launcher, which can be passed a version e.g. `py -3.8`, and it will

# execute an installed Python 3.8 interpreter. See also:

# https://docs.python.org/3/using/windows.html#python-launcher-for-windows

return ["py", f"-{v}"]

else:

return [f"python{v}"]

def _python_executable_from_version(python_version: tuple[int, int]) -> str:

if sys.version_info[:2] == python_version:

return sys.executable

str_ver = ".".join(map(str, python_version))

try:

sys_exe = (

subprocess.check_output(

python_executable_prefix(str_ver) + ["-c", "import sys; print(sys.executable)"],

stderr=subprocess.STDOUT,

)

.decode()

.strip()

)

return sys_exe

except (subprocess.CalledProcessError, FileNotFoundError) as e:

raise PythonExecutableInferenceError(

"failed to find a Python executable matching version {},"

" perhaps try --python-executable, or --no-site-packages?".format(python_version)

) from e

def infer_python_executable(options: Options, special_opts: argparse.Namespace) -> None:

"""Infer the Python executable from the given version.

This function mutates options based on special_opts to infer the correct Python executable

to use.

"""

# TODO: (ethanhs) Look at folding these checks and the site packages subprocess calls into

# one subprocess call for speed.

# Use the command line specified executable, or fall back to one set in the

# config file. If an executable is not specified, infer it from the version

# (unless no_executable is set)

python_executable = special_opts.python_executable or options.python_executable

if python_executable is None:

if not special_opts.no_executable and not options.no_site_packages:

python_executable = _python_executable_from_version(options.python_version)

options.python_executable = python_executable

HEADER: Final = """%(prog)s [-h] [-v] [-V] [more options; see below]

[-m MODULE] [-p PACKAGE] [-c PROGRAM_TEXT] [files ...]"""

DESCRIPTION: Final = """

Mypy is a program that will type check your Python code.

Pass in any files or folders you want to type check. Mypy will

recursively traverse any provided folders to find .py files:

$ mypy my_program.py my_src_folder

For more information on getting started, see:

- https://mypy.readthedocs.io/en/stable/getting_started.html

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

- https://mypy.readthedocs.io/en/stable/running_mypy.html

- https://mypy.readthedocs.io/en/stable/command_line.html

You can also use a config file to configure mypy instead of using

command line flags. For more details, see:

- https://mypy.readthedocs.io/en/stable/config_file.html

"""

FOOTER: Final = """Environment variables:

Define MYPYPATH for additional module search path entries.

Define MYPY_CACHE_DIR to override configuration cache_dir path."""

class CapturableArgumentParser(argparse.ArgumentParser):

"""Override ArgumentParser methods that use sys.stdout/sys.stderr directly.

This is needed because hijacking sys.std* is not thread-safe,

yet output must be captured to properly support mypy.api.run.

"""

def __init__(self, *args: Any, **kwargs: Any) -> None:

self.stdout = kwargs.pop("stdout", sys.stdout)

self.stderr = kwargs.pop("stderr", sys.stderr)

super().__init__(*args, **kwargs)

# =====================

# Help-printing methods

# =====================

def print_usage(self, file: SupportsWrite[str] | None = None) -> None:

if file is None:

file = self.stdout

self._print_message(self.format_usage(), file)

def print_help(self, file: SupportsWrite[str] | None = None) -> None:

if file is None:

file = self.stdout

self._print_message(self.format_help(), file)

def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None:

if message:

if file is None:

file = self.stderr

file.write(message)

# ===============

# Exiting methods

# ===============

def exit(self, status: int = 0, message: str | None = None) -> NoReturn:

if message:

self._print_message(message, self.stderr)

sys.exit(status)

def error(self, message: str) -> NoReturn:

"""error(message: string)

Prints a usage message incorporating the message to stderr and

exits.

If you override this in a subclass, it should not return -- it

should either exit or raise an exception.

"""

self.print_usage(self.stderr)

args = {"prog": self.prog, "message": message}

self.exit(2, gettext("%(prog)s: error: %(message)s\n") % args)

class CapturableVersionAction(argparse.Action):

"""Supplement CapturableArgumentParser to handle --version.

This is nearly identical to argparse._VersionAction except,

like CapturableArgumentParser, it allows output to be captured.

Another notable difference is that version is mandatory.

This allows removing a line in __call__ that falls back to parser.version

(which does not appear to exist).

"""

def __init__(

self,

option_strings: Sequence[str],

version: str,

dest: str = argparse.SUPPRESS,

default: str = argparse.SUPPRESS,

help: str = "show program's version number and exit",

stdout: IO[str] | None = None,

) -> None:

super().__init__(

option_strings=option_strings, dest=dest, default=default, nargs=0, help=help

)

self.version = version

self.stdout = stdout or sys.stdout

def __call__(

self,

parser: argparse.ArgumentParser,

namespace: argparse.Namespace,

values: str | Sequence[Any] | None,

option_string: str | None = None,

) -> NoReturn:

formatter = parser._get_formatter()

formatter.add_text(self.version)

parser._print_message(formatter.format_help(), self.stdout)

parser.exit()

def define_options(

program: str = "mypy",

header: str = HEADER,

stdout: TextIO = sys.stdout,

stderr: TextIO = sys.stderr,

server_options: bool = False,

) -> tuple[CapturableArgumentParser, list[str], list[tuple[str, bool]]]:

"""Define the options in the parser (by calling a bunch of methods that express/build our desired command-line flags).

Returns a tuple of:

a parser object, that can parse command line arguments to mypy (expected consumer: main's process_options),

a list of what flags are strict (expected consumer: docs' html_builder's _add_strict_list),

strict_flag_assignments (expected consumer: main's process_options)."""

parser = CapturableArgumentParser(

prog=program,

usage=header,

description=DESCRIPTION,

epilog=FOOTER,

fromfile_prefix_chars="@",

formatter_class=AugmentedHelpFormatter,

add_help=False,

stdout=stdout,

stderr=stderr,

)

strict_flag_names: list[str] = []

strict_flag_assignments: list[tuple[str, bool]] = []

def add_invertible_flag(

flag: str,

*,

inverse: str | None = None,

default: bool,

dest: str | None = None,

help: str,

strict_flag: bool = False,

group: argparse._ActionsContainer | None = None,

) -> None:

if inverse is None:

inverse = invert_flag_name(flag)

if group is None:

group = parser

if help is not argparse.SUPPRESS:

help += f" (inverse: {inverse})"

arg = group.add_argument(

flag, action="store_false" if default else "store_true", dest=dest, help=help

)

dest = arg.dest

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.

# Our style guide for formatting the output of running `mypy --help`:

# Flags:

# 1. The flag help text should start with a capital letter but never end with a period.

# 2. Keep the flag help text brief -- ideally just a single sentence.

# 3. All flags must be a part of a group, unless the flag is deprecated or suppressed.

# 4. Avoid adding new flags to the "miscellaneous" groups -- instead add them to an

# existing group or, if applicable, create a new group. Feel free to move existing

# flags to a new group: just be sure to also update the documentation to match.

#

# Groups:

# 1. The group title and description should start with a capital letter.

# 2. The first sentence of a group description should be written in the bare infinitive.

# Tip: try substituting the group title and description into the following sentence:

# > {group_title}: these flags will {group_description}

# Feel free to add subsequent sentences that add additional details.

# 3. If you cannot think of a meaningful description for a new group, omit it entirely.

# (E.g. see the "miscellaneous" sections).

# 4. The text of the group description should end with a period, optionally followed

# by a documentation reference (URL).

# 5. If you want to include a documentation reference, place it at the end of the

# description. Feel free to open with a brief reference ("See also:", "For more

# information:", etc.), followed by a space, then the entire URL including

# "https://" scheme identifier and fragment ("#some-target-heading"), if any.

# Do not end with a period (or any other characters not part of the URL).

# URLs longer than the available terminal width will overflow without being

# broken apart. This facilitates both URL detection, and manual copy-pasting.

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"

)

compilation_status = "no" if __file__.endswith(".py") else "yes"

general_group.add_argument(

"-V",

"--version",

action=CapturableVersionAction,

version="%(prog)s " + __version__ + f" (compiled: {compilation_status})",

help="Show program's version number and exit",

stdout=stdout,

)

general_group.add_argument(

"-O",

"--output",

metavar="FORMAT",

help="Set a custom output format",

choices=OUTPUT_CHOICES,

)

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

f"Configuration file, must have a [mypy] section "

f"(defaults to {', '.join(defaults.CONFIG_NAMES + defaults.SHARED_CONFIG_NAMES)})"

),

)

add_invertible_flag(

"--warn-unused-configs",

default=False,

help="Warn about unused '[mypy-<pattern>]' or '[[tool.mypy.overrides]]' config sections",

group=config_group,

)

imports_group = parser.add_argument_group(

title="Import discovery", description="Configure how imports are discovered and followed."

)

add_invertible_flag(

"--no-namespace-packages",

dest="namespace_packages",

default=True,

help="Disable support for namespace packages (PEP 420, __init__.py-less)",

group=imports_group,

)

imports_group.add_argument(

"--ignore-missing-imports",

action="store_true",

help="Silently ignore imports of missing modules",

)

imports_group.add_argument(

"--follow-untyped-imports",

action="store_true",

help="Typecheck modules without stubs or py.typed marker",

)

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

)

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(

"--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="Disallow dynamic typing",

description="Disallow the use of the dynamic 'Any' type under certain conditions.",

)

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,

)

add_invertible_flag(

"--disallow-any-unimported",

default=False,

help="Disallow Any types resulting from unfollowed imports",

group=disallow_any_group,

)

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,

)

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,

)

untyped_group.add_argument(

"--untyped-calls-exclude",

metavar="MODULE",

action="append",

default=[],

help="Disable --disallow-untyped-calls for functions/methods coming"

" from specific package, module, or class",

)

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 "

"(while still allowing entirely unannotated definitions)",

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

"https://mypy.readthedocs.io/en/stable/kinds_of_types.html#optional-types-and-the-none-type",

)

add_invertible_flag(

"--implicit-optional",

default=False,

help="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)",

)

lint_group = parser.add_argument_group(

title="Configuring 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,

)

add_invertible_flag(

"--warn-unreachable",

default=False,

strict_flag=False,

help="Warn about statements or expressions inferred to be unreachable",

group=lint_group,

)

add_invertible_flag(

"--report-deprecated-as-note",

default=False,

strict_flag=False,

help="Report importing or using deprecated features as notes instead of errors",

group=lint_group,

)

lint_group.add_argument(

"--deprecated-calls-exclude",

metavar="MODULE",

action="append",

default=[],

help="Disable deprecated warnings for functions/methods coming"

" from specific package, module, or class",

)

# 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="Miscellaneous strictness flags")

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="Alias to --allow-redefinition-old; will point to --allow-redefinition-new in v2.0",

group=strictness_group,

dest="allow_redefinition_old",

)

add_invertible_flag(

"--allow-redefinition-old",

default=False,

strict_flag=False,

help="Allow restricted, unconditional variable redefinition with a new type",

group=strictness_group,

)

add_invertible_flag(

"--allow-redefinition-new",

default=False,

strict_flag=False,

help="Allow more flexible variable redefinition semantics",

group=strictness_group,

)

add_invertible_flag(

"--no-implicit-reexport",

default=True,

strict_flag=True,

dest="implicit_reexport",

help="Treat imports as private unless aliased",

group=strictness_group,

)

add_invertible_flag(

"--strict-equality",

default=False,

strict_flag=True,

help="Prohibit equality, identity, and container checks for non-overlapping types "

"(except `None`)",

group=strictness_group,

)

add_invertible_flag(

"--strict-equality-for-none",

default=False,

strict_flag=False,

help="Extend `--strict-equality` for `None` checks",

group=strictness_group,

)

add_invertible_flag(

"--strict-bytes",

default=False,

strict_flag=True,

help="Disable treating bytearray and memoryview as subtypes of bytes",

group=strictness_group,

)

add_invertible_flag(

"--extra-checks",

default=False,

strict_flag=True,

help="Enable additional checks that are technically correct but may be impractical "

"in real code. For example, this prohibits partial overlap in TypedDict updates, "

"and makes arguments prepended via Concatenate positional-only",

group=strictness_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

)

strictness_group.add_argument(

"--disable-error-code",

metavar="NAME",

action="append",

default=[],

help="Disable a specific error code",

)

strictness_group.add_argument(

"--enable-error-code",

metavar="NAME",

action="append",

default=[],

help="Enable a specific error code",

)

error_group = parser.add_argument_group(

title="Configuring error messages",

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,

)

add_invertible_flag(

"--show-error-end",

default=False,

help="Show end line/end column numbers in error messages."

" This implies --show-column-numbers",

group=error_group,