terminal-colors

#!/sbin/python3

"""3.0.0 John Eikenberry <jae@zhar.net> GPL-3+ http://zhar.net/projects/

Copyright
    Copyright (C) 2010-2020 John Eikenberry <jae@zhar.net>

License
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.

Description
    My goal in writing this script was to provide all the functionality of all
    the various perl/sh scripts found around the web in one place with some
    additional bells and whistles.

    It automatically detects 8, 16, 88, 256 color capabilities (via ncurses)
    and displays the appropriate color charts. It can display the colors as
    blocks or (2d) cubes optionally with color values overlaid in int or hex
    values.  It can show the full rgb text string as well. It can also show the
    display with a vertical (default) or horizontal orientation. It has the
    option of additional padding and supports -h --help as well.

    It also works as a utility for converting between 256 and 88 color values.

Development
    A note on coding style. I was playing around with using classes as simple
    module-esque namespaces; i.e. having classes that have all staticmethods
    and never get instatiated. As a side effect of this it makes calls at the
    module level thus this script is not really importable, thus limiting
    reuse.

Contributors
    Isaac Cammann <icammann@gmail.com> - cube display bugfix
    Jan Larres <jan@majutsushi.net> - submitted patches for..
        - compact rgb display
        - use of color intensity to determine foreground contrast color
        - 16 color SGR ANSI chart
        - 88 color rgb display bugfix

"""
from __future__ import print_function

__version__ = __doc__.split('\n')[0]

import sys
import curses
from optparse import OptionParser, OptionGroup, make_option
from math import ceil, sqrt
from inspect import getdoc
from functools import wraps

# output constants
fg_escape = "\x1b[38;5;%dm"
bg_escape = "\x1b[48;5;%dm"
clear = "\x1b[0m"

def _get_options(args):
    """ Setup and parse options.
    """
    option_list = [
        make_option("-b", "--block", action="store_true", dest="block",
            default=True, help="Display as block format (vs cube) [default]."),
        make_option("-c", "--cube-slice", action="store_true", dest="cube",
            default=False, help="Display as cube slices (vs block)."),
        make_option("-f", "--foreground", action="store_true",
            dest="foreground", default=False,
            help="Use color for foreground text."),
        make_option("-l", "--rgb", action="store_true", dest="rgb",
            default=False, help="Long format. RGB values as text."),
        make_option("-n", "--numbers", action="store_true", dest="numbers",
            default=False, help="Include color escape numbers on chart."),
        make_option("-o", "--ansicodes", action="store_true",
            dest="ansicodes", default=False,
            help="Display 16 color chart with SGR ANSI escape codes."),
        make_option("-p", "--padding", action="store_true", dest="padding",
            default=False, help="Add extra padding (helps discern colors)."),
        make_option("-t", "--test", action="store_true", dest="test",
            default=False, help="Run tests."),
        make_option("-v", "--vertical", action="store_true", dest="vertical",
            default=True, help="Display with vertical orientation [default]."),
        make_option("-x", "--hex", action="store_true", dest="hex",
            default=False, help="Include hex color numbers on chart."),
        make_option("-z", "--horizontal", action="store_true",
            dest="horizontal", default=False,
            help="Display with horizontal orientation."),
        ]

    parser = OptionParser(version=__version__, option_list=option_list)

    convert_option_list = [
        make_option("-r", "--256to88", action="store", dest="reduce",
            metavar="N", type="int",
            help="Convert (reduce) 256 color value N to an 88 color value."),
        make_option("-e", "--88to256", action="store", dest="expand",
            metavar="N", type="int",
            help="Convert (expand) 88 color value N to an 256 color value."),
        ]
    group = OptionGroup(parser, "Conversion options")
    group.add_options(option_list=convert_option_list)
    parser.add_option_group(group)

    (opts, args) = parser.parse_args(args)
    return opts

# instantiate global options based on command arguments
options = _get_options(sys.argv[1:])
# don't allow -f by itself
options.foreground = options.foreground and (
        options.numbers or options.hex or options.rgb)

class _staticmethods(type):
    """ Got tired of adding @staticmethod in front of every method.
    """
    def __new__(mcs, n, b, d):
        """ turn all methods in to staticmethods.
            staticmethod() deals correctly with class attributes.
        """
        for (n, f) in d.items():
            if callable(f):
                d[n] = staticmethod(f)
        return type.__new__(mcs, n, b, d)

def _cached(f):
    """ Memoize function w/ no params
    """
    _cache = {}
    @wraps(f)
    def cache():
        if None not in _cache:
            _cache[None] = f()
        return _cache[None]
    return cache


