"""Table defines a data table with column and row 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

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

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

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

self.data[row_index] = row_data

def set_row_by_id(self, row_id, row_data):

"""sets the 'row_id' column

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

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'

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.

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.

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

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

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

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'

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.

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.

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)

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

# 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]

"""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

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

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

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

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

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

if col_index == 0:

col_id = '__row_column__'

else:

col_id = self._table.col_names[col_index-1]

"""A simple Table stylesheet

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

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

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

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

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

"""Defines a simple text renderer

def __init__(self, **properties):

"""keywords should be properties with an associated boolean as value.

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.

return content

def _make_cell_content(self, cell_content, table_style, col_index):

"""Makes the cell content (adds decoration data, like units for

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)

"""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.

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

"""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

"""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()