mirror of
https://github.com/evennia/evennia.git
synced 2026-03-19 14:26:30 +01:00
1335 lines
55 KiB
Python
1335 lines
55 KiB
Python
"""
|
|
|
|
EvTable
|
|
|
|
This is an advanced ASCII table creator. It was inspired
|
|
by prettytable but shares no code.
|
|
|
|
Note: to test ANSI colors on the command line you need to
|
|
call the printed table in a unicode() call, like print unicode(table).
|
|
This is due to a bug in the python interpreter and print.
|
|
|
|
Example usage:
|
|
|
|
table = EvTable("Heading1", "Heading2", table=[[1,2,3],[4,5,6],[7,8,9]], border="cells")
|
|
table.add_column("This is long data", "This is even longer data")
|
|
table.add_row("This is a single row")
|
|
print table
|
|
|
|
Result:
|
|
|
|
+----------------------+----------+---+--------------------------+
|
|
| Heading1 | Heading2 | | |
|
|
+~~~~~~~~~~~~~~~~~~~~~~+~~~~~~~~~~+~~~+~~~~~~~~~~~~~~~~~~~~~~~~~~+
|
|
| 1 | 4 | 7 | This is long data |
|
|
+----------------------+----------+---+--------------------------+
|
|
| 2 | 5 | 8 | This is even longer data |
|
|
+----------------------+----------+---+--------------------------+
|
|
| 3 | 6 | 9 | |
|
|
+----------------------+----------+---+--------------------------+
|
|
| This is a single row | | | |
|
|
+----------------------+----------+---+--------------------------+
|
|
|
|
As seen, the table will automatically expand with empty cells to make
|
|
the table symmetric.
|
|
|
|
Tables can be restricted to a given width.
|
|
|
|
table.reformat(width=50, align="l")
|
|
|
|
(We could just have added these keywords to the table creation call)
|
|
|
|
This yields the following result:
|
|
|
|
+-----------+------------+-----------+-----------+
|
|
| Heading1 | Heading2 | | |
|
|
+~~~~~~~~~~~+~~~~~~~~~~~~+~~~~~~~~~~~+~~~~~~~~~~~+
|
|
| 1 | 4 | 7 | This is |
|
|
| | | | long data |
|
|
+-----------+------------+-----------+-----------+
|
|
| | | | This is |
|
|
| 2 | 5 | 8 | even |
|
|
| | | | longer |
|
|
| | | | data |
|
|
+-----------+------------+-----------+-----------+
|
|
| 3 | 6 | 9 | |
|
|
+-----------+------------+-----------+-----------+
|
|
| This is a | | | |
|
|
| single | | | |
|
|
| row | | | |
|
|
+-----------+------------+-----------+-----------+
|
|
|
|
Table-columns can be individually formatted. Note that if an
|
|
individual column is set with a specific width, table auto-balancing
|
|
will not affect this column (this may lead to the full table being too
|
|
wide, so be careful mixing fixed-width columns with auto- balancing).
|
|
Here we change the width and alignment of the column at index 3
|
|
(Python starts from 0):
|
|
|
|
table.reformat_column(3, width=30, align="r")
|
|
print table
|
|
|
|
+-----------+-------+-----+-----------------------------+---------+
|
|
| Heading1 | Headi | | | |
|
|
| | ng2 | | | |
|
|
+~~~~~~~~~~~+~~~~~~~+~~~~~+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+~~~~~~~~~+
|
|
| 1 | 4 | 7 | This is long data | Test1 |
|
|
+-----------+-------+-----+-----------------------------+---------+
|
|
| 2 | 5 | 8 | This is even longer data | Test3 |
|
|
+-----------+-------+-----+-----------------------------+---------+
|
|
| 3 | 6 | 9 | | Test4 |
|
|
+-----------+-------+-----+-----------------------------+---------+
|
|
| This is a | | | | |
|
|
| single | | | | |
|
|
| row | | | | |
|
|
+-----------+-------+-----+-----------------------------+---------+
|
|
|
|
When adding new rows/columns their data can have its own alignments
|
|
(left/center/right, top/center/bottom).
|
|
|
|
If the height is restricted, cells will be restricted from expanding
|
|
vertically. This will lead to text contents being cropped. Each cell
|
|
can only shrink to a minimum width and height of 1.
|
|
|
|
EvTable is intended to be used with ANSIString for supporting
|
|
ANSI-coloured string types.
|
|
|
|
When a cell is auto-wrapped across multiple lines, ANSI-reset
|
|
sequences will be put at the end of each wrapped line. This means that
|
|
the colour of a wrapped cell will not "bleed", but it also means that
|
|
eventual colour outside
|
|
|
|
"""
|
|
#from textwrap import wrap
|
|
from textwrap import TextWrapper
|
|
from copy import deepcopy, copy
|
|
from src.utils.utils import to_unicode
|
|
from src.utils.ansi import ANSIString
|
|
|
|
def make_iter(obj):
|
|
"Makes sure that the object is always iterable."
|
|
return not hasattr(obj, '__iter__') and [obj] or obj
|
|
|
|
def _to_ansi(obj):
|
|
"convert to ANSIString"
|
|
if hasattr(obj, "__iter__"):
|
|
return [_to_ansi(o) for o in obj]
|
|
else:
|
|
return ANSIString(to_unicode(obj))
|
|
|
|
|
|
_unicode = unicode
|
|
_whitespace = '\t\n\x0b\x0c\r '
|
|
class ANSITextWrapper(TextWrapper):
|
|
|
|
def _munge_whitespace(self, text):
|
|
"""_munge_whitespace(text : string) -> string
|
|
|
|
Munge whitespace in text: expand tabs and convert all other
|
|
whitespace characters to spaces. Eg. " foo\tbar\n\nbaz"
|
|
becomes " foo bar baz".
|
|
"""
|
|
# ignore expand_tabs/replace_whitespace until ANSISTring handles them
|
|
return text
|
|
if self.expand_tabs:
|
|
text = text.expandtabs()
|
|
if self.replace_whitespace:
|
|
if isinstance(text, str):
|
|
text = text.translate(self.whitespace_trans)
|
|
elif isinstance(text, _unicode):
|
|
text = text.translate(self.unicode_whitespace_trans)
|
|
return text
|
|
|
|
|
|
def _split(self, text):
|
|
"""_split(text : string) -> [string]
|
|
|
|
Split the text to wrap into indivisible chunks. Chunks are
|
|
not quite the same as words; see _wrap_chunks() for full
|
|
details. As an example, the text
|
|
Look, goof-ball -- use the -b option!
|
|
breaks into the following chunks:
|
|
'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
|
|
'use', ' ', 'the', ' ', '-b', ' ', 'option!'
|
|
if break_on_hyphens is True, or in:
|
|
'Look,', ' ', 'goof-ball', ' ', '--', ' ',
|
|
'use', ' ', 'the', ' ', '-b', ' ', option!'
|
|
otherwise.
|
|
"""
|
|
# only use unicode wrapper
|
|
if self.break_on_hyphens:
|
|
pat = self.wordsep_re_uni
|
|
else:
|
|
pat = self.wordsep_simple_re_uni
|
|
chunks = pat.split(_to_ansi(text))
|
|
chunks = filter(None, chunks) # remove empty chunks
|
|
return chunks
|
|
|
|
def _wrap_chunks(self, chunks):
|
|
"""_wrap_chunks(chunks : [string]) -> [string]
|
|
|
|
Wrap a sequence of text chunks and return a list of lines of
|
|
length 'self.width' or less. (If 'break_long_words' is false,
|
|
some lines may be longer than this.) Chunks correspond roughly
|
|
to words and the whitespace between them: each chunk is
|
|
indivisible (modulo 'break_long_words'), but a line break can
|
|
come between any two chunks. Chunks should not have internal
|
|
whitespace; ie. a chunk is either all whitespace or a "word".
|
|
Whitespace chunks will be removed from the beginning and end of
|
|
lines, but apart from that whitespace is preserved.
|
|
"""
|
|
lines = []
|
|
if self.width <= 0:
|
|
raise ValueError("invalid width %r (must be > 0)" % self.width)
|
|
|
|
# Arrange in reverse order so items can be efficiently popped
|
|
# from a stack of chucks.
|
|
chunks.reverse()
|
|
|
|
while chunks:
|
|
|
|
# Start the list of chunks that will make up the current line.
|
|
# cur_len is just the length of all the chunks in cur_line.
|
|
cur_line = []
|
|
cur_len = 0
|
|
|
|
# Figure out which static string will prefix this line.
|
|
if lines:
|
|
indent = self.subsequent_indent
|
|
else:
|
|
indent = self.initial_indent
|
|
|
|
# Maximum width for this line.
|
|
width = self.width - len(indent)
|
|
|
|
# First chunk on line is whitespace -- drop it, unless this
|
|
# is the very beginning of the text (ie. no lines started yet).
|
|
if self.drop_whitespace and chunks[-1].strip() == '' and lines:
|
|
del chunks[-1]
|
|
|
|
while chunks:
|
|
l = len(chunks[-1])
|
|
|
|
# Can at least squeeze this chunk onto the current line.
|
|
if cur_len + l <= width:
|
|
cur_line.append(chunks.pop())
|
|
cur_len += l
|
|
|
|
# Nope, this line is full.
|
|
else:
|
|
break
|
|
|
|
# The current line is full, and the next chunk is too big to
|
|
# fit on *any* line (not just this one).
|
|
if chunks and len(chunks[-1]) > width:
|
|
self._handle_long_word(chunks, cur_line, cur_len, width)
|
|
|
|
# If the last chunk on this line is all whitespace, drop it.
|
|
if self.drop_whitespace and cur_line and cur_line[-1].strip() == '':
|
|
del cur_line[-1]
|
|
|
|
# Convert current line back to a string and store it in list
|
|
# of all lines (return value).
|
|
if cur_line:
|
|
l = ""
|
|
for w in cur_line: # ANSI fix
|
|
l += w #
|
|
lines.append(indent + l)
|
|
return lines
|
|
|
|
|
|
# -- Convenience interface ---------------------------------------------
|
|
|
|
def wrap(text, width=70, **kwargs):
|
|
"""Wrap a single paragraph of text, returning a list of wrapped lines.
|
|
|
|
Reformat the single paragraph in 'text' so it fits in lines of no
|
|
more than 'width' columns, and return a list of wrapped lines. By
|
|
default, tabs in 'text' are expanded with string.expandtabs(), and
|
|
all other whitespace characters (including newline) are converted to
|
|
space. See TextWrapper class for available keyword args to customize
|
|
wrapping behaviour.
|
|
"""
|
|
w = ANSITextWrapper(width=width, **kwargs)
|
|
return w.wrap(text)
|
|
|
|
def fill(text, width=70, **kwargs):
|
|
"""Fill a single paragraph of text, returning a new string.
|
|
|
|
Reformat the single paragraph in 'text' to fit in lines of no more
|
|
than 'width' columns, and return a new string containing the entire
|
|
wrapped paragraph. As with wrap(), tabs are expanded and other
|
|
whitespace characters converted to space. See TextWrapper class for
|
|
available keyword args to customize wrapping behaviour.
|
|
"""
|
|
w = ANSITextWrapper(width=width, **kwargs)
|
|
return w.fill(text)
|
|
|
|
# EvCell class (see further down for the EvTable itself)
|
|
|
|
class EvCell(object):
|
|
"""
|
|
Holds a single data cell for the table. A cell has a certain width
|
|
and height and contains one or more lines of data. It can shrink
|
|
and resize as needed.
|
|
"""
|
|
def __init__(self, data, **kwargs):
|
|
"""
|
|
data - the un-padded data of the entry.
|
|
kwargs:
|
|
width - desired width of cell. It will pad
|
|
to this size.
|
|
height - desired height of cell. it will pad
|
|
to this size
|
|
pad_width - general padding width. This can be overruled
|
|
by individual settings below
|
|
pad_left - number of extra pad characters on the left
|
|
pad_right - extra pad characters on the right
|
|
pad_top - extra pad lines top (will pad with vpad_char)
|
|
pad_bottom - extra pad lines bottom (will pad with vpad_char)
|
|
|
|
pad_char - pad character to use for padding. This is overruled
|
|
by individual settings below (default " ")
|
|
hpad_char - pad character to use both for extra horizontal
|
|
padding (default " ")
|
|
vpad_char - pad character to use for extra vertical padding
|
|
and for vertical fill (default " ")
|
|
|
|
fill_char - character used to filling (expanding cells to
|
|
desired size). This can be overruled by individual
|
|
settings below.
|
|
hfill_char - character used for horizontal fill (default " ")
|
|
vfill_char - character used for vertical fill (default " ")
|
|
|
|
align - "l", "r" or "c", default is left-aligned
|
|
valign - "t", "b" or "c", default is centered
|
|
|
|
border_width -general border width. This is overruled
|
|
- by individual settings below.
|
|
border_left - left border width
|
|
border_right - right border width
|
|
border_top - top border width
|
|
border_bottom - bottom border width
|
|
|
|
border_char - this will use a single border char for all borders.
|
|
overruled by individual settings below
|
|
border_left_char - char used for left border
|
|
border_right_char - char used for right border
|
|
border_top_char - char used for top border
|
|
border_bottom_char - char user for bottom border
|
|
|
|
corner_char - character used when two borders cross.
|
|
(default is ""). This is overruled by
|
|
individual settings below.
|
|
corner_top_left_char - char used for "nw" corner
|
|
corner_top_right_char - char used for "nw" corner
|
|
corner_bottom_left_char - char used for "sw" corner
|
|
corner_bottom_right_char - char used for "se" corner
|
|
|
|
crop_string - string to use when cropping sideways,
|
|
default is '[...]'
|
|
crop - crop content of cell rather than expand vertically,
|
|
default=False
|
|
|
|
|
|
enforce_size - if true, the width/height of the
|
|
cell is strictly enforced and
|
|
extra text will be cropped rather
|
|
than the cell growing vertically.
|
|
"""
|
|
|
|
self.formatted = None
|
|
padwidth = kwargs.get("pad_width", None)
|
|
padwidth = int(padwidth) if padwidth is not None else None
|
|
self.pad_left = int(kwargs.get("pad_left", padwidth if padwidth is not None else 1))
|
|
self.pad_right = int(kwargs.get("pad_right", padwidth if padwidth is not None else 1))
|
|
self.pad_top = int( kwargs.get("pad_top", padwidth if padwidth is not None else 0))
|
|
self.pad_bottom = int(kwargs.get("pad_bottom", padwidth if padwidth is not None else 0))
|
|
|
|
self.enforce_size = kwargs.get("enforce_size", False)
|
|
|
|
# avoid multi-char pad_chars messing up counting
|
|
pad_char = kwargs.get("pad_char", " ")
|
|
pad_char = pad_char[0] if pad_char else " "
|
|
hpad_char = kwargs.get("hpad_char", pad_char)
|
|
self.hpad_char = hpad_char[0] if hpad_char else pad_char
|
|
vpad_char = kwargs.get("vpad_char", pad_char)
|
|
self.vpad_char = vpad_char[0] if vpad_char else pad_char
|
|
|
|
fill_char = kwargs.get("fill_char", " ")
|
|
fill_char = fill_char[0] if fill_char else " "
|
|
hfill_char = kwargs.get("hfill_char", fill_char)
|
|
self.hfill_char = hfill_char[0] if hfill_char else " "
|
|
vfill_char = kwargs.get("vfill_char", fill_char)
|
|
self.vfill_char = vfill_char[0] if vfill_char else " "
|
|
|
|
self.crop_string = kwargs.get("crop_string", "[...]")
|
|
|
|
# borders and corners
|
|
borderwidth = kwargs.get("border_width", 0)
|
|
self.border_left = kwargs.get("border_left", borderwidth)
|
|
self.border_right = kwargs.get("border_right", borderwidth)
|
|
self.border_top = kwargs.get("border_top", borderwidth)
|
|
self.border_bottom = kwargs.get("border_bottom", borderwidth)
|
|
|
|
borderchar = kwargs.get("border_char", None)
|
|
self.border_left_char = kwargs.get("border_left_char", borderchar if borderchar else "|")
|
|
self.border_right_char = kwargs.get("border_right_char", borderchar if borderchar else "|")
|
|
self.border_top_char = kwargs.get("border_topchar", borderchar if borderchar else "-")
|
|
self.border_bottom_char = kwargs.get("border_bottom_char", borderchar if borderchar else "-")
|
|
|
|
corner_char = kwargs.get("corner_char", "+")
|
|
self.corner_top_left_char = kwargs.get("corner_top_left_char", corner_char)
|
|
self.corner_top_right_char = kwargs.get("corner_top_right_char", corner_char)
|
|
self.corner_bottom_left_char = kwargs.get("corner_bottom_left_char", corner_char)
|
|
self.corner_bottom_right_char = kwargs.get("corner_bottom_right_char", corner_char)
|
|
|
|
# alignments
|
|
self.align = kwargs.get("align", "l")
|
|
self.valign = kwargs.get("valign", "c")
|
|
|
|
#self.data = self._split_lines(unicode(data))
|
|
self.data = self._split_lines(_to_ansi(data))
|
|
self.raw_width = max(len(line) for line in self.data)
|
|
self.raw_height = len(self.data)
|
|
|
|
# this is extra trimming required for cels in the middle of a table only
|
|
self.trim_horizontal = 0
|
|
self.trim_vertical = 0
|
|
|
|
# width/height is given without left/right or top/bottom padding
|
|
if "width" in kwargs:
|
|
width = kwargs.pop("width")
|
|
self.width = width - self.pad_left - self.pad_right - self.border_left - self.border_right
|
|
if self.width <= 0:
|
|
raise Exception("Cell width too small - no space for data.")
|
|
else:
|
|
self.width = self.raw_width
|
|
if "height" in kwargs:
|
|
height = kwargs.pop("height")
|
|
self.height = height - self.pad_top - self.pad_bottom - self.border_top - self.border_bottom
|
|
if self.height <= 0:
|
|
raise Exception("Cell height too small - no space for data.")
|
|
else:
|
|
self.height = self.raw_height
|
|
|
|
# prepare data
|
|
#self.formatted = self._reformat()
|
|
|
|
def _crop(self, text, width):
|
|
"Apply cropping of text"
|
|
if len(text) > width:
|
|
crop_string = self.crop_string
|
|
return text[:width-len(crop_string)] + crop_string
|
|
return text
|
|
|
|
def _reformat(self):
|
|
"Apply formatting"
|
|
return self._border(self._pad(self._valign(self._align(self._fit_width(self.data)))))
|
|
|
|
def _split_lines(self, text):
|
|
"Simply split by linebreak"
|
|
return text.split("\n")
|
|
|
|
def _fit_width(self, data):
|
|
"""
|
|
Split too-long lines to fit the desired width of the Cell.
|
|
Note that this also updates raw_width
|
|
"""
|
|
width = self.width
|
|
adjusted_data = []
|
|
for line in data:
|
|
if 0 < width < len(line):
|
|
# replace_whitespace=False, expand_tabs=False is a
|
|
# fix for ANSIString not supporting expand_tabs/translate
|
|
adjusted_data.extend([ANSIString(part + ANSIString("{n"))
|
|
for part in wrap(line, width=width, drop_whitespace=False)])
|
|
else:
|
|
adjusted_data.append(line)
|
|
if self.enforce_size:
|
|
# don't allow too high cells
|
|
excess = len(adjusted_data) - self.height
|
|
if excess > 0:
|
|
# too many lines. Crop and mark last line with ...
|
|
adjusted_data = adjusted_data[:-excess]
|
|
if len(adjusted_data[-1]) > 3:
|
|
adjusted_data[-1] = adjusted_data[-1][:-2] + ".."
|
|
elif excess < 0:
|
|
# too few lines. Fill to height.
|
|
adjusted_data.extend(["" for i in xrange(excess)])
|
|
|
|
return adjusted_data
|
|
|
|
def _center(self, text, width, pad_char):
|
|
"Horizontally center text on line of certain width, using padding"
|
|
excess = width - len(text)
|
|
if excess <= 0:
|
|
return text
|
|
if excess % 2:
|
|
# uneven padding
|
|
narrowside = (excess // 2) * pad_char
|
|
widerside = narrowside + pad_char
|
|
if width % 2:
|
|
return narrowside + text + widerside
|
|
else:
|
|
return widerside + text + narrowside
|
|
else:
|
|
# even padding - same on both sides
|
|
side = (excess // 2) * pad_char
|
|
return side + text + side
|
|
|
|
def _align(self, data):
|
|
"Align list of rows of cell"
|
|
align = self.align
|
|
if align == "l":
|
|
return [line.ljust(self.width, self.hfill_char) for line in data]
|
|
elif align == "r":
|
|
return [line.rjust(self.width, self.hfill_char) for line in data]
|
|
else:
|
|
return [self._center(line, self.width, self.hfill_char) for line in data]
|
|
|
|
def _valign(self, data):
|
|
"align cell vertically"
|
|
valign = self.valign
|
|
height = self.height
|
|
cheight = len(data)
|
|
excess = height - cheight
|
|
padline = self.vfill_char * self.width
|
|
|
|
if excess <= 0:
|
|
return data
|
|
# only care if we need to add new lines
|
|
if valign == 't':
|
|
return data + [padline for i in xrange(excess)]
|
|
elif valign == 'b':
|
|
return [padline for i in xrange(excess)] + data
|
|
else: # center
|
|
narrowside = [padline for i in xrange(excess // 2)]
|
|
widerside = narrowside + [padline]
|
|
if excess % 2:
|
|
# uneven padding
|
|
if height % 2:
|
|
return widerside + data + narrowside
|
|
else:
|
|
return narrowside + data + widerside
|
|
else:
|
|
# even padding, same on both sides
|
|
return narrowside + data + narrowside
|
|
|
|
def _pad(self, data):
|
|
"Pad data with extra characters on all sides"
|
|
left = self.hpad_char * self.pad_left
|
|
right = self.hpad_char * self.pad_right
|
|
vfill = (self.width + self.pad_left + self.pad_right) * self.vpad_char
|
|
top = [vfill for i in xrange(self.pad_top)]
|
|
bottom = [vfill for i in xrange(self.pad_bottom)]
|
|
return top + [left + line + right for line in data] + bottom
|
|
|
|
def _border(self, data):
|
|
"Add borders to the cell"
|
|
|
|
left = self.border_left_char * self.border_left
|
|
right = self.border_right_char * self.border_right
|
|
|
|
cwidth = self.width + self.pad_left + self.pad_right + \
|
|
max(0,self.border_left-1) + max(0, self.border_right-1)
|
|
|
|
vfill = self.corner_top_left_char if left else ""
|
|
vfill += cwidth * self.border_top_char
|
|
vfill += self.corner_top_right_char if right else ""
|
|
top = [vfill for i in xrange(self.border_top)]
|
|
|
|
vfill = self.corner_bottom_left_char if left else ""
|
|
vfill += cwidth * self.border_bottom_char
|
|
vfill += self.corner_bottom_right_char if right else ""
|
|
bottom = [vfill for i in xrange(self.border_bottom)]
|
|
|
|
return top + [left + line + right for line in data] + bottom
|
|
|
|
def get_min_height(self):
|
|
"""
|
|
Get the minimum possible height of cell, including at least
|
|
one line for data.
|
|
"""
|
|
return self.pad_top + self.pad_bottom + self.border_bottom + self.border_top + 1
|
|
|
|
def get_min_width(self):
|
|
"""
|
|
Get the minimum possible width of cell, including at least one
|
|
character-width for data.
|
|
"""
|
|
return self.pad_left + self.pad_right + self.border_left + self.border_right + 1
|
|
|
|
def get_height(self):
|
|
"Get natural height of cell, including padding"
|
|
return len(self.formatted) #if self.formatted else 0
|
|
|
|
def get_width(self):
|
|
"Get natural width of cell, including padding"
|
|
return len(self.formatted[0]) #if self.formatted else 0
|
|
|
|
def replace_data(self, data, **kwargs):
|
|
"""
|
|
Replace cell data. This causes a full reformat of the cell.
|
|
|
|
kwargs - like when creating the cell anew.
|
|
"""
|
|
#self.data = self._split_lines(unicode(data))
|
|
self.data = self._split_lines(_to_ansi(data))
|
|
self.raw_width = max(len(line) for line in self.data)
|
|
self.raw_height = len(self.data)
|
|
self.reformat(**kwargs)
|
|
|
|
def reformat(self, **kwargs):
|
|
"""
|
|
Reformat the EvCell with new options
|
|
kwargs:
|
|
as the class __init__
|
|
"""
|
|
|
|
# keywords that require manipulation
|
|
|
|
padwidth = kwargs.get("pad_width", None)
|
|
padwidth = int(padwidth) if padwidth is not None else None
|
|
self.pad_left = int(kwargs.pop("pad_left", padwidth if padwidth is not None else self.pad_left))
|
|
self.pad_right = int(kwargs.pop("pad_right", padwidth if padwidth is not None else self.pad_right))
|
|
self.pad_top = int( kwargs.pop("pad_top", padwidth if padwidth is not None else self.pad_top))
|
|
self.pad_bottom = int(kwargs.pop("pad_bottom", padwidth if padwidth is not None else self.pad_bottom))
|
|
|
|
self.enforce_size = kwargs.get("enforce_size", False)
|
|
|
|
pad_char = kwargs.pop("pad_char", None)
|
|
hpad_char = kwargs.pop("hpad_char", pad_char)
|
|
self.hpad_char = hpad_char[0] if hpad_char else self.hpad_char
|
|
vpad_char = kwargs.pop("vpad_char", pad_char)
|
|
self.vpad_char = vpad_char[0] if vpad_char else self.vpad_char
|
|
|
|
fillchar = kwargs.pop("fill_char", None)
|
|
hfill_char = kwargs.pop("hfill_char", fillchar)
|
|
self.hfill_char = hfill_char[0] if hfill_char else self.hfill_char
|
|
vfill_char = kwargs.pop("vfill_char", fillchar)
|
|
self.vfill_char = vfill_char[0] if vfill_char else self.vfill_char
|
|
|
|
borderwidth = kwargs.get("border_width", None)
|
|
self.border_left = kwargs.pop("border_left", borderwidth if borderwidth is not None else self.border_left)
|
|
self.border_right = kwargs.pop("border_right", borderwidth if borderwidth is not None else self.border_right)
|
|
self.border_top = kwargs.pop("border_top", borderwidth if borderwidth is not None else self.border_top)
|
|
self.border_bottom = kwargs.pop("border_bottom", borderwidth if borderwidth is not None else self.border_bottom)
|
|
|
|
borderchar = kwargs.get("border_char", None)
|
|
self.border_left_char = kwargs.pop("border_left_char", borderchar if borderchar else self.border_left_char)
|
|
self.border_right_char = kwargs.pop("border_right_char", borderchar if borderchar else self.border_right_char)
|
|
self.border_top_char = kwargs.pop("border_topchar", borderchar if borderchar else self.border_top_char)
|
|
self.border_bottom_char = kwargs.pop("border_bottom_char", borderchar if borderchar else self.border_bottom_char)
|
|
|
|
corner_char = kwargs.get("corner_char", None)
|
|
self.corner_top_left_char = kwargs.pop("corner_top_left", corner_char if corner_char is not None else self.corner_top_left_char)
|
|
self.corner_top_right_char = kwargs.pop("corner_top_right", corner_char if corner_char is not None else self.corner_top_right_char)
|
|
self.corner_bottom_left_char = kwargs.pop("corner_bottom_left", corner_char if corner_char is not None else self.corner_bottom_left_char)
|
|
self.corner_bottom_right_char = kwargs.pop("corner_bottom_right", corner_char if corner_char is not None else self.corner_bottom_right_char)
|
|
|
|
# this is used by the table to adjust size of cells with borders in the middle
|
|
# of the table
|
|
self.trim_horizontal = kwargs.pop("trim_horizontal", self.trim_horizontal)
|
|
self.trim_vertical = kwargs.pop("trim_vertical", self.trim_vertical)
|
|
|
|
# fill all other properties
|
|
for key, value in kwargs.items():
|
|
setattr(self, key, value)
|
|
|
|
# Handle sizes
|
|
if "width" in kwargs:
|
|
width = kwargs.pop("width")
|
|
self.width = width - self.pad_left - self.pad_right - self.border_left - self.border_right + self.trim_horizontal
|
|
if self.width <= 0:
|
|
raise Exception("Cell width too small, no room for data.")
|
|
if "height" in kwargs:
|
|
height = kwargs.pop("height")
|
|
self.height = height - self.pad_top - self.pad_bottom - self.border_top - self.border_bottom + self.trim_vertical
|
|
if self.height <= 0:
|
|
raise Exception("Cell height too small, no room for data.")
|
|
|
|
# reformat (to new sizes, padding, header and borders)
|
|
self.formatted = self._reformat()
|
|
|
|
def get(self):
|
|
"""
|
|
Get data, padded and aligned in the form of a list of lines.
|
|
"""
|
|
self.formatted = self._reformat()
|
|
return self.formatted
|
|
|
|
def __repr__(self):
|
|
self.formatted = self._reformat()
|
|
return unicode(ANSIString("EvCel<%s>" % self.formatted))
|
|
|
|
def __str__(self):
|
|
"returns cell contents on string form"
|
|
self.formatted = self._reformat()
|
|
return str(unicode(ANSIString("\n").join(self.formatted)))
|
|
|
|
def __unicode__(self):
|
|
"returns cell contents"
|
|
self.formatted = self._reformat()
|
|
return unicode(ANSIString("\n").join(self.formatted))
|
|
|
|
|
|
## EvColumn class
|
|
|
|
class EvColumn(object):
|
|
"""
|
|
Column class
|
|
|
|
This class holds a list of Cells to represent a column of a table.
|
|
It holds operations and settings that affect *all* cells in the
|
|
column.
|
|
|
|
Columns are not intended to be used stand-alone; they should be
|
|
incorporated into an EvTable (like EvCells)
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
"""
|
|
Args:
|
|
Data for each row in the column
|
|
Keywords:
|
|
All EvCell keywords are available, these settings
|
|
will be persistently applied to every Cell in the column.
|
|
"""
|
|
self.options = kwargs # column-specific options
|
|
self.column = [EvCell(data, **kwargs) for data in args]
|
|
#self._balance()
|
|
|
|
def _balance(self, **kwargs):
|
|
"""
|
|
Make sure to adjust the width of all cells so we form a
|
|
coherent and lined-up column. Will enforce column-specific
|
|
options to cells.
|
|
"""
|
|
col = self.column
|
|
kwargs.update(self.options)
|
|
# use fixed width or adjust to the largest cell
|
|
if not "width" in kwargs:
|
|
[cell.reformat() for cell in col] # this is necessary to get initial widths of all cells
|
|
kwargs["width"] = max(cell.get_width() for cell in col) if col else 0
|
|
[cell.reformat(**kwargs) for cell in col]
|
|
|
|
def add_rows(self, *args, **kwargs):
|
|
"""
|
|
Add new cells to column. They will be inserted as
|
|
a series of rows. It will inherit the options
|
|
of the rest of the column's cells (use update to change
|
|
options).
|
|
|
|
Args:
|
|
data for the new cells
|
|
Keywords:
|
|
ypos - index position in table before which to insert the
|
|
new column. Uses Python indexing, so to insert at the top,
|
|
use ypos=0. If not given, data will be inserted at the end
|
|
of the column.
|
|
"""
|
|
ypos = kwargs.get("ypos", None)
|
|
if ypos is None or ypos > len(self.column):
|
|
# add to the end
|
|
self.column.extend([EvCell(data, **self.options) for data in args])
|
|
else:
|
|
# insert cells before given index
|
|
ypos = min(len(self.column)-1, max(0, int(ypos)))
|
|
new_cells = [EvCell(data, **self.options) for data in args]
|
|
self.column = self.column[:ypos] + new_cells + self.column[ypos:]
|
|
#self._balance(**kwargs)
|
|
|
|
def reformat(self, **kwargs):
|
|
"""
|
|
Change the options for the collumn.
|
|
"""
|
|
self._balance(**kwargs)
|
|
|
|
def reformat_cell(self, index, **kwargs):
|
|
"""
|
|
reformat cell at given index, keeping column
|
|
options if necessary
|
|
"""
|
|
kwargs.update(self.options)
|
|
self.column[index].reformat(**kwargs)
|
|
|
|
def __repr__(self):
|
|
return "EvColumn<%i cels>" % len(self.column)
|
|
def __len__(self):
|
|
return len(self.column)
|
|
def __iter__(self):
|
|
return iter(self.column)
|
|
def __getitem__(self, index):
|
|
return self.column[index]
|
|
def __setitem__(self, index, value):
|
|
self.column[index] = value
|
|
def __delitem__(self, index):
|
|
del self.column[index]
|
|
|
|
|
|
## Main Evtable class
|
|
|
|
class EvTable(object):
|
|
"""
|
|
Table class.
|
|
|
|
The table holds a list of EvColumns, each consisting of EvCells so
|
|
that the result is a 2D matrix.
|
|
"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""
|
|
Args:
|
|
headers for the table
|
|
|
|
Keywords:
|
|
table - list of columns (lists of lists, or lists of EvColumns) for seeding
|
|
the table. If not given, the table will start
|
|
out empty
|
|
header - True/False - turn off header being treated
|
|
as a header (like extra underlining)
|
|
|
|
pad_width - how much empty space to pad your cells with
|
|
(default is 1)
|
|
border - None, or one of
|
|
"table" - only a border around the whole table
|
|
"tablecols" - table and column borders
|
|
"header" - only border under header
|
|
"cols" - only vertical borders
|
|
"incols" - vertical borders, no outer edges
|
|
"rows" - only borders between rows
|
|
"cells" - border around all cells
|
|
border_width - width of table borders, if border is active.
|
|
Note that widths wider than 1 may give artifacts in the
|
|
corners. Default is 1.
|
|
corner_char - character to use in corners when border is
|
|
active.
|
|
corner_top_left_char - character to use in upper left corner of table
|
|
(defaults to corner_char)
|
|
corner_top_right_char
|
|
corner_bottom_left_char
|
|
corner_bottom_right_char
|
|
pretty_corners - (default True): use custom characters to make
|
|
the table corners look "rounded". Uses UTF-8
|
|
characters.
|
|
|
|
header_line_char - characters to use for underlining
|
|
the header row (default is '~')
|
|
Requires border to be active.
|
|
|
|
width - fixed width of table. If not set, width is
|
|
set by the total width of each column.
|
|
This will resize individual columns in
|
|
the vertical direction to fit.
|
|
height - fixed height of table. Defaults to unset.
|
|
Width is still given precedence. If
|
|
height is given, table cells will crop
|
|
text rather than expand vertically.
|
|
evenwidth - (default False). Used with the width keyword.
|
|
Adjusts collumns to have as even width as
|
|
possible. This often looks best also for
|
|
mixed-length tables.
|
|
maxwidth - This will set a maximum width of the table
|
|
while allowing it to be smaller. Only if it
|
|
grows wider than this size will it be resized.
|
|
This has no meaning if width is set.
|
|
|
|
See Cell class for further kwargs. These will be passed
|
|
to each cell in the table.
|
|
|
|
"""
|
|
# at this point table is a 2D grid - a list of columns
|
|
# x is the column position, y the row
|
|
table = kwargs.pop("table", [])
|
|
|
|
# header is a list of texts. We merge it to the table's top
|
|
header = list(args)
|
|
self.header = header != []
|
|
if self.header:
|
|
if table:
|
|
excess = len(header) - len(table)
|
|
if excess > 0:
|
|
# header bigger than table
|
|
self.table.extend([] for i in xrange(excess))
|
|
elif excess < 0:
|
|
# too short header
|
|
header.extend(_to_ansi(["" for i in xrange(abs(excess))]))
|
|
for ix, heading in enumerate(header):
|
|
table[ix].insert(0, heading)
|
|
else:
|
|
table = [[heading] for heading in header]
|
|
# even though we inserted the header, we can still turn off
|
|
# header border underling etc. We only allow this if a header
|
|
# was actually set
|
|
self.header = kwargs.pop("header", self.header) if self.header else False
|
|
hchar = kwargs.pop("header_line_char", "~")
|
|
self.header_line_char = hchar[0] if hchar else "~"
|
|
|
|
border = kwargs.pop("border", "tablecols")
|
|
if border is None:
|
|
border = "none"
|
|
if not border in ("none", "table", "tablecols",
|
|
"header", "incols", "cols", "rows", "cells"):
|
|
raise Exception("Unsupported border type: '%s'" % border)
|
|
self.border = border
|
|
|
|
# border settings are passed into Cell as well (so kwargs.get and not pop)
|
|
self.border_width = kwargs.get("border_width", 1)
|
|
self.corner_char = kwargs.get("corner_char", "+")
|
|
pcorners = kwargs.pop("pretty_corners", False)
|
|
self.corner_top_left_char = _to_ansi(kwargs.pop("corner_top_left_char", '.' if pcorners else self.corner_char))
|
|
self.corner_top_right_char = _to_ansi(kwargs.pop("corner_top_right_char", '.' if pcorners else self.corner_char))
|
|
self.corner_bottom_left_char = _to_ansi(kwargs.pop("corner_bottom_left_char", ' ' if pcorners else self.corner_char))
|
|
self.corner_bottom_right_char = _to_ansi(kwargs.pop("corner_bottom_right_char", ' ' if pcorners else self.corner_char))
|
|
|
|
self.width = kwargs.pop("width", None)
|
|
self.height = kwargs.pop("height", None)
|
|
self.evenwidth = kwargs.pop("evenwidth", False)
|
|
self.maxwidth = kwargs.pop("maxwidth", None)
|
|
if self.maxwidth and self.width and self.maxwidth < self.width:
|
|
raise Exception("table maxwidth < table width!")
|
|
# size in cell cols/rows
|
|
self.ncols = len(table)
|
|
self.nrows = max(len(col) for col in table) if table else 0
|
|
# size in characters (gets set when _balance is called)
|
|
self.nwidth = 0
|
|
self.nheight = 0
|
|
# save options
|
|
self.options = kwargs
|
|
|
|
# use the temporary table to generate the table on the fly, as a list of EvColumns
|
|
self.table = [EvColumn(*col, **kwargs) for col in table]
|
|
|
|
# this is the actual working table
|
|
self.worktable = None
|
|
|
|
# balance the table
|
|
#self._balance()
|
|
|
|
def _cellborders(self, ix, iy, nx, ny, kwargs):
|
|
"""
|
|
Adds borders to the table by adjusting the input
|
|
kwarg to instjruct cells to build a border in
|
|
the right positions. Returns a copy of the
|
|
kwarg to return to the cell. This is called
|
|
by self._borders.
|
|
"""
|
|
|
|
ret = kwargs.copy()
|
|
|
|
# handle the various border modes
|
|
border = self.border
|
|
header = self.header
|
|
|
|
bwidth = self.border_width
|
|
headchar = self.header_line_char
|
|
|
|
def corners(ret):
|
|
"Handle corners of table"
|
|
if ix == 0 and iy == 0:
|
|
ret["corner_top_left_char"] = self.corner_top_left_char
|
|
if ix == nx and iy == 0:
|
|
ret["corner_top_right_char"] = self.corner_top_right_char
|
|
if ix == 0 and iy == ny:
|
|
ret["corner_bottom_left_char"] = self.corner_bottom_left_char
|
|
if ix == nx and iy == ny:
|
|
ret["corner_bottom_right_char"] = self.corner_bottom_right_char
|
|
return ret
|
|
|
|
def left_edge(ret):
|
|
"add vertical border along left table edge"
|
|
if ix == 0:
|
|
ret["border_left"] = bwidth
|
|
ret["trim_horizontal"] = bwidth
|
|
return ret
|
|
|
|
def top_edge(ret):
|
|
"add border along top table edge"
|
|
if iy == 0:
|
|
ret["border_top"] = bwidth
|
|
#ret["trim_vertical"] = bwidth
|
|
return ret
|
|
|
|
def right_edge(ret):
|
|
"add vertical border along right table edge"
|
|
if ix == nx:# and 0 < iy < ny:
|
|
ret["border_right"] = bwidth
|
|
#ret["trim_horizontal"] = 0
|
|
return ret
|
|
|
|
def bottom_edge(ret):
|
|
"add border along bottom table edge"
|
|
if iy == ny:
|
|
ret["border_bottom"] = bwidth
|
|
#ret["trim_vertical"] = bwidth
|
|
return ret
|
|
|
|
def cols(ret):
|
|
"Adding vertical borders inside the table"
|
|
if 0 <= ix < nx:
|
|
ret["border_right"] = bwidth
|
|
return ret
|
|
|
|
def rows(ret):
|
|
"Adding horizontal borders inside the table"
|
|
if 0 <= iy < ny:
|
|
ret["border_bottom"] = bwidth
|
|
return ret
|
|
|
|
def head(ret):
|
|
"Add header underline"
|
|
if iy == 0:
|
|
# put different bottom line for header
|
|
ret["border_bottom"] = bwidth
|
|
ret["border_bottom_char"] = headchar
|
|
return ret
|
|
|
|
# use the helper functions to define various
|
|
# table "styles"
|
|
|
|
if border in ("table", "tablecols","cells"):
|
|
ret = bottom_edge(right_edge(top_edge(left_edge(corners(ret)))))
|
|
if border in ("cols", "tablecols", "cells"):
|
|
ret = cols(right_edge(left_edge(ret)))
|
|
if border in ("incols"):
|
|
ret = cols(ret)
|
|
if border in ("rows", "cells"):
|
|
ret = rows(bottom_edge(top_edge(ret)))
|
|
if header and not border in ("none", None):
|
|
ret = head(ret)
|
|
|
|
return ret
|
|
|
|
def _borders(self):
|
|
"""
|
|
Add borders to table. This is called from self._balance
|
|
"""
|
|
nx, ny = self.ncols-1, self.nrows-1
|
|
options = self.options
|
|
for ix, col in enumerate(self.worktable):
|
|
for iy, cell in enumerate(col):
|
|
col.reformat_cell(iy, **self._cellborders(ix,iy,nx,ny,options))
|
|
|
|
def _balance(self):
|
|
"""
|
|
Balance the table. This means to make sure
|
|
all cells on the same row have the same height,
|
|
that all columns have the same number of rows
|
|
and that the table fits within the given width.
|
|
"""
|
|
|
|
# we make all modifications on a working copy of the
|
|
# actual table. This allows us to add columns/rows
|
|
# and re-balance over and over without issue.
|
|
self.worktable = deepcopy(self.table)
|
|
options = copy(self.options)
|
|
|
|
# balance number of rows to make a rectangular table
|
|
# column by column
|
|
ncols = len(self.worktable)
|
|
nrows = [len(col) for col in self.worktable]
|
|
nrowmax = max(nrows) if nrows else 0
|
|
for icol, nrow in enumerate(nrows):
|
|
self.worktable[icol].reformat(**options)
|
|
if nrow < nrowmax:
|
|
# add more rows to too-short columns
|
|
empty_rows = ["" for i in xrange(nrowmax-nrow)]
|
|
self.worktable[icol].add_rows(*empty_rows)
|
|
self.ncols = ncols
|
|
self.nrows = nrowmax
|
|
|
|
# add borders - these add to the width/height, so we must do this before calculating width/height
|
|
self._borders()
|
|
|
|
# equalize widths within each column
|
|
#print [col.options for col in self.worktable]
|
|
#print [[cell.get_width() for cell in col] for col in self.worktable]
|
|
#print [[cell.get_height() for cell in col] for col in self.worktable]
|
|
cwidths = [max(cell.get_width() for cell in col) for col in self.worktable]
|
|
|
|
if self.width or self.maxwidth and self.maxwidth < sum(cwidths):
|
|
# we set a table width. Horizontal cells will be evenly distributed and
|
|
# expand vertically as needed (unless self.height is set, see below)
|
|
|
|
# use fixed width, or set to maxwidth
|
|
width = self.width if self.width else self.maxwidth
|
|
|
|
if ncols:
|
|
# get minimum possible cell widths for each row
|
|
cwidths_min = [max(cell.get_min_width() for cell in col) for col in self.worktable]
|
|
cwmin = sum(cwidths_min)
|
|
|
|
if cwmin > width:
|
|
# we cannot shrink any more
|
|
raise Exception("Cannot shrink table width to %s. Minimum size is %s." % (self.width, cwmin))
|
|
|
|
excess = width - cwmin
|
|
if self.evenwidth:
|
|
# make each collumn of equal width
|
|
for i in xrange(excess):
|
|
# flood-fill the minimum table starting with the smallest collumns
|
|
ci = cwidths_min.index(min(cwidths_min))
|
|
cwidths_min[ci] += 1
|
|
cwidths = cwidths_min
|
|
else:
|
|
# make each collumn expand more proportional to their data size
|
|
for i in xrange(excess):
|
|
# fill wider collumns first
|
|
ci = cwidths.index(max(cwidths))
|
|
cwidths_min[ci] += 1
|
|
cwidths[ci] -= 3
|
|
cwidths = cwidths_min
|
|
|
|
# reformat worktable (for width align)
|
|
for ix, col in enumerate(self.worktable):
|
|
try:
|
|
col.reformat(width=cwidths[ix], **options)
|
|
except Exception, e:
|
|
msg = "ix=%s, width=%s: %s" % (ix, cwidths[ix], e.message)
|
|
raise #Exception ("Error in horizontal allign:\n %s" % msg)
|
|
|
|
# equalize heights for each row (we must do this here, since it may have changed to fit new widths)
|
|
cheights = [max(cell.get_height() for cell in (col[iy] for col in self.worktable)) for iy in xrange(nrowmax)]
|
|
|
|
if self.height:
|
|
# if we are fixing the table height, it means cells must crop text instead of resizing.
|
|
if nrowmax:
|
|
|
|
# get minimum possible cell heights for each collumn
|
|
cheights_min = [max(cell.get_min_height() for cell in (col[iy] for col in self.worktable)) for iy in xrange(nrowmax)]
|
|
chmin = sum(cheights_min)
|
|
#print "cheights_min:", cheights_min
|
|
|
|
if chmin > self.height:
|
|
# we cannot shrink any more
|
|
raise Exception("Cannot shrink table height to %s. Minimum size is %s." % (self.height, chmin))
|
|
|
|
# now we add all the extra height up to the desired table-height.
|
|
# We do this so that the tallest cells gets expanded first (and
|
|
# thus avoid getting cropped)
|
|
|
|
excess = self.height - chmin
|
|
even = self.height % 2 == 0
|
|
for i in xrange(excess):
|
|
# expand the cells with the most rows first
|
|
if 0 <= i < nrowmax and nrowmax > 1:
|
|
# avoid adding to header first round (looks bad on very small tables)
|
|
ci = cheights[1:].index(max(cheights[1:])) + 1
|
|
else:
|
|
ci = cheights.index(max(cheights))
|
|
cheights_min[ci] += 1
|
|
if ci == 0 and self.header:
|
|
# it doesn't look very good if header expands too fast
|
|
cheights[ci] -= 2 if even else 3
|
|
cheights[ci] -= 2 if even else 1
|
|
cheights = cheights_min
|
|
|
|
# we must tell cells to crop instead of expanding
|
|
options["enforce_size"] = True
|
|
#print "cheights2:", cheights
|
|
|
|
# reformat table (for vertical align)
|
|
for ix, col in enumerate(self.worktable):
|
|
for iy, cell in enumerate(col):
|
|
try:
|
|
col.reformat_cell(iy, height=cheights[iy], **options)
|
|
except Exception, e:
|
|
msg = "ix=%s, iy=%s, height=%s: %s" % (ix, iy, cheights[iy], e.message)
|
|
raise Exception ("Error in vertical allign:\n %s" % msg)
|
|
|
|
# calculate actual table width/height in characters
|
|
self.cwidth = sum(cwidths)
|
|
self.cheight = sum(cheights)
|
|
#print "actual table width, height:", self.cwidth, self.cheight, self.width, self.height
|
|
|
|
def _generate_lines(self):
|
|
"""
|
|
Generates lines across all columns
|
|
(each cell may contain multiple lines)
|
|
This will also balance the table.
|
|
"""
|
|
self._balance()
|
|
for iy in xrange(self.nrows):
|
|
cell_row = [col[iy] for col in self.worktable]
|
|
# this produces a list of lists, each of equal length
|
|
cell_data = [cell.get() for cell in cell_row]
|
|
cell_height = min(len(lines) for lines in cell_data)
|
|
for iline in xrange(cell_height):
|
|
yield ANSIString("").join(_to_ansi(celldata[iline] for celldata in cell_data))
|
|
|
|
def add_header(self, *args, **kwargs):
|
|
"""
|
|
Add header to table. This is a number of texts to
|
|
be put at the top of the table. They will replace
|
|
an existing header.
|
|
"""
|
|
self.header = True
|
|
self.add_row(ypos=0, *args, **kwargs)
|
|
|
|
def add_column(self, *args, **kwargs):
|
|
"""
|
|
Add a column to table. If there are more
|
|
rows in new column than there are rows in the
|
|
current table, the table will expand with
|
|
empty rows in the other columns. If too few,
|
|
the new column with get new empty rows. All
|
|
filling rows are added to the end.
|
|
Args:
|
|
Either a single EvColumn instance or
|
|
a number of data to be used to create a new column
|
|
keyword-
|
|
header - the header text for the column
|
|
xpos - index position in table before which
|
|
to input new column. If not given,
|
|
column will be added to the end. Uses
|
|
Python indexing (so first column is xpos=0)
|
|
See Cell class for other keyword arguments
|
|
"""
|
|
# this will replace default options with new ones without changing default
|
|
options = dict(self.options.items() + kwargs.items())
|
|
|
|
xpos = kwargs.get("xpos", None)
|
|
column = EvColumn(*args, **options)
|
|
wtable = self.ncols
|
|
htable = self.nrows
|
|
excess = len(column) - htable
|
|
|
|
if excess > 0:
|
|
# we need to add new rows to table
|
|
for col in self.table:
|
|
empty_rows = ["" for i in xrange(excess)]
|
|
col.add_rows(*empty_rows, **options)
|
|
self.nrows += excess
|
|
elif excess < 0:
|
|
# we need to add new rows to new column
|
|
empty_rows = ["" for i in xrange(abs(excess))]
|
|
column.add_rows(*empty_rows, **options)
|
|
self.nrows -= excess
|
|
|
|
header = kwargs.get("header", None)
|
|
if header:
|
|
column.add_rows(unicode(header), ypos=0, **options)
|
|
self.header = True
|
|
elif self.header:
|
|
# we have a header already. Offset
|
|
column.add_rows("", ypos=0, **options)
|
|
if xpos is None or xpos > wtable - 1:
|
|
# add to the end
|
|
self.table.append(column)
|
|
else:
|
|
# insert column
|
|
xpos = min(wtable-1, max(0, int(xpos)))
|
|
self.table.insert(xpos, column)
|
|
self.ncols += 1
|
|
#self._balance()
|
|
|
|
def add_row(self, *args, **kwargs):
|
|
"""
|
|
Add a row to table (not a header). If there are
|
|
more cells in the given row than there are cells
|
|
in the current table the table will be expanded
|
|
with empty columns to match. These will be added
|
|
to the end of the table. In the same way, adding
|
|
a line with too few cells will lead to the last
|
|
ones getting padded.
|
|
keyword
|
|
ypos - index position in table before which to
|
|
input new row. If not given, will be added
|
|
to the end. Uses Python indexing (so first row is
|
|
ypos=0)
|
|
See EvCell class for other keyword arguments
|
|
"""
|
|
# this will replace default options with new ones without changing default
|
|
row = list(args)
|
|
options = dict(self.options.items() + kwargs.items())
|
|
|
|
ypos = kwargs.get("ypos", None)
|
|
wtable = self.ncols
|
|
htable = self.nrows
|
|
excess = len(row) - wtable
|
|
|
|
if excess > 0:
|
|
# we need to add new empty columns to table
|
|
empty_rows = ["" for i in xrange(htable)]
|
|
self.table.extend([EvColumn(*empty_rows, **options) for i in xrange(excess)])
|
|
self.ncols += excess
|
|
elif excess < 0:
|
|
# we need to add more cells to row
|
|
row.extend(["" for i in xrange(abs(excess))])
|
|
self.ncols -= excess
|
|
|
|
if ypos is None or ypos > htable - 1:
|
|
# add new row to the end
|
|
for icol, col in enumerate(self.table):
|
|
col.add_rows(row[icol], **options)
|
|
else:
|
|
# insert row elsewhere
|
|
ypos = min(htable-1, max(0, int(ypos)))
|
|
for icol, col in enumerate(self.table):
|
|
col.add_rows(row[icol], ypos=ypos, **options)
|
|
self.nrows += 1
|
|
#self._balance()
|
|
|
|
def reformat(self, **kwargs):
|
|
"""
|
|
Force a re-shape of the entire table
|
|
"""
|
|
self.width = kwargs.pop("width", self.width)
|
|
self.height = kwargs.pop("height", self.height)
|
|
for key, value in kwargs.items():
|
|
setattr(self, key, value)
|
|
|
|
hchar = kwargs.pop("header_line_char", self.header_line_char)
|
|
|
|
# border settings are also passed on into EvCells (so kwargs.get, not kwargs.pop)
|
|
self.header_line_char = hchar[0] if hchar else self.header_line_char
|
|
self.border_width = kwargs.get("border_width", self.border_width)
|
|
self.corner_char = kwargs.get("corner_char", self.corner_char)
|
|
self.header_line_char = kwargs.get("header_line_char", self.header_line_char)
|
|
|
|
self.corner_top_left_char = _to_ansi(kwargs.pop("corner_top_left_char", self.corner_char))
|
|
self.corner_top_right_char = _to_ansi(kwargs.pop("corner_top_right_char", self.corner_char))
|
|
self.corner_bottom_left_char = _to_ansi(kwargs.pop("corner_bottom_left_char", self.corner_char))
|
|
self.corner_bottom_right_char = _to_ansi(kwargs.pop("corner_bottom_right_char", self.corner_char))
|
|
|
|
self.options.update(kwargs)
|
|
#self._balance()
|
|
|
|
def reformat_column(self, index, **kwargs):
|
|
"""
|
|
Sends custom options to a specific column in the table. The column
|
|
is identified by its index in the table (0-Ncol)
|
|
"""
|
|
if index > len(self.table):
|
|
raise Exception("Not a valid column index")
|
|
self.table[index].options.update(kwargs)
|
|
self.table[index].reformat(**kwargs)
|
|
#self._balance()
|
|
|
|
def get(self):
|
|
"""
|
|
Return lines of table as a list
|
|
"""
|
|
return [line for line in self._generate_lines()]
|
|
|
|
def __str__(self):
|
|
"print table (this also balances it)"
|
|
return str(unicode(ANSIString("\n").join([line for line in self._generate_lines()])))
|
|
|
|
def __unicode__(self):
|
|
return unicode(ANSIString("\n").join([line for line in self._generate_lines()]))
|
|
|
|
def _test():
|
|
"Test"
|
|
table = EvTable("{yHeading1{n", "{gHeading2{n", table=[[1,2,3],[4,5,6],[7,8,9]], border="cells", align="l")
|
|
table.add_column("{rThis is long data{n", "{bThis is even longer data{n")
|
|
table.add_row("This is a single row")
|
|
print unicode(table)
|
|
table.reformat(width=50)
|
|
print unicode(table)
|
|
table.reformat_column(3, width=30, align='r')
|
|
print unicode(table)
|
|
return table
|
|
|
|
|
|
|