Simplified ansi color dictionaries and lookup methods

Also:
- Updated examples that use color to use cmd2.ansi instead of colorama
- Updated tests that use color to use cmd2.ansi instead of colorama
- plumbum_colorspy example shows how to override color lookup functions to use a different color library

Author: tleonhardt

cmd2/ansi.py

@@ -21,15 +21,15 @@
 
 # Foreground color presets
 FG_COLORS = {
+    'black': Fore.BLACK,
+    'red': Fore.RED,
+    'green': Fore.GREEN,
+    'yellow': Fore.YELLOW,
+    'blue': Fore.BLUE,
+    'magenta': Fore.MAGENTA,
+    'cyan': Fore.CYAN,
+    'white': Fore.WHITE,
     'reset': Fore.RESET,
-    'gray': Fore.LIGHTBLACK_EX,
-    'lightred': Fore.LIGHTRED_EX,
-    'lightblue': Fore.LIGHTBLUE_EX,
-    'lightgreen': Fore.LIGHTGREEN_EX,
-    'lightyellow': Fore.LIGHTYELLOW_EX,
-    'lightmagenta': Fore.LIGHTMAGENTA_EX,
-    'lightcyan': Fore.LIGHTCYAN_EX,
-    'lightwhite': Fore.LIGHTWHITE_EX,
     'bright_black': Fore.LIGHTBLACK_EX,
     'bright_red': Fore.LIGHTRED_EX,
     'bright_green': Fore.LIGHTGREEN_EX,
@@ -39,19 +39,18 @@
     'bright_cyan': Fore.LIGHTCYAN_EX,
     'bright_white': Fore.LIGHTWHITE_EX,
 }
-FG_RESET = FG_COLORS['reset']
 
 # Background color presets
 BG_COLORS = {
+    'black': Back.BLACK,
+    'red': Back.RED,
+    'green': Back.GREEN,
+    'yellow': Back.YELLOW,
+    'blue': Back.BLUE,
+    'magenta': Back.MAGENTA,
+    'cyan': Back.CYAN,
+    'white': Back.WHITE,
     'reset': Back.RESET,
-    'gray': Back.LIGHTBLACK_EX,
-    'lightred': Back.LIGHTRED_EX,
-    'lightblue': Back.LIGHTBLUE_EX,
-    'lightgreen': Back.LIGHTGREEN_EX,
-    'lightyellow': Back.LIGHTYELLOW_EX,
-    'lightmagenta': Back.LIGHTMAGENTA_EX,
-    'lightcyan': Back.LIGHTCYAN_EX,
-    'lightwhite': Back.LIGHTWHITE_EX,
     'bright_black': Back.LIGHTBLACK_EX,
     'bright_red': Back.LIGHTRED_EX,
     'bright_green': Back.LIGHTGREEN_EX,
@@ -61,7 +60,10 @@
     'bright_cyan': Back.LIGHTCYAN_EX,
     'bright_white': Back.LIGHTWHITE_EX,
 }
+
+FG_RESET = FG_COLORS['reset']
 BG_RESET = BG_COLORS['reset']
+RESET_ALL = Style.RESET_ALL
 
 # ANSI escape sequences not provided by colorama
 UNDERLINE_ENABLE = colorama.ansi.code_to_chars(4)
@@ -104,38 +106,28 @@ def ansi_aware_write(fileobj: IO, msg: str) -> None:
 def fg_lookup(fg_name: str) -> str:
     """Look up ANSI escape codes based on foreground color name.
 
-    This function first searches the FG_COLORS dictionary and then falls back to searching colorama.Fore.
-
     :param fg_name: foreground color name to look up ANSI escape code(s) for
     :return: ANSI escape code(s) associated with this color
     :raises ValueError if the color cannot be found
     """
     try:
         ansi_escape = FG_COLORS[fg_name.lower()]
     except KeyError:
-        try:
-            ansi_escape = getattr(Fore, fg_name.upper())
-        except AttributeError:
-            raise ValueError('Foreground color {!r} does not exist.'.format(fg_name))
+        raise ValueError('Foreground color {!r} does not exist.'.format(fg_name))
     return ansi_escape
 
 
 def bg_lookup(bg_name: str) -> str:
     """Look up ANSI escape codes based on background color name.
 
-    This function first searches the BG_COLORS dictionary and then falls back to searching colorama.Back.
-
     :param bg_name: background color name to look up ANSI escape code(s) for
     :return: ANSI escape code(s) associated with this color
     :raises ValueError if the color cannot be found
     """
     try:
         ansi_escape = BG_COLORS[bg_name.lower()]
     except KeyError:
