1105 lines
32 KiB
Python
1105 lines
32 KiB
Python
|
#!/usr/bin/python
|
||
|
|
#
|
||
|
|
# Copyright 2012 Google Inc. All Rights Reserved.
|
||
|
|
#
|
||
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
# you may not use this file except in compliance with the License.
|
||
|
|
# You may obtain a copy of the License at
|
||
|
|
#
|
||
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
#
|
||
|
|
# Unless required by applicable law or agreed to in writing, software
|
||
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||
|
|
# implied. See the License for the specific language governing
|
||
|
|
# permissions and limitations under the License.
|
||
|
|
|
||
|
|
"""A module to represent and manipulate tabular text data.
|
||
|
|
|
||
|
|
A table of rows, indexed on row number. Each row is a ordered dictionary of row
|
||
|
|
elements that maintains knowledge of the parent table and column headings.
|
||
|
|
|
||
|
|
Tables can be created from CSV input and in-turn supports a number of display
|
||
|
|
formats such as CSV and variable sized and justified rows.
|
||
|
|
"""
|
||
|
|
|
||
|
|
import copy
|
||
|
|
import functools
|
||
|
|
import textwrap
|
||
|
|
|
||
|
|
from textfsm import terminal
|
||
|
|
|
||
|
|
|
||
|
|
class Error(Exception):
|
||
|
|
"""Base class for errors."""
|
||
|
|
|
||
|
|
|
||
|
|
class TableError(Error):
|
||
|
|
"""Error in TextTable."""
|
||
|
|
|
||
|
|
|
||
|
|
class Row(dict):
|
||
|
|
"""Represents a table row. We implement this as an ordered dictionary.
|
||
|
|
|
||
|
|
The order is the chronological order of data insertion. Methods are supplied
|
||
|
|
to make it behave like a regular dict() and list().
|
||
|
|
|
||
|
|
Attributes:
|
||
|
|
color: Colour spec of this row.
|
||
|
|
header: List of row's headers.
|
||
|
|
row: int, the row number in the container table. 0 is the header row.
|
||
|
|
table: A TextTable(), the associated container table.
|
||
|
|
values: List of row's values.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self, *args, **kwargs):
|
||
|
|
super(Row, self).__init__(*args, **kwargs)
|
||
|
|
self._keys = list()
|
||
|
|
self._values = list()
|
||
|
|
self.row = None
|
||
|
|
self.table = None
|
||
|
|
self._color = None
|
||
|
|
self._index = {}
|
||
|
|
|
||
|
|
def _BuildIndex(self):
|
||
|
|
"""Recreate the key index."""
|
||
|
|
self._index = {}
|
||
|
|
for i, k in enumerate(self._keys):
|
||
|
|
self._index[k] = i
|
||
|
|
|
||
|
|
def __getitem__(self, column):
|
||
|
|
"""Support for [] notation.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
column: Tuple of column names, or a (str) column name, or positional
|
||
|
|
column number, 0-indexed.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A list or string with column value(s).
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
IndexError: The given column(s) were not found.
|
||
|
|
"""
|
||
|
|
if isinstance(column, (list, tuple)):
|
||
|
|
ret = []
|
||
|
|
for col in column:
|
||
|
|
ret.append(self[col])
|
||
|
|
return ret
|
||
|
|
|
||
|
|
try:
|
||
|
|
return self._values[self._index[column]]
|
||
|
|
except (KeyError, TypeError, ValueError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
# Perhaps we have a range like '1', ':-1' or '1:'.
|
||
|
|
try:
|
||
|
|
return self._values[column]
|
||
|
|
except (IndexError, TypeError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
raise IndexError('No such column "%s" in row.' % column)
|
||
|
|
|
||
|
|
def __contains__(self, value):
|
||
|
|
return value in self._values
|
||
|
|
|
||
|
|
def __setitem__(self, column, value):
|
||
|
|
for i in range(len(self)):
|
||
|
|
if self._keys[i] == column:
|
||
|
|
self._values[i] = value
|
||
|
|
return
|
||
|
|
# No column found, add a new one.
|
||
|
|
self._keys.append(column)
|
||
|
|
self._values.append(value)
|
||
|
|
self._BuildIndex()
|
||
|
|
|
||
|
|
def __iter__(self):
|
||
|
|
return iter(self._values)
|
||
|
|
|
||
|
|
def __len__(self):
|
||
|
|
return len(self._keys)
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
ret = ''
|
||
|
|
for v in self._values:
|
||
|
|
ret += '%12s ' % v
|
||
|
|
ret += '\n'
|
||
|
|
return ret
|
||
|
|
|
||
|
|
def __repr__(self):
|
||
|
|
return '%s(%r)' % (self.__class__.__name__, str(self))
|
||
|
|
|
||
|
|
def get(self, column, default_value=None):
|
||
|
|
"""Get an item from the Row by column name.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
column: Tuple of column names, or a (str) column name, or positional
|
||
|
|
column number, 0-indexed.
|
||
|
|
default_value: The value to use if the key is not found.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A list or string with column value(s) or default_value if not found.
|
||
|
|
"""
|
||
|
|
if isinstance(column, (list, tuple)):
|
||
|
|
ret = []
|
||
|
|
for col in column:
|
||
|
|
ret.append(self.get(col, default_value))
|
||
|
|
return ret
|
||
|
|
# Perhaps we have a range like '1', ':-1' or '1:'.
|
||
|
|
try:
|
||
|
|
return self._values[column]
|
||
|
|
except (IndexError, TypeError):
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
return self[column]
|
||
|
|
except IndexError:
|
||
|
|
return default_value
|
||
|
|
|
||
|
|
def index(self, column): # pylint: disable=invalid-name
|
||
|
|
"""Fetches the column number (0 indexed).
|
||
|
|
|
||
|
|
Args:
|
||
|
|
column: A string, column to fetch the index of.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
An int, the row index number.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
ValueError: The specified column was not found.
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return self._keys.index(column)
|
||
|
|
except ValueError as exc:
|
||
|
|
raise ValueError('Column "%s" not found.' % column) from exc
|
||
|
|
|
||
|
|
def iterkeys(self): # pylint: disable=invalid-name
|
||
|
|
return iter(self._keys)
|
||
|
|
|
||
|
|
def items(self):
|
||
|
|
# TODO(harro): self.get(k) should work here but didn't ?
|
||
|
|
return [(k, self.__getitem__(k)) for k in self._keys]
|
||
|
|
|
||
|
|
def _GetValues(self):
|
||
|
|
"""Return the row's values."""
|
||
|
|
return self._values
|
||
|
|
|
||
|
|
def _GetHeader(self):
|
||
|
|
"""Return the row's header."""
|
||
|
|
return self._keys
|
||
|
|
|
||
|
|
def _SetHeader(self, values):
|
||
|
|
"""Set the row's header from a list."""
|
||
|
|
if self._values and len(values) != len(self._values):
|
||
|
|
raise ValueError('Header values not equal to existing data width.')
|
||
|
|
if not self._values:
|
||
|
|
for _ in range(len(values)):
|
||
|
|
self._values.append(None)
|
||
|
|
self._keys = list(values)
|
||
|
|
self._BuildIndex()
|
||
|
|
|
||
|
|
def _SetColour(self, value_list):
|
||
|
|
"""Sets row's colour attributes to a list of values in terminal.SGR."""
|
||
|
|
if value_list is None:
|
||
|
|
self._color = None
|
||
|
|
return
|
||
|
|
colors = []
|
||
|
|
for color in value_list:
|
||
|
|
if color in terminal.SGR:
|
||
|
|
colors.append(color)
|
||
|
|
elif color in terminal.FG_COLOR_WORDS:
|
||
|
|
colors += terminal.FG_COLOR_WORDS[color]
|
||
|
|
elif color in terminal.BG_COLOR_WORDS:
|
||
|
|
colors += terminal.BG_COLOR_WORDS[color]
|
||
|
|
else:
|
||
|
|
raise ValueError('Invalid colour specification.')
|
||
|
|
self._color = list(set(colors))
|
||
|
|
|
||
|
|
def _GetColour(self):
|
||
|
|
if self._color is None:
|
||
|
|
return None
|
||
|
|
return list(self._color)
|
||
|
|
|
||
|
|
def _SetValues(self, values):
|
||
|
|
"""Set values from supplied dictionary or list.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
values: A Row, dict indexed by column name, or list.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TypeError: Argument is not a list or dict, or list is not equal row
|
||
|
|
length or dictionary keys don't match.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def _ToStr(value):
|
||
|
|
"""Convert individul list entries to string."""
|
||
|
|
if isinstance(value, (list, tuple)):
|
||
|
|
result = []
|
||
|
|
for val in value:
|
||
|
|
result.append(str(val))
|
||
|
|
return result
|
||
|
|
else:
|
||
|
|
return str(value)
|
||
|
|
|
||
|
|
# Row with identical header can be copied directly.
|
||
|
|
if isinstance(values, Row):
|
||
|
|
if self._keys != values.header:
|
||
|
|
raise TypeError('Attempt to append row with mismatched header.')
|
||
|
|
self._values = copy.deepcopy(values.values)
|
||
|
|
|
||
|
|
elif isinstance(values, dict):
|
||
|
|
for key in self._keys:
|
||
|
|
if key not in values:
|
||
|
|
raise TypeError('Dictionary key mismatch with row.')
|
||
|
|
for key in self._keys:
|
||
|
|
self[key] = _ToStr(values[key])
|
||
|
|
|
||
|
|
elif isinstance(values, list) or isinstance(values, tuple):
|
||
|
|
if len(values) != len(self._values):
|
||
|
|
raise TypeError('Supplied list length != row length')
|
||
|
|
for index, value in enumerate(values):
|
||
|
|
self._values[index] = _ToStr(value)
|
||
|
|
|
||
|
|
else:
|
||
|
|
raise TypeError(
|
||
|
|
'Supplied argument must be Row, dict or list, not %s' % type(values)
|
||
|
|
)
|
||
|
|
|
||
|
|
def Insert(self, key, value, row_index):
|
||
|
|
"""Inserts new values at a specified offset.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
key: string for header value.
|
||
|
|
value: string for a data value.
|
||
|
|
row_index: Offset into row for data.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
IndexError: If the offset is out of bands.
|
||
|
|
"""
|
||
|
|
if row_index < 0:
|
||
|
|
row_index += len(self)
|
||
|
|
|
||
|
|
if not 0 <= row_index < len(self):
|
||
|
|
raise IndexError('Index "%s" is out of bounds.' % row_index)
|
||
|
|
|
||
|
|
new_row = Row()
|
||
|
|
for idx in self.header:
|
||
|
|
if self.index(idx) == row_index:
|
||
|
|
new_row[key] = value
|
||
|
|
new_row[idx] = self[idx]
|
||
|
|
self._keys = new_row.header
|
||
|
|
self._values = new_row.values
|
||
|
|
del new_row
|
||
|
|
self._BuildIndex()
|
||
|
|
|
||
|
|
color = property(_GetColour, _SetColour, doc='Colour spec of this row')
|
||
|
|
header = property(_GetHeader, _SetHeader, doc="List of row's headers.")
|
||
|
|
values = property(_GetValues, _SetValues, doc="List of row's values.")
|
||
|
|
|
||
|
|
|
||
|
|
class TextTable(object):
|
||
|
|
"""Class that provides data methods on a tabular format.
|
||
|
|
|
||
|
|
Data is stored as a list of Row() objects. The first row is always present as
|
||
|
|
the header row.
|
||
|
|
|
||
|
|
Attributes:
|
||
|
|
row_class: class, A class to use for the Row object.
|
||
|
|
separator: str, field separator when printing table.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self, row_class=Row):
|
||
|
|
"""Initialises a new table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
row_class: A class to use as the row object. This should be a subclass of
|
||
|
|
this module's Row() class.
|
||
|
|
"""
|
||
|
|
self.row_class = row_class
|
||
|
|
self.separator = ', '
|
||
|
|
self.Reset()
|
||
|
|
|
||
|
|
def Reset(self):
|
||
|
|
self._row_index = 1
|
||
|
|
self._table = [[]]
|
||
|
|
self._iterator = 0 # While loop row index
|
||
|
|
|
||
|
|
def __repr__(self):
|
||
|
|
return '%s(%r)' % (self.__class__.__name__, str(self))
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
"""Displays table with pretty formatting."""
|
||
|
|
return self.table
|
||
|
|
|
||
|
|
def __incr__(self, incr=1):
|
||
|
|
self._SetRowIndex(self._row_index + incr)
|
||
|
|
|
||
|
|
def __contains__(self, name):
|
||
|
|
"""Whether the given column header name exists."""
|
||
|
|
return name in self.header
|
||
|
|
|
||
|
|
def __getitem__(self, row):
|
||
|
|
"""Fetches the given row number."""
|
||
|
|
return self._table[row]
|
||
|
|
|
||
|
|
def __iter__(self):
|
||
|
|
"""Iterator that excludes the header row."""
|
||
|
|
return next(self)
|
||
|
|
|
||
|
|
def __next__(self):
|
||
|
|
# Maintain a counter so a row can know what index it is.
|
||
|
|
# Save the old value to support nested interations.
|
||
|
|
old_iter = self._iterator
|
||
|
|
try:
|
||
|
|
for r in self._table[1:]:
|
||
|
|
self._iterator = r.row
|
||
|
|
yield r
|
||
|
|
finally:
|
||
|
|
# Recover the original index after loop termination or exit with break.
|
||
|
|
self._iterator = old_iter
|
||
|
|
|
||
|
|
def __add__(self, other):
|
||
|
|
"""Merges two with identical columns."""
|
||
|
|
|
||
|
|
new_table = copy.copy(self)
|
||
|
|
for row in other:
|
||
|
|
new_table.Append(row)
|
||
|
|
|
||
|
|
return new_table
|
||
|
|
|
||
|
|
def __copy__(self):
|
||
|
|
"""Copy table instance."""
|
||
|
|
|
||
|
|
new_table = self.__class__()
|
||
|
|
# pylint: disable=protected-access
|
||
|
|
new_table._table = [self.header]
|
||
|
|
for row in self[1:]:
|
||
|
|
new_table.Append(row)
|
||
|
|
return new_table
|
||
|
|
|
||
|
|
def Filter(self, function=None):
|
||
|
|
"""Construct Textable from the rows of which the function returns true.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
function: A function applied to each row which returns a bool. If function
|
||
|
|
is None, all rows with empty column values are removed.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A new TextTable()
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: When an invalid row entry is Append()'d
|
||
|
|
"""
|
||
|
|
flat = lambda x: x if isinstance(x, str) else ''.join([flat(y) for y in x])
|
||
|
|
if function is None:
|
||
|
|
function = lambda row: bool(flat(row.values))
|
||
|
|
|
||
|
|
new_table = self.__class__()
|
||
|
|
# pylint: disable=protected-access
|
||
|
|
new_table._table = [self.header]
|
||
|
|
for row in self:
|
||
|
|
if function(row):
|
||
|
|
new_table.Append(row)
|
||
|
|
return new_table
|
||
|
|
|
||
|
|
def Map(self, function):
|
||
|
|
"""Applies the function to every row in the table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
function: A function applied to each row.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A new TextTable()
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: When transform is not invalid row entry. The transform
|
||
|
|
must be compatible with Append().
|
||
|
|
"""
|
||
|
|
new_table = self.__class__()
|
||
|
|
# pylint: disable=protected-access
|
||
|
|
new_table._table = [self.header]
|
||
|
|
for row in self:
|
||
|
|
filtered_row = function(row)
|
||
|
|
if filtered_row:
|
||
|
|
new_table.Append(filtered_row)
|
||
|
|
return new_table
|
||
|
|
|
||
|
|
# pylint: disable=W0622
|
||
|
|
# pylint: disable=invalid-name
|
||
|
|
def sort(self, cmp=None, key=None, reverse=False):
|
||
|
|
"""Sorts rows in the texttable.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
cmp: func, non default sort algorithm to use.
|
||
|
|
key: func, applied to each element before sorting.
|
||
|
|
reverse: bool, reverse order of sort.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def _DefaultKey(value):
|
||
|
|
"""Default key func is to create a list of all fields."""
|
||
|
|
result = []
|
||
|
|
for key in self.header:
|
||
|
|
# Try sorting as numerical value if possible.
|
||
|
|
try:
|
||
|
|
result.append(float(value[key]))
|
||
|
|
except ValueError:
|
||
|
|
result.append(value[key])
|
||
|
|
return result
|
||
|
|
|
||
|
|
key = key or _DefaultKey
|
||
|
|
# Exclude header by copying table.
|
||
|
|
new_table = self._table[1:]
|
||
|
|
|
||
|
|
if cmp is not None:
|
||
|
|
key = functools.cmp_to_key(cmp)
|
||
|
|
|
||
|
|
new_table.sort(key=key, reverse=reverse)
|
||
|
|
|
||
|
|
# Regenerate the table with original header
|
||
|
|
self._table = [self.header]
|
||
|
|
self._table.extend(new_table)
|
||
|
|
# Re-write the 'row' attribute of each row
|
||
|
|
for index, row in enumerate(self._table):
|
||
|
|
row.row = index
|
||
|
|
|
||
|
|
# pylint: enable=W0622
|
||
|
|
# pylint: enable=invalid-name
|
||
|
|
|
||
|
|
def extend(self, table, keys=None): # pylint: disable=invalid-name
|
||
|
|
"""Extends all rows in the texttable.
|
||
|
|
|
||
|
|
The rows are extended with the new columns from the table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
table: A texttable, the table to extend this table by.
|
||
|
|
keys: A set, the set of columns to use as the key. If None, the row index
|
||
|
|
is used.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
IndexError: If key is not a valid column name.
|
||
|
|
"""
|
||
|
|
if keys:
|
||
|
|
for k in keys:
|
||
|
|
if k not in self._Header():
|
||
|
|
raise IndexError("Unknown key: '%s'" % k)
|
||
|
|
|
||
|
|
extend_with = []
|
||
|
|
for column in table.header:
|
||
|
|
if column not in self.header:
|
||
|
|
extend_with.append(column)
|
||
|
|
|
||
|
|
if not extend_with:
|
||
|
|
return
|
||
|
|
|
||
|
|
for column in extend_with:
|
||
|
|
self.AddColumn(column)
|
||
|
|
|
||
|
|
if not keys:
|
||
|
|
for row1, row2 in zip(self, table):
|
||
|
|
for column in extend_with:
|
||
|
|
row1[column] = row2[column]
|
||
|
|
return
|
||
|
|
|
||
|
|
for row1 in self:
|
||
|
|
for row2 in table:
|
||
|
|
for k in keys:
|
||
|
|
if row1[k] != row2[k]:
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
for column in extend_with:
|
||
|
|
row1[column] = row2[column]
|
||
|
|
break
|
||
|
|
|
||
|
|
def Remove(self, row):
|
||
|
|
"""Removes a row from the table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
row: int, the row number to delete. Must be >= 1, as the header cannot be
|
||
|
|
removed.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: Attempt to remove nonexistent or header row.
|
||
|
|
"""
|
||
|
|
if row == 0 or row > self.size:
|
||
|
|
raise TableError('Attempt to remove header row')
|
||
|
|
new_table = []
|
||
|
|
# pylint: disable=E1103
|
||
|
|
for t_row in self._table:
|
||
|
|
if t_row.row != row:
|
||
|
|
new_table.append(t_row)
|
||
|
|
if t_row.row > row:
|
||
|
|
t_row.row -= 1
|
||
|
|
self._table = new_table
|
||
|
|
|
||
|
|
def _Header(self):
|
||
|
|
"""Returns the header row."""
|
||
|
|
return self._table[0]
|
||
|
|
|
||
|
|
def _GetRow(self, columns=None):
|
||
|
|
"""Returns the current row as a tuple."""
|
||
|
|
|
||
|
|
row = self._table[self._row_index]
|
||
|
|
if columns:
|
||
|
|
result = []
|
||
|
|
for col in columns:
|
||
|
|
if col not in self.header:
|
||
|
|
raise TableError('Column header %s not known in table.' % col)
|
||
|
|
result.append(row[self.header.index(col)])
|
||
|
|
row = result
|
||
|
|
return row
|
||
|
|
|
||
|
|
def _SetRow(self, new_values, row=0):
|
||
|
|
"""Sets the current row to new list.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
new_values: List|dict of new values to insert into row.
|
||
|
|
row: int, Row to insert values into.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: If number of new values is not equal to row size.
|
||
|
|
"""
|
||
|
|
|
||
|
|
if not row:
|
||
|
|
row = self._row_index
|
||
|
|
|
||
|
|
if row > self.size:
|
||
|
|
raise TableError('Entry %s beyond table size %s.' % (row, self.size))
|
||
|
|
|
||
|
|
self._table[row].values = new_values
|
||
|
|
|
||
|
|
def _SetHeader(self, new_values):
|
||
|
|
"""Sets header of table to the given tuple.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
new_values: Tuple of new header values.
|
||
|
|
"""
|
||
|
|
row = self.row_class()
|
||
|
|
row.row = 0
|
||
|
|
for v in new_values:
|
||
|
|
row[v] = v
|
||
|
|
self._table[0] = row
|
||
|
|
|
||
|
|
def _SetRowIndex(self, row):
|
||
|
|
if not row or row > self.size:
|
||
|
|
raise TableError('Entry %s beyond table size %s.' % (row, self.size))
|
||
|
|
self._row_index = row
|
||
|
|
|
||
|
|
def _GetRowIndex(self):
|
||
|
|
return self._row_index
|
||
|
|
|
||
|
|
def _GetSize(self):
|
||
|
|
"""Returns number of rows in table."""
|
||
|
|
|
||
|
|
if not self._table:
|
||
|
|
return 0
|
||
|
|
return len(self._table) - 1
|
||
|
|
|
||
|
|
def _GetTable(self):
|
||
|
|
"""Returns table, with column headers and separators.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
The whole table including headers as a string. Each row is
|
||
|
|
joined by a newline and each entry by self.separator.
|
||
|
|
"""
|
||
|
|
result = []
|
||
|
|
# Avoid the global lookup cost on each iteration.
|
||
|
|
lstr = str
|
||
|
|
for row in self._table:
|
||
|
|
result.append('%s\n' % self.separator.join(lstr(v) for v in row))
|
||
|
|
|
||
|
|
return ''.join(result)
|
||
|
|
|
||
|
|
def _SetTable(self, table):
|
||
|
|
"""Sets table, with column headers and separators."""
|
||
|
|
if not isinstance(table, TextTable):
|
||
|
|
raise TypeError('Not an instance of TextTable.')
|
||
|
|
self.Reset()
|
||
|
|
self._table = copy.deepcopy(table._table) # pylint: disable=W0212
|
||
|
|
# Point parent table of each row back ourselves.
|
||
|
|
for row in self:
|
||
|
|
row.table = self
|
||
|
|
|
||
|
|
def _SmallestColSize(self, text):
|
||
|
|
"""Finds the largest indivisible word of a string.
|
||
|
|
|
||
|
|
...and thus the smallest possible column width that can contain that
|
||
|
|
word unsplit over rows.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
text: A string of text potentially consisting of words.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Integer size of the largest single word in the text.
|
||
|
|
"""
|
||
|
|
if not text:
|
||
|
|
return 0
|
||
|
|
stripped = terminal.StripAnsiText(text)
|
||
|
|
return max(len(word) for word in stripped.split())
|
||
|
|
|
||
|
|
def _TextJustify(self, text, col_size):
|
||
|
|
"""Formats text within column with white space padding.
|
||
|
|
|
||
|
|
A single space is prefixed, and a number of spaces are added as a
|
||
|
|
suffix such that the length of the resultant string equals the col_size.
|
||
|
|
|
||
|
|
If the length of the text exceeds the column width available then it
|
||
|
|
is split into words and returned as a list of string, each string
|
||
|
|
contains one or more words padded to the column size.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
text: String of text to format.
|
||
|
|
col_size: integer size of column to pad out the text to.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
List of strings col_size in length.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: If col_size is too small to fit the words in the text.
|
||
|
|
"""
|
||
|
|
result = []
|
||
|
|
if '\n' in text:
|
||
|
|
for paragraph in text.split('\n'):
|
||
|
|
result.extend(self._TextJustify(paragraph, col_size))
|
||
|
|
return result
|
||
|
|
|
||
|
|
wrapper = textwrap.TextWrapper(
|
||
|
|
width=col_size - 2, break_long_words=False, expand_tabs=False
|
||
|
|
)
|
||
|
|
try:
|
||
|
|
text_list = wrapper.wrap(text)
|
||
|
|
except ValueError as exc:
|
||
|
|
raise TableError('Field too small (minimum width: 3)') from exc
|
||
|
|
|
||
|
|
if not text_list:
|
||
|
|
return [' ' * col_size]
|
||
|
|
|
||
|
|
for current_line in text_list:
|
||
|
|
stripped_len = len(terminal.StripAnsiText(current_line))
|
||
|
|
ansi_color_adds = len(current_line) - stripped_len
|
||
|
|
# +2 for white space on either side.
|
||
|
|
if stripped_len + 2 > col_size:
|
||
|
|
raise TableError('String contains words that do not fit in column.')
|
||
|
|
|
||
|
|
result.append(' %-*s' % (col_size - 1 + ansi_color_adds, current_line))
|
||
|
|
|
||
|
|
return result
|
||
|
|
|
||
|
|
def FormattedTable(
|
||
|
|
self,
|
||
|
|
width=80,
|
||
|
|
force_display=False,
|
||
|
|
ml_delimiter=True,
|
||
|
|
color=True,
|
||
|
|
display_header=True,
|
||
|
|
columns=None,
|
||
|
|
):
|
||
|
|
"""Returns whole table, with whitespace padding and row delimiters.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
width: An int, the max width we want the table to fit in.
|
||
|
|
force_display: A bool, if set to True will display table when the table
|
||
|
|
can't be made to fit to the width.
|
||
|
|
ml_delimiter: A bool, if set to False will not display the multi-line
|
||
|
|
delimiter.
|
||
|
|
color: A bool. If true, display any colours in row.colour.
|
||
|
|
display_header: A bool. If true, display header.
|
||
|
|
columns: A list of str, show only columns with these names.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A string. The tabled output.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: Width too narrow to display table.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def _FilteredCols():
|
||
|
|
"""Returns list of column names to display."""
|
||
|
|
if not columns:
|
||
|
|
return self._Header().values
|
||
|
|
return [col for col in self._Header().values if col in columns]
|
||
|
|
|
||
|
|
# Largest is the biggest data entry in a column.
|
||
|
|
largest = {}
|
||
|
|
# Smallest is the same as above but with linewrap i.e. largest unbroken
|
||
|
|
# word in the data stream.
|
||
|
|
smallest = {}
|
||
|
|
# largest == smallest for a column with a single word of data.
|
||
|
|
# Initialise largest and smallest for all columns.
|
||
|
|
for key in _FilteredCols():
|
||
|
|
largest[key] = 0
|
||
|
|
smallest[key] = 0
|
||
|
|
|
||
|
|
# Find the largest and smallest values.
|
||
|
|
# Include Title line in equation.
|
||
|
|
# pylint: disable=E1103
|
||
|
|
for row in self._table:
|
||
|
|
for key, value in row.items():
|
||
|
|
if key not in _FilteredCols():
|
||
|
|
continue
|
||
|
|
# Convert lists into a string.
|
||
|
|
if isinstance(value, list):
|
||
|
|
value = ', '.join(value)
|
||
|
|
value = terminal.StripAnsiText(value)
|
||
|
|
largest[key] = max(len(value), largest[key])
|
||
|
|
smallest[key] = max(self._SmallestColSize(value), smallest[key])
|
||
|
|
# pylint: enable=E1103
|
||
|
|
|
||
|
|
min_total_width = 0
|
||
|
|
multi_word = []
|
||
|
|
# Bump up the size of each column to include minimum pad.
|
||
|
|
# Find all columns that can be wrapped (multi-line).
|
||
|
|
# And the minimum width needed to display all columns (even if wrapped).
|
||
|
|
for key in _FilteredCols():
|
||
|
|
# Each column is bracketed by a space on both sides.
|
||
|
|
# So increase size required accordingly.
|
||
|
|
largest[key] += 2
|
||
|
|
smallest[key] += 2
|
||
|
|
min_total_width += smallest[key]
|
||
|
|
# If column contains data that 'could' be split over multiple lines.
|
||
|
|
if largest[key] != smallest[key]:
|
||
|
|
multi_word.append(key)
|
||
|
|
|
||
|
|
# Check if we have enough space to display the table.
|
||
|
|
if min_total_width > width and not force_display:
|
||
|
|
raise TableError('Width too narrow to display table.')
|
||
|
|
|
||
|
|
# We have some columns that may need wrapping over several lines.
|
||
|
|
if multi_word:
|
||
|
|
# Find how much space is left over for the wrapped columns to use.
|
||
|
|
# Also find how much space we would need if they were not wrapped.
|
||
|
|
# These are 'spare_width' and 'desired_width' respectively.
|
||
|
|
desired_width = 0
|
||
|
|
spare_width = width - min_total_width
|
||
|
|
for key in multi_word:
|
||
|
|
spare_width += smallest[key]
|
||
|
|
desired_width += largest[key]
|
||
|
|
|
||
|
|
# Scale up the space we give each wrapped column.
|
||
|
|
# Proportional to its size relative to 'desired_width' for all columns.
|
||
|
|
# Rinse and repeat if we changed the wrap list in this iteration.
|
||
|
|
# Once done we will have a list of columns that definitely need wrapping.
|
||
|
|
done = False
|
||
|
|
while not done:
|
||
|
|
done = True
|
||
|
|
for key in multi_word:
|
||
|
|
# If we scale past the desired width for this particular column,
|
||
|
|
# then give it its desired width and remove it from the wrapped list.
|
||
|
|
if largest[key] <= round(
|
||
|
|
(largest[key] / float(desired_width)) * spare_width
|
||
|
|
):
|
||
|
|
smallest[key] = largest[key]
|
||
|
|
multi_word.remove(key)
|
||
|
|
spare_width -= smallest[key]
|
||
|
|
desired_width -= largest[key]
|
||
|
|
done = False
|
||
|
|
# If we scale below the minimum width for this particular column,
|
||
|
|
# then leave it at its minimum and remove it from the wrapped list.
|
||
|
|
elif smallest[key] >= round(
|
||
|
|
(largest[key] / float(desired_width)) * spare_width
|
||
|
|
):
|
||
|
|
multi_word.remove(key)
|
||
|
|
spare_width -= smallest[key]
|
||
|
|
desired_width -= largest[key]
|
||
|
|
done = False
|
||
|
|
|
||
|
|
# Repeat the scaling algorithm with the final wrap list.
|
||
|
|
# This time we assign the extra column space by increasing 'smallest'.
|
||
|
|
for key in multi_word:
|
||
|
|
smallest[key] = int(
|
||
|
|
round((largest[key] / float(desired_width)) * spare_width)
|
||
|
|
)
|
||
|
|
|
||
|
|
total_width = 0
|
||
|
|
row_count = 0
|
||
|
|
result_dict = {}
|
||
|
|
# Format the header lines and add to result_dict.
|
||
|
|
# Find what the total width will be and use this for the ruled lines.
|
||
|
|
# Find how many rows are needed for the most wrapped line (row_count).
|
||
|
|
for key in _FilteredCols():
|
||
|
|
result_dict[key] = self._TextJustify(key, smallest[key])
|
||
|
|
if len(result_dict[key]) > row_count:
|
||
|
|
row_count = len(result_dict[key])
|
||
|
|
total_width += smallest[key]
|
||
|
|
|
||
|
|
# Store header in header_list, working down the wrapped rows.
|
||
|
|
header_list = []
|
||
|
|
for row_idx in range(row_count):
|
||
|
|
for key in _FilteredCols():
|
||
|
|
try:
|
||
|
|
header_list.append(result_dict[key][row_idx])
|
||
|
|
except IndexError:
|
||
|
|
# If no value than use whitespace of equal size.
|
||
|
|
header_list.append(' ' * smallest[key])
|
||
|
|
header_list.append('\n')
|
||
|
|
|
||
|
|
# Format and store the body lines
|
||
|
|
result_dict = {}
|
||
|
|
body_list = []
|
||
|
|
# We separate multi line rows with a single line delimiter.
|
||
|
|
prev_muli_line = False
|
||
|
|
# Unless it is the first line in which there is already the header line.
|
||
|
|
first_line = True
|
||
|
|
for row in self:
|
||
|
|
row_count = 0
|
||
|
|
for key, value in row.items():
|
||
|
|
if key not in _FilteredCols():
|
||
|
|
continue
|
||
|
|
# Convert field contents to a string.
|
||
|
|
if isinstance(value, list):
|
||
|
|
value = ', '.join(value)
|
||
|
|
# Store results in result_dict and take note of wrapped line count.
|
||
|
|
result_dict[key] = self._TextJustify(value, smallest[key])
|
||
|
|
if len(result_dict[key]) > row_count:
|
||
|
|
row_count = len(result_dict[key])
|
||
|
|
|
||
|
|
if row_count > 1:
|
||
|
|
prev_muli_line = True
|
||
|
|
# If current or prior line was multi-line then include delimiter.
|
||
|
|
if not first_line and prev_muli_line and ml_delimiter:
|
||
|
|
body_list.append('-' * total_width + '\n')
|
||
|
|
if row_count == 1:
|
||
|
|
# Our current line was not wrapped, so clear flag.
|
||
|
|
prev_muli_line = False
|
||
|
|
|
||
|
|
row_list = []
|
||
|
|
for row_idx in range(row_count):
|
||
|
|
for key in _FilteredCols():
|
||
|
|
try:
|
||
|
|
row_list.append(result_dict[key][row_idx])
|
||
|
|
except IndexError:
|
||
|
|
# If no value than use whitespace of equal size.
|
||
|
|
row_list.append(' ' * smallest[key])
|
||
|
|
row_list.append('\n')
|
||
|
|
|
||
|
|
if color and row.color is not None:
|
||
|
|
body_list.append(
|
||
|
|
terminal.AnsiText(''.join(row_list)[:-1], command_list=row.color)
|
||
|
|
)
|
||
|
|
body_list.append('\n')
|
||
|
|
else:
|
||
|
|
body_list.append(''.join(row_list))
|
||
|
|
|
||
|
|
first_line = False
|
||
|
|
|
||
|
|
header = ''.join(header_list) + '=' * total_width
|
||
|
|
if color and self._Header().color is not None:
|
||
|
|
header = terminal.AnsiText(header, command_list=self._Header().color)
|
||
|
|
# Add double line delimiter between header and main body.
|
||
|
|
if display_header:
|
||
|
|
return '%s\n%s' % (header, ''.join(body_list))
|
||
|
|
return '%s' % ''.join(body_list)
|
||
|
|
|
||
|
|
def LabelValueTable(self, label_list=None):
|
||
|
|
"""Returns whole table as rows of name/value pairs.
|
||
|
|
|
||
|
|
One (or more) column entries are used for the row prefix label.
|
||
|
|
The remaining columns are each displayed as a row entry with the
|
||
|
|
prefix labels appended.
|
||
|
|
|
||
|
|
Use the first column as the label if label_list is None.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
label_list: A list of prefix labels to use.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Label/Value formatted table.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: If specified label is not a column header of the table.
|
||
|
|
"""
|
||
|
|
label_list = label_list or self._Header()[0]
|
||
|
|
# Ensure all labels are valid.
|
||
|
|
for label in label_list:
|
||
|
|
if label not in self._Header():
|
||
|
|
raise TableError('Invalid label prefix: %s.' % label)
|
||
|
|
|
||
|
|
sorted_list = []
|
||
|
|
for header in self._Header():
|
||
|
|
if header in label_list:
|
||
|
|
sorted_list.append(header)
|
||
|
|
|
||
|
|
label_str = '# LABEL %s\n' % '.'.join(sorted_list)
|
||
|
|
|
||
|
|
body = []
|
||
|
|
for row in self:
|
||
|
|
# Some row values are pulled into the label, stored in label_prefix.
|
||
|
|
label_prefix = []
|
||
|
|
value_list = []
|
||
|
|
for key, value in row.items():
|
||
|
|
if key in sorted_list:
|
||
|
|
# Set prefix.
|
||
|
|
label_prefix.append(value)
|
||
|
|
else:
|
||
|
|
value_list.append('%s %s' % (key, value))
|
||
|
|
|
||
|
|
body.append(
|
||
|
|
''.join(['%s.%s\n' % ('.'.join(label_prefix), v) for v in value_list])
|
||
|
|
)
|
||
|
|
|
||
|
|
return '%s%s' % (label_str, ''.join(body))
|
||
|
|
|
||
|
|
table = property(_GetTable, _SetTable, doc='Whole table')
|
||
|
|
row = property(_GetRow, _SetRow, doc='Current row')
|
||
|
|
header = property(_Header, _SetHeader, doc='List of header entries.')
|
||
|
|
row_index = property(_GetRowIndex, _SetRowIndex, doc='Current row.')
|
||
|
|
size = property(_GetSize, doc='Number of rows in table.')
|
||
|
|
|
||
|
|
def RowWith(self, column, value):
|
||
|
|
"""Retrieves the first non header row with the column of the given value.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
column: str, the name of the column to check.
|
||
|
|
value: str, The value of the column to check.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A Row() of the first row found, None otherwise.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
IndexError: The specified column does not exist.
|
||
|
|
"""
|
||
|
|
for row in self._table[1:]:
|
||
|
|
if row[column] == value:
|
||
|
|
return row
|
||
|
|
return None
|
||
|
|
|
||
|
|
def AddColumn(self, column, default='', col_index=-1):
|
||
|
|
"""Appends a new column to the table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
column: A string, name of the column to add.
|
||
|
|
default: Default value for entries. Defaults to ''.
|
||
|
|
col_index: Integer index for where to insert new column.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: Column name already exists.
|
||
|
|
"""
|
||
|
|
if column in self.table:
|
||
|
|
raise TableError('Column %r already in table.' % column)
|
||
|
|
if col_index == -1:
|
||
|
|
self._table[0][column] = column
|
||
|
|
for i in range(1, len(self._table)):
|
||
|
|
self._table[i][column] = default
|
||
|
|
else:
|
||
|
|
self._table[0].Insert(column, column, col_index)
|
||
|
|
for i in range(1, len(self._table)):
|
||
|
|
self._table[i].Insert(column, default, col_index)
|
||
|
|
|
||
|
|
def Append(self, new_values):
|
||
|
|
"""Adds a new row (list) to the table.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
new_values: Tuple, dict, or Row() of new values to append as a row.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: Supplied tuple not equal to table width.
|
||
|
|
"""
|
||
|
|
newrow = self.NewRow()
|
||
|
|
newrow.values = new_values
|
||
|
|
self._table.append(newrow)
|
||
|
|
|
||
|
|
def NewRow(self, value=''):
|
||
|
|
"""Fetches a new, empty row, with headers populated.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
value: Initial value to set each row entry to.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
A Row() object.
|
||
|
|
"""
|
||
|
|
newrow = self.row_class()
|
||
|
|
newrow.row = self.size + 1
|
||
|
|
newrow.table = self
|
||
|
|
headers = self._Header()
|
||
|
|
for header in headers:
|
||
|
|
newrow[header] = value
|
||
|
|
return newrow
|
||
|
|
|
||
|
|
def CsvToTable(self, buf, header=True, separator=','):
|
||
|
|
"""Parses buffer into tabular format.
|
||
|
|
|
||
|
|
Strips off comments (preceded by '#').
|
||
|
|
Optionally parses and indexes by first line (header).
|
||
|
|
|
||
|
|
Args:
|
||
|
|
buf: String file buffer containing CSV data.
|
||
|
|
header: Is the first line of buffer a header.
|
||
|
|
separator: String that CSV is separated by.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
int, the size of the table created.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: A parsing error occurred.
|
||
|
|
"""
|
||
|
|
self.Reset()
|
||
|
|
|
||
|
|
header_row = self.row_class()
|
||
|
|
header_length = 0
|
||
|
|
if header:
|
||
|
|
line = buf.readline()
|
||
|
|
header_str = ''
|
||
|
|
while not header_str:
|
||
|
|
if not isinstance(line, str):
|
||
|
|
line = line.decode('utf-8')
|
||
|
|
# Remove comments.
|
||
|
|
header_str = line.split('#')[0].strip()
|
||
|
|
if not header_str:
|
||
|
|
line = buf.readline()
|
||
|
|
|
||
|
|
header_list = header_str.split(separator)
|
||
|
|
header_length = len(header_list)
|
||
|
|
|
||
|
|
for entry in header_list:
|
||
|
|
entry = entry.strip()
|
||
|
|
if entry in header_row:
|
||
|
|
raise TableError('Duplicate header entry %r.' % entry)
|
||
|
|
|
||
|
|
header_row[entry] = entry
|
||
|
|
header_row.row = 0
|
||
|
|
self._table[0] = header_row
|
||
|
|
|
||
|
|
# xreadlines would be better but not supported by StringIO for testing.
|
||
|
|
for line in buf:
|
||
|
|
if not isinstance(line, str):
|
||
|
|
line = line.decode('utf-8')
|
||
|
|
# Support commented lines, provide '#' is first character of line.
|
||
|
|
if line.startswith('#'):
|
||
|
|
continue
|
||
|
|
|
||
|
|
lst = line.split(separator)
|
||
|
|
lst = [l.strip() for l in lst]
|
||
|
|
if header and len(lst) != header_length:
|
||
|
|
# Silently drop illegal line entries
|
||
|
|
continue
|
||
|
|
if not header:
|
||
|
|
header_row = self.row_class()
|
||
|
|
header_length = len(lst)
|
||
|
|
header_row.values = dict(
|
||
|
|
zip(range(header_length), range(header_length))
|
||
|
|
)
|
||
|
|
self._table[0] = header_row
|
||
|
|
header = True
|
||
|
|
continue
|
||
|
|
|
||
|
|
new_row = self.NewRow()
|
||
|
|
new_row.values = lst
|
||
|
|
header_row.row = self.size + 1
|
||
|
|
self._table.append(new_row)
|
||
|
|
|
||
|
|
return self.size
|
||
|
|
|
||
|
|
def index(self, name=None): # pylint: disable=invalid-name
|
||
|
|
"""Returns index number of supplied column name.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
name: string of column name.
|
||
|
|
|
||
|
|
Raises:
|
||
|
|
TableError: If name not found.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Index of the specified header entry.
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
return self.header.index(name)
|
||
|
|
except ValueError as exc:
|
||
|
|
raise TableError('Unknown index name %s.' % name) from exc
|