X-Git-Url: https://wannabe.guru.org/gitweb/?a=blobdiff_plain;f=ansi.py;h=dee52424fefa6bd80daccc3d8830c0a707e12b6a;hb=532df2c5b57c7517dfb3dddd8c1358fbadf8baf3;hp=089863931e6f8fc7b7f000af56c37274e33916af;hpb=3bc4daf1edc121cd633429187392227f2fa61885;p=python_utils.git

diff --git a/ansi.py b/ansi.py
index 0898639..dee5242 100755
--- a/ansi.py
+++ b/ansi.py
@@ -1,10 +1,25 @@
 #!/usr/bin/env python3
 
+# © Copyright 2021-2022, Scott Gasch
+
+"""A bunch of color names mapped into RGB tuples and some methods for
+setting the text color, background, etc... using ANSI escape
+sequences.
+
+"""
+
+import contextlib
 import difflib
+import io
 import logging
+import re
 import sys
-from typing import Dict, Optional, Tuple
+from abc import abstractmethod
+from typing import Any, Callable, Dict, Iterable, Literal, Optional, Tuple
+
+from overrides import overrides
 
+import logging_utils
 import string_utils
 
 logger = logging.getLogger(__name__)
@@ -1636,7 +1651,7 @@ def strike_through() -> str:
 
 
 def is_16color(num: int) -> bool:
-    return num == 255 or num == 128
+    return num in (255, 128)
 
 
 def is_216color(num: int) -> bool:
@@ -1725,13 +1740,30 @@ def _find_color_by_name(name: str) -> Tuple[int, int, int]:
     return rgb
 
 
