def __repr__(self):
h, r = self._get_repr_()
h, r = formatted_cells(r, header=h)
result = simple_format(h, r, title=self.test_name)
components = CategoryCounts(self.observed.to_dict(),
expected=self.expected.to_dict())
result = [result, str(components)]
return "\n".join(result)
def array_repr(self, a):
if len(a.shape) == 1:
heading = [str(n) for n in self.names[0]]
a = a[numpy.newaxis, :]
elif len(a.shape) == 2:
heading = [""] + [str(n) for n in self.names[1]]
a = [[str(name)] + list(row)
for (name, row) in zip(self.names[0], a)]
else:
return "%s dimensional %s" % (len(self.names), type(self).__name__)
formatted = table.formatted_cells(rows=a, header=heading)
return str(table.simple_format(formatted[0], formatted[1], space=4))
def to_string(self,
format="",
borders=True,
sep=None,
center=False,
**kwargs):
"""Return the table as a formatted string.
Parameters
----------
format
possible formats are 'rest'/'rst', 'markdown'/'md',
'latex', 'html', 'phylip', 'bedgraph', 'csv', 'tsv', or 'simple'
(default).
sep
A string separator for delineating columns, e.g. ',' or
'\t'. Overrides format.
center
content is centered in the column, default is right
justified
NOTE: If format is bedgraph, assumes that column headers are chrom,
start, end, value. In that order!
"""
if format.lower() == "phylip":
missing_data = "%.4f" % 0.0
else:
missing_data = self._missing_data
if format.lower() in ("tsv", "csv"):
sep = sep or {"tsv": "\t", "csv": ","}[format.lower()]
format = ""
# convert self to a 2D list
formatted_table = self.array.tolist()
if format != "bedgraph":
header, formatted_table = table_format.formatted_cells(
formatted_table,
self.header,
digits=self._digits,
column_templates=self._column_templates,
missing_data=missing_data,
center=center,
)
args = (header, formatted_table, self.title, self.legend)
if sep and format != "bedgraph":
return table_format.separator_format(*args + (sep, ))
elif format in ("rest", "rst"):
return table_format.grid_table_format(*args)
elif format in ("markdown", "md"):
return table_format.markdown(header, formatted_table, **kwargs)
elif format.endswith("tex"):
caption = None
if self.title or self.legend:
caption = " ".join([self.title or "", self.legend or ""])
return table_format.latex(formatted_table,
header,
caption=caption,
**kwargs)
elif format == "html":
return self.to_rich_html(**kwargs)
elif format == "phylip":
# need to eliminate row identifiers
formatted_table = [row[self._row_ids:] for row in formatted_table]
header = header[self._row_ids:]
return table_format.phylip_matrix(formatted_table, header)
elif format == "bedgraph":
assert self.shape[1] == 4, "bedgraph format is for 4 column tables"
# assuming that header order is chrom, start, end, val
formatted_table = bedgraph.bedgraph(self.sorted().array.tolist(),
**kwargs)
return formatted_table
else:
return table_format.simple_format(
*args + (self._max_width, self._row_ids, borders, self.space))
def _get_repr_(self, html=False):
obs = self.observed.array.tolist()
exp = self.expected.array.tolist()
res = self.residuals.array.tolist()
ndim = len(self.observed.shape)
if ndim == 1:
row_labels = "Observed", "Expected", "Residuals"
row_cell_func = _format_row_cell(row_labels)
col_labels = [str(c) for c in self.observed.template.names[0]]
rows = []
# format floats for expecteds and resid
for row_label, row in zip(row_labels, [obs, exp, res]):
if row_label == "Observed":
row = [row_label] + [f"{v:,}" for v in row]
else:
row = [row_label] + [f"{v:,.2f}" for v in row]
rows.append(row)
if html:
rows = rich_html(
rows,
header=[""] + col_labels,
row_cell_func=row_cell_func,
merge_identical=False,
)
else:
header, rows = formatted_cells(rows, header=[""] + col_labels)
rows = simple_format(header, rows)
else:
row_labels = self.observed.template.names[0]
col_labels = self.observed.template.names[1]
row_cell_func = _format_row_cell(row_labels)
result = []
for caption, table in zip(("Observed", "Expected", "Residuals"),
(obs, exp, res)):
rows = []
for i, r in enumerate(table):
if caption == "Observed":
r = [f"{v:,}" for v in r]
else:
r = [f"{v:,.2f}" for v in r]
rows.append([row_labels[i]] + r)
if html:
result.append(
rich_html(
rows,
header=[""] + col_labels,
caption=f"<b>{caption}</b>",
row_cell_func=row_cell_func,
merge_identical=False,
))
else:
header, rows = formatted_cells(rows,
header=[""] + col_labels)
result.append(simple_format(header, rows, title=caption))
joiner = "<br>" if html else "\n"
rows = joiner.join(result)
return rows