class term16(object):
    """ Basic 16 color terminal.
    """
    __metaclass__ = _staticmethods

    def label(n, esc):
        """ color label for 256 color values
        >>> options.numbers = True
        >>> term16.label(95, lambda n: '')
        ' 95 '
        >>> options.numbers = False
        >>> options.hex = True
        >>> term16.label(95, lambda n: '')
        ' 5f '
        """
        if options.numbers:
            return esc(n) + "%3d " % n
        elif options.hex:
            return esc(n) + " %2x " % n
        return esc(n) + "  "

    def _render():
        """ 16 color info
        >>> term16._render()[0][-1]
        '\\x1b[48;5;7m\\x1b[38;5;15m  \\x1b[0m'
        >>> len(term16._render())
        2
        >>> len(term16._render()[0])
        8
        """
        if options.foreground:
            esc = lambda n: fg_escape % n
        else:
            esc = lambda n: bg_escape % n + fg_escape % (15 if n < 9 else 0)
        return [[term16.label(n, esc) + clear for n in range(8)],
                [term16.label(n, esc) + clear for n in range(8, 16)]]

    def ansicodes():
        """ base 16 SGR ANSI escape codes
        >>> term16.ansicodes()[0][:6]
        ['    0m ', '    1m ', '   30m ', ' 1;30m ', '   31m ', ' 1;31m ']
        >>> term16.ansicodes()[1][:6]
        ['      ', '   _   ', '  40m  ', '  41m  ', '  42m  ', '  43m  ']
        >>> len(term16.ansicodes()[2])
        18
        >>> term16.ansicodes()[2][17][0]
        '\\x1b[1;37m\\x1b[_  gYw  \\x1b[0m'
        """
        fg_codes = ['0m', '1m'] + [fg for pair in
            [["{}m".format(i), "1;{}m".format(i)] for i in range(30, 38)]
            for fg in pair]
        bg_codes = ["_"] + ["{}m".format(n) for n in range(40, 48)]

        x_labels = ["%6s " % fg for fg in fg_codes]
        y_labels = [' ' * 6]
        y_labels.extend(["{: ^5}".format(bg) for bg in bg_codes])

        text, esc_code = " gYw ", "\x1b[%s"

        codes = [[esc_code % fg + esc_code % bg + text + clear
                            for bg in bg_codes] for fg in fg_codes]

        return x_labels, y_labels, codes

    def ansicodes_display():
        """ 16 SGR ANSI escape codes in traditional format
        """
        x_labels, y_labels, codes = term16.ansicodes()

        print(' '.join(y_labels))
        for i, code in enumerate(codes):
            print(x_labels[i], end='')
            print(' '.join(code))

    def display():
        """ display 16 color info
        """
        colors = term16._render()
        print()
        padding = '  ' if options.padding else ''
        for r in colors:
            print(padding.join(i for i in r))
            if options.padding: print()