-def fg(name: Optional[str] = "",
-       red: Optional[int] = None,
-       green: Optional[int] = None,
-       blue: Optional[int] = None,
-       *,
-       force_16color: bool = False,
-       force_216color: bool = False) -> str:
+@logging_utils.squelch_repeated_log_messages(1)
+def fg(
+    name: Optional[str] = "",
+    red: Optional[int] = None,
+    green: Optional[int] = None,
+    blue: Optional[int] = None,
+    *,
+    force_16color: bool = False,
+    force_216color: bool = False,
+) -> str:
+    """Return the ANSI escape sequence to change the foreground color
+    being printed.  Target colors may be indicated by name or R/G/B.
+    Result will use the 16 or 216 color scheme if force_16color or
+    force_216color are passed (respectively).  Otherwise the code will
+    do what it thinks best.
+
+    >>> import string_utils as su
+    >>> su.to_base64(fg('blue'))
+    b'G1szODs1OzIxbQ==\\n'
+
+    """
+    if name is not None and name == 'reset':
+        return '\033[39m'
+
     if name is not None and string_utils.is_full_string(name):
         rgb = _find_color_by_name(name)
         return fg(
@@ -1740,7 +1772,7 @@ def fg(name: Optional[str] = "",
             rgb[1],
             rgb[2],
             force_16color=force_16color,
-            force_216color=force_216color
+            force_216color=force_216color,
         )
 
     if red is None:
@@ -1749,14 +1781,10 @@ def fg(name: Optional[str] = "",
         green = 0
     if blue is None:
         blue = 0
-    if (
-        is_16color(red) and is_16color(green) and is_16color(blue)
-    ) or force_16color:
+    if (is_16color(red) and is_16color(green) and is_16color(blue)) or force_16color:
         logger.debug("Using 16-color strategy")
         return fg_16color(red, green, blue)
-    if (
-        is_216color(red) and is_216color(green) and is_216color(blue)
-    ) or force_216color:
+    if (is_216color(red) and is_216color(green) and is_216color(blue)) or force_216color:
         logger.debug("Using 216-color strategy")
         return fg_216color(red, green, blue)
     logger.debug("Using 24-bit color strategy")
@@ -1769,14 +1797,27 @@ def _rgb_to_yiq(rgb: Tuple[int, int, int]) -> int:
 
 def _contrast(rgb: Tuple[int, int, int]) -> Tuple[int, int, int]:
     if _rgb_to_yiq(rgb) < 128:
-        return (0xff, 0xff, 0xff)
+        return (0xFF, 0xFF, 0xFF)
     return (0, 0, 0)
 
 
-def pick_contrasting_color(name: Optional[str] = "",
-                           red: Optional[int] = None,
-                           green: Optional[int] = None,
-                           blue: Optional[int] = None) -> Tuple[int, int, int]:
+def pick_contrasting_color(
+    name: Optional[str] = "",
+    red: Optional[int] = None,
+    green: Optional[int] = None,
+    blue: Optional[int] = None,
+) -> Tuple[int, int, int]:
+    """This method will return a red, green, blue tuple representing a
+    contrasting color given the red, green, blue of a background
+    color or a color name of the background color.
+
+    >>> pick_contrasting_color(None, 20, 20, 20)
+    (255, 255, 255)
+
+    >>> pick_contrasting_color("white")
+    (0, 0, 0)
+
+    """
     if name is not None and string_utils.is_full_string(name):
         rgb = _find_color_by_name(name)
     else:
@@ -1792,26 +1833,36 @@ def guess_name(name: str) -> str:
     best_guess = None
     max_ratio = None
     for possibility in COLOR_NAMES_TO_RGB:
-        r = difflib.SequenceMatcher(
-            None,
-            name,
-            possibility
-        ).ratio()
+        r = difflib.SequenceMatcher(None, name, possibility).ratio()
         if max_ratio is None or r > max_ratio:
             max_ratio = r
             best_guess = possibility
     assert best_guess is not None
-    logger.debug(f"Best guess at color name is {best_guess}")
+    logger.debug("Best guess at color name is %s", best_guess)
     return best_guess
 
 
-def bg(name: Optional[str] = "",
-       red: Optional[int] = None,
-       green: Optional[int] = None,
-       blue: Optional[int] = None,
-       *,
-       force_16color: bool = False,
-       force_216color: bool = False) -> str:
+@logging_utils.squelch_repeated_log_messages(1)
+def bg(
+    name: Optional[str] = "",
+    red: Optional[int] = None,
+    green: Optional[int] = None,
+    blue: Optional[int] = None,
+    *,
+    force_16color: bool = False,
+    force_216color: bool = False,
+) -> str:
+    """Returns an ANSI color code for changing the current background
+    color.
+
+    >>> import string_utils as su
+    >>> su.to_base64(bg("red"))    # b'\x1b[48;5;196m'
+    b'G1s0ODs1OzE5Nm0=\\n'
+
+    """
+    if name is not None and name == 'reset':
+        return '\033[49m'
+
     if name is not None and string_utils.is_full_string(name):
         rgb = _find_color_by_name(name)
         return bg(
@@ -1820,7 +1871,7 @@ def bg(name: Optional[str] = "",
             rgb[1],
             rgb[2],
             force_16color=force_16color,
-            force_216color=force_216color
+            force_216color=force_216color,
         )
     if red is None:
         red = 0
@@ -1828,22 +1879,66 @@ def bg(name: Optional[str] = "",
         green = 0
     if blue is None:
         blue = 0
-    if (
-        is_16color(red) and is_16color(green) and is_16color(blue)
-    ) or force_16color:
+    if (is_16color(red) and is_16color(green) and is_16color(blue)) or force_16color:
         logger.debug("Using 16-color strategy")
         return bg_16color(red, green, blue)
-    if (
-        is_216color(red) and is_216color(green) and is_216color(blue)
-    ) or force_216color:
+    if (is_216color(red) and is_216color(green) and is_216color(blue)) or force_216color:
         logger.debug("Using 216-color strategy")
         return bg_216color(red, green, blue)
     logger.debug("Using 24-bit color strategy")
     return bg_24bit(red, green, blue)
 
 
+class StdoutInterceptor(io.TextIOBase, contextlib.AbstractContextManager):
+    """An interceptor for data written to stdout.  Use as a context."""
+
+    def __init__(self):
+        super().__init__()
+        self.saved_stdout: io.TextIO = None
+        self.buf = ''
+
+    @abstractmethod
+    def write(self, s: str):
+        pass
+
+    def __enter__(self):
+        self.saved_stdout = sys.stdout
+        sys.stdout = self
+        return self
+
+    def __exit__(self, *args) -> Literal[False]:
+        sys.stdout = self.saved_stdout
+        print(self.buf)
+        return False
+
+
+class ProgrammableColorizer(StdoutInterceptor):
+    """A colorizing interceptor; pass it re.Patterns -> methods that do
+    something (usually add color to) the match.
+
+    """
+
+    def __init__(
+        self,
+        patterns: Iterable[Tuple[re.Pattern, Callable[[Any, re.Pattern], str]]],
+    ):
+        super().__init__()
+        self.patterns = list(patterns)
+
+    @overrides
+    def write(self, s: str):
+        for pattern in self.patterns:
+            s = pattern[0].sub(pattern[1], s)
+        self.buf += s
+
+
 if __name__ == '__main__':
+
     def main() -> None:
+        import doctest
+
+        doctest.testmod()
+
         name = " ".join(sys.argv[1:])
         for possibility in COLOR_NAMES_TO_RGB:
             if name in possibility:
@@ -1852,6 +1947,6 @@ if __name__ == '__main__':
                 _ = pick_contrasting_color(possibility)
                 xf = fg(None, _[0], _[1], _[2])
                 xb = bg(None, _[0], _[1], _[2])
-                print(f'{f}{xb}{possibility}{reset()}\t\t\t'
-                      f'{b}{xf}{possibility}{reset()}')
+                print(f'{f}{xb}{possibility}{reset()}\t\t\t' f'{b}{xf}{possibility}{reset()}')
+
     main()