Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
1003 lines
39 KiB
Python
1003 lines
39 KiB
Python
from dataclasses import dataclass, field, replace
|
|
from typing import (
|
|
TYPE_CHECKING,
|
|
Dict,
|
|
Iterable,
|
|
List,
|
|
NamedTuple,
|
|
Optional,
|
|
Sequence,
|
|
Tuple,
|
|
Union,
|
|
)
|
|
|
|
from . import box, errors
|
|
from ._loop import loop_first_last, loop_last
|
|
from ._pick import pick_bool
|
|
from ._ratio import ratio_distribute, ratio_reduce
|
|
from .align import VerticalAlignMethod
|
|
from .jupyter import JupyterMixin
|
|
from .measure import Measurement
|
|
from .padding import Padding, PaddingDimensions
|
|
from .protocol import is_renderable
|
|
from .segment import Segment
|
|
from .style import Style, StyleType
|
|
from .text import Text, TextType
|
|
|
|
if TYPE_CHECKING:
|
|
from .console import (
|
|
Console,
|
|
ConsoleOptions,
|
|
JustifyMethod,
|
|
OverflowMethod,
|
|
RenderableType,
|
|
RenderResult,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class Column:
|
|
"""Defines a column within a ~Table.
|
|
|
|
Args:
|
|
title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.
|
|
caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.
|
|
width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.
|
|
min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.
|
|
box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.
|
|
safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
|
|
padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).
|
|
collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.
|
|
pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.
|
|
expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
|
|
show_header (bool, optional): Show a header row. Defaults to True.
|
|
show_footer (bool, optional): Show a footer row. Defaults to False.
|
|
show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.
|
|
show_lines (bool, optional): Draw lines between every row. Defaults to False.
|
|
leading (bool, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.
|
|
style (Union[str, Style], optional): Default style for the table. Defaults to "none".
|
|
row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.
|
|
header_style (Union[str, Style], optional): Style of the header. Defaults to "table.header".
|
|
footer_style (Union[str, Style], optional): Style of the footer. Defaults to "table.footer".
|
|
border_style (Union[str, Style], optional): Style of the border. Defaults to None.
|
|
title_style (Union[str, Style], optional): Style of the title. Defaults to None.
|
|
caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.
|
|
title_justify (str, optional): Justify method for title. Defaults to "center".
|
|
caption_justify (str, optional): Justify method for caption. Defaults to "center".
|
|
highlight (bool, optional): Highlight cell contents (if str). Defaults to False.
|
|
"""
|
|
|
|
header: "RenderableType" = ""
|
|
"""RenderableType: Renderable for the header (typically a string)"""
|
|
|
|
footer: "RenderableType" = ""
|
|
"""RenderableType: Renderable for the footer (typically a string)"""
|
|
|
|
header_style: StyleType = ""
|
|
"""StyleType: The style of the header."""
|
|
|
|
footer_style: StyleType = ""
|
|
"""StyleType: The style of the footer."""
|
|
|
|
style: StyleType = ""
|
|
"""StyleType: The style of the column."""
|
|
|
|
justify: "JustifyMethod" = "left"
|
|
"""str: How to justify text within the column ("left", "center", "right", or "full")"""
|
|
|
|
vertical: "VerticalAlignMethod" = "top"
|
|
"""str: How to vertically align content ("top", "middle", or "bottom")"""
|
|
|
|
overflow: "OverflowMethod" = "ellipsis"
|
|
"""str: Overflow method."""
|
|
|
|
width: Optional[int] = None
|
|
"""Optional[int]: Width of the column, or ``None`` (default) to auto calculate width."""
|
|
|
|
min_width: Optional[int] = None
|
|
"""Optional[int]: Minimum width of column, or ``None`` for no minimum. Defaults to None."""
|
|
|
|
max_width: Optional[int] = None
|
|
"""Optional[int]: Maximum width of column, or ``None`` for no maximum. Defaults to None."""
|
|
|
|
ratio: Optional[int] = None
|
|
"""Optional[int]: Ratio to use when calculating column width, or ``None`` (default) to adapt to column contents."""
|
|
|
|
no_wrap: bool = False
|
|
"""bool: Prevent wrapping of text within the column. Defaults to ``False``."""
|
|
|
|
_index: int = 0
|
|
"""Index of column."""
|
|
|
|
_cells: List["RenderableType"] = field(default_factory=list)
|
|
|
|
def copy(self) -> "Column":
|
|
"""Return a copy of this Column."""
|
|
return replace(self, _cells=[])
|
|
|
|
@property
|
|
def cells(self) -> Iterable["RenderableType"]:
|
|
"""Get all cells in the column, not including header."""
|
|
yield from self._cells
|
|
|
|
@property
|
|
def flexible(self) -> bool:
|
|
"""Check if this column is flexible."""
|
|
return self.ratio is not None
|
|
|
|
|
|
@dataclass
|
|
class Row:
|
|
"""Information regarding a row."""
|
|
|
|
style: Optional[StyleType] = None
|
|
"""Style to apply to row."""
|
|
|
|
end_section: bool = False
|
|
"""Indicated end of section, which will force a line beneath the row."""
|
|
|
|
|
|
class _Cell(NamedTuple):
|
|
"""A single cell in a table."""
|
|
|
|
style: StyleType
|
|
"""Style to apply to cell."""
|
|
renderable: "RenderableType"
|
|
"""Cell renderable."""
|
|
vertical: VerticalAlignMethod
|
|
"""Cell vertical alignment."""
|
|
|
|
|
|
class Table(JupyterMixin):
|
|
"""A console renderable to draw a table.
|
|
|
|
Args:
|
|
*headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.
|
|
title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.
|
|
caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.
|
|
width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.
|
|
min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.
|
|
box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.
|
|
safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
|
|
padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).
|
|
collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.
|
|
pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.
|
|
expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
|
|
show_header (bool, optional): Show a header row. Defaults to True.
|
|
show_footer (bool, optional): Show a footer row. Defaults to False.
|
|
show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.
|
|
show_lines (bool, optional): Draw lines between every row. Defaults to False.
|
|
leading (bool, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.
|
|
style (Union[str, Style], optional): Default style for the table. Defaults to "none".
|
|
row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.
|
|
header_style (Union[str, Style], optional): Style of the header. Defaults to "table.header".
|
|
footer_style (Union[str, Style], optional): Style of the footer. Defaults to "table.footer".
|
|
border_style (Union[str, Style], optional): Style of the border. Defaults to None.
|
|
title_style (Union[str, Style], optional): Style of the title. Defaults to None.
|
|
caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.
|
|
title_justify (str, optional): Justify method for title. Defaults to "center".
|
|
caption_justify (str, optional): Justify method for caption. Defaults to "center".
|
|
highlight (bool, optional): Highlight cell contents (if str). Defaults to False.
|
|
"""
|
|
|
|
columns: List[Column]
|
|
rows: List[Row]
|
|
|
|
def __init__(
|
|
self,
|
|
*headers: Union[Column, str],
|
|
title: Optional[TextType] = None,
|
|
caption: Optional[TextType] = None,
|
|
width: Optional[int] = None,
|
|
min_width: Optional[int] = None,
|
|
box: Optional[box.Box] = box.HEAVY_HEAD,
|
|
safe_box: Optional[bool] = None,
|
|
padding: PaddingDimensions = (0, 1),
|
|
collapse_padding: bool = False,
|
|
pad_edge: bool = True,
|
|
expand: bool = False,
|
|
show_header: bool = True,
|
|
show_footer: bool = False,
|
|
show_edge: bool = True,
|
|
show_lines: bool = False,
|
|
leading: int = 0,
|
|
style: StyleType = "none",
|
|
row_styles: Optional[Iterable[StyleType]] = None,
|
|
header_style: Optional[StyleType] = "table.header",
|
|
footer_style: Optional[StyleType] = "table.footer",
|
|
border_style: Optional[StyleType] = None,
|
|
title_style: Optional[StyleType] = None,
|
|
caption_style: Optional[StyleType] = None,
|
|
title_justify: "JustifyMethod" = "center",
|
|
caption_justify: "JustifyMethod" = "center",
|
|
highlight: bool = False,
|
|
) -> None:
|
|
|
|
self.columns: List[Column] = []
|
|
self.rows: List[Row] = []
|
|
self.title = title
|
|
self.caption = caption
|
|
self.width = width
|
|
self.min_width = min_width
|
|
self.box = box
|
|
self.safe_box = safe_box
|
|
self._padding = Padding.unpack(padding)
|
|
self.pad_edge = pad_edge
|
|
self._expand = expand
|
|
self.show_header = show_header
|
|
self.show_footer = show_footer
|
|
self.show_edge = show_edge
|
|
self.show_lines = show_lines
|
|
self.leading = leading
|
|
self.collapse_padding = collapse_padding
|
|
self.style = style
|
|
self.header_style = header_style or ""
|
|
self.footer_style = footer_style or ""
|
|
self.border_style = border_style
|
|
self.title_style = title_style
|
|
self.caption_style = caption_style
|
|
self.title_justify: "JustifyMethod" = title_justify
|
|
self.caption_justify: "JustifyMethod" = caption_justify
|
|
self.highlight = highlight
|
|
self.row_styles: Sequence[StyleType] = list(row_styles or [])
|
|
append_column = self.columns.append
|
|
for header in headers:
|
|
if isinstance(header, str):
|
|
self.add_column(header=header)
|
|
else:
|
|
header._index = len(self.columns)
|
|
append_column(header)
|
|
|
|
@classmethod
|
|
def grid(
|
|
cls,
|
|
*headers: Union[Column, str],
|
|
padding: PaddingDimensions = 0,
|
|
collapse_padding: bool = True,
|
|
pad_edge: bool = False,
|
|
expand: bool = False,
|
|
) -> "Table":
|
|
"""Get a table with no lines, headers, or footer.
|
|
|
|
Args:
|
|
*headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.
|
|
padding (PaddingDimensions, optional): Get padding around cells. Defaults to 0.
|
|
collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to True.
|
|
pad_edge (bool, optional): Enable padding around edges of table. Defaults to False.
|
|
expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
|
|
|
|
Returns:
|
|
Table: A table instance.
|
|
"""
|
|
return cls(
|
|
*headers,
|
|
box=None,
|
|
padding=padding,
|
|
collapse_padding=collapse_padding,
|
|
show_header=False,
|
|
show_footer=False,
|
|
show_edge=False,
|
|
pad_edge=pad_edge,
|
|
expand=expand,
|
|
)
|
|
|
|
@property
|
|
def expand(self) -> bool:
|
|
"""Setting a non-None self.width implies expand."""
|
|
return self._expand or self.width is not None
|
|
|
|
@expand.setter
|
|
def expand(self, expand: bool) -> None:
|
|
"""Set expand."""
|
|
self._expand = expand
|
|
|
|
@property
|
|
def _extra_width(self) -> int:
|
|
"""Get extra width to add to cell content."""
|
|
width = 0
|
|
if self.box and self.show_edge:
|
|
width += 2
|
|
if self.box:
|
|
width += len(self.columns) - 1
|
|
return width
|
|
|
|
@property
|
|
def row_count(self) -> int:
|
|
"""Get the current number of rows."""
|
|
return len(self.rows)
|
|
|
|
def get_row_style(self, console: "Console", index: int) -> StyleType:
|
|
"""Get the current row style."""
|
|
style = Style.null()
|
|
if self.row_styles:
|
|
style += console.get_style(self.row_styles[index % len(self.row_styles)])
|
|
row_style = self.rows[index].style
|
|
if row_style is not None:
|
|
style += console.get_style(row_style)
|
|
return style
|
|
|
|
def __rich_measure__(
|
|
self, console: "Console", options: "ConsoleOptions"
|
|
) -> Measurement:
|
|
max_width = options.max_width
|
|
if self.width is not None:
|
|
max_width = self.width
|
|
if max_width < 0:
|
|
return Measurement(0, 0)
|
|
|
|
extra_width = self._extra_width
|
|
max_width = sum(
|
|
self._calculate_column_widths(
|
|
console, options.update_width(max_width - extra_width)
|
|
)
|
|
)
|
|
_measure_column = self._measure_column
|
|
|
|
measurements = [
|
|
_measure_column(console, options.update_width(max_width), column)
|
|
for column in self.columns
|
|
]
|
|
minimum_width = (
|
|
sum(measurement.minimum for measurement in measurements) + extra_width
|
|
)
|
|
maximum_width = (
|
|
sum(measurement.maximum for measurement in measurements) + extra_width
|
|
if (self.width is None)
|
|
else self.width
|
|
)
|
|
measurement = Measurement(minimum_width, maximum_width)
|
|
measurement = measurement.clamp(self.min_width)
|
|
return measurement
|
|
|
|
@property
|
|
def padding(self) -> Tuple[int, int, int, int]:
|
|
"""Get cell padding."""
|
|
return self._padding
|
|
|
|
@padding.setter
|
|
def padding(self, padding: PaddingDimensions) -> "Table":
|
|
"""Set cell padding."""
|
|
self._padding = Padding.unpack(padding)
|
|
return self
|
|
|
|
def add_column(
|
|
self,
|
|
header: "RenderableType" = "",
|
|
footer: "RenderableType" = "",
|
|
*,
|
|
header_style: Optional[StyleType] = None,
|
|
footer_style: Optional[StyleType] = None,
|
|
style: Optional[StyleType] = None,
|
|
justify: "JustifyMethod" = "left",
|
|
vertical: "VerticalAlignMethod" = "top",
|
|
overflow: "OverflowMethod" = "ellipsis",
|
|
width: Optional[int] = None,
|
|
min_width: Optional[int] = None,
|
|
max_width: Optional[int] = None,
|
|
ratio: Optional[int] = None,
|
|
no_wrap: bool = False,
|
|
) -> None:
|
|
"""Add a column to the table.
|
|
|
|
Args:
|
|
header (RenderableType, optional): Text or renderable for the header.
|
|
Defaults to "".
|
|
footer (RenderableType, optional): Text or renderable for the footer.
|
|
Defaults to "".
|
|
header_style (Union[str, Style], optional): Style for the header, or None for default. Defaults to None.
|
|
footer_style (Union[str, Style], optional): Style for the footer, or None for default. Defaults to None.
|
|
style (Union[str, Style], optional): Style for the column cells, or None for default. Defaults to None.
|
|
justify (JustifyMethod, optional): Alignment for cells. Defaults to "left".
|
|
vertical (VerticalAlignMethod, optional): Vertical alignment, one of "top", "middle", or "bottom". Defaults to "top".
|
|
overflow (OverflowMethod): Overflow method: "crop", "fold", "ellipsis". Defaults to "ellipsis".
|
|
width (int, optional): Desired width of column in characters, or None to fit to contents. Defaults to None.
|
|
min_width (Optional[int], optional): Minimum width of column, or ``None`` for no minimum. Defaults to None.
|
|
max_width (Optional[int], optional): Maximum width of column, or ``None`` for no maximum. Defaults to None.
|
|
ratio (int, optional): Flexible ratio for the column (requires ``Table.expand`` or ``Table.width``). Defaults to None.
|
|
no_wrap (bool, optional): Set to ``True`` to disable wrapping of this column.
|
|
"""
|
|
|
|
column = Column(
|
|
_index=len(self.columns),
|
|
header=header,
|
|
footer=footer,
|
|
header_style=header_style or "",
|
|
footer_style=footer_style or "",
|
|
style=style or "",
|
|
justify=justify,
|
|
vertical=vertical,
|
|
overflow=overflow,
|
|
width=width,
|
|
min_width=min_width,
|
|
max_width=max_width,
|
|
ratio=ratio,
|
|
no_wrap=no_wrap,
|
|
)
|
|
self.columns.append(column)
|
|
|
|
def add_row(
|
|
self,
|
|
*renderables: Optional["RenderableType"],
|
|
style: Optional[StyleType] = None,
|
|
end_section: bool = False,
|
|
) -> None:
|
|
"""Add a row of renderables.
|
|
|
|
Args:
|
|
*renderables (None or renderable): Each cell in a row must be a renderable object (including str),
|
|
or ``None`` for a blank cell.
|
|
style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
|
|
end_section (bool, optional): End a section and draw a line. Defaults to False.
|
|
|
|
Raises:
|
|
errors.NotRenderableError: If you add something that can't be rendered.
|
|
"""
|
|
|
|
def add_cell(column: Column, renderable: "RenderableType") -> None:
|
|
column._cells.append(renderable)
|
|
|
|
cell_renderables: List[Optional["RenderableType"]] = list(renderables)
|
|
|
|
columns = self.columns
|
|
if len(cell_renderables) < len(columns):
|
|
cell_renderables = [
|
|
*cell_renderables,
|
|
*[None] * (len(columns) - len(cell_renderables)),
|
|
]
|
|
for index, renderable in enumerate(cell_renderables):
|
|
if index == len(columns):
|
|
column = Column(_index=index)
|
|
for _ in self.rows:
|
|
add_cell(column, Text(""))
|
|
self.columns.append(column)
|
|
else:
|
|
column = columns[index]
|
|
if renderable is None:
|
|
add_cell(column, "")
|
|
elif is_renderable(renderable):
|
|
add_cell(column, renderable)
|
|
else:
|
|
raise errors.NotRenderableError(
|
|
f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
|
|
)
|
|
self.rows.append(Row(style=style, end_section=end_section))
|
|
|
|
def add_section(self) -> None:
|
|
"""Add a new section (draw a line after current row)."""
|
|
|
|
if self.rows:
|
|
self.rows[-1].end_section = True
|
|
|
|
def __rich_console__(
|
|
self, console: "Console", options: "ConsoleOptions"
|
|
) -> "RenderResult":
|
|
|
|
if not self.columns:
|
|
yield Segment("\n")
|
|
return
|
|
|
|
max_width = options.max_width
|
|
if self.width is not None:
|
|
max_width = self.width
|
|
|
|
extra_width = self._extra_width
|
|
widths = self._calculate_column_widths(
|
|
console, options.update_width(max_width - extra_width)
|
|
)
|
|
table_width = sum(widths) + extra_width
|
|
|
|
render_options = options.update(
|
|
width=table_width, highlight=self.highlight, height=None
|
|
)
|
|
|
|
def render_annotation(
|
|
text: TextType, style: StyleType, justify: "JustifyMethod" = "center"
|
|
) -> "RenderResult":
|
|
render_text = (
|
|
console.render_str(text, style=style, highlight=False)
|
|
if isinstance(text, str)
|
|
else text
|
|
)
|
|
return console.render(
|
|
render_text, options=render_options.update(justify=justify)
|
|
)
|
|
|
|
if self.title:
|
|
yield from render_annotation(
|
|
self.title,
|
|
style=Style.pick_first(self.title_style, "table.title"),
|
|
justify=self.title_justify,
|
|
)
|
|
yield from self._render(console, render_options, widths)
|
|
if self.caption:
|
|
yield from render_annotation(
|
|
self.caption,
|
|
style=Style.pick_first(self.caption_style, "table.caption"),
|
|
justify=self.caption_justify,
|
|
)
|
|
|
|
def _calculate_column_widths(
|
|
self, console: "Console", options: "ConsoleOptions"
|
|
) -> List[int]:
|
|
"""Calculate the widths of each column, including padding, not including borders."""
|
|
max_width = options.max_width
|
|
columns = self.columns
|
|
width_ranges = [
|
|
self._measure_column(console, options, column) for column in columns
|
|
]
|
|
widths = [_range.maximum or 1 for _range in width_ranges]
|
|
get_padding_width = self._get_padding_width
|
|
extra_width = self._extra_width
|
|
if self.expand:
|
|
ratios = [col.ratio or 0 for col in columns if col.flexible]
|
|
if any(ratios):
|
|
fixed_widths = [
|
|
0 if column.flexible else _range.maximum
|
|
for _range, column in zip(width_ranges, columns)
|
|
]
|
|
flex_minimum = [
|
|
(column.width or 1) + get_padding_width(column._index)
|
|
for column in columns
|
|
if column.flexible
|
|
]
|
|
flexible_width = max_width - sum(fixed_widths)
|
|
flex_widths = ratio_distribute(flexible_width, ratios, flex_minimum)
|
|
iter_flex_widths = iter(flex_widths)
|
|
for index, column in enumerate(columns):
|
|
if column.flexible:
|
|
widths[index] = fixed_widths[index] + next(iter_flex_widths)
|
|
table_width = sum(widths)
|
|
|
|
if table_width > max_width:
|
|
widths = self._collapse_widths(
|
|
widths,
|
|
[(column.width is None and not column.no_wrap) for column in columns],
|
|
max_width,
|
|
)
|
|
table_width = sum(widths)
|
|
# last resort, reduce columns evenly
|
|
if table_width > max_width:
|
|
excess_width = table_width - max_width
|
|
widths = ratio_reduce(excess_width, [1] * len(widths), widths, widths)
|
|
table_width = sum(widths)
|
|
|
|
width_ranges = [
|
|
self._measure_column(console, options.update_width(width), column)
|
|
for width, column in zip(widths, columns)
|
|
]
|
|
widths = [_range.maximum or 0 for _range in width_ranges]
|
|
|
|
if (table_width < max_width and self.expand) or (
|
|
self.min_width is not None and table_width < (self.min_width - extra_width)
|
|
):
|
|
_max_width = (
|
|
max_width
|
|
if self.min_width is None
|
|
else min(self.min_width - extra_width, max_width)
|
|
)
|
|
pad_widths = ratio_distribute(_max_width - table_width, widths)
|
|
widths = [_width + pad for _width, pad in zip(widths, pad_widths)]
|
|
|
|
return widths
|
|
|
|
@classmethod
|
|
def _collapse_widths(
|
|
cls, widths: List[int], wrapable: List[bool], max_width: int
|
|
) -> List[int]:
|
|
"""Reduce widths so that the total is under max_width.
|
|
|
|
Args:
|
|
widths (List[int]): List of widths.
|
|
wrapable (List[bool]): List of booleans that indicate if a column may shrink.
|
|
max_width (int): Maximum width to reduce to.
|
|
|
|
Returns:
|
|
List[int]: A new list of widths.
|
|
"""
|
|
total_width = sum(widths)
|
|
excess_width = total_width - max_width
|
|
if any(wrapable):
|
|
while total_width and excess_width > 0:
|
|
max_column = max(
|
|
width for width, allow_wrap in zip(widths, wrapable) if allow_wrap
|
|
)
|
|
second_max_column = max(
|
|
width if allow_wrap and width != max_column else 0
|
|
for width, allow_wrap in zip(widths, wrapable)
|
|
)
|
|
column_difference = max_column - second_max_column
|
|
ratios = [
|
|
(1 if (width == max_column and allow_wrap) else 0)
|
|
for width, allow_wrap in zip(widths, wrapable)
|
|
]
|
|
if not any(ratios) or not column_difference:
|
|
break
|
|
max_reduce = [min(excess_width, column_difference)] * len(widths)
|
|
widths = ratio_reduce(excess_width, ratios, max_reduce, widths)
|
|
|
|
total_width = sum(widths)
|
|
excess_width = total_width - max_width
|
|
return widths
|
|
|
|
def _get_cells(
|
|
self, console: "Console", column_index: int, column: Column
|
|
) -> Iterable[_Cell]:
|
|
"""Get all the cells with padding and optional header."""
|
|
|
|
collapse_padding = self.collapse_padding
|
|
pad_edge = self.pad_edge
|
|
padding = self.padding
|
|
any_padding = any(padding)
|
|
|
|
first_column = column_index == 0
|
|
last_column = column_index == len(self.columns) - 1
|
|
|
|
_padding_cache: Dict[Tuple[bool, bool], Tuple[int, int, int, int]] = {}
|
|
|
|
def get_padding(first_row: bool, last_row: bool) -> Tuple[int, int, int, int]:
|
|
cached = _padding_cache.get((first_row, last_row))
|
|
if cached:
|
|
return cached
|
|
top, right, bottom, left = padding
|
|
|
|
if collapse_padding:
|
|
if not first_column:
|
|
left = max(0, left - right)
|
|
if not last_row:
|
|
bottom = max(0, top - bottom)
|
|
|
|
if not pad_edge:
|
|
if first_column:
|
|
left = 0
|
|
if last_column:
|
|
right = 0
|
|
if first_row:
|
|
top = 0
|
|
if last_row:
|
|
bottom = 0
|
|
_padding = (top, right, bottom, left)
|
|
_padding_cache[(first_row, last_row)] = _padding
|
|
return _padding
|
|
|
|
raw_cells: List[Tuple[StyleType, "RenderableType"]] = []
|
|
_append = raw_cells.append
|
|
get_style = console.get_style
|
|
if self.show_header:
|
|
header_style = get_style(self.header_style or "") + get_style(
|
|
column.header_style
|
|
)
|
|
_append((header_style, column.header))
|
|
cell_style = get_style(column.style or "")
|
|
for cell in column.cells:
|
|
_append((cell_style, cell))
|
|
if self.show_footer:
|
|
footer_style = get_style(self.footer_style or "") + get_style(
|
|
column.footer_style
|
|
)
|
|
_append((footer_style, column.footer))
|
|
|
|
if any_padding:
|
|
_Padding = Padding
|
|
for first, last, (style, renderable) in loop_first_last(raw_cells):
|
|
yield _Cell(
|
|
style,
|
|
_Padding(renderable, get_padding(first, last)),
|
|
getattr(renderable, "vertical", None) or column.vertical,
|
|
)
|
|
else:
|
|
for (style, renderable) in raw_cells:
|
|
yield _Cell(
|
|
style,
|
|
renderable,
|
|
getattr(renderable, "vertical", None) or column.vertical,
|
|
)
|
|
|
|
def _get_padding_width(self, column_index: int) -> int:
|
|
"""Get extra width from padding."""
|
|
_, pad_right, _, pad_left = self.padding
|
|
if self.collapse_padding:
|
|
if column_index > 0:
|
|
pad_left = max(0, pad_left - pad_right)
|
|
return pad_left + pad_right
|
|
|
|
def _measure_column(
|
|
self,
|
|
console: "Console",
|
|
options: "ConsoleOptions",
|
|
column: Column,
|
|
) -> Measurement:
|
|
"""Get the minimum and maximum width of the column."""
|
|
|
|
max_width = options.max_width
|
|
if max_width < 1:
|
|
return Measurement(0, 0)
|
|
|
|
padding_width = self._get_padding_width(column._index)
|
|
|
|
if column.width is not None:
|
|
# Fixed width column
|
|
return Measurement(
|
|
column.width + padding_width, column.width + padding_width
|
|
).with_maximum(max_width)
|
|
# Flexible column, we need to measure contents
|
|
min_widths: List[int] = []
|
|
max_widths: List[int] = []
|
|
append_min = min_widths.append
|
|
append_max = max_widths.append
|
|
get_render_width = Measurement.get
|
|
for cell in self._get_cells(console, column._index, column):
|
|
_min, _max = get_render_width(console, options, cell.renderable)
|
|
append_min(_min)
|
|
append_max(_max)
|
|
|
|
measurement = Measurement(
|
|
max(min_widths) if min_widths else 1,
|
|
max(max_widths) if max_widths else max_width,
|
|
).with_maximum(max_width)
|
|
measurement = measurement.clamp(
|
|
None if column.min_width is None else column.min_width + padding_width,
|
|
None if column.max_width is None else column.max_width + padding_width,
|
|
)
|
|
return measurement
|
|
|
|
def _render(
|
|
self, console: "Console", options: "ConsoleOptions", widths: List[int]
|
|
) -> "RenderResult":
|
|
table_style = console.get_style(self.style or "")
|
|
|
|
border_style = table_style + console.get_style(self.border_style or "")
|
|
_column_cells = (
|
|
self._get_cells(console, column_index, column)
|
|
for column_index, column in enumerate(self.columns)
|
|
)
|
|
row_cells: List[Tuple[_Cell, ...]] = list(zip(*_column_cells))
|
|
_box = (
|
|
self.box.substitute(
|
|
options, safe=pick_bool(self.safe_box, console.safe_box)
|
|
)
|
|
if self.box
|
|
else None
|
|
)
|
|
_box = _box.get_plain_headed_box() if _box and not self.show_header else _box
|
|
|
|
new_line = Segment.line()
|
|
|
|
columns = self.columns
|
|
show_header = self.show_header
|
|
show_footer = self.show_footer
|
|
show_edge = self.show_edge
|
|
show_lines = self.show_lines
|
|
leading = self.leading
|
|
|
|
_Segment = Segment
|
|
if _box:
|
|
box_segments = [
|
|
(
|
|
_Segment(_box.head_left, border_style),
|
|
_Segment(_box.head_right, border_style),
|
|
_Segment(_box.head_vertical, border_style),
|
|
),
|
|
(
|
|
_Segment(_box.foot_left, border_style),
|
|
_Segment(_box.foot_right, border_style),
|
|
_Segment(_box.foot_vertical, border_style),
|
|
),
|
|
(
|
|
_Segment(_box.mid_left, border_style),
|
|
_Segment(_box.mid_right, border_style),
|
|
_Segment(_box.mid_vertical, border_style),
|
|
),
|
|
]
|
|
if show_edge:
|
|
yield _Segment(_box.get_top(widths), border_style)
|
|
yield new_line
|
|
else:
|
|
box_segments = []
|
|
|
|
get_row_style = self.get_row_style
|
|
get_style = console.get_style
|
|
|
|
for index, (first, last, row_cell) in enumerate(loop_first_last(row_cells)):
|
|
header_row = first and show_header
|
|
footer_row = last and show_footer
|
|
row = (
|
|
self.rows[index - show_header]
|
|
if (not header_row and not footer_row)
|
|
else None
|
|
)
|
|
max_height = 1
|
|
cells: List[List[List[Segment]]] = []
|
|
if header_row or footer_row:
|
|
row_style = Style.null()
|
|
else:
|
|
row_style = get_style(
|
|
get_row_style(console, index - 1 if show_header else index)
|
|
)
|
|
for width, cell, column in zip(widths, row_cell, columns):
|
|
render_options = options.update(
|
|
width=width,
|
|
justify=column.justify,
|
|
no_wrap=column.no_wrap,
|
|
overflow=column.overflow,
|
|
height=None,
|
|
)
|
|
lines = console.render_lines(
|
|
cell.renderable,
|
|
render_options,
|
|
style=get_style(cell.style) + row_style,
|
|
)
|
|
max_height = max(max_height, len(lines))
|
|
cells.append(lines)
|
|
|
|
row_height = max(len(cell) for cell in cells)
|
|
|
|
def align_cell(
|
|
cell: List[List[Segment]],
|
|
vertical: "VerticalAlignMethod",
|
|
width: int,
|
|
style: Style,
|
|
) -> List[List[Segment]]:
|
|
if header_row:
|
|
vertical = "bottom"
|
|
elif footer_row:
|
|
vertical = "top"
|
|
|
|
if vertical == "top":
|
|
return _Segment.align_top(cell, width, row_height, style)
|
|
elif vertical == "middle":
|
|
return _Segment.align_middle(cell, width, row_height, style)
|
|
return _Segment.align_bottom(cell, width, row_height, style)
|
|
|
|
cells[:] = [
|
|
_Segment.set_shape(
|
|
align_cell(
|
|
cell,
|
|
_cell.vertical,
|
|
width,
|
|
get_style(_cell.style) + row_style,
|
|
),
|
|
width,
|
|
max_height,
|
|
)
|
|
for width, _cell, cell, column in zip(widths, row_cell, cells, columns)
|
|
]
|
|
|
|
if _box:
|
|
if last and show_footer:
|
|
yield _Segment(
|
|
_box.get_row(widths, "foot", edge=show_edge), border_style
|
|
)
|
|
yield new_line
|
|
left, right, _divider = box_segments[0 if first else (2 if last else 1)]
|
|
|
|
# If the column divider is whitespace also style it with the row background
|
|
divider = (
|
|
_divider
|
|
if _divider.text.strip()
|
|
else _Segment(
|
|
_divider.text, row_style.background_style + _divider.style
|
|
)
|
|
)
|
|
for line_no in range(max_height):
|
|
if show_edge:
|
|
yield left
|
|
for last_cell, rendered_cell in loop_last(cells):
|
|
yield from rendered_cell[line_no]
|
|
if not last_cell:
|
|
yield divider
|
|
if show_edge:
|
|
yield right
|
|
yield new_line
|
|
else:
|
|
for line_no in range(max_height):
|
|
for rendered_cell in cells:
|
|
yield from rendered_cell[line_no]
|
|
yield new_line
|
|
if _box and first and show_header:
|
|
yield _Segment(
|
|
_box.get_row(widths, "head", edge=show_edge), border_style
|
|
)
|
|
yield new_line
|
|
end_section = row and row.end_section
|
|
if _box and (show_lines or leading or end_section):
|
|
if (
|
|
not last
|
|
and not (show_footer and index >= len(row_cells) - 2)
|
|
and not (show_header and header_row)
|
|
):
|
|
if leading:
|
|
yield _Segment(
|
|
_box.get_row(widths, "mid", edge=show_edge) * leading,
|
|
border_style,
|
|
)
|
|
else:
|
|
yield _Segment(
|
|
_box.get_row(widths, "row", edge=show_edge), border_style
|
|
)
|
|
yield new_line
|
|
|
|
if _box and show_edge:
|
|
yield _Segment(_box.get_bottom(widths), border_style)
|
|
yield new_line
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
from pip._vendor.rich.console import Console
|
|
from pip._vendor.rich.highlighter import ReprHighlighter
|
|
from pip._vendor.rich.table import Table as Table
|
|
|
|
from ._timer import timer
|
|
|
|
with timer("Table render"):
|
|
table = Table(
|
|
title="Star Wars Movies",
|
|
caption="Rich example table",
|
|
caption_justify="right",
|
|
)
|
|
|
|
table.add_column(
|
|
"Released", header_style="bright_cyan", style="cyan", no_wrap=True
|
|
)
|
|
table.add_column("Title", style="magenta")
|
|
table.add_column("Box Office", justify="right", style="green")
|
|
|
|
table.add_row(
|
|
"Dec 20, 2019",
|
|
"Star Wars: The Rise of Skywalker",
|
|
"$952,110,690",
|
|
)
|
|
table.add_row("May 25, 2018", "Solo: A Star Wars Story", "$393,151,347")
|
|
table.add_row(
|
|
"Dec 15, 2017",
|
|
"Star Wars Ep. V111: The Last Jedi",
|
|
"$1,332,539,889",
|
|
style="on black",
|
|
end_section=True,
|
|
)
|
|
table.add_row(
|
|
"Dec 16, 2016",
|
|
"Rogue One: A Star Wars Story",
|
|
"$1,332,439,889",
|
|
)
|
|
|
|
def header(text: str) -> None:
|
|
console.print()
|
|
console.rule(highlight(text))
|
|
console.print()
|
|
|
|
console = Console()
|
|
highlight = ReprHighlighter()
|
|
header("Example Table")
|
|
console.print(table, justify="center")
|
|
|
|
table.expand = True
|
|
header("expand=True")
|
|
console.print(table)
|
|
|
|
table.width = 50
|
|
header("width=50")
|
|
|
|
console.print(table, justify="center")
|
|
|
|
table.width = None
|
|
table.expand = False
|
|
table.row_styles = ["dim", "none"]
|
|
header("row_styles=['dim', 'none']")
|
|
|
|
console.print(table, justify="center")
|
|
|
|
table.width = None
|
|
table.expand = False
|
|
table.row_styles = ["dim", "none"]
|
|
table.leading = 1
|
|
header("leading=1, row_styles=['dim', 'none']")
|
|
console.print(table, justify="center")
|
|
|
|
table.width = None
|
|
table.expand = False
|
|
table.row_styles = ["dim", "none"]
|
|
table.show_lines = True
|
|
table.leading = 0
|
|
header("show_lines=True, row_styles=['dim', 'none']")
|
|
console.print(table, justify="center")
|