class term256(term16):
    """ eg. xterm-256
    """

    @_cached
    def _rgb_lookup():
        """ color rgb lookup dict
        >>> term256._rgb_lookup()[16]
        (0, 0, 0)
        >>> term256._rgb_lookup()[128]
        (175, 0, 215)
        >>> term256._rgb_lookup()[255]
        (238, 238, 238)
        """
        # color increment is based on xterm/rxvt palette
        cincr = [0] + [95+40*n for n in range(5)]
        color_rgb = [rgb(i, j, k)
                for i in cincr for j in cincr for k in cincr]
        color_rgb = dict(zip(range(16, len(color_rgb)+16), color_rgb))
        greys = [rgb(*((n,)*3)) for n in range(8, 248, 10)]
        greys = dict(zip(range(232, 256), greys))
        color_rgb.update(greys)
        return color_rgb

    def _to_rgb(n):
        """ Convert color value to rgb tuple.
        >>> term256._to_rgb(128)
        (175, 0, 215)
        """
        return term256._rgb_lookup()[n]

    def _rgb_color_table():
        """ 256 color info
        >>> term256._rgb_color_table()[0][0]
        '\\x1b[38;5;16m  16: \\x1b[38;5;255m\\x1b[48;5;16m#000000\\x1b[0m'
        >>> term256._rgb_color_table()[-1][-1]
        '\\x1b[38;5;255m 255: \\x1b[38;5;16m\\x1b[48;5;255m#eeeeee\\x1b[0m'
        """
        rgbl = term256._rgb_lookup()
        label_num = "% 4d: "
        label_val = "%s"
        if options.foreground:
            render = lambda n: fg_escape % n + label_num % n + \
                    label_val % str(rgbl[n]) + clear
        else:
            render = lambda n: fg_escape % n + label_num % n + \
                    fg_escape % (16 if rgbl[n].is_light() else 255) \
                    + bg_escape % n + label_val % str(rgbl[n]) + clear
        return [[render(n) for n in [i+j for j in range(6)]]
                    for i in range(16, 256, 6)]

    def _rgb_display():
        """ display colors with rgb hex info
        """
        colors = term256._rgb_color_table()
        padding = '  ' if options.padding else ''
        while colors:
            rows, colors = colors[:6], colors[6:]
            if not options.horizontal:
                rows = zip(*rows)
            for r in rows:
                print(padding.join(i for i in r))
                if options.padding: print()
            print()

    def _colors():
        """ 256 color numbers
        """
        return [[i+j for j in range(6)] for i in range(16, 232, 6)]

    def _greyscale():
        """ 256 greyscale numbers
        """
        return [[i+j for j in range(12)] for i in range(232, 256, 12)]

    def _render(palette):
        """ compact 256 color info
        """
        if options.foreground:
            esc = lambda n: fg_escape % n
            render = lambda n: term256.label(n, esc) + clear
        else:
            esc = lambda n: fg_escape % \
                    (16 if term256._to_rgb(n).is_light() else 255)
            render = lambda n: bg_escape % n + term256.label(n, esc) + clear
        return [[render(n) for n in i] for i in iter(palette)]

    def _compact_display():
        """ display colors in compact format
        """
        colors = term256._render(term256._colors())
        if options.cube:
            _cube_display(colors)
        elif options.block:
            _block_display(colors)
        print()
        greys = term256._render(term256._greyscale())
        padding = '  ' if options.padding else ''
        for r in greys:
            print(padding.join(i for i in r))
            if options.padding: print()

    def display():
        """ display 256 color info (+ 16 in compact format)
        """
        if options.rgb:
            print("Xterm RGB values for 6x6x6 color cube and greyscale.")
            print()
        else:
            term16.display()
class term88(term16):
    """ xterm-88 or urxvt
    """

    @_cached
    def _rgb_lookup():
        """ color rgb lookup dict
        """
        # color increment is based on rxvt palette
        cincr = [0, 0x8b, 0xcd, 0xff]
        color_rgb = [rgb(i, j, k)
                for i in cincr for j in cincr for k in cincr]
        color_rgb = dict(zip(range(16, len(color_rgb)+16), color_rgb))
        greys = [rgb(*((n,)*3))
                for n in [0x2e, 0x5c, 0x73, 0x8b, 0xa2, 0xb9, 0xd0, 0xe7]]
        greys = dict(zip(range(80, 88), greys))
        color_rgb.update(greys)
        return color_rgb

    def _to_rgb(n):
        """ Convert color value to rgb tuple.
        """
        return term88._rgb_lookup()[n]

    def _rgb_color_table():
        """ 88 color info
        """
        rgbl = term88._rgb_lookup()
        label_num = "% 4d: "
        label_val = "%s"
        if options.foreground:
            render = lambda n: fg_escape % n + label_num % n + \
                    label_val % str(rgbl[n]) + clear
        else:
            render = lambda n: fg_escape % n + label_num % n + \
                    fg_escape % (16 if rgbl[n].is_light() else 87) \
                    + bg_escape % n + label_val % str(rgbl[n]) + clear
        return [[render(n) for n in [i+j for j in range(4)]]
                    for i in range(16, 88, 4)]

    def _rgb_display():
        """ display colors with rgb hex info
        """
        colors = term88._rgb_color_table()
        while colors:
            rows, colors = colors[:4], colors[4:]
            for r in zip(*rows):
                print(''.join(i for i in r))
            print()

    def _render(palette):
        """ 88 color info
        """
        if options.foreground:
            esc = lambda n: fg_escape % n
            render = lambda n: term88.label(n, esc) + clear
        else:
            esc = lambda n: fg_escape % \
                    (16 if term88._to_rgb(n).is_light() else 87)
            render = lambda n: bg_escape % n + term88.label(n, esc) + clear
        return [[render(n) for n in i] for i in iter(palette)]

    def _colors():
        """ 88 color numbers
        """
        return [[i+j for j in range(4)] for i in range(16, 80, 4)]

    def _greyscale():
        """ 88 greyscale numbers
        """
        return [range(80, 88)]


    def display():
        """ display 16 + 88 color info
        """
        if options.rgb:
            print("Xterm RGB values for 4x4x4 color cube and greyscale.")
            print()
            term88._rgb_display()
        else:
            padding = '  ' if options.padding else ''
            term16.display()
            print()
            print("4x4x4 color cube and greyscale:")
            colors = term88._render(term88._colors())
            if options.cube:
                _cube_display(colors)
            elif options.block:
                _block_display(colors)
            print()
            greys = term88._render(term88._greyscale())
            for r in greys:
                print(padding.join(i for i in r))

