Move colordepth logic to Output implementations.

Author: jonathanslenders

prompt_toolkit/application/application.py

@@ -366,15 +366,23 @@ def conditional_pygments_style() -> BaseStyle:
     @property
     def color_depth(self) -> ColorDepth:
         """
-        Active :class:`.ColorDepth`.
+        The active :class:`.ColorDepth`.
+
+        The current value is determined as follows:
+        - If a color depth was given explicitely to this application, use that
+          value.
+        - Otherwise, fall back to the color depth that is reported by the
+          :class:`.Output` implementation. If the :class:`.Output` class was
+          created using `output.defaults.create_output`, then this value is
+          coming from the $PROMPT_TOOLKIT_COLOR_DEPTH environment variable.
         """
         depth = self._color_depth
 
         if callable(depth):
-            return depth() or self.output.get_default_color_depth()
+            depth = depth()
 
         if depth is None:
-            return self.output.get_default_color_depth()
+            depth = self.output.get_default_color_depth()
 
         return depth
 

prompt_toolkit/output/base.py

@@ -165,7 +165,20 @@ def get_rows_below_cursor_position(self) -> int:
 
     @abstractmethod
     def get_default_color_depth(self) -> ColorDepth:
-        " Get default color depth for this output. "
+        """
+        Get default color depth for this output.
+
+        This value will be used if no color depth was explicitely passed to the
+        `Application`.
+
+        .. note::
+
+            If the `$PROMPT_TOOLKIT_COLOR_DEPTH` environment variable has been
+            set, then `outputs.defaults.create_output` will pass this value to
+            the implementation as the default_color_depth, which is returned
+            here. (This is not used when the output corresponds to a
+            prompt_toolkit SSH/Telnet session.)
+        """
 
 
 class DummyOutput(Output):

prompt_toolkit/output/color_depth.py

@@ -2,8 +2,6 @@
 from enum import Enum
 from typing import Optional
 
-from prompt_toolkit.utils import is_dumb_terminal, is_windows
-
 __all__ = [
     "ColorDepth",
 ]
@@ -35,61 +33,26 @@ class ColorDepth(str, Enum):
     TRUE_COLOR = DEPTH_24_BIT
 
     @classmethod
-    def local_default(cls, term: Optional[str] = None) -> "ColorDepth":
+    def from_env(cls) -> Optional["ColorDepth"]:
         """
-        Return the default color depth, according to the $TERM value.
-
-        We prefer 256 colors almost always, because this is what most terminals
-        support these days, and is a good default.
+        Return the color depth if the $PROMPT_TOOLKIT_COLOR_DEPTH environment
+        variable has been set.
 
-        The $PROMPT_TOOLKIT_COLOR_DEPTH environment variable can be used to
-        override this outcome. This is a way to enforce a certain color depth
-        in all prompt_toolkit applications.
-
-        If no `term` parameter is given, we use the $TERM environment variable.
+        This is a way to enforce a certain color depth in all prompt_toolkit
+        applications.
         """
-        # Take `TERM` value from environment variable if nothing was passed.
-        if term is None:
-            term = os.environ.get("TERM")
-
-        if is_dumb_terminal(term):
-            return cls.DEPTH_1_BIT
-
         # Check the `PROMPT_TOOLKIT_COLOR_DEPTH` environment variable.
         all_values = [i.value for i in ColorDepth]
         if os.environ.get("PROMPT_TOOLKIT_COLOR_DEPTH") in all_values:
             return cls(os.environ["PROMPT_TOOLKIT_COLOR_DEPTH"])
 
-        return cls.windows_default() if is_windows() else cls.vt100_default(term)
+        return None
 
     @classmethod
-    def vt100_default(cls, term: Optional[str] = None) -> "ColorDepth":
-        """Return the default color depth for a vt100 terminal, according to the term
-        value.
-
-        Contrary to `local_default`, this method doesn't take the local system into
-        account.
+    def default(cls) -> "ColorDepth":
         """
-        if term is None:
-            return cls.DEFAULT
-
-        if is_dumb_terminal(term):
-            return cls.DEPTH_1_BIT
-
-        if term in ("linux", "eterm-color"):
-            return cls.DEPTH_4_BIT
-
-        return cls.DEFAULT
-
-    @classmethod
-    def windows_default(cls) -> "ColorDepth":
-        """Return the default color depth for a windows terminal.
-
-        Contrary to `local_default`, this method doesn't take the local system into
-        account.
+        Return the default color depth for the default output.
         """
