Spaces:
Runtime error
Runtime error
| import numpy as np | |
| from collections import OrderedDict | |
| class ResultTable: | |
| """ | |
| Class to save and show result neatly. | |
| First column is always 'NAME' column. | |
| """ | |
| def __init__(self, table_name='table', header=None, splitter='||', int_formatter='%3d', float_formatter='%.4f'): | |
| """ | |
| Initialize table setting. | |
| :param list header: list of string, table headers. | |
| :param str splitter: | |
| :param str int_formatter: | |
| :param str float_formatter: | |
| """ | |
| self.table_name = table_name | |
| self.header = header | |
| if self.header is not None: | |
| self.set_headers(self.header) | |
| self.num_rows = 0 | |
| self.splitter = splitter | |
| self.int_formatter = int_formatter | |
| self.float_formatter = float_formatter | |
| def set_headers(self, header): | |
| """ | |
| Set table headers as given and clear all data. | |
| :param list header: list of header strings | |
| :return: None | |
| """ | |
| self.header = header | |
| if 'NAME' not in header: | |
| self.header = ['NAME'] + self.header | |
| self.data = OrderedDict([(h, []) for h in self.header]) | |
| self.max_len = OrderedDict([(h, len(h)) for h in self.header]) | |
| # {h: len(h) for h in self.header} | |
| def add_row(self, row_name, row_dict): | |
| """ | |
| Add new row into the table. | |
| :param str row_name: name of the row, which will be the first column | |
| :param dict row_dict: dictionary containing column name as a key and column value as value. | |
| :return: None | |
| """ | |
| # If header is not defined, fetch from input dict | |
| if self.header is None: | |
| self.set_headers(list(row_dict.keys())) | |
| # If input dict has new column, make one | |
| for key in row_dict: | |
| if key not in self.data: | |
| self.set_headers(self.header + [key]) | |
| for h in self.header: | |
| if h == 'NAME': | |
| self.data['NAME'].append(row_name) | |
| self.max_len[h] = max(self.max_len['NAME'], len(row_name)) | |
| else: | |
| # If input dict doesn't have values for table header, make empty value. | |
| if h not in row_dict: | |
| row_dict[h] = '-' | |
| # convert input dict to string | |
| d = row_dict[h] | |
| if isinstance(d, (int, np.integer)): | |
| d_str = self.int_formatter % d | |
| elif isinstance(d, (float, np.float)): | |
| d_str = self.float_formatter % d | |
| elif isinstance(d, str): | |
| d_str = d | |
| elif isinstance(d, list): | |
| d_str = str(d) | |
| else: | |
| raise NotImplementedError('data type currently not supported. %s' % str(type(d))) | |
| self.data[h].append(d_str) | |
| self.max_len[h] = max(self.max_len[h], len(d_str)) | |
| self.num_rows += 1 | |
| def row_to_line(self, row_values): | |
| """ | |
| Convert a row into string form | |
| :param list row_values: list of row values as string | |
| :return: string form of a row | |
| """ | |
| value_str = [] | |
| for i, header in enumerate(self.header): | |
| max_length = self.max_len[header] | |
| length = len(row_values[i]) | |
| diff = max_length - length | |
| # Center align | |
| # left_space = diff // 2 | |
| # right_space = diff - left_space | |
| # s = ' ' * left_space + row_values[i] + ' ' * right_space | |
| # Left align | |
| s = row_values[i] + ' ' * diff | |
| value_str.append(s) | |
| # for i, max_length in enumerate(self.max_len.values()): | |
| # length = len(row_values[i]) | |
| # diff = max_length - length | |
| # | |
| # # Center align | |
| # # left_space = diff // 2 | |
| # # right_space = diff - left_space | |
| # # s = ' ' * left_space + row_values[i] + ' ' * right_space | |
| # | |
| # # Left align | |
| # s = row_values[i] + ' ' * diff | |
| # value_str.append(s) | |
| return self.splitter + ' ' + (' %s ' % self.splitter).join(value_str) + ' ' + self.splitter | |
| def to_string(self): | |
| """ | |
| Convert a table into string form | |
| :return: string form of the table | |
| """ | |
| size_per_col = {h: self.max_len[h] + 2 + len(self.splitter) for h in self.header} | |
| line_len = sum([size_per_col[c] for c in size_per_col]) + len(self.splitter) | |
| table_str = '\n' | |
| # TABLE NAME | |
| table_str += self.table_name + '\n' | |
| # HEADER | |
| line = self.row_to_line(self.header) | |
| table_str += '=' * line_len + '\n' | |
| table_str += line + '\n' | |
| table_str += self.splitter + '-' * (line_len - len(self.splitter) * 2) + self.splitter + '\n' | |
| # DATA | |
| for row_values in zip(*self.data.values()): | |
| line = self.row_to_line(row_values) | |
| table_str += line + '\n' | |
| table_str += '=' * line_len + '\n' | |
| return table_str | |
| def show(self): | |
| print(self.to_string()) | |
| def shape(self): | |
| return (self.num_rows, self.num_cols) | |
| def num_cols(self): | |
| return len(self.header) |