summaryrefslogtreecommitdiff
path: root/table.py
diff options
context:
space:
mode:
authorroot <devnull@localhost>2006-04-26 10:48:09 +0000
committerroot <devnull@localhost>2006-04-26 10:48:09 +0000
commit8b1e1c104bdff504b3e775b450432e6462b8d09b (patch)
tree0367359f6a18f318741f387d82dc3dcfd8139950 /table.py
downloadlogilab-common-8b1e1c104bdff504b3e775b450432e6462b8d09b.tar.gz
forget the past.
forget the past.
Diffstat (limited to 'table.py')
-rw-r--r--table.py958
1 files changed, 958 insertions, 0 deletions
diff --git a/table.py b/table.py
new file mode 100644
index 0000000..5d9b5b2
--- /dev/null
+++ b/table.py
@@ -0,0 +1,958 @@
+"""Table management module
+"""
+
+__revision__ = '$Id: table.py,v 1.18 2006-04-09 22:30:53 nico Exp $'
+
+from warnings import warn
+
+from logilab.common.compat import enumerate, sum, set
+
+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)
+
+ 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 = [(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
+ sort_list.sort()
+ # 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 dictionnaries 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)
+
+
+ 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_dimensions(self):
+ """Returns a tuple which represents the table's shape
+ """
+ warn('table.get_dimensions() is deprecated, use table.shape instead',
+ DeprecationWarning)
+ return self.shape
+
+ def get_element(self, row_index, col_index):
+ """Returns the element at [row_index][col_index]
+ """
+ warn('Table.get_element() is deprecated, use Table.get_cell instead',
+ DeprecationWarning)
+ return self.data[row_index][col_index]
+
+ def get_cell(self, row_index, col_index):
+ warn('table.get_cell(i,j) is deprecated, use table[i,j] instead',
+ DeprecationWarning)
+ return self.data[row_index][col_index]
+
+ def get_cell_by_ids(self, row_id, col_id):
+ """Returns the element at [row_id][col_id]
+ """
+ warn('table.get_cell_by_ids(i,j) is deprecated, use table[i,j] instead',
+ DeprecationWarning)
+ 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(self, row_index):
+ """Returns the 'row_index' row
+ """
+ warn('table.get_row(i) is deprecated, use table[i] instead',
+ DeprecationWarning)
+ return self.data[row_index]
+
+ def get_row_by_id(self, row_id):
+ """Returns the 'row_id' row
+ """
+ warn('table.get_row_by_id(i) is deprecated, use table[i] instead',
+ DeprecationWarning)
+ try:
+ row_index = self.row_names.index(row_id)
+ except ValueError:
+ raise KeyError("Row (%s) not found in table" % (row_id))
+ return self.get_row(row_index)
+
+ def get_column(self, col_index, distinct=False):
+ """Returns the 'col_index' col
+ """
+ warn('table.get_column(i) is deprecated, use table[:,i] instead',
+ DeprecationWarning)
+ col = [row[col_index] for row in self.data]
+ if distinct:
+ return set(col)
+ else:
+ return col
+
+ def get_column_by_id(self, col_id, distinct=False):
+ """Returns the 'col_id' col
+ """
+ warn('table.get_column_by_id(i) is deprecated, use table[:,i] instead',
+ DeprecationWarning)
+ 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_rows(self):
+ """Returns all the rows in the table
+ """
+ warn('table.get_rows() is deprecated, just iterate over table instead',
+ DeprecationWarning)
+ return self.data
+
+
+ def get_columns(self):
+ """Returns all the columns in the table
+ """
+ return [self.get_column(index) for index in range(len(self.col_names))]
+
+
+ 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 maxium 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.encode('iso-8859-1') + ' '*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].encode('iso-8859-1')
+ 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.encode('iso-8859-1')
+ 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.encode('iso-8859-1')
+ 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 overriden 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')
+
+