/usr/lib/python2.7/dist-packages/nibabel/rstutils.py is in python-nibabel 2.1.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | """ ReStructured Text utilities
* Make ReST table given array of values
"""
from __future__ import division
import numpy as np
def rst_table(cell_values,
row_names=None,
col_names=None,
title='',
val_fmt='{0:5.2f}',
format_chars=None
):
""" Return string for ReST table with entries `cell_values`
Parameters
----------
cell_values : (R, C) array-like
At least 2D. Can be greater than 2D, in which case you should adapt
the `val_fmt` to deal with the multiple entries that will go in each
cell
row_names : None or (R,) length sequence, optional
Row names. If None, use ``row[0]`` etc.
col_names : None or (C,) length sequence, optional
Column names. If None, use ``col[0]`` etc.
title : str, optional
Title for table. Add as heading above table
val_fmt : str, optional
Format string using string ``format`` method mini-language. Converts
the result of ``cell_values[r, c]`` to a string to make the cell
contents. Default assumes a floating point value in a 2D `cell_values`.
format_chars : None or dict, optional
With keys 'down', 'along', 'thick_long', 'cross' and 'title_heading'.
Values are characters for: lines going down; lines going along; thick
lines along; two lines crossing; and the title overline / underline.
All missing values filled with rst defaults.
Returns
-------
table_str : str
Multiline string with ascii table, suitable for printing
"""
# formatting
if format_chars is None:
format_chars = {}
down = format_chars.pop('down', '|')
along = format_chars.pop('along', '-')
thick_long = format_chars.pop('thick_long', '=')
cross = format_chars.pop('cross', '+')
title_heading = format_chars.pop('title_heading', '*')
if len(format_chars) != 0:
raise ValueError('Unexpected ``format_char`` keys {0}'.format(
', '.join(format_chars)))
down_joiner = ' ' + down + ' '
down_starter = down + ' '
down_ender = ' ' + down
cross_joiner = along + cross + along
cross_starter = cross + along
cross_ender = along + cross
cross_thick_joiner = thick_long + cross + thick_long
cross_thick_starter = cross + thick_long
cross_thick_ender = thick_long + cross
# lengths of row names, column names and values
cell_values = np.asarray(cell_values)
R, C = cell_values.shape[:2]
if row_names is None:
row_names = ['row[{0}]'.format(r) for r in range(R)]
elif len(row_names) != R:
raise ValueError('len(row_names) != number of rows')
if col_names is None:
col_names = ['col[{0}]'.format(c) for c in range(C)]
elif len(col_names) != C:
raise ValueError('len(col_names) != number of columns')
row_len = max(len(name) for name in row_names)
col_len = max(len(name) for name in col_names)
# Compile row value strings, find longest, extend col length to match
row_str_list = []
for row_no in range(R):
row_strs = [val_fmt.format(val) for val in cell_values[row_no]]
max_len = max(len(s) for s in row_strs)
if max_len > col_len:
col_len = max_len
row_str_list.append(row_strs)
row_name_fmt = "{0:<" + str(row_len) + "}"
row_names = [row_name_fmt.format(name) for name in row_names]
col_name_fmt = "{0:^" + str(col_len) + "}"
col_names = [col_name_fmt.format(name) for name in col_names]
col_headings = [' ' * row_len] + col_names
col_header = down_joiner.join(col_headings)
row_val_fmt = '{0:<' + str(col_len) + '}'
table_strs = []
if title != '':
table_strs += [title_heading * len(title),
title,
title_heading * len(title),
'']
along_headings = [along * len(h) for h in col_headings]
crossed_line = (cross_starter +
cross_joiner.join(along_headings) +
cross_ender)
thick_long_headings = [thick_long * len(h) for h in col_headings]
crossed_thick_line = (cross_thick_starter +
cross_thick_joiner.join(thick_long_headings) +
cross_thick_ender)
table_strs += [crossed_line,
down_starter + col_header + down_ender,
crossed_thick_line]
for row_no, row_name in enumerate(row_names):
row_vals = [row_val_fmt.format(row_str)
for row_str in row_str_list[row_no]]
row_line = (down_starter +
down_joiner.join([row_name] + row_vals) +
down_ender)
table_strs.append(row_line)
table_strs.append(crossed_line)
return '\n'.join(table_strs)
|