|
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) |
|
|
|
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__": |
|
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) |
|
|
