647 lines
24 KiB
Python
647 lines
24 KiB
Python
"""
|
||
Module for formatting output data in HTML.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
from textwrap import dedent
|
||
from typing import (
|
||
TYPE_CHECKING,
|
||
Any,
|
||
Final,
|
||
cast,
|
||
)
|
||
|
||
from pandas._config import get_option
|
||
|
||
from pandas._libs import lib
|
||
|
||
from pandas import (
|
||
MultiIndex,
|
||
option_context,
|
||
)
|
||
|
||
from pandas.io.common import is_url
|
||
from pandas.io.formats.format import (
|
||
DataFrameFormatter,
|
||
get_level_lengths,
|
||
)
|
||
from pandas.io.formats.printing import pprint_thing
|
||
|
||
if TYPE_CHECKING:
|
||
from collections.abc import (
|
||
Hashable,
|
||
Iterable,
|
||
Mapping,
|
||
)
|
||
|
||
|
||
class HTMLFormatter:
|
||
"""
|
||
Internal class for formatting output data in html.
|
||
This class is intended for shared functionality between
|
||
DataFrame.to_html() and DataFrame._repr_html_().
|
||
Any logic in common with other output formatting methods
|
||
should ideally be inherited from classes in format.py
|
||
and this class responsible for only producing html markup.
|
||
"""
|
||
|
||
indent_delta: Final = 2
|
||
|
||
def __init__(
|
||
self,
|
||
formatter: DataFrameFormatter,
|
||
classes: str | list[str] | tuple[str, ...] | None = None,
|
||
border: int | bool | None = None,
|
||
table_id: str | None = None,
|
||
render_links: bool = False,
|
||
) -> None:
|
||
self.fmt = formatter
|
||
self.classes = classes
|
||
|
||
self.frame = self.fmt.frame
|
||
self.columns = self.fmt.tr_frame.columns
|
||
self.elements: list[str] = []
|
||
self.bold_rows = self.fmt.bold_rows
|
||
self.escape = self.fmt.escape
|
||
self.show_dimensions = self.fmt.show_dimensions
|
||
if border is None or border is True:
|
||
border = cast(int, get_option("display.html.border"))
|
||
elif not border:
|
||
border = None
|
||
|
||
self.border = border
|
||
self.table_id = table_id
|
||
self.render_links = render_links
|
||
|
||
self.col_space = {}
|
||
is_multi_index = isinstance(self.columns, MultiIndex)
|
||
for column, value in self.fmt.col_space.items():
|
||
col_space_value = f"{value}px" if isinstance(value, int) else value
|
||
self.col_space[column] = col_space_value
|
||
# GH 53885: Handling case where column is index
|
||
# Flatten the data in the multi index and add in the map
|
||
if is_multi_index and isinstance(column, tuple):
|
||
for column_index in column:
|
||
self.col_space[str(column_index)] = col_space_value
|
||
|
||
def to_string(self) -> str:
|
||
lines = self.render()
|
||
if any(isinstance(x, str) for x in lines):
|
||
lines = [str(x) for x in lines]
|
||
return "\n".join(lines)
|
||
|
||
def render(self) -> list[str]:
|
||
self._write_table()
|
||
|
||
if self.should_show_dimensions:
|
||
by = chr(215) # × # noqa: RUF003
|
||
self.write(
|
||
f"<p>{len(self.frame)} rows {by} {len(self.frame.columns)} columns</p>"
|
||
)
|
||
|
||
return self.elements
|
||
|
||
@property
|
||
def should_show_dimensions(self) -> bool:
|
||
return self.fmt.should_show_dimensions
|
||
|
||
@property
|
||
def show_row_idx_names(self) -> bool:
|
||
return self.fmt.show_row_idx_names
|
||
|
||
@property
|
||
def show_col_idx_names(self) -> bool:
|
||
return self.fmt.show_col_idx_names
|
||
|
||
@property
|
||
def row_levels(self) -> int:
|
||
if self.fmt.index:
|
||
# showing (row) index
|
||
return self.frame.index.nlevels
|
||
elif self.show_col_idx_names:
|
||
# see gh-22579
|
||
# Column misalignment also occurs for
|
||
# a standard index when the columns index is named.
|
||
# If the row index is not displayed a column of
|
||
# blank cells need to be included before the DataFrame values.
|
||
return 1
|
||
# not showing (row) index
|
||
return 0
|
||
|
||
def _get_columns_formatted_values(self) -> Iterable:
|
||
return self.columns
|
||
|
||
@property
|
||
def is_truncated(self) -> bool:
|
||
return self.fmt.is_truncated
|
||
|
||
@property
|
||
def ncols(self) -> int:
|
||
return len(self.fmt.tr_frame.columns)
|
||
|
||
def write(self, s: Any, indent: int = 0) -> None:
|
||
rs = pprint_thing(s)
|
||
self.elements.append(" " * indent + rs)
|
||
|
||
def write_th(
|
||
self, s: Any, header: bool = False, indent: int = 0, tags: str | None = None
|
||
) -> None:
|
||
"""
|
||
Method for writing a formatted <th> cell.
|
||
|
||
If col_space is set on the formatter then that is used for
|
||
the value of min-width.
|
||
|
||
Parameters
|
||
----------
|
||
s : object
|
||
The data to be written inside the cell.
|
||
header : bool, default False
|
||
Set to True if the <th> is for use inside <thead>. This will
|
||
cause min-width to be set if there is one.
|
||
indent : int, default 0
|
||
The indentation level of the cell.
|
||
tags : str, default None
|
||
Tags to include in the cell.
|
||
|
||
Returns
|
||
-------
|
||
A written <th> cell.
|
||
"""
|
||
col_space = self.col_space.get(s, None)
|
||
|
||
if header and col_space is not None:
|
||
tags = tags or ""
|
||
tags += f'style="min-width: {col_space};"'
|
||
|
||
self._write_cell(s, kind="th", indent=indent, tags=tags)
|
||
|
||
def write_td(self, s: Any, indent: int = 0, tags: str | None = None) -> None:
|
||
self._write_cell(s, kind="td", indent=indent, tags=tags)
|
||
|
||
def _write_cell(
|
||
self, s: Any, kind: str = "td", indent: int = 0, tags: str | None = None
|
||
) -> None:
|
||
if tags is not None:
|
||
start_tag = f"<{kind} {tags}>"
|
||
else:
|
||
start_tag = f"<{kind}>"
|
||
|
||
if self.escape:
|
||
# escape & first to prevent double escaping of &
|
||
esc = {"&": r"&", "<": r"<", ">": r">"}
|
||
else:
|
||
esc = {}
|
||
|
||
rs = pprint_thing(s, escape_chars=esc).strip()
|
||
|
||
if self.render_links and is_url(rs):
|
||
rs_unescaped = pprint_thing(s, escape_chars={}).strip()
|
||
start_tag += f'<a href="{rs_unescaped}" target="_blank">'
|
||
end_a = "</a>"
|
||
else:
|
||
end_a = ""
|
||
|
||
self.write(f"{start_tag}{rs}{end_a}</{kind}>", indent)
|
||
|
||
def write_tr(
|
||
self,
|
||
line: Iterable,
|
||
indent: int = 0,
|
||
indent_delta: int = 0,
|
||
header: bool = False,
|
||
align: str | None = None,
|
||
tags: dict[int, str] | None = None,
|
||
nindex_levels: int = 0,
|
||
) -> None:
|
||
if tags is None:
|
||
tags = {}
|
||
|
||
if align is None:
|
||
self.write("<tr>", indent)
|
||
else:
|
||
self.write(f'<tr style="text-align: {align};">', indent)
|
||
indent += indent_delta
|
||
|
||
for i, s in enumerate(line):
|
||
val_tag = tags.get(i, None)
|
||
if header or (self.bold_rows and i < nindex_levels):
|
||
self.write_th(s, indent=indent, header=header, tags=val_tag)
|
||
else:
|
||
self.write_td(s, indent, tags=val_tag)
|
||
|
||
indent -= indent_delta
|
||
self.write("</tr>", indent)
|
||
|
||
def _write_table(self, indent: int = 0) -> None:
|
||
_classes = ["dataframe"] # Default class.
|
||
use_mathjax = get_option("display.html.use_mathjax")
|
||
if not use_mathjax:
|
||
_classes.append("tex2jax_ignore")
|
||
if self.classes is not None:
|
||
if isinstance(self.classes, str):
|
||
self.classes = self.classes.split()
|
||
if not isinstance(self.classes, (list, tuple)):
|
||
raise TypeError(
|
||
"classes must be a string, list, "
|
||
f"or tuple, not {type(self.classes)}"
|
||
)
|
||
_classes.extend(self.classes)
|
||
|
||
if self.table_id is None:
|
||
id_section = ""
|
||
else:
|
||
id_section = f' id="{self.table_id}"'
|
||
|
||
if self.border is None:
|
||
border_attr = ""
|
||
else:
|
||
border_attr = f' border="{self.border}"'
|
||
|
||
self.write(
|
||
f'<table{border_attr} class="{" ".join(_classes)}"{id_section}>',
|
||
indent,
|
||
)
|
||
|
||
if self.fmt.header or self.show_row_idx_names:
|
||
self._write_header(indent + self.indent_delta)
|
||
|
||
self._write_body(indent + self.indent_delta)
|
||
|
||
self.write("</table>", indent)
|
||
|
||
def _write_col_header(self, indent: int) -> None:
|
||
row: list[Hashable]
|
||
is_truncated_horizontally = self.fmt.is_truncated_horizontally
|
||
if isinstance(self.columns, MultiIndex):
|
||
template = 'colspan="{span:d}" halign="left"'
|
||
|
||
sentinel: lib.NoDefault | bool
|
||
if self.fmt.sparsify:
|
||
# GH3547
|
||
sentinel = lib.no_default
|
||
else:
|
||
sentinel = False
|
||
levels = self.columns._format_multi(sparsify=sentinel, include_names=False)
|
||
level_lengths = get_level_lengths(levels, sentinel)
|
||
inner_lvl = len(level_lengths) - 1
|
||
for lnum, (records, values) in enumerate(zip(level_lengths, levels)):
|
||
if is_truncated_horizontally:
|
||
# modify the header lines
|
||
ins_col = self.fmt.tr_col_num
|
||
if self.fmt.sparsify:
|
||
recs_new = {}
|
||
# Increment tags after ... col.
|
||
for tag, span in list(records.items()):
|
||
if tag >= ins_col:
|
||
recs_new[tag + 1] = span
|
||
elif tag + span > ins_col:
|
||
recs_new[tag] = span + 1
|
||
if lnum == inner_lvl:
|
||
values = (
|
||
values[:ins_col] + ("...",) + values[ins_col:]
|
||
)
|
||
else:
|
||
# sparse col headers do not receive a ...
|
||
values = (
|
||
values[:ins_col]
|
||
+ (values[ins_col - 1],)
|
||
+ values[ins_col:]
|
||
)
|
||
else:
|
||
recs_new[tag] = span
|
||
# if ins_col lies between tags, all col headers
|
||
# get ...
|
||
if tag + span == ins_col:
|
||
recs_new[ins_col] = 1
|
||
values = values[:ins_col] + ("...",) + values[ins_col:]
|
||
records = recs_new
|
||
inner_lvl = len(level_lengths) - 1
|
||
if lnum == inner_lvl:
|
||
records[ins_col] = 1
|
||
else:
|
||
recs_new = {}
|
||
for tag, span in list(records.items()):
|
||
if tag >= ins_col:
|
||
recs_new[tag + 1] = span
|
||
else:
|
||
recs_new[tag] = span
|
||
recs_new[ins_col] = 1
|
||
records = recs_new
|
||
values = values[:ins_col] + ["..."] + values[ins_col:]
|
||
|
||
# see gh-22579
|
||
# Column Offset Bug with to_html(index=False) with
|
||
# MultiIndex Columns and Index.
|
||
# Initially fill row with blank cells before column names.
|
||
# TODO: Refactor to remove code duplication with code
|
||
# block below for standard columns index.
|
||
row = [""] * (self.row_levels - 1)
|
||
if self.fmt.index or self.show_col_idx_names:
|
||
# see gh-22747
|
||
# If to_html(index_names=False) do not show columns
|
||
# index names.
|
||
# TODO: Refactor to use _get_column_name_list from
|
||
# DataFrameFormatter class and create a
|
||
# _get_formatted_column_labels function for code
|
||
# parity with DataFrameFormatter class.
|
||
if self.fmt.show_index_names:
|
||
name = self.columns.names[lnum]
|
||
row.append(pprint_thing(name or ""))
|
||
else:
|
||
row.append("")
|
||
|
||
tags = {}
|
||
j = len(row)
|
||
for i, v in enumerate(values):
|
||
if i in records:
|
||
if records[i] > 1:
|
||
tags[j] = template.format(span=records[i])
|
||
else:
|
||
continue
|
||
j += 1
|
||
row.append(v)
|
||
self.write_tr(row, indent, self.indent_delta, tags=tags, header=True)
|
||
else:
|
||
# see gh-22579
|
||
# Column misalignment also occurs for
|
||
# a standard index when the columns index is named.
|
||
# Initially fill row with blank cells before column names.
|
||
# TODO: Refactor to remove code duplication with code block
|
||
# above for columns MultiIndex.
|
||
row = [""] * (self.row_levels - 1)
|
||
if self.fmt.index or self.show_col_idx_names:
|
||
# see gh-22747
|
||
# If to_html(index_names=False) do not show columns
|
||
# index names.
|
||
# TODO: Refactor to use _get_column_name_list from
|
||
# DataFrameFormatter class.
|
||
if self.fmt.show_index_names:
|
||
row.append(self.columns.name or "")
|
||
else:
|
||
row.append("")
|
||
row.extend(self._get_columns_formatted_values())
|
||
align = self.fmt.justify
|
||
|
||
if is_truncated_horizontally:
|
||
ins_col = self.row_levels + self.fmt.tr_col_num
|
||
row.insert(ins_col, "...")
|
||
|
||
self.write_tr(row, indent, self.indent_delta, header=True, align=align)
|
||
|
||
def _write_row_header(self, indent: int) -> None:
|
||
is_truncated_horizontally = self.fmt.is_truncated_horizontally
|
||
row = [x if x is not None else "" for x in self.frame.index.names] + [""] * (
|
||
self.ncols + (1 if is_truncated_horizontally else 0)
|
||
)
|
||
self.write_tr(row, indent, self.indent_delta, header=True)
|
||
|
||
def _write_header(self, indent: int) -> None:
|
||
self.write("<thead>", indent)
|
||
|
||
if self.fmt.header:
|
||
self._write_col_header(indent + self.indent_delta)
|
||
|
||
if self.show_row_idx_names:
|
||
self._write_row_header(indent + self.indent_delta)
|
||
|
||
self.write("</thead>", indent)
|
||
|
||
def _get_formatted_values(self) -> dict[int, list[str]]:
|
||
with option_context("display.max_colwidth", None):
|
||
fmt_values = {i: self.fmt.format_col(i) for i in range(self.ncols)}
|
||
return fmt_values
|
||
|
||
def _write_body(self, indent: int) -> None:
|
||
self.write("<tbody>", indent)
|
||
fmt_values = self._get_formatted_values()
|
||
|
||
# write values
|
||
if self.fmt.index and isinstance(self.frame.index, MultiIndex):
|
||
self._write_hierarchical_rows(fmt_values, indent + self.indent_delta)
|
||
else:
|
||
self._write_regular_rows(fmt_values, indent + self.indent_delta)
|
||
|
||
self.write("</tbody>", indent)
|
||
|
||
def _write_regular_rows(
|
||
self, fmt_values: Mapping[int, list[str]], indent: int
|
||
) -> None:
|
||
is_truncated_horizontally = self.fmt.is_truncated_horizontally
|
||
is_truncated_vertically = self.fmt.is_truncated_vertically
|
||
|
||
nrows = len(self.fmt.tr_frame)
|
||
|
||
if self.fmt.index:
|
||
fmt = self.fmt._get_formatter("__index__")
|
||
if fmt is not None:
|
||
index_values = self.fmt.tr_frame.index.map(fmt)
|
||
else:
|
||
# only reached with non-Multi index
|
||
index_values = self.fmt.tr_frame.index._format_flat(include_name=False)
|
||
|
||
row: list[str] = []
|
||
for i in range(nrows):
|
||
if is_truncated_vertically and i == (self.fmt.tr_row_num):
|
||
str_sep_row = ["..."] * len(row)
|
||
self.write_tr(
|
||
str_sep_row,
|
||
indent,
|
||
self.indent_delta,
|
||
tags=None,
|
||
nindex_levels=self.row_levels,
|
||
)
|
||
|
||
row = []
|
||
if self.fmt.index:
|
||
row.append(index_values[i])
|
||
# see gh-22579
|
||
# Column misalignment also occurs for
|
||
# a standard index when the columns index is named.
|
||
# Add blank cell before data cells.
|
||
elif self.show_col_idx_names:
|
||
row.append("")
|
||
row.extend(fmt_values[j][i] for j in range(self.ncols))
|
||
|
||
if is_truncated_horizontally:
|
||
dot_col_ix = self.fmt.tr_col_num + self.row_levels
|
||
row.insert(dot_col_ix, "...")
|
||
self.write_tr(
|
||
row, indent, self.indent_delta, tags=None, nindex_levels=self.row_levels
|
||
)
|
||
|
||
def _write_hierarchical_rows(
|
||
self, fmt_values: Mapping[int, list[str]], indent: int
|
||
) -> None:
|
||
template = 'rowspan="{span}" valign="top"'
|
||
|
||
is_truncated_horizontally = self.fmt.is_truncated_horizontally
|
||
is_truncated_vertically = self.fmt.is_truncated_vertically
|
||
frame = self.fmt.tr_frame
|
||
nrows = len(frame)
|
||
|
||
assert isinstance(frame.index, MultiIndex)
|
||
idx_values = frame.index._format_multi(sparsify=False, include_names=False)
|
||
idx_values = list(zip(*idx_values))
|
||
|
||
if self.fmt.sparsify:
|
||
# GH3547
|
||
sentinel = lib.no_default
|
||
levels = frame.index._format_multi(sparsify=sentinel, include_names=False)
|
||
|
||
level_lengths = get_level_lengths(levels, sentinel)
|
||
inner_lvl = len(level_lengths) - 1
|
||
if is_truncated_vertically:
|
||
# Insert ... row and adjust idx_values and
|
||
# level_lengths to take this into account.
|
||
ins_row = self.fmt.tr_row_num
|
||
inserted = False
|
||
for lnum, records in enumerate(level_lengths):
|
||
rec_new = {}
|
||
for tag, span in list(records.items()):
|
||
if tag >= ins_row:
|
||
rec_new[tag + 1] = span
|
||
elif tag + span > ins_row:
|
||
rec_new[tag] = span + 1
|
||
|
||
# GH 14882 - Make sure insertion done once
|
||
if not inserted:
|
||
dot_row = list(idx_values[ins_row - 1])
|
||
dot_row[-1] = "..."
|
||
idx_values.insert(ins_row, tuple(dot_row))
|
||
inserted = True
|
||
else:
|
||
dot_row = list(idx_values[ins_row])
|
||
dot_row[inner_lvl - lnum] = "..."
|
||
idx_values[ins_row] = tuple(dot_row)
|
||
else:
|
||
rec_new[tag] = span
|
||
# If ins_row lies between tags, all cols idx cols
|
||
# receive ...
|
||
if tag + span == ins_row:
|
||
rec_new[ins_row] = 1
|
||
if lnum == 0:
|
||
idx_values.insert(
|
||
ins_row, tuple(["..."] * len(level_lengths))
|
||
)
|
||
|
||
# GH 14882 - Place ... in correct level
|
||
elif inserted:
|
||
dot_row = list(idx_values[ins_row])
|
||
dot_row[inner_lvl - lnum] = "..."
|
||
idx_values[ins_row] = tuple(dot_row)
|
||
level_lengths[lnum] = rec_new
|
||
|
||
level_lengths[inner_lvl][ins_row] = 1
|
||
for ix_col in fmt_values:
|
||
fmt_values[ix_col].insert(ins_row, "...")
|
||
nrows += 1
|
||
|
||
for i in range(nrows):
|
||
row = []
|
||
tags = {}
|
||
|
||
sparse_offset = 0
|
||
j = 0
|
||
for records, v in zip(level_lengths, idx_values[i]):
|
||
if i in records:
|
||
if records[i] > 1:
|
||
tags[j] = template.format(span=records[i])
|
||
else:
|
||
sparse_offset += 1
|
||
continue
|
||
|
||
j += 1
|
||
row.append(v)
|
||
|
||
row.extend(fmt_values[j][i] for j in range(self.ncols))
|
||
if is_truncated_horizontally:
|
||
row.insert(
|
||
self.row_levels - sparse_offset + self.fmt.tr_col_num, "..."
|
||
)
|
||
self.write_tr(
|
||
row,
|
||
indent,
|
||
self.indent_delta,
|
||
tags=tags,
|
||
nindex_levels=len(levels) - sparse_offset,
|
||
)
|
||
else:
|
||
row = []
|
||
for i in range(len(frame)):
|
||
if is_truncated_vertically and i == (self.fmt.tr_row_num):
|
||
str_sep_row = ["..."] * len(row)
|
||
self.write_tr(
|
||
str_sep_row,
|
||
indent,
|
||
self.indent_delta,
|
||
tags=None,
|
||
nindex_levels=self.row_levels,
|
||
)
|
||
|
||
idx_values = list(
|
||
zip(*frame.index._format_multi(sparsify=False, include_names=False))
|
||
)
|
||
row = []
|
||
row.extend(idx_values[i])
|
||
row.extend(fmt_values[j][i] for j in range(self.ncols))
|
||
if is_truncated_horizontally:
|
||
row.insert(self.row_levels + self.fmt.tr_col_num, "...")
|
||
self.write_tr(
|
||
row,
|
||
indent,
|
||
self.indent_delta,
|
||
tags=None,
|
||
nindex_levels=frame.index.nlevels,
|
||
)
|
||
|
||
|
||
class NotebookFormatter(HTMLFormatter):
|
||
"""
|
||
Internal class for formatting output data in html for display in Jupyter
|
||
Notebooks. This class is intended for functionality specific to
|
||
DataFrame._repr_html_() and DataFrame.to_html(notebook=True)
|
||
"""
|
||
|
||
def _get_formatted_values(self) -> dict[int, list[str]]:
|
||
return {i: self.fmt.format_col(i) for i in range(self.ncols)}
|
||
|
||
def _get_columns_formatted_values(self) -> list[str]:
|
||
# only reached with non-Multi Index
|
||
return self.columns._format_flat(include_name=False)
|
||
|
||
def write_style(self) -> None:
|
||
# We use the "scoped" attribute here so that the desired
|
||
# style properties for the data frame are not then applied
|
||
# throughout the entire notebook.
|
||
template_first = """\
|
||
<style scoped>"""
|
||
template_last = """\
|
||
</style>"""
|
||
template_select = """\
|
||
.dataframe %s {
|
||
%s: %s;
|
||
}"""
|
||
element_props = [
|
||
("tbody tr th:only-of-type", "vertical-align", "middle"),
|
||
("tbody tr th", "vertical-align", "top"),
|
||
]
|
||
if isinstance(self.columns, MultiIndex):
|
||
element_props.append(("thead tr th", "text-align", "left"))
|
||
if self.show_row_idx_names:
|
||
element_props.append(
|
||
("thead tr:last-of-type th", "text-align", "right")
|
||
)
|
||
else:
|
||
element_props.append(("thead th", "text-align", "right"))
|
||
template_mid = "\n\n".join(template_select % t for t in element_props)
|
||
template = dedent(f"{template_first}\n{template_mid}\n{template_last}")
|
||
self.write(template)
|
||
|
||
def render(self) -> list[str]:
|
||
self.write("<div>")
|
||
self.write_style()
|
||
super().render()
|
||
self.write("</div>")
|
||
return self.elements
|