| # copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
| # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
| # |
| # This file is part of logilab-common. |
| # |
| # logilab-common is free software: you can redistribute it and/or modify it under |
| # the terms of the GNU Lesser General Public License as published by the Free |
| # Software Foundation, either version 2.1 of the License, or (at your option) any |
| # later version. |
| # |
| # logilab-common 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 Lesser General Public License for more |
| # details. |
| # |
| # You should have received a copy of the GNU Lesser General Public License along |
| # with logilab-common. If not, see <http://www.gnu.org/licenses/>. |
| """Table management module.""" |
| |
| from __future__ import print_function |
| |
| __docformat__ = "restructuredtext en" |
| |
| from six.moves import range |
| |
| class Table(object): |
| """Table defines a data table with column and row names. |
| inv: |
| len(self.data) <= len(self.row_names) |
| forall(self.data, lambda x: len(x) <= len(self.col_names)) |
| """ |
| |
| def __init__(self, default_value=0, col_names=None, row_names=None): |
| self.col_names = [] |
| self.row_names = [] |
| self.data = [] |
| self.default_value = default_value |
| if col_names: |
| self.create_columns(col_names) |
| if row_names: |
| self.create_rows(row_names) |
| |
| def _next_row_name(self): |
| return 'row%s' % (len(self.row_names)+1) |
| |
| def __iter__(self): |
| return iter(self.data) |
| |
| def __eq__(self, other): |
| if other is None: |
| return False |
| else: |
| return list(self) == list(other) |
| |
| __hash__ = object.__hash__ |
| |
| def __ne__(self, other): |
| return not self == other |
| |
| def __len__(self): |
| return len(self.row_names) |
| |
| ## Rows / Columns creation ################################################# |
| def create_rows(self, row_names): |
| """Appends row_names to the list of existing rows |
| """ |
| self.row_names.extend(row_names) |
| for row_name in row_names: |
| self.data.append([self.default_value]*len(self.col_names)) |
| |
| def create_columns(self, col_names): |
| """Appends col_names to the list of existing columns |
| """ |
| for col_name in col_names: |
| self.create_column(col_name) |
| |
| def create_row(self, row_name=None): |
| """Creates a rowname to the row_names list |
| """ |
| row_name = row_name or self._next_row_name() |
| self.row_names.append(row_name) |
| self.data.append([self.default_value]*len(self.col_names)) |
| |
| |
| def create_column(self, col_name): |
| """Creates a colname to the col_names list |
| """ |
| self.col_names.append(col_name) |
| for row in self.data: |
| row.append(self.default_value) |
| |
| ## Sort by column ########################################################## |
| def sort_by_column_id(self, col_id, method = 'asc'): |
| """Sorts the table (in-place) according to data stored in col_id |
| """ |
| try: |
| col_index = self.col_names.index(col_id) |
| self.sort_by_column_index(col_index, method) |
| except ValueError: |
| raise KeyError("Col (%s) not found in table" % (col_id)) |
| |
| |
| def sort_by_column_index(self, col_index, method = 'asc'): |
| """Sorts the table 'in-place' according to data stored in col_index |
| |
| method should be in ('asc', 'desc') |
| """ |
| sort_list = sorted([(row[col_index], row, row_name) |
| for row, row_name in zip(self.data, self.row_names)]) |
| # Sorting sort_list will sort according to col_index |
| # If we want reverse sort, then reverse list |
| if method.lower() == 'desc': |
| sort_list.reverse() |
| |
| # Rebuild data / row names |
| self.data = [] |
| self.row_names = [] |
| for val, row, row_name in sort_list: |
| self.data.append(row) |
| self.row_names.append(row_name) |
| |
| def groupby(self, colname, *others): |
| """builds indexes of data |
| :returns: nested dictionaries pointing to actual rows |
| """ |
| groups = {} |
| colnames = (colname,) + others |
| col_indexes = [self.col_names.index(col_id) for col_id in colnames] |
| for row in self.data: |
| ptr = groups |
| for col_index in col_indexes[:-1]: |
| ptr = ptr.setdefault(row[col_index], {}) |
| ptr = ptr.setdefault(row[col_indexes[-1]], |
| Table(default_value=self.default_value, |
| col_names=self.col_names)) |
| ptr.append_row(tuple(row)) |
| return groups |
| |
| def select(self, colname, value): |
| grouped = self.groupby(colname) |
| try: |
| return grouped[value] |
| except KeyError: |
| return [] |
| |
| def remove(self, colname, value): |
| col_index = self.col_names.index(colname) |
| for row in self.data[:]: |
| if row[col_index] == value: |
| self.data.remove(row) |
| |
| |
| ## The 'setter' part ####################################################### |
| def set_cell(self, row_index, col_index, data): |
| """sets value of cell 'row_indew', 'col_index' to data |
| """ |
| self.data[row_index][col_index] = data |
| |
| |
| def set_cell_by_ids(self, row_id, col_id, data): |
| """sets value of cell mapped by row_id and col_id to data |
| Raises a KeyError if row_id or col_id are not found in the table |
| """ |
| try: |
| row_index = self.row_names.index(row_id) |
| except ValueError: |
| raise KeyError("Row (%s) not found in table" % (row_id)) |
| else: |
| try: |
| col_index = self.col_names.index(col_id) |
| self.data[row_index][col_index] = data |
| except ValueError: |
| raise KeyError("Column (%s) not found in table" % (col_id)) |
| |
| |
| def set_row(self, row_index, row_data): |
| """sets the 'row_index' row |
| pre: |
| type(row_data) == types.ListType |
| len(row_data) == len(self.col_names) |
| """ |
| self.data[row_index] = row_data |
| |
| |
| def set_row_by_id(self, row_id, row_data): |
| """sets the 'row_id' column |
| pre: |
| type(row_data) == types.ListType |
| len(row_data) == len(self.row_names) |
| Raises a KeyError if row_id is not found |
| """ |
| try: |
| row_index = self.row_names.index(row_id) |
| self.set_row(row_index, row_data) |
| except ValueError: |
| raise KeyError('Row (%s) not found in table' % (row_id)) |
| |
| |
| def append_row(self, row_data, row_name=None): |
| """Appends a row to the table |
| pre: |
| type(row_data) == types.ListType |
| len(row_data) == len(self.col_names) |
| """ |
| row_name = row_name or self._next_row_name() |
| self.row_names.append(row_name) |
| self.data.append(row_data) |
| return len(self.data) - 1 |
| |
| def insert_row(self, index, row_data, row_name=None): |
| """Appends row_data before 'index' in the table. To make 'insert' |
| behave like 'list.insert', inserting in an out of range index will |
| insert row_data to the end of the list |
| pre: |
| type(row_data) == types.ListType |
| len(row_data) == len(self.col_names) |
| """ |
| row_name = row_name or self._next_row_name() |
| self.row_names.insert(index, row_name) |
| self.data.insert(index, row_data) |
| |
| |
| def delete_row(self, index): |
| """Deletes the 'index' row in the table, and returns it. |
| Raises an IndexError if index is out of range |
| """ |
| self.row_names.pop(index) |
| return self.data.pop(index) |
| |
| |
| def delete_row_by_id(self, row_id): |
| """Deletes the 'row_id' row in the table. |
| Raises a KeyError if row_id was not found. |
| """ |
| try: |
| row_index = self.row_names.index(row_id) |
| self.delete_row(row_index) |
| except ValueError: |
| raise KeyError('Row (%s) not found in table' % (row_id)) |
| |
| |
| def set_column(self, col_index, col_data): |
| """sets the 'col_index' column |
| pre: |
| type(col_data) == types.ListType |
| len(col_data) == len(self.row_names) |
| """ |
| |
| for row_index, cell_data in enumerate(col_data): |
| self.data[row_index][col_index] = cell_data |
| |
| |
| def set_column_by_id(self, col_id, col_data): |
| """sets the 'col_id' column |
| pre: |
| type(col_data) == types.ListType |
| len(col_data) == len(self.col_names) |
| Raises a KeyError if col_id is not found |
| """ |
| try: |
| col_index = self.col_names.index(col_id) |
| self.set_column(col_index, col_data) |
| except ValueError: |
| raise KeyError('Column (%s) not found in table' % (col_id)) |
| |
| |
| def append_column(self, col_data, col_name): |
| """Appends the 'col_index' column |
| pre: |
| type(col_data) == types.ListType |
| len(col_data) == len(self.row_names) |
| """ |
| self.col_names.append(col_name) |
| for row_index, cell_data in enumerate(col_data): |
| self.data[row_index].append(cell_data) |
| |
| |
| def insert_column(self, index, col_data, col_name): |
| """Appends col_data before 'index' in the table. To make 'insert' |
| behave like 'list.insert', inserting in an out of range index will |
| insert col_data to the end of the list |
| pre: |
| type(col_data) == types.ListType |
| len(col_data) == len(self.row_names) |
| """ |
| self.col_names.insert(index, col_name) |
| for row_index, cell_data in enumerate(col_data): |
| self.data[row_index].insert(index, cell_data) |
| |
| |
| def delete_column(self, index): |
| """Deletes the 'index' column in the table, and returns it. |
| Raises an IndexError if index is out of range |
| """ |
| self.col_names.pop(index) |
| return [row.pop(index) for row in self.data] |
| |
| |
| def delete_column_by_id(self, col_id): |
| """Deletes the 'col_id' col in the table. |
| Raises a KeyError if col_id was not found. |
| """ |
| try: |
| col_index = self.col_names.index(col_id) |
| self.delete_column(col_index) |
| except ValueError: |
| raise KeyError('Column (%s) not found in table' % (col_id)) |
| |
| |
| ## The 'getter' part ####################################################### |
| |
| def get_shape(self): |
| """Returns a tuple which represents the table's shape |
| """ |
| return len(self.row_names), len(self.col_names) |
| shape = property(get_shape) |
| |
| def __getitem__(self, indices): |
| """provided for convenience""" |
| rows, multirows = None, False |
| cols, multicols = None, False |
| if isinstance(indices, tuple): |
| rows = indices[0] |
| if len(indices) > 1: |
| cols = indices[1] |
| else: |
| rows = indices |
| # define row slice |
| if isinstance(rows, str): |
| try: |
| rows = self.row_names.index(rows) |
| except ValueError: |
| raise KeyError("Row (%s) not found in table" % (rows)) |
| if isinstance(rows, int): |
| rows = slice(rows, rows+1) |
| multirows = False |
| else: |
| rows = slice(None) |
| multirows = True |
| # define col slice |
| if isinstance(cols, str): |
| try: |
| cols = self.col_names.index(cols) |
| except ValueError: |
| raise KeyError("Column (%s) not found in table" % (cols)) |
| if isinstance(cols, int): |
| cols = slice(cols, cols+1) |
| multicols = False |
| else: |
| cols = slice(None) |
| multicols = True |
| # get sub-table |
| tab = Table() |
| tab.default_value = self.default_value |
| tab.create_rows(self.row_names[rows]) |
| tab.create_columns(self.col_names[cols]) |
| for idx, row in enumerate(self.data[rows]): |
| tab.set_row(idx, row[cols]) |
| if multirows : |
| if multicols: |
| return tab |
| else: |
| return [item[0] for item in tab.data] |
| else: |
| if multicols: |
| return tab.data[0] |
| else: |
| return tab.data[0][0] |
| |
| def get_cell_by_ids(self, row_id, col_id): |
| """Returns the element at [row_id][col_id] |
| """ |
| try: |
| row_index = self.row_names.index(row_id) |
| except ValueError: |
| raise KeyError("Row (%s) not found in table" % (row_id)) |
| else: |
| try: |
| col_index = self.col_names.index(col_id) |
| except ValueError: |
| raise KeyError("Column (%s) not found in table" % (col_id)) |
| return self.data[row_index][col_index] |
| |
| def get_row_by_id(self, row_id): |
| """Returns the 'row_id' row |
| """ |
| try: |
| row_index = self.row_names.index(row_id) |
| except ValueError: |
| raise KeyError("Row (%s) not found in table" % (row_id)) |
| return self.data[row_index] |
| |
| def get_column_by_id(self, col_id, distinct=False): |
| """Returns the 'col_id' col |
| """ |
| try: |
| col_index = self.col_names.index(col_id) |
| except ValueError: |
| raise KeyError("Column (%s) not found in table" % (col_id)) |
| return self.get_column(col_index, distinct) |
| |
| def get_columns(self): |
| """Returns all the columns in the table |
| """ |
| return [self[:, index] for index in range(len(self.col_names))] |
| |
| def get_column(self, col_index, distinct=False): |
| """get a column by index""" |
| col = [row[col_index] for row in self.data] |
| if distinct: |
| col = list(set(col)) |
| return col |
| |
| def apply_stylesheet(self, stylesheet): |
| """Applies the stylesheet to this table |
| """ |
| for instruction in stylesheet.instructions: |
| eval(instruction) |
| |
| |
| def transpose(self): |
| """Keeps the self object intact, and returns the transposed (rotated) |
| table. |
| """ |
| transposed = Table() |
| transposed.create_rows(self.col_names) |
| transposed.create_columns(self.row_names) |
| for col_index, column in enumerate(self.get_columns()): |
| transposed.set_row(col_index, column) |
| return transposed |
| |
| |
| def pprint(self): |
| """returns a string representing the table in a pretty |
| printed 'text' format. |
| """ |
| # The maximum row name (to know the start_index of the first col) |
| max_row_name = 0 |
| for row_name in self.row_names: |
| if len(row_name) > max_row_name: |
| max_row_name = len(row_name) |
| col_start = max_row_name + 5 |
| |
| lines = [] |
| # Build the 'first' line <=> the col_names one |
| # The first cell <=> an empty one |
| col_names_line = [' '*col_start] |
| for col_name in self.col_names: |
| col_names_line.append(col_name + ' '*5) |
| lines.append('|' + '|'.join(col_names_line) + '|') |
| max_line_length = len(lines[0]) |
| |
| # Build the table |
| for row_index, row in enumerate(self.data): |
| line = [] |
| # First, build the row_name's cell |
| row_name = self.row_names[row_index] |
| line.append(row_name + ' '*(col_start-len(row_name))) |
| |
| # Then, build all the table's cell for this line. |
| for col_index, cell in enumerate(row): |
| col_name_length = len(self.col_names[col_index]) + 5 |
| data = str(cell) |
| line.append(data + ' '*(col_name_length - len(data))) |
| lines.append('|' + '|'.join(line) + '|') |
| if len(lines[-1]) > max_line_length: |
| max_line_length = len(lines[-1]) |
| |
| # Wrap the table with '-' to make a frame |
| lines.insert(0, '-'*max_line_length) |
| lines.append('-'*max_line_length) |
| return '\n'.join(lines) |
| |
| |
| def __repr__(self): |
| return repr(self.data) |
| |
| def as_text(self): |
| data = [] |
| # We must convert cells into strings before joining them |
| for row in self.data: |
| data.append([str(cell) for cell in row]) |
| lines = ['\t'.join(row) for row in data] |
| return '\n'.join(lines) |
| |
| |
| |
| class TableStyle: |
| """Defines a table's style |
| """ |
| |
| def __init__(self, table): |
| |
| self._table = table |
| self.size = dict([(col_name, '1*') for col_name in table.col_names]) |
| # __row_column__ is a special key to define the first column which |
| # actually has no name (<=> left most column <=> row names column) |
| self.size['__row_column__'] = '1*' |
| self.alignment = dict([(col_name, 'right') |
| for col_name in table.col_names]) |
| self.alignment['__row_column__'] = 'right' |
| |
| # We shouldn't have to create an entry for |
| # the 1st col (the row_column one) |
| self.units = dict([(col_name, '') for col_name in table.col_names]) |
| self.units['__row_column__'] = '' |
| |
| # XXX FIXME : params order should be reversed for all set() methods |
| def set_size(self, value, col_id): |
| """sets the size of the specified col_id to value |
| """ |
| self.size[col_id] = value |
| |
| def set_size_by_index(self, value, col_index): |
| """Allows to set the size according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| self.size[col_id] = value |
| |
| |
| def set_alignment(self, value, col_id): |
| """sets the alignment of the specified col_id to value |
| """ |
| self.alignment[col_id] = value |
| |
| |
| def set_alignment_by_index(self, value, col_index): |
| """Allows to set the alignment according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| self.alignment[col_id] = value |
| |
| |
| def set_unit(self, value, col_id): |
| """sets the unit of the specified col_id to value |
| """ |
| self.units[col_id] = value |
| |
| |
| def set_unit_by_index(self, value, col_index): |
| """Allows to set the unit according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| (Note that in the 'unit' case, you shouldn't have to set a unit |
| for the 1st column (the __row__column__ one)) |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| self.units[col_id] = value |
| |
| |
| def get_size(self, col_id): |
| """Returns the size of the specified col_id |
| """ |
| return self.size[col_id] |
| |
| |
| def get_size_by_index(self, col_index): |
| """Allows to get the size according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| return self.size[col_id] |
| |
| |
| def get_alignment(self, col_id): |
| """Returns the alignment of the specified col_id |
| """ |
| return self.alignment[col_id] |
| |
| |
| def get_alignment_by_index(self, col_index): |
| """Allors to get the alignment according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| return self.alignment[col_id] |
| |
| |
| def get_unit(self, col_id): |
| """Returns the unit of the specified col_id |
| """ |
| return self.units[col_id] |
| |
| |
| def get_unit_by_index(self, col_index): |
| """Allors to get the unit according to the column index rather than |
| using the column's id. |
| BE CAREFUL : the '0' column is the '__row_column__' one ! |
| """ |
| if col_index == 0: |
| col_id = '__row_column__' |
| else: |
| col_id = self._table.col_names[col_index-1] |
| |
| return self.units[col_id] |
| |
| |
| import re |
| CELL_PROG = re.compile("([0-9]+)_([0-9]+)") |
| |
| class TableStyleSheet: |
| """A simple Table stylesheet |
| Rules are expressions where cells are defined by the row_index |
| and col_index separated by an underscore ('_'). |
| For example, suppose you want to say that the (2,5) cell must be |
| the sum of its two preceding cells in the row, you would create |
| the following rule : |
| 2_5 = 2_3 + 2_4 |
| You can also use all the math.* operations you want. For example: |
| 2_5 = sqrt(2_3**2 + 2_4**2) |
| """ |
| |
| def __init__(self, rules = None): |
| rules = rules or [] |
| self.rules = [] |
| self.instructions = [] |
| for rule in rules: |
| self.add_rule(rule) |
| |
| |
| def add_rule(self, rule): |
| """Adds a rule to the stylesheet rules |
| """ |
| try: |
| source_code = ['from math import *'] |
| source_code.append(CELL_PROG.sub(r'self.data[\1][\2]', rule)) |
| self.instructions.append(compile('\n'.join(source_code), |
| 'table.py', 'exec')) |
| self.rules.append(rule) |
| except SyntaxError: |
| print("Bad Stylesheet Rule : %s [skipped]" % rule) |
| |
| |
| def add_rowsum_rule(self, dest_cell, row_index, start_col, end_col): |
| """Creates and adds a rule to sum over the row at row_index from |
| start_col to end_col. |
| dest_cell is a tuple of two elements (x,y) of the destination cell |
| No check is done for indexes ranges. |
| pre: |
| start_col >= 0 |
| end_col > start_col |
| """ |
| cell_list = ['%d_%d'%(row_index, index) for index in range(start_col, |
| end_col + 1)] |
| rule = '%d_%d=' % dest_cell + '+'.join(cell_list) |
| self.add_rule(rule) |
| |
| |
| def add_rowavg_rule(self, dest_cell, row_index, start_col, end_col): |
| """Creates and adds a rule to make the row average (from start_col |
| to end_col) |
| dest_cell is a tuple of two elements (x,y) of the destination cell |
| No check is done for indexes ranges. |
| pre: |
| start_col >= 0 |
| end_col > start_col |
| """ |
| cell_list = ['%d_%d'%(row_index, index) for index in range(start_col, |
| end_col + 1)] |
| num = (end_col - start_col + 1) |
| rule = '%d_%d=' % dest_cell + '('+'+'.join(cell_list)+')/%f'%num |
| self.add_rule(rule) |
| |
| |
| def add_colsum_rule(self, dest_cell, col_index, start_row, end_row): |
| """Creates and adds a rule to sum over the col at col_index from |
| start_row to end_row. |
| dest_cell is a tuple of two elements (x,y) of the destination cell |
| No check is done for indexes ranges. |
| pre: |
| start_row >= 0 |
| end_row > start_row |
| """ |
| cell_list = ['%d_%d'%(index, col_index) for index in range(start_row, |
| end_row + 1)] |
| rule = '%d_%d=' % dest_cell + '+'.join(cell_list) |
| self.add_rule(rule) |
| |
| |
| def add_colavg_rule(self, dest_cell, col_index, start_row, end_row): |
| """Creates and adds a rule to make the col average (from start_row |
| to end_row) |
| dest_cell is a tuple of two elements (x,y) of the destination cell |
| No check is done for indexes ranges. |
| pre: |
| start_row >= 0 |
| end_row > start_row |
| """ |
| cell_list = ['%d_%d'%(index, col_index) for index in range(start_row, |
| end_row + 1)] |
| num = (end_row - start_row + 1) |
| rule = '%d_%d=' % dest_cell + '('+'+'.join(cell_list)+')/%f'%num |
| self.add_rule(rule) |
| |
| |
| |
| class TableCellRenderer: |
| """Defines a simple text renderer |
| """ |
| |
| def __init__(self, **properties): |
| """keywords should be properties with an associated boolean as value. |
| For example : |
| renderer = TableCellRenderer(units = True, alignment = False) |
| An unspecified property will have a 'False' value by default. |
| Possible properties are : |
| alignment, unit |
| """ |
| self.properties = properties |
| |
| |
| def render_cell(self, cell_coord, table, table_style): |
| """Renders the cell at 'cell_coord' in the table, using table_style |
| """ |
| row_index, col_index = cell_coord |
| cell_value = table.data[row_index][col_index] |
| final_content = self._make_cell_content(cell_value, |
| table_style, col_index +1) |
| return self._render_cell_content(final_content, |
| table_style, col_index + 1) |
| |
| |
| def render_row_cell(self, row_name, table, table_style): |
| """Renders the cell for 'row_id' row |
| """ |
| cell_value = row_name |
| return self._render_cell_content(cell_value, table_style, 0) |
| |
| |
| def render_col_cell(self, col_name, table, table_style): |
| """Renders the cell for 'col_id' row |
| """ |
| cell_value = col_name |
| col_index = table.col_names.index(col_name) |
| return self._render_cell_content(cell_value, table_style, col_index +1) |
| |
| |
| |
| def _render_cell_content(self, content, table_style, col_index): |
| """Makes the appropriate rendering for this cell content. |
| Rendering properties will be searched using the |
| *table_style.get_xxx_by_index(col_index)' methods |
| |
| **This method should be overridden in the derived renderer classes.** |
| """ |
| return content |
| |
| |
| def _make_cell_content(self, cell_content, table_style, col_index): |
| """Makes the cell content (adds decoration data, like units for |
| example) |
| """ |
| final_content = cell_content |
| if 'skip_zero' in self.properties: |
| replacement_char = self.properties['skip_zero'] |
| else: |
| replacement_char = 0 |
| if replacement_char and final_content == 0: |
| return replacement_char |
| |
| try: |
| units_on = self.properties['units'] |
| if units_on: |
| final_content = self._add_unit( |
| cell_content, table_style, col_index) |
| except KeyError: |
| pass |
| |
| return final_content |
| |
| |
| def _add_unit(self, cell_content, table_style, col_index): |
| """Adds unit to the cell_content if needed |
| """ |
| unit = table_style.get_unit_by_index(col_index) |
| return str(cell_content) + " " + unit |
| |
| |
| |
| class DocbookRenderer(TableCellRenderer): |
| """Defines how to render a cell for a docboook table |
| """ |
| |
| def define_col_header(self, col_index, table_style): |
| """Computes the colspec element according to the style |
| """ |
| size = table_style.get_size_by_index(col_index) |
| return '<colspec colname="c%d" colwidth="%s"/>\n' % \ |
| (col_index, size) |
| |
| |
| def _render_cell_content(self, cell_content, table_style, col_index): |
| """Makes the appropriate rendering for this cell content. |
| Rendering properties will be searched using the |
| table_style.get_xxx_by_index(col_index)' methods. |
| """ |
| try: |
| align_on = self.properties['alignment'] |
| alignment = table_style.get_alignment_by_index(col_index) |
| if align_on: |
| return "<entry align='%s'>%s</entry>\n" % \ |
| (alignment, cell_content) |
| except KeyError: |
| # KeyError <=> Default alignment |
| return "<entry>%s</entry>\n" % cell_content |
| |
| |
| class TableWriter: |
| """A class to write tables |
| """ |
| |
| def __init__(self, stream, table, style, **properties): |
| self._stream = stream |
| self.style = style or TableStyle(table) |
| self._table = table |
| self.properties = properties |
| self.renderer = None |
| |
| |
| def set_style(self, style): |
| """sets the table's associated style |
| """ |
| self.style = style |
| |
| |
| def set_renderer(self, renderer): |
| """sets the way to render cell |
| """ |
| self.renderer = renderer |
| |
| |
| def update_properties(self, **properties): |
| """Updates writer's properties (for cell rendering) |
| """ |
| self.properties.update(properties) |
| |
| |
| def write_table(self, title = ""): |
| """Writes the table |
| """ |
| raise NotImplementedError("write_table must be implemented !") |
| |
| |
| |
| class DocbookTableWriter(TableWriter): |
| """Defines an implementation of TableWriter to write a table in Docbook |
| """ |
| |
| def _write_headers(self): |
| """Writes col headers |
| """ |
| # Define col_headers (colstpec elements) |
| for col_index in range(len(self._table.col_names)+1): |
| self._stream.write(self.renderer.define_col_header(col_index, |
| self.style)) |
| |
| self._stream.write("<thead>\n<row>\n") |
| # XXX FIXME : write an empty entry <=> the first (__row_column) column |
| self._stream.write('<entry></entry>\n') |
| for col_name in self._table.col_names: |
| self._stream.write(self.renderer.render_col_cell( |
| col_name, self._table, |
| self.style)) |
| |
| self._stream.write("</row>\n</thead>\n") |
| |
| |
| def _write_body(self): |
| """Writes the table body |
| """ |
| self._stream.write('<tbody>\n') |
| |
| for row_index, row in enumerate(self._table.data): |
| self._stream.write('<row>\n') |
| row_name = self._table.row_names[row_index] |
| # Write the first entry (row_name) |
| self._stream.write(self.renderer.render_row_cell(row_name, |
| self._table, |
| self.style)) |
| |
| for col_index, cell in enumerate(row): |
| self._stream.write(self.renderer.render_cell( |
| (row_index, col_index), |
| self._table, self.style)) |
| |
| self._stream.write('</row>\n') |
| |
| self._stream.write('</tbody>\n') |
| |
| |
| def write_table(self, title = ""): |
| """Writes the table |
| """ |
| self._stream.write('<table>\n<title>%s></title>\n'%(title)) |
| self._stream.write( |
| '<tgroup cols="%d" align="left" colsep="1" rowsep="1">\n'% |
| (len(self._table.col_names)+1)) |
| self._write_headers() |
| self._write_body() |
| |
| self._stream.write('</tgroup>\n</table>\n') |
| |
| |