-        try:
-            ansi_escape = getattr(Back, bg_name.upper())
-        except AttributeError:
-            raise ValueError('Background color {!r} does not exist.'.format(bg_name))
+        raise ValueError('Background color {!r} does not exist.'.format(bg_name))
     return ansi_escape
 
 
@@ -144,7 +136,7 @@ def style(text: Any, *, fg: str = '', bg: str = '', bold: bool = False, underlin
     Applies styles to text
 
     :param text: Any object compatible with str.format()
-    :param fg: foreground color. Expects color names in FG_COLORS (e.g. 'lightred'). Defaults to no color.
+    :param fg: foreground color. Expects color names in FG_COLORS (e.g. 'red'). Defaults to no color.
     :param bg: background color. Expects color names in BG_COLORS (e.g. 'black'). Defaults to no color.
     :param bold: apply the bold style if True. Defaults to False.
     :param underline: apply the underline style if True. Defaults to False.
@@ -186,5 +178,5 @@ def style(text: Any, *, fg: str = '', bg: str = '', bold: bool = False, underlin
 # These can be altered to suit an application's needs and only need to be a
 # function with the following structure: func(str) -> str
 style_success = functools.partial(style, fg='green', bold=True)
-style_warning = functools.partial(style, fg='lightyellow')
-style_error = functools.partial(style, fg='lightred')
+style_warning = functools.partial(style, fg='bright_yellow')
+style_error = functools.partial(style, fg='bright_red')

examples/async_printing.py

@@ -4,15 +4,13 @@
 A simple example demonstrating an application that asynchronously prints alerts, updates the prompt
 and changes the window title
 """
-
 import random
 import threading
 import time
 from typing import List
 
-from colorama import Fore
-
 import cmd2
+from cmd2 import ansi
 
 ALERTS = ["Watch as this application prints alerts and updates the prompt",
           "This will only happen when the prompt is present",
@@ -141,26 +139,12 @@ def _generate_alert_str(self) -> str:
         return alert_str
 
     def _generate_colored_prompt(self) -> str:
-        """
-        Randomly generates a colored prompt
+        """Randomly generates a colored prompt
         :return: the new prompt
         """
-        rand_num = random.randint(1, 20)
-
-        status_color = Fore.RESET
-
-        if rand_num == 1:
-            status_color = Fore.LIGHTRED_EX
-        elif rand_num == 2:
-            status_color = Fore.LIGHTYELLOW_EX
-        elif rand_num == 3:
-            status_color = Fore.CYAN
-        elif rand_num == 4:
-            status_color = Fore.LIGHTGREEN_EX
-        elif rand_num == 5:
-            status_color = Fore.LIGHTBLUE_EX
-
-        return status_color + self.visible_prompt + Fore.RESET
+        fg_color = random.choice(list(ansi.FG_COLORS.keys()))
+        bg_color = random.choice(list(ansi.BG_COLORS.keys()))
+        return ansi.style(self.visible_prompt, fg=fg_color, bg=bg_color)
 
     def _alerter_thread_func(self) -> None:
         """ Prints alerts and updates the prompt any time the prompt is showing """

examples/colors.py

@@ -6,7 +6,7 @@
 Experiment with the command line options on the `speak` command to see how
 different output colors ca
 
-The colors setting has three possible values:
+The allow_ansi setting has three possible values:
 
 Never
     poutput(), pfeedback(), and ppaged() strip all ANSI escape sequences
@@ -16,68 +16,38 @@
     (the default value) poutput(), pfeedback(), and ppaged() do not strip any
     ANSI escape sequences when the output is a terminal, but if the output is
     a pipe or a file the escape sequences are stripped. If you want colorized
-    output you must add ANSI escape sequences, preferably using some python
-    color library like `plumbum.colors`, `colorama`, `blessings`, or
-    `termcolor`.
+    output you must add ANSI escape sequences using either cmd2's internal ansi
+    module or another color library such as `plumbum.colors` or `colorama`.
 
 Always
     poutput(), pfeedback(), and ppaged() never strip ANSI escape sequences,
     regardless of the output destination
 """
-
-import random
 import argparse
 
 import cmd2
-from colorama import Fore, Back
-
-FG_COLORS = {
-    'black': Fore.BLACK,
-    'red': Fore.RED,
-    'green': Fore.GREEN,
-    'yellow': Fore.YELLOW,
-    'blue': Fore.BLUE,
-    'magenta': Fore.MAGENTA,
-    'cyan': Fore.CYAN,
-    'white': Fore.WHITE,
-}
-BG_COLORS = {
-    'black': Back.BLACK,
-    'red': Back.RED,
-    'green': Back.GREEN,
-    'yellow': Back.YELLOW,
-    'blue': Back.BLUE,
-    'magenta': Back.MAGENTA,
-    'cyan': Back.CYAN,
-    'white': Back.WHITE,
-}
+from cmd2 import ansi
 
 
 class CmdLineApp(cmd2.Cmd):
     """Example cmd2 application demonstrating colorized output."""
-
-    # Setting this true makes it run a shell command if a cmd2/cmd command doesn't exist
-    # default_to_shell = True
-    MUMBLES = ['like', '...', 'um', 'er', 'hmmm', 'ahh']
-    MUMBLE_FIRST = ['so', 'like', 'well']
-    MUMBLE_LAST = ['right?']
-
     def __init__(self):
-        shortcuts = dict(cmd2.DEFAULT_SHORTCUTS)
-        shortcuts.update({'&': 'speak'})
         # Set use_ipython to True to enable the "ipy" command which embeds and interactive IPython shell
-        super().__init__(use_ipython=True, multiline_commands=['orate'], shortcuts=shortcuts)
+        super().__init__(use_ipython=True)
 
         self.maxrepeats = 3
         # Make maxrepeats settable at runtime
         self.settable['maxrepeats'] = 'max repetitions for speak command'
 
+        # Should ANSI color output be allowed
+        self.allow_ansi = ansi.ANSI_TERMINAL
+
     speak_parser = argparse.ArgumentParser()
     speak_parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
     speak_parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
     speak_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
-    speak_parser.add_argument('-f', '--fg', choices=FG_COLORS, help='foreground color to apply to output')
-    speak_parser.add_argument('-b', '--bg', choices=BG_COLORS, help='background color to apply to output')
+    speak_parser.add_argument('-f', '--fg', choices=ansi.FG_COLORS, help='foreground color to apply to output')
+    speak_parser.add_argument('-b', '--bg', choices=ansi.BG_COLORS, help='background color to apply to output')
     speak_parser.add_argument('words', nargs='+', help='words to say')
 
     @cmd2.with_argparser(speak_parser)
@@ -92,49 +62,11 @@ def do_speak(self, args):
             words.append(word)
 
         repetitions = args.repeat or 1
-
-        color_on = ''
-        if args.fg:
-            color_on += FG_COLORS[args.fg]
-        if args.bg:
-            color_on += BG_COLORS[args.bg]
-        color_off = Fore.RESET + Back.RESET
+        output_str = ansi.style(' '.join(words), fg=args.fg, bg=args.bg)
 
         for i in range(min(repetitions, self.maxrepeats)):
             # .poutput handles newlines, and accommodates output redirection too
-            self.poutput(color_on + ' '.join(words) + color_off)
-
-    do_say = do_speak  # now "say" is a synonym for "speak"
-    do_orate = do_speak  # another synonym, but this one takes multi-line input
-
-    mumble_parser = argparse.ArgumentParser()
-    mumble_parser.add_argument('-r', '--repeat', type=int, help='how many times to repeat')
-    mumble_parser.add_argument('-f', '--fg', help='foreground color to apply to output')
-    mumble_parser.add_argument('-b', '--bg', help='background color to apply to output')
-    mumble_parser.add_argument('words', nargs='+', help='words to say')
-
-    @cmd2.with_argparser(mumble_parser)
-    def do_mumble(self, args):
-        """Mumbles what you tell me to."""
-        color_on = ''
-        if args.fg and args.fg in FG_COLORS:
-            color_on += FG_COLORS[args.fg]
-        if args.bg and args.bg in BG_COLORS:
-            color_on += BG_COLORS[args.bg]
-        color_off = Fore.RESET + Back.RESET
-
-        repetitions = args.repeat or 1
-        for i in range(min(repetitions, self.maxrepeats)):
-            output = []
-            if random.random() < .33:
-                output.append(random.choice(self.MUMBLE_FIRST))
-            for word in args.words:
-                if random.random() < .40:
-                    output.append(random.choice(self.MUMBLES))
-                output.append(word)
-            if random.random() < .25:
-                output.append(random.choice(self.MUMBLE_LAST))
-            self.poutput(color_on + ' '.join(output) + color_off)
+            self.poutput(output_str)
 
 
 if __name__ == '__main__':