-        # For now, always use 4 bit color on Windows 10 by default, even when
-        # vt100 escape sequences with ENABLE_VIRTUAL_TERMINAL_PROCESSING are
-        # supported. We don't have a reliable way yet to know whether our
-        # console supports true color or only 4-bit.
-        return cls.DEPTH_4_BIT
+        from .defaults import create_output
+
+        return create_output().get_default_color_depth()

prompt_toolkit/output/conemu.py

@@ -1,8 +1,9 @@
-from typing import Any, TextIO
+from typing import Any, Optional, TextIO
 
 from prompt_toolkit.data_structures import Size
 from prompt_toolkit.renderer import Output
 
+from .color_depth import ColorDepth
 from .vt100 import Vt100_Output
 from .win32 import Win32Output
 
@@ -27,9 +28,13 @@ class ConEmuOutput:
     http://gooseberrycreative.com/cmder/
     """
 
-    def __init__(self, stdout: TextIO) -> None:
-        self.win32_output = Win32Output(stdout)
-        self.vt100_output = Vt100_Output(stdout, lambda: Size(0, 0))
+    def __init__(
+        self, stdout: TextIO, default_color_depth: Optional[ColorDepth] = None
+    ) -> None:
+        self.win32_output = Win32Output(stdout, default_color_depth=default_color_depth)
+        self.vt100_output = Vt100_Output(
+            stdout, lambda: Size(0, 0), default_color_depth=default_color_depth
+        )
 
     def __getattr__(self, name: str) -> Any:
         if name in (

prompt_toolkit/output/defaults.py

@@ -9,6 +9,7 @@
 )
 
 from .base import Output
+from .color_depth import ColorDepth
 
 __all__ = [
     "create_output",
@@ -28,6 +29,12 @@ def create_output(
         consumed by something other then a terminal, so this is a reasonable
         default.)
     """
+    # Consider TERM and PROMPT_TOOLKIT_COLOR_DEPTH environment variables.
+    # Notice that PROMPT_TOOLKIT_COLOR_DEPTH value is the default that's used
+    # if the Application doesn't override it.
+    term_from_env = get_term_environment_variable()
+    color_depth_from_env = ColorDepth.from_env()
+
     if stdout is None:
         # By default, render to stdout. If the output is piped somewhere else,
         # render to stderr.
