Add force option

Author: studyingegret

docs/source/command_line.rst

@@ -923,25 +923,28 @@ in error messages.
     Use visually nicer output in error messages: use soft word wrap,
     show source code snippets, and show error location markers.
 
-.. option:: --color-output[=auto]
+.. option:: --color-output[=force]
 
-    Enables colored output in error messages.
+    ``--color-output`` enables colored output if the output is going to a terminal.
 
-    When ``--color-output=auto`` is given, uses colored output if the output
-    (both stdout and stderr) is going to a tty. This is also the default.
+    ``--color-output=force`` enables colored output unconditionally.
+
+    Output will still be uncolored if mypy fails to detect a color code scheme.
 
     .. note::
         When the environment variable ``MYPY_FORCE_COLOR`` is set to a
-        non-``0`` non-empty string, mypy always enables colored output
-        (even if ``--no-color-output`` is given).
+        non-``0`` non-empty string, mypy ignores ``--color-output[=force]``
+        and ``--no-color-output``, and behaves as if ``--color-output=force``
+        is given.
+
+        If ``MYPY_FORCE_COLOR`` is ``0``, it has no effect.
 
-        .. Note: Here I decide not to document ``FORCE_COLOR`` as its
-           logic seems counter-intuitive from earlier conventions
-           (PR13853)
+        If ``MYPY_FORCE_COLOR`` is not defined, but ``FORCE_COLOR`` is defined,
+        it is treated the same way (like a fallback).
 
 .. option:: --no-color-output
 
-    Disables colored output in error messages.
+    Disables colored output.
 
     See also note above.
 

mypy/dmypy_server.py

