#!/usr/bin/env python3
"""3.0.1 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
"""
print("System colors:")
colors = term16._render()
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()
term256._rgb_display()
else:
term16.display()
print()
print("6x6x6 color cube and greyscale:")
term256._compact_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')
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 options.ansicodes:
print(getdoc(term16.ansicodes_display))
term16.ansicodes_display()
else:
term.display()
if __name__ == "__main__":
main()