Path 1: 1 calls (1.0)

Console (1)

ConsoleOptions (1)

Table (1) None (1) 

1def __rich_console__(
2        self, console: Console, options: ConsoleOptions
3    ) -> RenderResult:
4        render_str = console.render_str
5        renderables = [
6            render_str(renderable) if isinstance(renderable, str) else renderable
7            for renderable in self.renderables
8        ]
9        if not renderables:
10            return
11        _top, right, _bottom, left = Padding.unpack(self.padding)
12        width_padding = max(left, right)
13        max_width = options.max_width
14        widths: Dict[int, int] = defaultdict(int)
15        column_count = len(renderables)
16
17        get_measurement = Measurement.get
18        renderable_widths = [
19            get_measurement(console, options, renderable).maximum
20            for renderable in renderables
21        ]
22        if self.equal:
23            renderable_widths = [max(renderable_widths)] * len(renderable_widths)
24
25        def iter_renderables(
26            column_count: int,
27        ) -> Iterable[Tuple[int, Optional[RenderableType]]]:
28            item_count = len(renderables)
29            if self.column_first:
30                width_renderables = list(zip(renderable_widths, renderables))
31
32                column_lengths: List[int] = [item_count // column_count] * column_count
33                for col_no in range(item_count % column_count):
34                    column_lengths[col_no] += 1
35
36                row_count = (item_count + column_count - 1) // column_count
37                cells = [[-1] * column_count for _ in range(row_count)]
38                row = col = 0
39                for index in range(item_count):
40                    cells[row][col] = index
41                    column_lengths[col] -= 1
42                    if column_lengths[col]:
43                        row += 1
44                    else:
45                        col += 1
46                        row = 0
47                for index in chain.from_iterable(cells):
48                    if index == -1:
49                        break
50                    yield width_renderables[index]
51            else:
52                yield from zip(renderable_widths, renderables)
53            # Pad odd elements with spaces
54            if item_count % column_count:
55                for _ in range(column_count - (item_count % column_count)):
56                    yield 0, None
57
58        table = Table.grid(padding=self.padding, collapse_padding=True, pad_edge=False)
59        table.expand = self.expand
60        table.title = self.title
61
62        if self.width is not None:
63            column_count = (max_width) // (self.width + width_padding)
64            for _ in range(column_count):
65                table.add_column(width=self.width)
66        else:
67            while column_count > 1:
68                widths.clear()
69                column_no = 0
70                for renderable_width, _ in iter_renderables(column_count):
71                    widths[column_no] = max(widths[column_no], renderable_width)
72                    total_width = sum(widths.values()) + width_padding * (
73                        len(widths) - 1
74                    )
75                    if total_width > max_width:
76                        column_count = len(widths) - 1
77                        break
78                    else:
79                        column_no = (column_no + 1) % column_count
80                else:
81                    break
82
83        get_renderable = itemgetter(1)
84        _renderables = [
85            get_renderable(_renderable)
86            for _renderable in iter_renderables(column_count)
87        ]
88        if self.equal:
89            _renderables = [
90                None
91                if renderable is None
92                else Constrain(renderable, renderable_widths[0])
93                for renderable in _renderables
94            ]
95        if self.align:
96            align = self.align
97            _Align = Align
98            _renderables = [
99                None if renderable is None else _Align(renderable, align)
100                for renderable in _renderables
101            ]
102
103        right_to_left = self.right_to_left
104        add_row = table.add_row
105        for start in range(0, len(_renderables), column_count):
106            row = _renderables[start : start + column_count]
107            if right_to_left:
108                row = row[::-1]
109            add_row(*row)
110        yield table