@@ -200,17 +200,12 @@ def __init__(self, options: Options, status_file: str, timeout: int | None = Non
         options.local_partial_types = True
         self.status_file = status_file
 
-        # Type annotation needed for mypy (Pyright understands this)
-        use_color: bool | Literal["auto"] = (
-            True
-            if util.should_force_color()
-            else ("auto" if options.color_output == "auto" else cast(bool, options.color_output))
-        )
-
         # Since the object is created in the parent process we can check
         # the output terminal options here.
         self.formatter = FancyFormatter(
-            sys.stdout, sys.stderr, options.hide_error_codes, color_request=use_color
+            sys.stdout, sys.stderr, options.hide_error_codes,
+            color_request=util.should_force_color() or options.color_output is not False,
+            warn_color_fail=options.warn_color_fail
         )
 
     def _response_metadata(self) -> dict[str, str]:
@@ -853,10 +848,8 @@ def pretty_messages(
     ) -> list[str]:
         use_color = (
             True
-            if util.should_force_color()
-            else (
-                is_tty if self.options.color_output == "auto" else bool(self.options.color_output)
-            )
+            if util.should_force_color() or self.options.color_output == "force"
+            else (is_tty if self.options.color_output is True else False)
         )
         fit_width = self.options.pretty and is_tty
         if fit_width:

mypy/main.py

@@ -90,19 +90,20 @@ def main(
     if clean_exit:
         options.fast_exit = False
 
-    # Type annotation needed for mypy (Pyright understands this)
-    use_color: bool | Literal["auto"] = (
-        True
-        if util.should_force_color()
-        else ("auto" if options.color_output == "auto" else cast(bool, options.color_output))
-    )
-
     formatter = util.FancyFormatter(
         stdout,
         stderr,
         options.hide_error_codes,
         hide_success=bool(options.output),
-        color_request=use_color,
+        color_request=util.should_force_color() or options.color_output is not False,
+        warn_color_fail=options.warn_color_fail,
+    )
+
+    # Type annotation needed for mypy (Pyright understands this)
+    use_color: bool = (
+        True if util.should_force_color() or options.color_output == "force"
+        else formatter.default_colored if options.color_output is True
+        else False
     )
 
     if options.allow_redefinition_new and not options.local_partial_types:
@@ -195,14 +196,15 @@ def run_build(
     t0: float,
     stdout: TextIO,
     stderr: TextIO,
-    use_color: bool | Literal["auto"],
+    use_color: bool,
 ) -> tuple[build.BuildResult | None, list[str], bool]:
     formatter = util.FancyFormatter(
         stdout,
         stderr,
         options.hide_error_codes,
         hide_success=bool(options.output),
         color_request=use_color,
+        warn_color_fail=options.warn_color_fail,
     )
 
     messages = []
@@ -260,10 +262,8 @@ def show_messages(
     f: TextIO,
     formatter: util.FancyFormatter,
     options: Options,
-    use_color: bool | Literal["auto"],
+    use_color: bool,
 ) -> None:
-    if use_color == "auto":
-        use_color = formatter.default_colored
     for msg in messages:
         if use_color:
             msg = formatter.colorize(msg)
@@ -495,8 +495,8 @@ def __call__(
         values: str | Sequence[Any] | None,
         option_string: str | None = None,
     ) -> None:
-        assert values in ("auto", None)
-        setattr(namespace, self.dest, True if values is None else "auto")
+        assert values in ("force", None)
+        setattr(namespace, self.dest, True if values is None else "force")
 
 
 def define_options(
@@ -1037,15 +1037,21 @@ def add_invertible_flag(
         dest="color_output",
         action=ColorOutputAction,
         nargs="?",
-        choices=["auto"],
-        help="Colorize error messages (inverse: --no-color-output). "
-        "Detects if to use color when option is omitted and --no-color-output "
-        "is not given, or when --color-output=auto",
+        choices=["force"],
+        help="Colorize error messages if output is going to a terminal (inverse: --no-color-output). "
+        "When --color-output=auto, colorizes output unconditionally",
     )
     error_group.add_argument(
         "--no-color-output", dest="color_output", action="store_false", help=argparse.SUPPRESS
     )
-    # error_group.set_defaults(color_output="auto")
+    add_invertible_flag(
+        "--warn-color-fail",
+        dest="warn_color_fail",
+        default=False,
+        help="Print warning message when mypy cannot detect "
+        "a terminal color scheme and colored output is requested",
+        group=error_group,
+    )
     add_invertible_flag(
         "--no-error-summary",
         dest="error_summary",

mypy/options.py

@@ -7,7 +7,7 @@
 import warnings
 from collections.abc import Mapping
 from re import Pattern
-from typing import Any, Callable, Final
+from typing import Any, Callable, Final, Literal
 
 from mypy import defaults
 from mypy.errorcodes import ErrorCode, error_codes
@@ -206,8 +206,9 @@ def __init__(self) -> None:
         self.show_error_context = False
 
         # Use nicer output (when possible).
-        self.color_output = "auto"
+        self.color_output: bool | Literal["force"] = True
         self.error_summary = True
+        self.warn_color_fail: bool = False
 
         # Assume arguments with default values of None are Optional
         self.implicit_optional = False

mypy/test/test_color_output.py

@@ -1,38 +1,80 @@
 from functools import partial
-from subprocess import run
-from typing import Any
-
+import subprocess
+from typing import TYPE_CHECKING, Any
+import sys
 import pytest
 
-# TODO Would like help with this test, how do I make it runnable?
+#XXX Would like help with this test, how do I make it runnable?
+
+# Haven't run this test yet
+
+PTY_SIZE = (80, 40)
 
+if sys.platform == "win32":
+    if TYPE_CHECKING:
+        from winpty.winpty import PTY
+    else:
+        from winpty import PTY
 
-def test(expect_color: bool, *args: Any, **kwargs: Any) -> None:
-    res = run(*args, capture_output=True, **kwargs)
-    if "Found" not in res.stdout:  # ??
+    def run_pty(cmd: str, env: dict[str, str] = {}) -> tuple[str, str]:
+        pty = PTY(*PTY_SIZE)
+        # For the purposes of this test, str.split() is enough
+        appname, cmdline = cmd.split(maxsplit=1)
+        pty.spawn(appname, cmdline, "\0".join(map(lambda kv: f"{kv[0]}={kv[1]}", env.items())))
+        while pty.isalive():
+            pass
+        return pty.read(), pty.read_stderr()
+elif sys.platform == "unix":
+    from pty import openpty
+
+    def run_pty(cmd: str, env: dict[str, str] = {}) -> tuple[str, str]:
+        # TODO Would like help checking quality of this function,
+        # it's partially written by Copilot because I'm not familiar with Unix openpty
+        master_fd, slave_fd = openpty()
+        try:
+            p = subprocess.run(cmd, stdout=slave_fd, stderr=subprocess.PIPE, env=env, text=True)
+            os.close(slave_fd)
+            return os.read(slave_fd, 10000).decode(), p.stderr
+        finally:
+            os.close(master_fd)
+def test(expect_color: bool, pty: bool, cmd: str, env: dict[str, str] = {}) -> None:
+    if pty:
+        stdout, stderr = run_pty(cmd, env=env)
+    else:
+        proc = subprocess.run(cmd, capture_output=True, env=env, text=True)
+        stdout = proc.stdout
+        stderr = proc.stderr
+    if "Found" not in stdout:  # ??
         pytest.fail("Command failed to complete or did not detect type error")
     if expect_color:  # Expect color control chars
-        assert "<string>:1: error:" not in res.stdout
-        assert "\nFound" not in res.stdout
+        assert "<string>:1: error:" not in stdout
+        assert "\nFound" not in stdout
     else:  # Expect no color control chars
-        assert "<string>:1: error:" in res.stdout
-        assert "\nFound" in res.stdout
+        assert "<string>:1: error:" in stdout
+        assert "\nFound" in stdout
+
 
+def test_pty(expect_color: bool, cmd: str, env: dict[str, str] = {}) -> None:
+    test(expect_color, True, cmd, env)
 
-colored = partial(test, True)
-not_colored = partial(test, False)
+def test_not_pty(expect_color: bool, cmd: str, env: dict[str, str] = {}) -> None:
+    test(expect_color, False, cmd, env)
 
 
 @pytest.mark.parametrize("command", ["mypy", "dmypy run --"])
-def test_color_output(command: str) -> None:
+def test_it(command: str) -> None:
     # Note: Though we don't check stderr, capturing it is useful
     # because it provides traceback if mypy crashes due to exception
     # and pytest reveals it upon failure (?)
-    not_colored(f"{command} -c \"1+'a'\"")
-    colored(f"{command} -c \"1+'a'\"", env={"MYPY_FORCE_COLOR": "1"})
-    colored(f"{command} -c \"1+'a'\" --color-output")
-    not_colored(f"{command} -c \"1+'a'\" --no-color-output")
-    colored(f"{command} -c \"1+'a'\" --no-color-output", env={"MYPY_FORCE_COLOR": "1"})  # TODO
+    test_pty(True, "mypy -c \"1+'a'\" --color-output=force")
+    test_pty(False, "mypy -c \"1+'a'\" --no-color-output")
+    test_not_pty(False, "mypy -c \"1+'a'\" --color-output")
+    test_not_pty(True, "mypy -c \"1+'a'\" --color-output=force")
+    test_not_pty(False, "mypy -c \"1+'a'\" --color-output", {"MYPY_FORCE_COLOR": "1"})
+    test_not_pty(True, "mypy -c \"1+'a'\" --color-output=force", {"MYPY_FORCE_COLOR": "1"})
+    test_not_pty(False, "mypy -c \"1+'a'\" --no-color-output", {"MYPY_FORCE_COLOR": "1"})
+    test_not_pty(False, "mypy -c \"1+'a'\" --no-color-output", {"FORCE_COLOR": "1"})
+    test_not_pty(False, "mypy -c \"1+'a'\" --color-output", {"MYPY_FORCE_COLOR": "0"})
 
 
 # TODO: Tests in the terminal (require manual testing?)