class rgb(tuple):
    """ An RGB, (red, green, blue) tuple. Takes integers.
    """
    def __new__(cls, r, g, b):
        """ We want 3 colors.
        """
        return super(rgb, cls).__new__(cls, (r, g, b))

    def __str__(self):
        """ Display in compact rgb format.
        """
        return "#%02x%02x%02x" % self

    def is_light(self):
        """ Is this color light (or dark).
        """
        red, green, blue = self[0], self[1], self[2]
        intensity = red*0.2126 + green*0.7152 + blue*0.0722
        return intensity > 127


def _cube_display(colors):
    """ Display color cube as color aligned flatten cube sides.
    """
    padding = '  ' if options.padding else ''
    if options.horizontal:
        def _horizontal(colors):
            size = int(sqrt(len(colors)))
            for n in (n*size for n in range(size)):
                colors[n:n+size] = zip(*colors[n:n+size])
            while colors:
                rows, colors = colors[:size*2], colors[size*2:]
                for n in range(size):
                    print(padding.join(i
                            for i in rows[n]+tuple(reversed(rows[n+size]))))
                    if options.padding: print(padding)
                if colors: print()
        _horizontal(colors)
    else: #options.vertical - default
        def _vertical(colors):
            size = int(sqrt(len(colors)))
            top = [colors[n:len(colors):size*2] for n in range(size)]
            bottom = [colors[n+size:len(colors):size*2]
                    for n in reversed(range(size))]
            for group in [top, bottom]:
                for rows in group:
                    for r in rows:
                        print(padding.join(i for i in r), end=' ')
                        if options.padding: print(padding, end=' ')
                    if options.padding: print()
                    print()
        _vertical(colors)

def _block_display(colors):
    """ Display color cube as cube sides organized by color #s (default).
    """
    padding = '  ' if options.padding else ''
    size = int(sqrt(len(colors)))
    if not options.horizontal:
        for n in (n*size for n in range(size)):
            colors[n:n+size] = zip(*colors[n:n+size])
    while colors:
        half = size*(size//2)
        rows, colors = colors[:half], colors[half:]
        for n in range(size):
            for r in rows[n:len(rows):size]:
                print(padding.join(i for i in r), end=' ')
                if options.padding: print(padding, end=' ')
            if options.padding: print()
            print()
        if colors: print()

def convert88to256(n):
    """ 88 (4x4x4) color cube to 256 (6x6x6) color cube values
    """
    if n < 16:
        return n
    elif n > 79:
        return 234 + (3 * (n - 80))
    else:
        def m(n):
            "0->0, 1->1, 2->3, 3->5"
            return n and n + n-1 or n
        b = n - 16
        x = b % 4
        y = (b // 4) % 4
        z = b // 16
        return 16 + m(x) + (6 * m(y) + 36 * m(z))

def convert256to88(n):
    """ 256 (6x6x6) color cube to 88 (4x4x4) color cube values
    """
    if n < 16:
        return n
    elif n > 231:
        if n < 234:
            return 0
        return 80 + ((n - 234) // 3)
    else:
        def m(n, _ratio=(4./6.)):
            if n < 2:
                return int(ceil(_ratio*n))
            else:
                return int(_ratio*n)
        b = n - 16
        x = b % 6
        y = (b // 6) % 6
        z = b // 36
        return 16 + m(x) + (4 * m(y) + 16 * m(z))

def _terminal():
    """ detect # of colors supported by terminal and return appropriate
        terminal class
    """
    curses.setupterm()
    num_colors = curses.tigetnum('colors')
    if num_colors > 0:
        return {16:term16, 88:term88, 256:term256}.get(num_colors, term16)

def main():
    if options.test:
        print("Running tests...")
        import doctest
        doctest.testmod()
        print("Done.")
    elif options.reduce:
        v = convert256to88(options.reduce)
        # reconvert back to display reduction in context
        print("%s (equivalent to 256 value: %s)" % (v, convert88to256(v)))
    elif options.expand:
        print(convert88to256(options.expand))
    else:
        term = _terminal()
        if term is None:
            print("Your terminal reports that it has no color support.")
        else:
            if options.ansicodes:
                print(getdoc(term16.ansicodes_display))
                term16.ansicodes_display()
            else:
                term.display()

if __name__ == "__main__":
    main()