"""
```sparkwidgets```
========================
A set of sparkline-ish widgets for urwid
This module contains a set of urwid text-like widgets for creating tiny but
hopefully useful sparkline-like visualizations of data.
"""
import urwid
from urwid_utils.palette import *
from collections import deque
import math
import operator
import itertools
import collections
from dataclasses import dataclass
BLOCK_VERTICAL = [ chr(x) for x in range(0x2581, 0x2589) ]
BLOCK_HORIZONTAL = [" "] + [ chr(x) for x in range(0x258F, 0x2587, -1) ]
DEFAULT_LABEL_COLOR = "black"
DEFAULT_LABEL_COLOR_DARK = "black"
DEFAULT_LABEL_COLOR_LIGHT = "white"
DEFAULT_BAR_COLOR = "white"
DISTINCT_COLORS_16 = urwid.display_common._BASIC_COLORS[1:]
DISTINCT_COLORS_256 = [
'#f00', '#080', '#00f', '#d6f', '#0ad', '#f80', '#8f0', '#666',
'#f88', '#808', '#0fd', '#66f', '#aa8', '#060', '#faf', '#860',
'#60a', '#600', '#ff8', '#086', '#8a6', '#adf', '#88a', '#f60',
'#068', '#a66', '#f0a', '#fda'
]
DISTINCT_COLORS_TRUE = [
'#ff0000', '#008c00', '#0000ff', '#c34fff',
'#01a5ca', '#ec9d00', '#76ff00', '#595354',
'#ff7598', '#940073', '#00f3cc', '#4853ff',
'#a6a19a', '#004301', '#edb7ff', '#8a6800',
'#6100a3', '#5c0011', '#fff585', '#007b69',
'#92b853', '#abd4ff', '#7e79a3', '#ff5401',
'#0a577d', '#a8615c', '#e700b9', '#ffc3a6'
]
COLOR_SCHEMES = {
"mono": {
"mode": "mono"
},
"rotate_16": {
"mode": "rotate",
"colors": DISTINCT_COLORS_16
},
"rotate_256": {
"mode": "rotate",
"colors": DISTINCT_COLORS_256
},
"rotate_true": {
"mode": "rotate",
"colors": DISTINCT_COLORS_TRUE
},
"signed": {
"mode": "rules",
"colors": {
"nonnegative": "default",
"negative": "dark red"
},
"rules": [
( "<", 0, "negative" ),
( "else", "nonnegative" ),
]
}
}
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = itertools.tee(iterable)
next(b, None)
return zip(a, b)
def get_palette_entries(
chart_colors = None,
label_colors = None
):
NORMAL_FG_MONO = "white"
NORMAL_FG_16 = "light gray"
NORMAL_BG_16 = "black"
NORMAL_FG_256 = "light gray"
NORMAL_BG_256 = "black"
palette_entries = {}
if not label_colors:
label_colors = list(set([
DEFAULT_LABEL_COLOR,
DEFAULT_LABEL_COLOR_DARK,
DEFAULT_LABEL_COLOR_LIGHT
]))
if chart_colors:
colors = chart_colors
else:
colors = (urwid.display_common._BASIC_COLORS
+ DISTINCT_COLORS_256
+ DISTINCT_COLORS_TRUE )
fcolors = colors + label_colors
bcolors = colors
for fcolor in fcolors:
if isinstance(fcolor, PaletteEntry):
fname = fcolor.name
ffg = fcolor.foreground
fbg = NORMAL_BG_16
ffghi = fcolor.foreground_high
fbghi = NORMAL_BG_256
else:
fname = fcolor
ffg = (fcolor
if fcolor in urwid.display_common._BASIC_COLORS
else NORMAL_FG_16)
fbg = NORMAL_BG_16
ffghi = fcolor
fbghi = NORMAL_BG_256
palette_entries.update({
fname: PaletteEntry(
name = fname,
mono = NORMAL_FG_MONO,
foreground = ffg,
background = fbg,
foreground_high = ffghi,
background_high = fbghi
),
})
for bcolor in bcolors:
if isinstance(bcolor, PaletteEntry):
bname = "%s:%s" %(fname, bcolor.name)
bfg = ffg
bbg = bcolor.background
bfghi = ffghi
bbghi = bcolor.background_high
else:
bname = "%s:%s" %(fname, bcolor)
bfg = fcolor
bbg = bcolor
bfghi = fcolor
bbghi = bcolor
palette_entries.update({
bname: PaletteEntry(
name = bname,
mono = NORMAL_FG_MONO,
foreground = (bfg
if bfg in urwid.display_common._BASIC_COLORS
else NORMAL_BG_16),
background = (bbg
if bbg in urwid.display_common._BASIC_COLORS
else NORMAL_BG_16),
foreground_high = bfghi,
background_high = bbghi
),
})
return palette_entries
OPERATOR_MAP = {
"<": operator.lt,
"<=": operator.le,
">": operator.gt,
">=": operator.ge,
"=": operator.eq,
"else": lambda a, b: True
}
class SparkWidget(urwid.Text):
@staticmethod
def make_rule_function(scheme):
rules = scheme["rules"]
def rule_function(value):
return scheme["colors"].get(
next(iter(filter(
lambda rule: all(
OPERATOR_MAP[cond[0]](value, cond[1] if len(cond) > 1 else None)
for cond in [rule]
), scheme["rules"]
)))[-1]
)
return rule_function
@staticmethod
def normalize(v, a, b, scale_min, scale_max):
if scale_max == scale_min:
return v
return max(
a,
min(
b,
(((v - scale_min) / (scale_max - scale_min) ) * (b - a) + a)
)
)
def parse_scheme(self, scheme):
if isinstance(scheme, dict):
color_scheme = scheme
else:
try:
color_scheme = COLOR_SCHEMES[scheme]
except:
return lambda x: scheme
# raise Exception("Unknown color scheme: %s" %(scheme))
mode = color_scheme["mode"]
if mode == "mono":
return None
elif mode == "rotate":
return deque(color_scheme["colors"])
elif mode == "rules":
return self.make_rule_function(color_scheme)
else:
raise Exception("Unknown color scheme mode: %s" %(mode))
@property
def current_color(self):
return self.colors[0]
def next_color(self):
if not self.colors:
return
self.colors.rotate(-1)
return self.current_color
def get_color(self, item):
if not self.colors:
color = None
elif callable(self.colors):
color = self.colors(item)
elif isinstance(self.colors, collections.Iterable):
color = self.current_color
self.next_color()
return color
else:
raise Exception(self.colors)
return color
class SparkColumnWidget(SparkWidget):
"""
A sparkline-ish column widget for Urwid.
Given a list of numeric values, this widget will draw a small text-based
vertical bar graph of the values, one character per value. Column segments
can be colorized according to a color scheme or by assigning each
value a color.
:param items: A list of items to be charted in the widget. Items can be
either numeric values or tuples, the latter of which must be of the form
('attribute', value) where attribute is an urwid text attribute and value
is a numeric value.
:param color_scheme: A string or dictionary containing the name of or
definition of a color scheme for the widget.
:param underline: one of None, "negative", or "min", specifying values that
should be marked in the chart. "negative" shows negative values as little
dots at the bottom of the chart, while "min" uses a unicode combining
three dots character to indicate minimum values. Results of this and the
rest of these parameters may not look great with all terminals / fonts,
so if this looks weird, don't use it.
:param overline: one of None or "max" specfying values that should be marked
in the chart. "max" draws three dots above the max value. See underline
description for caveats.
:param scale_min: Set a minimum scale for the chart. By default, the range
of the chart's Y axis will expand to show all values, but this parameter
can be used to restrict or expand the Y-axis.
:param scale_max: Set the maximum for the Y axis. -- see scale_min.
"""
chars = BLOCK_VERTICAL
def __init__(self, items,
color_scheme = "mono",
scale_min = None,
scale_max = None,
underline = None,
overline = None,
*args, **kwargs):
self.items = items
self.colors = self.parse_scheme(color_scheme)
self.underline = underline
self.overline = overline
self.values = [ i[1] if isinstance(i, tuple) else i for i in self.items ]
v_min = min(self.values)
v_max = max(self.values)
def item_to_glyph(item):
color = None
if isinstance(item, tuple):
color = item[0]
value = item[1]
else:
color = self.get_color(item)
value = item
if self.underline == "negative" and value < 0:
glyph = " \N{COMBINING DOT BELOW}"
else:
# idx = scale_value(value, scale_min=scale_min, scale_max=scale_max)
idx = self.normalize(
value, 0, len(self.chars)-1,
scale_min if scale_min else v_min,
scale_max if scale_max else v_max)
glyph = self.chars[int(round(idx))]
if self.underline == "min" and value == v_min:
glyph = "%s\N{COMBINING TRIPLE UNDERDOT}" %(glyph)
if self.overline == "max" and value == v_max:
glyph = "%s\N{COMBINING THREE DOTS ABOVE}" %(glyph)
if color:
return (color, glyph)
else:
return glyph
self.sparktext = [
item_to_glyph(i)
for i in self.items
]
super(SparkColumnWidget, self).__init__(self.sparktext, *args, **kwargs)
# via https://github.com/rg3/dhondt
def dhondt_formula(votes, seats):
return votes / (seats + 1)
def bar_widths(party_votes, total_seats):
# Calculate the quotients matrix (list in this case).
quot = []
ret = dict()
for p in dict(enumerate(party_votes)):
ret[p] = 0
for s in range(0, total_seats):
q = dhondt_formula(party_votes[p], s)
quot.append((q, p))
# Sort the quotients by value.
quot.sort(reverse=True)
# Take the highest quotients with the assigned parties.
for s in range(0, total_seats):
ret[quot[s][1]] += 1
return list(ret.values())
@dataclass
class SparkBarItem:
value: int
label: str = None
fcolor: str = None
bcolor: str = None
align: str = "<"
fill: str = " "
@property
def steps(self):
return len(BLOCK_HORIZONTAL)
def formatted_label(self, total):
if self.label is None:
return None
try:
pct = int(round(self.value/total*100, 0))
except:
pct = ""
return str(self.label).format(
value=self.value,
pct=pct
)
def truncated_label(self, width, total):
label = self.formatted_label(total)
if not label:
return None
return (
label[:width-1] + "\N{HORIZONTAL ELLIPSIS}"
if len(label) > width
else label
)
# s = "{label:.{n}}".format(
# label=self.formatted_label(total),
# n=min(len(label), width),
# )
# if len(s) > width:
# chars[-1] = "\N{HORIZONTAL ELLIPSIS}"
def output(self, width, total, next_color=None):
steps_width = width % self.steps if next_color else None
chars_width = width // self.steps# - (1 if steps_width else 0)
# print(width, chars_width, steps_width)
label = self.truncated_label(chars_width, total)
if label:
chars = "{:{a}{m}.{m}}".format(
label,
m=max(chars_width, 0),
a=self.align or "<",
)
# if len(label) > chars_width:
# chars[-1] = "\N{HORIZONTAL ELLIPSIS}"
else:
chars = self.fill * chars_width
output = [
(
"%s:%s" %(
self.fcolor or DEFAULT_LABEL_COLOR,
self.bcolor or DEFAULT_BAR_COLOR), chars
)
]
if steps_width:
attr = f"{self.bcolor}:{next_color}"
output.append(
(attr, BLOCK_HORIZONTAL[steps_width])
)
return output
class SparkBarWidget(SparkWidget):
"""
A sparkline-ish horizontal stacked bar widget for Urwid.
This widget graphs a set of values in a horizontal bar style.
:param items: A list of items to be charted in the widget. Items can be
either numeric values or tuples, the latter of which must be of the form
('attribute', value) where attribute is an urwid text attribute and value
is a numeric value.
:param width: Width of the widget in characters.
:param color_scheme: A string or dictionary containing the name of or
definition of a color scheme for the widget.
"""
fill_char = " "
def __init__(self, items, width,
color_scheme="mono",
label_color=None,
min_width=None,
fit_label=False,
normalize=None,
fill_char=None,
*args, **kwargs):
self.items = [
i if isinstance(i, SparkBarItem) else SparkBarItem(i)
for i in items
]
self.colors = self.parse_scheme(color_scheme)
for i in self.items:
if not i.bcolor:
i.bcolor = self.get_color(i)
if fill_char:
i.fill_char = fill_char
self.width = width
self.label_color = label_color
self.min_width = min_width
self.fit_label = fit_label
values = None
total = None
if normalize:
values = [ item.value for item in self.items ]
v_min = min(values)
v_max = max(values)
values = [
int(self.normalize(v,
normalize[0], normalize[1],
v_min, v_max))
for v in values
]
for i, v in enumerate(values):
self.items[i].value = v
filtered_items = self.items
values = [i.value for i in filtered_items]
total = sum(values)
charwidth = total / self.width
self.sparktext = []
position = 0
lastcolor = None
values = [i.value for i in filtered_items]
# number of steps that can be represented within each screen character
# represented by Unicode block characters
steps = len(BLOCK_HORIZONTAL)
# use a prorportional representation algorithm to distribute the number
# of available steps among each bar segment
self.bars = bar_widths(values, self.width*steps)
if self.min_width or self.fit_label:
# make any requested adjustments to bar widths
for i in range(len(self.bars)):
if self.min_width and self.bars[i] < self.min_width*steps:
self.bars[i] = self.min_width*steps
if self.fit_label:
# need some slack here to compensate for self.bars that don't
# begin on a character boundary
label_len = len(self.items[i].formatted_label(total))+2
if self.bars[i] < label_len*steps:
self.bars[i] = label_len*steps
# use modified proportions to calculate new proportions that try
# to account for min_width and fit_label
self.bars = bar_widths(self.bars, self.width*steps)
# filtered_items = [item for i, item in enumerate(self.items) if self.bars[i]]
# self.bars = [b for b in self.bars if b]
for i, (item, item_next) in enumerate(pairwise(filtered_items)):
width = self.bars[i]
output = item.output(width, total=total, next_color=item_next.bcolor)
self.sparktext += output
output = filtered_items[-1].output(self.bars[-1], total=total)
self.sparktext += output
if not self.sparktext:
self.sparktext = ""
self.set_text(self.sparktext)
super(SparkBarWidget, self).__init__(self.sparktext, *args, **kwargs)
def bar_width(self, index):
return self.bars[index]//len(BLOCK_HORIZONTAL)
__all__ = [
"SparkColumnWidget", "SparkBarWidget", "SparkBarItem",
"get_palette_entries",
"DEFAULT_LABEL_COLOR", "DEFAULT_LABEL_COLOR_DARK", "DEFAULT_LABEL_COLOR_LIGHT"
]