cli-ih 0.6.3.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

venv/Lib/site-packages/pip/_vendor/rich/columns.py

@@ -1,187 +0,0 @@
-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)