@@ -51,12 +58,19 @@ def create_output(
         from .windows10 import Windows10_Output, is_win_vt100_enabled
 
         if is_win_vt100_enabled():
-            return cast(Output, Windows10_Output(stdout))
+            return cast(
+                Output,
+                Windows10_Output(stdout, default_color_depth=color_depth_from_env),
+            )
         if is_conemu_ansi():
-            return cast(Output, ConEmuOutput(stdout))
+            return cast(
+                Output, ConEmuOutput(stdout, default_color_depth=color_depth_from_env)
+            )
         else:
-            return Win32Output(stdout)
+            return Win32Output(stdout, default_color_depth=color_depth_from_env)
     else:
         from .vt100 import Vt100_Output
 
-        return Vt100_Output.from_pty(stdout, term=get_term_environment_variable())
+        return Vt100_Output.from_pty(
+            stdout, term=term_from_env, default_color_depth=color_depth_from_env
+        )

prompt_toolkit/output/vt100.py

@@ -26,6 +26,7 @@
 from prompt_toolkit.data_structures import Size
 from prompt_toolkit.output import Output
 from prompt_toolkit.styles import ANSI_COLOR_NAMES, Attrs
+from prompt_toolkit.utils import is_dumb_terminal
 
 from .color_depth import ColorDepth
 
@@ -415,6 +416,7 @@ def __init__(
         get_size: Callable[[], Size],
         term: Optional[str] = None,
         write_binary: bool = True,
+        default_color_depth: Optional[ColorDepth] = None,
     ) -> None:
 
         assert all(hasattr(stdout, a) for a in ("write", "flush"))
@@ -425,6 +427,7 @@ def __init__(
         self._buffer: List[str] = []
         self.stdout = stdout
         self.write_binary = write_binary
+        self.default_color_depth = default_color_depth
         self._get_size = get_size
         self.term = term
 
@@ -437,7 +440,12 @@ def __init__(
         }
 
     @classmethod
-    def from_pty(cls, stdout: TextIO, term: Optional[str] = None) -> "Vt100_Output":
+    def from_pty(
+        cls,
+        stdout: TextIO,
+        term: Optional[str] = None,
+        default_color_depth: Optional[ColorDepth] = None,
+    ) -> "Vt100_Output":
         """
         Create an Output class from a pseudo terminal.
         (This will take the dimensions by reading the pseudo
@@ -470,7 +478,7 @@ def get_size() -> Size:
                 pass
             return Size(rows=rows or 24, columns=columns or 80)
 
-        return cls(stdout, get_size, term=term)
+        return cls(stdout, get_size, term=term, default_color_depth=default_color_depth)
 
     def get_size(self) -> Size:
         return self._get_size()
@@ -685,4 +693,25 @@ def bell(self) -> None:
         self.flush()
 
     def get_default_color_depth(self) -> ColorDepth:
-        return ColorDepth.vt100_default(self.term)
+        """
+        Return the default color depth for a vt100 terminal, according to the
+        our term value.
+
+        We prefer 256 colors almost always, because this is what most terminals
+        support these days, and is a good default.
+        """
+        if self.default_color_depth is not None:
+            return self.default_color_depth
+
+        term = self.term
+
+        if term is None:
+            return ColorDepth.DEFAULT
+
+        if is_dumb_terminal(term):
+            return ColorDepth.DEPTH_1_BIT
+
+        if term in ("linux", "eterm-color"):
+            return ColorDepth.DEPTH_4_BIT
+
+        return ColorDepth.DEFAULT

prompt_toolkit/output/win32.py

@@ -10,7 +10,7 @@
     windll,
 )
 from ctypes.wintypes import DWORD, HANDLE
-from typing import Dict, List, TextIO, Tuple
+from typing import Dict, List, Optional, TextIO, Tuple
 
 from prompt_toolkit.data_structures import Size
 from prompt_toolkit.renderer import Output
@@ -85,8 +85,14 @@ class Win32Output(Output):
     (cmd.exe and similar.)
     """
 
-    def __init__(self, stdout: TextIO, use_complete_width: bool = False) -> None:
+    def __init__(
+        self,
+        stdout: TextIO,
+        use_complete_width: bool = False,
+        default_color_depth: Optional[ColorDepth] = None,
+    ) -> None:
         self.use_complete_width = use_complete_width
+        self.default_color_depth = default_color_depth
 
         self._buffer: List[str] = []
         self.stdout = stdout
@@ -480,7 +486,21 @@ def win32_refresh_window(cls) -> None:
         windll.user32.RedrawWindow(handle, None, None, c_uint(RDW_INVALIDATE))
 
     def get_default_color_depth(self) -> ColorDepth:
-        return ColorDepth.windows_default()
+        """
+        Return the default color depth for a windows terminal.
+
+        Contrary to the Vt100 implementation, this doesn't depend on a $TERM
+        variable.
+        """
+        if self.default_color_depth is not None:
+            return self.default_color_depth
+
+        # For now, by default, always use 4 bit color on Windows 10 by default,
+        # even when vt100 escape sequences with
+        # ENABLE_VIRTUAL_TERMINAL_PROCESSING are supported. We don't have a
+        # reliable way yet to know whether our console supports true color or
+        # only 4-bit.
+        return ColorDepth.DEPTH_4_BIT
 
 
 class FOREGROUND_COLOR:

prompt_toolkit/output/windows10.py

@@ -1,12 +1,13 @@
 from ctypes import byref, windll
 from ctypes.wintypes import DWORD, HANDLE
-from typing import Any, TextIO
+from typing import Any, Optional, TextIO
 
 from prompt_toolkit.data_structures import Size
 from prompt_toolkit.renderer import Output
 from prompt_toolkit.utils import is_windows
 from prompt_toolkit.win32_types import STD_OUTPUT_HANDLE
 
+from .color_depth import ColorDepth
 from .vt100 import Vt100_Output
 from .win32 import Win32Output
 
@@ -24,9 +25,13 @@ class Windows10_Output:
     Windows 10 output abstraction. This enables and uses vt100 escape sequences.
     """
 
-    def __init__(self, stdout: TextIO) -> None:
-        self.win32_output = Win32Output(stdout)
-        self.vt100_output = Vt100_Output(stdout, lambda: Size(0, 0))
+    def __init__(
+        self, stdout: TextIO, default_color_depth: Optional[ColorDepth] = None
+    ) -> None:
+        self.win32_output = Win32Output(stdout, default_color_depth=default_color_depth)
+        self.vt100_output = Vt100_Output(
+            stdout, lambda: Size(0, 0), default_color_depth=default_color_depth
+        )
         self._hconsole = HANDLE(windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE))
 
     def flush(self) -> None:

prompt_toolkit/utils.py

@@ -26,6 +26,7 @@
     "is_conemu_ansi",
     "is_windows",
     "in_main_thread",
+    "get_term_environment_variable",
     "take_using_weights",
     "to_str",
     "to_int",