188 lines
7.0 KiB
Python
188 lines
7.0 KiB
Python
from collections import defaultdict
|
|
from itertools import chain
|
|
from operator import itemgetter
|
|
from typing import Dict, Iterable, List, Optional, Tuple
|
|
|
|
from .align import Align, AlignMethod
|
|
from .console import Console, ConsoleOptions, RenderableType, RenderResult
|
|
from .constrain import Constrain
|
|
from .measure import Measurement
|
|
from .padding import Padding, PaddingDimensions
|
|
from .table import Table
|
|
from .text import TextType
|
|
from .jupyter import JupyterMixin
|
|
|
|
|
|
class Columns(JupyterMixin):
|
|
"""Display renderables in neat columns.
|
|
|
|
Args:
|
|
renderables (Iterable[RenderableType]): Any number of Rich renderables (including str).
|
|
width (int, optional): The desired width of the columns, or None to auto detect. Defaults to None.
|
|
padding (PaddingDimensions, optional): Optional padding around cells. Defaults to (0, 1).
|
|
expand (bool, optional): Expand columns to full width. Defaults to False.
|
|
equal (bool, optional): Arrange in to equal sized columns. Defaults to False.
|
|
column_first (bool, optional): Align items from top to bottom (rather than left to right). Defaults to False.
|
|
right_to_left (bool, optional): Start column from right hand side. Defaults to False.
|
|
align (str, optional): Align value ("left", "right", or "center") or None for default. Defaults to None.
|
|
title (TextType, optional): Optional title for Columns.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
renderables: Optional[Iterable[RenderableType]] = None,
|
|
padding: PaddingDimensions = (0, 1),
|
|
*,
|
|
width: Optional[int] = None,
|
|
expand: bool = False,
|
|
equal: bool = False,
|
|
column_first: bool = False,
|
|
right_to_left: bool = False,
|
|
align: Optional[AlignMethod] = None,
|
|
title: Optional[TextType] = None,
|
|
) -> None:
|
|
self.renderables = list(renderables or [])
|
|
self.width = width
|
|
self.padding = padding
|
|
self.expand = expand
|
|
self.equal = equal
|
|
self.column_first = column_first
|
|
self.right_to_left = right_to_left
|
|
self.align: Optional[AlignMethod] = align
|
|
self.title = title
|
|
|
|
def add_renderable(self, renderable: RenderableType) -> None:
|
|
"""Add a renderable to the columns.
|
|
|
|
Args:
|
|
renderable (RenderableType): Any renderable object.
|
|
"""
|
|
self.renderables.append(renderable)
|
|
|
|
def __rich_console__(
|
|
self, console: Console, options: ConsoleOptions
|
|
) -> RenderResult:
|
|
render_str = console.render_str
|
|
renderables = [
|
|
render_str(renderable) if isinstance(renderable, str) else renderable
|
|
for renderable in self.renderables
|
|
]
|
|
if not renderables:
|
|
return
|
|
_top, right, _bottom, left = Padding.unpack(self.padding)
|
|
width_padding = max(left, right)
|
|
max_width = options.max_width
|
|
widths: Dict[int, int] = defaultdict(int)
|
|
column_count = len(renderables)
|
|
|
|
get_measurement = Measurement.get
|
|
renderable_widths = [
|
|
get_measurement(console, options, renderable).maximum
|
|
for renderable in renderables
|
|
]
|
|
if self.equal:
|
|
renderable_widths = [max(renderable_widths)] * len(renderable_widths)
|
|
|
|
def iter_renderables(
|
|
column_count: int,
|
|
) -> Iterable[Tuple[int, Optional[RenderableType]]]:
|
|
item_count = len(renderables)
|
|
if self.column_first:
|
|
width_renderables = list(zip(renderable_widths, renderables))
|
|
|
|
column_lengths: List[int] = [item_count // column_count] * column_count
|
|
for col_no in range(item_count % column_count):
|
|
column_lengths[col_no] += 1
|
|
|
|
row_count = (item_count + column_count - 1) // column_count
|
|
cells = [[-1] * column_count for _ in range(row_count)]
|
|
row = col = 0
|
|
for index in range(item_count):
|
|
cells[row][col] = index
|
|
column_lengths[col] -= 1
|
|
if column_lengths[col]:
|
|
row += 1
|
|
else:
|
|
col += 1
|
|
row = 0
|
|
for index in chain.from_iterable(cells):
|
|
if index == -1:
|
|
break
|
|
yield width_renderables[index]
|
|
else:
|
|
yield from zip(renderable_widths, renderables)
|
|
# Pad odd elements with spaces
|
|
if item_count % column_count:
|
|
for _ in range(column_count - (item_count % column_count)):
|
|
yield 0, None
|
|
|
|
table = Table.grid(padding=self.padding, collapse_padding=True, pad_edge=False)
|
|
table.expand = self.expand
|
|
table.title = self.title
|
|
|
|
if self.width is not None:
|
|
column_count = (max_width) // (self.width + width_padding)
|
|
for _ in range(column_count):
|
|
table.add_column(width=self.width)
|
|
else:
|
|
while column_count > 1:
|
|
widths.clear()
|
|
column_no = 0
|
|
for renderable_width, _ in iter_renderables(column_count):
|
|
widths[column_no] = max(widths[column_no], renderable_width)
|
|
total_width = sum(widths.values()) + width_padding * (
|
|
len(widths) - 1
|
|
)
|
|
if total_width > max_width:
|
|
column_count = len(widths) - 1
|
|
break
|
|
else:
|
|
column_no = (column_no + 1) % column_count
|
|
else:
|
|
break
|
|
|
|
get_renderable = itemgetter(1)
|
|
_renderables = [
|
|
get_renderable(_renderable)
|
|
for _renderable in iter_renderables(column_count)
|
|
]
|
|
if self.equal:
|
|
_renderables = [
|
|
None
|
|
if renderable is None
|
|
else Constrain(renderable, renderable_widths[0])
|
|
for renderable in _renderables
|
|
]
|
|
if self.align:
|
|
align = self.align
|
|
_Align = Align
|
|
_renderables = [
|
|
None if renderable is None else _Align(renderable, align)
|
|
for renderable in _renderables
|
|
]
|
|
|
|
right_to_left = self.right_to_left
|
|
add_row = table.add_row
|
|
for start in range(0, len(_renderables), column_count):
|
|
row = _renderables[start : start + column_count]
|
|
if right_to_left:
|
|
row = row[::-1]
|
|
add_row(*row)
|
|
yield table
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
import os
|
|
|
|
console = Console()
|
|
|
|
files = [f"{i} {s}" for i, s in enumerate(sorted(os.listdir()))]
|
|
columns = Columns(files, padding=(0, 1), expand=False, equal=False)
|
|
console.print(columns)
|
|
console.rule()
|
|
columns.column_first = True
|
|
console.print(columns)
|
|
columns.right_to_left = True
|
|
console.rule()
|
|
console.print(columns)
|