# Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Table generating, analyzing and printing functions.
This defines several classes that are used to generate, analyze and print
tables.
Example usage:
from cros_utils import tabulator
data = [["benchmark1", "33", "44"],["benchmark2", "44", "33"]]
tabulator.GetSimpleTable(data)
You could also use it to generate more complex tables with analysis such as
p-values, custom colors, etc. Tables are generated by TableGenerator and
analyzed/formatted by TableFormatter. TableFormatter can take in a list of
columns with custom result computation and coloring, and will compare values in
each row according to taht scheme. Here is a complex example on printing a
table:
from cros_utils import tabulator
runs = [[{"k1": "10", "k2": "12", "k5": "40", "k6": "40",
"ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
"k10": "0"},
{"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
"k9": "FAIL", "k10": "0"}],
[{"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
"45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
"PASS"}]]
labels = ["vanilla", "modified"]
tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
table = tg.GetTable()
columns = [Column(LiteralResult(),
Format(),
"Literal"),
Column(AmeanResult(),
Format()),
Column(StdResult(),
Format()),
Column(CoeffVarResult(),
CoeffVarFormat()),
Column(NonEmptyCountResult(),
Format()),
Column(AmeanRatioResult(),
PercentFormat()),
Column(AmeanRatioResult(),
RatioFormat()),
Column(GmeanRatioResult(),
RatioFormat()),
Column(PValueResult(),
PValueFormat()),
]
tf = TableFormatter(table, columns)
cell_table = tf.GetCellTable()
tp = TablePrinter(cell_table, out_to)
print tp.Print()
"""
from __future__ import print_function
import getpass
import math
import sys
import numpy
from email_sender import EmailSender
import misc
def _AllFloat(values):
return all([misc.IsFloat(v) for v in values])
def _GetFloats(values):
return [float(v) for v in values]
def _StripNone(results):
res = []
for result in results:
if result is not None:
res.append(result)
return res
class TableGenerator(object):
"""Creates a table from a list of list of dicts.
The main public function is called GetTable().
"""
SORT_BY_KEYS = 0
SORT_BY_KEYS_DESC = 1
SORT_BY_VALUES = 2
SORT_BY_VALUES_DESC = 3
MISSING_VALUE = 'x'
def __init__(self, d, l, sort=SORT_BY_KEYS, key_name='keys'):
self._runs = d
self._labels = l
self._sort = sort
self._key_name = key_name
def _AggregateKeys(self):
keys = set([])
for run_list in self._runs:
for run in run_list:
keys = keys.union(run.keys())
return keys
def _GetHighestValue(self, key):
values = []
for run_list in self._runs:
for run in run_list:
if key in run:
values.append(run[key])
values = _StripNone(values)
if _AllFloat(values):
values = _GetFloats(values)
return max(values)
def _GetLowestValue(self, key):
values = []
for run_list in self._runs:
for run in run_list:
if key in run:
values.append(run[key])
values = _StripNone(values)
if _AllFloat(values):
values = _GetFloats(values)
return min(values)
def _SortKeys(self, keys):
if self._sort == self.SORT_BY_KEYS:
return sorted(keys)
elif self._sort == self.SORT_BY_VALUES:
# pylint: disable=unnecessary-lambda
return sorted(keys, key=lambda x: self._GetLowestValue(x))
elif self._sort == self.SORT_BY_VALUES_DESC:
# pylint: disable=unnecessary-lambda
return sorted(keys, key=lambda x: self._GetHighestValue(x), reverse=True)
else:
assert 0, 'Unimplemented sort %s' % self._sort
def _GetKeys(self):
keys = self._AggregateKeys()
return self._SortKeys(keys)
def GetTable(self, number_of_rows=sys.maxint):
"""Returns a table from a list of list of dicts.
The list of list of dicts is passed into the constructor of TableGenerator.
This method converts that into a canonical list of lists which represents a
table of values.
Args:
number_of_rows: Maximum number of rows to return from the table.
Returns:
A list of lists which is the table.
Example:
We have the following runs:
[[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}],
[{"k1": "v4", "k4": "v5"}]]
and the following labels:
["vanilla", "modified"]
it will return:
[["Key", "vanilla", "modified"]
["k1", ["v1", "v3"], ["v4"]]
["k2", ["v2"], []]
["k4", [], ["v5"]]]
The returned table can then be processed further by other classes in this
module.
"""
keys = self._GetKeys()
header = [self._key_name] + self._labels
table = [header]
rows = 0
for k in keys:
row = [k]
unit = None
for run_list in self._runs:
v = []
for run in run_list:
if k in run:
if type(run[k]) is list:
val = run[k][0]
unit = run[k][1]
else:
val = run[k]
v.append(val)
else:
v.append(None)
row.append(v)
# If we got a 'unit' value, append the units name to the key name.
if unit:
keyname = row[0] + ' (%s) ' % unit
row[0] = keyname
table.append(row)
rows += 1
if rows == number_of_rows:
break
return table
class Result(object):
"""A class that respresents a single result.
This single result is obtained by condensing the information from a list of
runs and a list of baseline runs.
"""
def __init__(self):
pass
def _AllStringsSame(self, values):
values_set = set(values)
return len(values_set) == 1
def NeedsBaseline(self):
return False
# pylint: disable=unused-argument
def _Literal(self, cell, values, baseline_values):
cell.value = ' '.join([str(v) for v in values])
def _ComputeFloat(self, cell, values, baseline_values):
self._Literal(cell, values, baseline_values)
def _ComputeString(self, cell, values, baseline_values):
self._Literal(cell, values, baseline_values)
def _InvertIfLowerIsBetter(self, cell):
pass
def _GetGmean(self, values):
if not values:
return float('nan')
if any([v < 0 for v in values]):
return float('nan')
if any([v == 0 for v in values]):
return 0.0
log_list = [math.log(v) for v in values]
gmean_log = sum(log_list) / len(log_list)
return math.exp(gmean_log)
def Compute(self, cell, values, baseline_values):
"""Compute the result given a list of values and baseline values.
Args:
cell: A cell data structure to populate.
values: List of values.
baseline_values: List of baseline values. Can be none if this is the
baseline itself.
"""
all_floats = True
values = _StripNone(values)
if not values:
cell.value = ''
return
if _AllFloat(values):
float_values = _GetFloats(values)
else:
all_floats = False
if baseline_values:
baseline_values = _StripNone(baseline_values)
if baseline_values:
if _AllFloat(baseline_values):
float_baseline_values = _GetFloats(baseline_values)
else:
all_floats = False
else:
if self.NeedsBaseline():
cell.value = ''
return
float_baseline_values = None
if all_floats:
self._ComputeFloat(cell, float_values, float_baseline_values)
self._InvertIfLowerIsBetter(cell)
else:
self._ComputeString(cell, values, baseline_values)
class LiteralResult(Result):
"""A literal result."""
def __init__(self, iteration=0):
super(LiteralResult, self).__init__()
self.iteration = iteration
def Compute(self, cell, values, baseline_values):
try:
cell.value = values[self.iteration]
except IndexError:
cell.value = '-'
class NonEmptyCountResult(Result):
"""A class that counts the number of non-empty results.
The number of non-empty values will be stored in the cell.
"""
def Compute(self, cell, values, baseline_values):
"""Put the number of non-empty values in the cell result.
Args:
cell: Put the result in cell.value.
values: A list of values for the row.
baseline_values: A list of baseline values for the row.
"""
cell.value = len(_StripNone(values))
if not baseline_values:
return
base_value = len(_StripNone(baseline_values))
if cell.value == base_value:
return
f = ColorBoxFormat()
len_values = len(values)
len_baseline_values = len(baseline_values)
tmp_cell = Cell()
tmp_cell.value = 1.0 + (float(cell.value - base_value) /
(max(len_values, len_baseline_values)))
f.Compute(tmp_cell)
cell.bgcolor = tmp_cell.bgcolor
class StringMeanResult(Result):
"""Mean of string values."""
def _ComputeString(self, cell, values, baseline_values):
if self._AllStringsSame(values):
cell.value = str(values[0])
else:
cell.value = '?'
class AmeanResult(StringMeanResult):
"""Arithmetic mean."""
def _ComputeFloat(self, cell, values, baseline_values):
cell.value = numpy.mean(values)
class RawResult(Result):
"""Raw result."""
pass
class MinResult(Result):
"""Minimum."""
def _ComputeFloat(self, cell, values, baseline_values):
cell.value = min(values)
def _ComputeString(self, cell, values, baseline_values):
if values:
cell.value = min(values)
else:
cell.value = ''
class MaxResult(Result):
"""Maximum."""
def _ComputeFloat(self, cell, values, baseline_values):
cell.value = max(values)
def _ComputeString(self, cell, values, baseline_values):
if values:
cell.value = max(values)
else:
cell.value = ''
class NumericalResult(Result):
"""Numerical result."""
def _ComputeString(self, cell, values, baseline_values):
cell.value = '?'
class StdResult(NumericalResult):
"""Standard deviation."""
def _ComputeFloat(self, cell, values, baseline_values):
cell.value = numpy.std(values)
class CoeffVarResult(NumericalResult):
"""Standard deviation / Mean"""
def _ComputeFloat(self, cell, values, baseline_values):
if numpy.mean(values) != 0.0:
noise = numpy.abs(numpy.std(values) / numpy.mean(values))
else:
noise = 0.0
cell.value = noise
class ComparisonResult(Result):
"""Same or Different."""
def NeedsBaseline(self):
return True
def _ComputeString(self, cell, values, baseline_values):
value = None
baseline_value = None
if self._AllStringsSame(values):
value = values[0]
if self._AllStringsSame(baseline_values):
baseline_value = baseline_values[0]
if value is not None and baseline_value is not None:
if value == baseline_value:
cell.value = 'SAME'
else:
cell.value = 'DIFFERENT'
else:
cell.value = '?'
class PValueResult(ComparisonResult):
"""P-value."""
def _ComputeFloat(self, cell, values, baseline_values):
if len(values) < 2 or len(baseline_values) < 2:
cell.value = float('nan')
return
import stats
_, cell.value = stats.lttest_ind(values, baseline_values)
def _ComputeString(self, cell, values, baseline_values):
return float('nan')
class KeyAwareComparisonResult(ComparisonResult):
"""Automatic key aware comparison."""
def _IsLowerBetter(self, key):
# TODO(llozano): Trying to guess direction by looking at the name of the
# test does not seem like a good idea. Test frameworks should provide this
# info explicitly. I believe Telemetry has this info. Need to find it out.
#
# Below are some test names for which we are not sure what the
# direction is.
#
# For these we dont know what the direction is. But, since we dont
# specify anything, crosperf will assume higher is better:
# --percent_impl_scrolled--percent_impl_scrolled--percent
# --solid_color_tiles_analyzed--solid_color_tiles_analyzed--count
# --total_image_cache_hit_count--total_image_cache_hit_count--count
# --total_texture_upload_time_by_url
#
# About these we are doubtful but we made a guess:
# --average_num_missing_tiles_by_url--*--units (low is good)
# --experimental_mean_frame_time_by_url--*--units (low is good)
# --experimental_median_frame_time_by_url--*--units (low is good)
# --texture_upload_count--texture_upload_count--count (high is good)
# --total_deferred_image_decode_count--count (low is good)
# --total_tiles_analyzed--total_tiles_analyzed--count (high is good)
lower_is_better_keys = ['milliseconds', 'ms_', 'seconds_', 'KB', 'rdbytes',
'wrbytes', 'dropped_percent', '(ms)', '(seconds)',
'--ms', '--average_num_missing_tiles',
'--experimental_jank', '--experimental_mean_frame',
'--experimental_median_frame_time',
'--total_deferred_image_decode_count', '--seconds']
return any([l in key for l in lower_is_better_keys])
def _InvertIfLowerIsBetter(self, cell):
if self._IsLowerBetter(cell.name):
if cell.value:
cell.value = 1.0 / cell.value
class AmeanRatioResult(KeyAwareComparisonResult):
"""Ratio of arithmetic means of values vs. baseline values."""
def _ComputeFloat(self, cell, values, baseline_values):
if numpy.mean(baseline_values) != 0:
cell.value = numpy.mean(values) / numpy.mean(baseline_values)
elif numpy.mean(values) != 0:
cell.value = 0.00
# cell.value = 0 means the values and baseline_values have big difference
else:
cell.value = 1.00
# no difference if both values and baseline_values are 0
class GmeanRatioResult(KeyAwareComparisonResult):
"""Ratio of geometric means of values vs. baseline values."""
def _ComputeFloat(self, cell, values, baseline_values):
if self._GetGmean(baseline_values) != 0:
cell.value = self._GetGmean(values) / self._GetGmean(baseline_values)
elif self._GetGmean(values) != 0:
cell.value = 0.00
else:
cell.value = 1.00
class Color(object):
"""Class that represents color in RGBA format."""
def __init__(self, r=0, g=0, b=0, a=0):
self.r = r
self.g = g
self.b = b
self.a = a
def __str__(self):
return 'r: %s g: %s: b: %s: a: %s' % (self.r, self.g, self.b, self.a)
def Round(self):
"""Round RGBA values to the nearest integer."""
self.r = int(self.r)
self.g = int(self.g)
self.b = int(self.b)
self.a = int(self.a)
def GetRGB(self):
"""Get a hex representation of the color."""
return '%02x%02x%02x' % (self.r, self.g, self.b)
@classmethod
def Lerp(cls, ratio, a, b):
"""Perform linear interpolation between two colors.
Args:
ratio: The ratio to use for linear polation.
a: The first color object (used when ratio is 0).
b: The second color object (used when ratio is 1).
Returns:
Linearly interpolated color.
"""
ret = cls()
ret.r = (b.r - a.r) * ratio + a.r
ret.g = (b.g - a.g) * ratio + a.g
ret.b = (b.b - a.b) * ratio + a.b
ret.a = (b.a - a.a) * ratio + a.a
return ret
class Format(object):
"""A class that represents the format of a column."""
def __init__(self):
pass
def Compute(self, cell):
"""Computes the attributes of a cell based on its value.
Attributes typically are color, width, etc.
Args:
cell: The cell whose attributes are to be populated.
"""
if cell.value is None:
cell.string_value = ''
if isinstance(cell.value, float):
self._ComputeFloat(cell)
else:
self._ComputeString(cell)
def _ComputeFloat(self, cell):
cell.string_value = '{0:.2f}'.format(cell.value)
def _ComputeString(self, cell):
cell.string_value = str(cell.value)
def _GetColor(self, value, low, mid, high, power=6, mid_value=1.0):
min_value = 0.0
max_value = 2.0
if math.isnan(value):
return mid
if value > mid_value:
value = max_value - mid_value / value
return self._GetColorBetweenRange(value, min_value, mid_value, max_value,
low, mid, high, power)
def _GetColorBetweenRange(self, value, min_value, mid_value, max_value,
low_color, mid_color, high_color, power):
assert value <= max_value
assert value >= min_value
if value > mid_value:
value = (max_value - value) / (max_value - mid_value)
value **= power
ret = Color.Lerp(value, high_color, mid_color)
else:
value = (value - min_value) / (mid_value - min_value)
value **= power
ret = Color.Lerp(value, low_color, mid_color)
ret.Round()
return ret
class PValueFormat(Format):
"""Formatting for p-value."""
def _ComputeFloat(self, cell):
cell.string_value = '%0.2f' % float(cell.value)
if float(cell.value) < 0.05:
cell.bgcolor = self._GetColor(cell.value,
Color(255, 255, 0, 0),
Color(255, 255, 255, 0),
Color(255, 255, 255, 0),
mid_value=0.05,
power=1)
class StorageFormat(Format):
"""Format the cell as a storage number.
Example:
If the cell contains a value of 1024, the string_value will be 1.0K.
"""
def _ComputeFloat(self, cell):
base = 1024
suffices = ['K', 'M', 'G']
v = float(cell.value)
current = 0
while v >= base**(current + 1) and current < len(suffices):
current += 1
if current:
divisor = base**current
cell.string_value = '%1.1f%s' % ((v / divisor), suffices[current - 1])
else:
cell.string_value = str(cell.value)
class CoeffVarFormat(Format):
"""Format the cell as a percent.
Example:
If the cell contains a value of 1.5, the string_value will be +150%.
"""
def _ComputeFloat(self, cell):
cell.string_value = '%1.1f%%' % (float(cell.value) * 100)
cell.color = self._GetColor(cell.value,
Color(0, 255, 0, 0),
Color(0, 0, 0, 0),
Color(255, 0, 0, 0),
mid_value=0.02,
power=1)
class PercentFormat(Format):
"""Format the cell as a percent.
Example:
If the cell contains a value of 1.5, the string_value will be +50%.
"""
def _ComputeFloat(self, cell):
cell.string_value = '%+1.1f%%' % ((float(cell.value) - 1) * 100)
cell.color = self._GetColor(cell.value, Color(255, 0, 0, 0),
Color(0, 0, 0, 0), Color(0, 255, 0, 0))
class RatioFormat(Format):
"""Format the cell as a ratio.
Example:
If the cell contains a value of 1.5642, the string_value will be 1.56.
"""
def _ComputeFloat(self, cell):
cell.string_value = '%+1.1f%%' % ((cell.value - 1) * 100)
cell.color = self._GetColor(cell.value, Color(255, 0, 0, 0),
Color(0, 0, 0, 0), Color(0, 255, 0, 0))
class ColorBoxFormat(Format):
"""Format the cell as a color box.
Example:
If the cell contains a value of 1.5, it will get a green color.
If the cell contains a value of 0.5, it will get a red color.
The intensity of the green/red will be determined by how much above or below
1.0 the value is.
"""
def _ComputeFloat(self, cell):
cell.string_value = '--'
bgcolor = self._GetColor(cell.value, Color(255, 0, 0, 0),
Color(255, 255, 255, 0), Color(0, 255, 0, 0))
cell.bgcolor = bgcolor
cell.color = bgcolor
class Cell(object):
"""A class to represent a cell in a table.
Attributes:
value: The raw value of the cell.
color: The color of the cell.
bgcolor: The background color of the cell.
string_value: The string value of the cell.
suffix: A string suffix to be attached to the value when displaying.
prefix: A string prefix to be attached to the value when displaying.
color_row: Indicates whether the whole row is to inherit this cell's color.
bgcolor_row: Indicates whether the whole row is to inherit this cell's
bgcolor.
width: Optional specifier to make a column narrower than the usual width.
The usual width of a column is the max of all its cells widths.
colspan: Set the colspan of the cell in the HTML table, this is used for
table headers. Default value is 1.
name: the test name of the cell.
header: Whether this is a header in html.
"""
def __init__(self):
self.value = None
self.color = None
self.bgcolor = None
self.string_value = None
self.suffix = None
self.prefix = None
# Entire row inherits this color.
self.color_row = False
self.bgcolor_row = False
self.width = None
self.colspan = 1
self.name = None
self.header = False
def __str__(self):
l = []
l.append('value: %s' % self.value)
l.append('string_value: %s' % self.string_value)
return ' '.join(l)
class Column(object):
"""Class representing a column in a table.
Attributes:
result: an object of the Result class.
fmt: an object of the Format class.
"""
def __init__(self, result, fmt, name=''):
self.result = result
self.fmt = fmt
self.name = name
# Takes in:
# ["Key", "Label1", "Label2"]
# ["k", ["v", "v2"], [v3]]
# etc.
# Also takes in a format string.
# Returns a table like:
# ["Key", "Label1", "Label2"]
# ["k", avg("v", "v2"), stddev("v", "v2"), etc.]]
# according to format string
class TableFormatter(object):
"""Class to convert a plain table into a cell-table.
This class takes in a table generated by TableGenerator and a list of column
formats to apply to the table and returns a table of cells.
"""
def __init__(self, table, columns):
"""The constructor takes in a table and a list of columns.
Args:
table: A list of lists of values.
columns: A list of column containing what to produce and how to format it.
"""
self._table = table
self._columns = columns
self._table_columns = []
self._out_table = []
def GenerateCellTable(self, table_type):
row_index = 0
all_failed = False
for row in self._table[1:]:
# It does not make sense to put retval in the summary table.
if str(row[0]) == 'retval' and table_type == 'summary':
# Check to see if any runs passed, and update all_failed.
all_failed = True
for values in row[1:]:
if 0 in values:
all_failed = False
continue
key = Cell()
key.string_value = str(row[0])
out_row = [key]
baseline = None
for values in row[1:]:
for column in self._columns:
cell = Cell()
cell.name = key.string_value
if column.result.NeedsBaseline():
if baseline is not None:
column.result.Compute(cell, values, baseline)
column.fmt.Compute(cell)
out_row.append(cell)
if not row_index:
self._table_columns.append(column)
else:
column.result.Compute(cell, values, baseline)
column.fmt.Compute(cell)
out_row.append(cell)
if not row_index:
self._table_columns.append(column)
if baseline is None:
baseline = values
self._out_table.append(out_row)
row_index += 1
# If this is a summary table, and the only row in it is 'retval', and
# all the test runs failed, we need to a 'Results' row to the output
# table.
if table_type == 'summary' and all_failed and len(self._table) == 2:
labels_row = self._table[0]
key = Cell()
key.string_value = 'Results'
out_row = [key]
baseline = None
for _ in labels_row[1:]:
for column in self._columns:
cell = Cell()
cell.name = key.string_value
column.result.Compute(cell, ['Fail'], baseline)
column.fmt.Compute(cell)
out_row.append(cell)
if not row_index:
self._table_columns.append(column)
self._out_table.append(out_row)
def AddColumnName(self):
"""Generate Column name at the top of table."""
key = Cell()
key.header = True
key.string_value = 'Keys'
header = [key]
for column in self._table_columns:
cell = Cell()
cell.header = True
if column.name:
cell.string_value = column.name
else:
result_name = column.result.__class__.__name__
format_name = column.fmt.__class__.__name__
cell.string_value = '%s %s' % (result_name.replace('Result', ''),
format_name.replace('Format', ''))
header.append(cell)
self._out_table = [header] + self._out_table
def AddHeader(self, s):
"""Put additional string on the top of the table."""
cell = Cell()
cell.header = True
cell.string_value = str(s)
header = [cell]
colspan = max(1, max(len(row) for row in self._table))
cell.colspan = colspan
self._out_table = [header] + self._out_table
def GetPassesAndFails(self, values):
passes = 0
fails = 0
for val in values:
if val == 0:
passes = passes + 1
else:
fails = fails + 1
return passes, fails
def AddLabelName(self):
"""Put label on the top of the table."""
top_header = []
base_colspan = len([c for c in self._columns if not c.result.NeedsBaseline()
])
compare_colspan = len(self._columns)
# Find the row with the key 'retval', if it exists. This
# will be used to calculate the number of iterations that passed and
# failed for each image label.
retval_row = None
for row in self._table:
if row[0] == 'retval':
retval_row = row
# The label is organized as follows
# "keys" label_base, label_comparison1, label_comparison2
# The first cell has colspan 1, the second is base_colspan
# The others are compare_colspan
column_position = 0
for label in self._table[0]:
cell = Cell()
cell.header = True
# Put the number of pass/fail iterations in the image label header.
if column_position > 0 and retval_row:
retval_values = retval_row[column_position]
if type(retval_values) is list:
passes, fails = self.GetPassesAndFails(retval_values)
cell.string_value = str(label) + ' (pass:%d fail:%d)' % (passes,
fails)
else:
cell.string_value = str(label)
else:
cell.string_value = str(label)
if top_header:
cell.colspan = base_colspan
if len(top_header) > 1:
cell.colspan = compare_colspan
top_header.append(cell)
column_position = column_position + 1
self._out_table = [top_header] + self._out_table
def _PrintOutTable(self):
o = ''
for row in self._out_table:
for cell in row:
o += str(cell) + ' '
o += '\n'
print(o)
def GetCellTable(self, table_type='full', headers=True):
"""Function to return a table of cells.
The table (list of lists) is converted into a table of cells by this
function.
Args:
table_type: Can be 'full' or 'summary'
headers: A boolean saying whether we want default headers
Returns:
A table of cells with each cell having the properties and string values as
requiested by the columns passed in the constructor.
"""
# Generate the cell table, creating a list of dynamic columns on the fly.
if not self._out_table:
self.GenerateCellTable(table_type)
if headers:
self.AddColumnName()
self.AddLabelName()
return self._out_table
class TablePrinter(object):
"""Class to print a cell table to the console, file or html."""
PLAIN = 0
CONSOLE = 1
HTML = 2
TSV = 3
EMAIL = 4
def __init__(self, table, output_type):
"""Constructor that stores the cell table and output type."""
self._table = table
self._output_type = output_type
self._row_styles = []
self._column_styles = []
# Compute whole-table properties like max-size, etc.
def _ComputeStyle(self):
self._row_styles = []
for row in self._table:
row_style = Cell()
for cell in row:
if cell.color_row:
assert cell.color, 'Cell color not set but color_row set!'
assert not row_style.color, 'Multiple row_style.colors found!'
row_style.color = cell.color
if cell.bgcolor_row:
assert cell.bgcolor, 'Cell bgcolor not set but bgcolor_row set!'
assert not row_style.bgcolor, 'Multiple row_style.bgcolors found!'
row_style.bgcolor = cell.bgcolor
self._row_styles.append(row_style)
self._column_styles = []
if len(self._table) < 2:
return
for i in range(max(len(row) for row in self._table)):
column_style = Cell()
for row in self._table:
if not any([cell.colspan != 1 for cell in row]):
column_style.width = max(column_style.width, len(row[i].string_value))
self._column_styles.append(column_style)
def _GetBGColorFix(self, color):
if self._output_type == self.CONSOLE:
prefix = misc.rgb2short(color.r, color.g, color.b)
# pylint: disable=anomalous-backslash-in-string
prefix = '\033[48;5;%sm' % prefix
suffix = '\033[0m'
elif self._output_type in [self.EMAIL, self.HTML]:
rgb = color.GetRGB()
prefix = ("<FONT style=\"BACKGROUND-COLOR:#{0}\">".format(rgb))
suffix = '</FONT>'
elif self._output_type in [self.PLAIN, self.TSV]:
prefix = ''
suffix = ''
return prefix, suffix
def _GetColorFix(self, color):
if self._output_type == self.CONSOLE:
prefix = misc.rgb2short(color.r, color.g, color.b)
# pylint: disable=anomalous-backslash-in-string
prefix = '\033[38;5;%sm' % prefix
suffix = '\033[0m'
elif self._output_type in [self.EMAIL, self.HTML]:
rgb = color.GetRGB()
prefix = '<FONT COLOR=#{0}>'.format(rgb)
suffix = '</FONT>'
elif self._output_type in [self.PLAIN, self.TSV]:
prefix = ''
suffix = ''
return prefix, suffix
def Print(self):
"""Print the table to a console, html, etc.
Returns:
A string that contains the desired representation of the table.
"""
self._ComputeStyle()
return self._GetStringValue()
def _GetCellValue(self, i, j):
cell = self._table[i][j]
out = cell.string_value
raw_width = len(out)
if cell.color:
p, s = self._GetColorFix(cell.color)
out = '%s%s%s' % (p, out, s)
if cell.bgcolor:
p, s = self._GetBGColorFix(cell.bgcolor)
out = '%s%s%s' % (p, out, s)
if self._output_type in [self.PLAIN, self.CONSOLE, self.EMAIL]:
if cell.width:
width = cell.width
else:
if self._column_styles:
width = self._column_styles[j].width
else:
width = len(cell.string_value)
if cell.colspan > 1:
width = 0
start = 0
for k in range(j):
start += self._table[i][k].colspan
for k in range(cell.colspan):
width += self._column_styles[start + k].width
if width > raw_width:
padding = ('%' + str(width - raw_width) + 's') % ''
out = padding + out
if self._output_type == self.HTML:
if cell.header:
tag = 'th'
else:
tag = 'td'
out = "<{0} colspan = \"{2}\"> {1} </{0}>".format(tag, out, cell.colspan)
return out
def _GetHorizontalSeparator(self):
if self._output_type in [self.CONSOLE, self.PLAIN, self.EMAIL]:
return ' '
if self._output_type == self.HTML:
return ''
if self._output_type == self.TSV:
return '\t'
def _GetVerticalSeparator(self):
if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
return '\n'
if self._output_type == self.HTML:
return '</tr>\n<tr>'
def _GetPrefix(self):
if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
return ''
if self._output_type == self.HTML:
return "<p></p><table id=\"box-table-a\">\n<tr>"
def _GetSuffix(self):
if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
return ''
if self._output_type == self.HTML:
return '</tr>\n</table>'
def _GetStringValue(self):
o = ''
o += self._GetPrefix()
for i in range(len(self._table)):
row = self._table[i]
# Apply row color and bgcolor.
p = s = bgp = bgs = ''
if self._row_styles[i].bgcolor:
bgp, bgs = self._GetBGColorFix(self._row_styles[i].bgcolor)
if self._row_styles[i].color:
p, s = self._GetColorFix(self._row_styles[i].color)
o += p + bgp
for j in range(len(row)):
out = self._GetCellValue(i, j)
o += out + self._GetHorizontalSeparator()
o += s + bgs
o += self._GetVerticalSeparator()
o += self._GetSuffix()
return o
# Some common drivers
def GetSimpleTable(table, out_to=TablePrinter.CONSOLE):
"""Prints a simple table.
This is used by code that has a very simple list-of-lists and wants to produce
a table with ameans, a percentage ratio of ameans and a colorbox.
Args:
table: a list of lists.
out_to: specify the fomat of output. Currently it supports HTML and CONSOLE.
Returns:
A string version of the table that can be printed to the console.
Example:
GetSimpleConsoleTable([["binary", "b1", "b2"],["size", "300", "400"]])
will produce a colored table that can be printed to the console.
"""
columns = [
Column(AmeanResult(), Format()),
Column(AmeanRatioResult(), PercentFormat()),
Column(AmeanRatioResult(), ColorBoxFormat()),
]
our_table = [table[0]]
for row in table[1:]:
our_row = [row[0]]
for v in row[1:]:
our_row.append([v])
our_table.append(our_row)
tf = TableFormatter(our_table, columns)
cell_table = tf.GetCellTable()
tp = TablePrinter(cell_table, out_to)
return tp.Print()
# pylint: disable=redefined-outer-name
def GetComplexTable(runs, labels, out_to=TablePrinter.CONSOLE):
"""Prints a complex table.
This can be used to generate a table with arithmetic mean, standard deviation,
coefficient of variation, p-values, etc.
Args:
runs: A list of lists with data to tabulate.
labels: A list of labels that correspond to the runs.
out_to: specifies the format of the table (example CONSOLE or HTML).
Returns:
A string table that can be printed to the console or put in an HTML file.
"""
tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
table = tg.GetTable()
columns = [Column(LiteralResult(), Format(), 'Literal'),
Column(AmeanResult(), Format()), Column(StdResult(), Format()),
Column(CoeffVarResult(), CoeffVarFormat()),
Column(NonEmptyCountResult(), Format()),
Column(AmeanRatioResult(), PercentFormat()),
Column(AmeanRatioResult(), RatioFormat()),
Column(GmeanRatioResult(), RatioFormat()),
Column(PValueResult(), PValueFormat())]
tf = TableFormatter(table, columns)
cell_table = tf.GetCellTable()
tp = TablePrinter(cell_table, out_to)
return tp.Print()
if __name__ == '__main__':
# Run a few small tests here.
runs = [[{'k1': '10',
'k2': '12',
'k5': '40',
'k6': '40',
'ms_1': '20',
'k7': 'FAIL',
'k8': 'PASS',
'k9': 'PASS',
'k10': '0'}, {'k1': '13',
'k2': '14',
'k3': '15',
'ms_1': '10',
'k8': 'PASS',
'k9': 'FAIL',
'k10': '0'}], [{'k1': '50',
'k2': '51',
'k3': '52',
'k4': '53',
'k5': '35',
'k6': '45',
'ms_1': '200',
'ms_2': '20',
'k7': 'FAIL',
'k8': 'PASS',
'k9': 'PASS'}]]
labels = ['vanilla', 'modified']
t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
print(t)
email = GetComplexTable(runs, labels, TablePrinter.EMAIL)
runs = [[{'k1': '1'}, {'k1': '1.1'}, {'k1': '1.2'}],
[{'k1': '5'}, {'k1': '5.1'}, {'k1': '5.2'}]]
t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
print(t)
simple_table = [
['binary', 'b1', 'b2', 'b3'],
['size', 100, 105, 108],
['rodata', 100, 80, 70],
['data', 100, 100, 100],
['debug', 100, 140, 60],
]
t = GetSimpleTable(simple_table)
print(t)
email += GetSimpleTable(simple_table, TablePrinter.HTML)
email_to = [getpass.getuser()]
email = "<pre style='font-size: 13px'>%s</pre>" % email
EmailSender().SendEmail(email_to, 'SimpleTableTest', email, msg_type='html')