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

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

@@ -1,474 +0,0 @@
-from typing import TYPE_CHECKING, Iterable, List, Literal
-
-
-from ._loop import loop_last
-
-if TYPE_CHECKING:
-    from pip._vendor.rich.console import ConsoleOptions
-
-
-class Box:
-    """Defines characters to render boxes.
-
-    ┌─┬┐ top
-    │ ││ head
-    ├─┼┤ head_row
-    │ ││ mid
-    ├─┼┤ row
-    ├─┼┤ foot_row
-    │ ││ foot
-    └─┴┘ bottom
-
-    Args:
-        box (str): Characters making up box.
-        ascii (bool, optional): True if this box uses ascii characters only. Default is False.
-    """
-
-    def __init__(self, box: str, *, ascii: bool = False) -> None:
-        self._box = box
-        self.ascii = ascii
-        line1, line2, line3, line4, line5, line6, line7, line8 = box.splitlines()
-        # top
-        self.top_left, self.top, self.top_divider, self.top_right = iter(line1)
-        # head
-        self.head_left, _, self.head_vertical, self.head_right = iter(line2)
-        # head_row
-        (
-            self.head_row_left,
-            self.head_row_horizontal,
-            self.head_row_cross,
-            self.head_row_right,
-        ) = iter(line3)
-
-        # mid
-        self.mid_left, _, self.mid_vertical, self.mid_right = iter(line4)
-        # row
-        self.row_left, self.row_horizontal, self.row_cross, self.row_right = iter(line5)
-        # foot_row
-        (
-            self.foot_row_left,
-            self.foot_row_horizontal,
-            self.foot_row_cross,
-            self.foot_row_right,
-        ) = iter(line6)
-        # foot
-        self.foot_left, _, self.foot_vertical, self.foot_right = iter(line7)
-        # bottom
-        self.bottom_left, self.bottom, self.bottom_divider, self.bottom_right = iter(
-            line8
-        )
-
-    def __repr__(self) -> str:
-        return "Box(...)"
-
-    def __str__(self) -> str:
-        return self._box
-
-    def substitute(self, options: "ConsoleOptions", safe: bool = True) -> "Box":
-        """Substitute this box for another if it won't render due to platform issues.
-
-        Args:
-            options (ConsoleOptions): Console options used in rendering.
-            safe (bool, optional): Substitute this for another Box if there are known problems
-                displaying on the platform (currently only relevant on Windows). Default is True.
-
-        Returns:
-            Box: A different Box or the same Box.
-        """
-        box = self
-        if options.legacy_windows and safe:
-            box = LEGACY_WINDOWS_SUBSTITUTIONS.get(box, box)
-        if options.ascii_only and not box.ascii:
-            box = ASCII
-        return box
-
-    def get_plain_headed_box(self) -> "Box":
-        """If this box uses special characters for the borders of the header, then
-        return the equivalent box that does not.
-
-        Returns:
-            Box: The most similar Box that doesn't use header-specific box characters.
-                If the current Box already satisfies this criterion, then it's returned.
-        """
-        return PLAIN_HEADED_SUBSTITUTIONS.get(self, self)
-
-    def get_top(self, widths: Iterable[int]) -> str:
-        """Get the top of a simple box.
-
-        Args:
-            widths (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-
-        parts: List[str] = []
-        append = parts.append
-        append(self.top_left)
-        for last, width in loop_last(widths):
-            append(self.top * width)
-            if not last:
-                append(self.top_divider)
-        append(self.top_right)
-        return "".join(parts)
-
-    def get_row(
-        self,
-        widths: Iterable[int],
-        level: Literal["head", "row", "foot", "mid"] = "row",
-        edge: bool = True,
-    ) -> str:
-        """Get the top of a simple box.
-
-        Args:
-            width (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-        if level == "head":
-            left = self.head_row_left
-            horizontal = self.head_row_horizontal
-            cross = self.head_row_cross
-            right = self.head_row_right
-        elif level == "row":
-            left = self.row_left
-            horizontal = self.row_horizontal
-            cross = self.row_cross
-            right = self.row_right
-        elif level == "mid":
-            left = self.mid_left
-            horizontal = " "
-            cross = self.mid_vertical
-            right = self.mid_right
-        elif level == "foot":
-            left = self.foot_row_left
-            horizontal = self.foot_row_horizontal
-            cross = self.foot_row_cross
-            right = self.foot_row_right
-        else:
-            raise ValueError("level must be 'head', 'row' or 'foot'")
-
-        parts: List[str] = []
-        append = parts.append
-        if edge:
-            append(left)
-        for last, width in loop_last(widths):
-            append(horizontal * width)
-            if not last:
-                append(cross)
-        if edge:
-            append(right)
-        return "".join(parts)
-
-    def get_bottom(self, widths: Iterable[int]) -> str:
-        """Get the bottom of a simple box.
-
-        Args:
-            widths (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-
-        parts: List[str] = []
-        append = parts.append
-        append(self.bottom_left)
-        for last, width in loop_last(widths):
-            append(self.bottom * width)
-            if not last:
-                append(self.bottom_divider)
-        append(self.bottom_right)
-        return "".join(parts)
-
-
-# fmt: off
-ASCII: Box = Box(
-    "+--+\n"
-    "| ||\n"
-    "|-+|\n"
-    "| ||\n"
-    "|-+|\n"
-    "|-+|\n"
-    "| ||\n"
-    "+--+\n",
-    ascii=True,
-)
-
-ASCII2: Box = Box(
-    "+-++\n"
-    "| ||\n"
-    "+-++\n"
-    "| ||\n"
-    "+-++\n"
-    "+-++\n"
-    "| ||\n"
-    "+-++\n",
-    ascii=True,
-)
-
-ASCII_DOUBLE_HEAD: Box = Box(
-    "+-++\n"
-    "| ||\n"
-    "+=++\n"
-    "| ||\n"
-    "+-++\n"
-    "+-++\n"
-    "| ||\n"
-    "+-++\n",
-    ascii=True,
-)
-
-SQUARE: Box = Box(
-    "┌─┬┐\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "└─┴┘\n"
-)
-
-SQUARE_DOUBLE_HEAD: Box = Box(
-    "┌─┬┐\n"
-    "│ ││\n"
-    "╞═╪╡\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "└─┴┘\n"
-)
-
-MINIMAL: Box = Box(
-    "  ╷ \n"
-    "  │ \n"
-    "╶─┼╴\n"
-    "  │ \n"
-    "╶─┼╴\n"
-    "╶─┼╴\n"
-    "  │ \n"
-    "  ╵ \n"
-)
-
-
-MINIMAL_HEAVY_HEAD: Box = Box(
-    "  ╷ \n"
-    "  │ \n"
-    "╺━┿╸\n"
-    "  │ \n"
-    "╶─┼╴\n"
-    "╶─┼╴\n"
-    "  │ \n"
-    "  ╵ \n"
-)
-
-MINIMAL_DOUBLE_HEAD: Box = Box(
-    "  ╷ \n"
-    "  │ \n"
-    " ═╪ \n"
-    "  │ \n"
-    " ─┼ \n"
-    " ─┼ \n"
-    "  │ \n"
-    "  ╵ \n"
-)
-
-
-SIMPLE: Box = Box(
-    "    \n"
-    "    \n"
-    " ── \n"
-    "    \n"
-    "    \n"
-    " ── \n"
-    "    \n"
-    "    \n"
-)
-
-SIMPLE_HEAD: Box = Box(
-    "    \n"
-    "    \n"
-    " ── \n"
-    "    \n"
-    "    \n"
-    "    \n"
-    "    \n"
-    "    \n"
-)
-
-
-SIMPLE_HEAVY: Box = Box(
-    "    \n"
-    "    \n"
-    " ━━ \n"
-    "    \n"
-    "    \n"
-    " ━━ \n"
-    "    \n"
-    "    \n"
-)
-
-
-HORIZONTALS: Box = Box(
-    " ── \n"
-    "    \n"
-    " ── \n"
-    "    \n"
-    " ── \n"
-    " ── \n"
-    "    \n"
-    " ── \n"
-)
-
-ROUNDED: Box = Box(
-    "╭─┬╮\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "╰─┴╯\n"
-)
-
-HEAVY: Box = Box(
-    "┏━┳┓\n"
-    "┃ ┃┃\n"
-    "┣━╋┫\n"
-    "┃ ┃┃\n"
-    "┣━╋┫\n"
-    "┣━╋┫\n"
-    "┃ ┃┃\n"
-    "┗━┻┛\n"
-)
-
-HEAVY_EDGE: Box = Box(
-    "┏━┯┓\n"
-    "┃ │┃\n"
-    "┠─┼┨\n"
-    "┃ │┃\n"
-    "┠─┼┨\n"
-    "┠─┼┨\n"
-    "┃ │┃\n"
-    "┗━┷┛\n"
-)
-
-HEAVY_HEAD: Box = Box(
-    "┏━┳┓\n"
-    "┃ ┃┃\n"
-    "┡━╇┩\n"
-    "│ ││\n"
-    "├─┼┤\n"
-    "├─┼┤\n"
-    "│ ││\n"
-    "└─┴┘\n"
-)
-
-DOUBLE: Box = Box(
-    "╔═╦╗\n"
-    "║ ║║\n"
-    "╠═╬╣\n"
-    "║ ║║\n"
-    "╠═╬╣\n"
-    "╠═╬╣\n"
-    "║ ║║\n"
-    "╚═╩╝\n"
-)
-
-DOUBLE_EDGE: Box = Box(
-    "╔═╤╗\n"
-    "║ │║\n"
-    "╟─┼╢\n"
-    "║ │║\n"
-    "╟─┼╢\n"
-    "╟─┼╢\n"
-    "║ │║\n"
-    "╚═╧╝\n"
-)
-
-MARKDOWN: Box = Box(
-    "    \n"
-    "| ||\n"
-    "|-||\n"
-    "| ||\n"
-    "|-||\n"
-    "|-||\n"
-    "| ||\n"
-    "    \n",
-    ascii=True,
-)
-# fmt: on
-
-# Map Boxes that don't render with raster fonts on to equivalent that do
-LEGACY_WINDOWS_SUBSTITUTIONS = {
-    ROUNDED: SQUARE,
-    MINIMAL_HEAVY_HEAD: MINIMAL,
-    SIMPLE_HEAVY: SIMPLE,
-    HEAVY: SQUARE,
-    HEAVY_EDGE: SQUARE,
-    HEAVY_HEAD: SQUARE,
-}
-
-# Map headed boxes to their headerless equivalents
-PLAIN_HEADED_SUBSTITUTIONS = {
-    HEAVY_HEAD: SQUARE,
-    SQUARE_DOUBLE_HEAD: SQUARE,
-    MINIMAL_DOUBLE_HEAD: MINIMAL,
-    MINIMAL_HEAVY_HEAD: MINIMAL,
-    ASCII_DOUBLE_HEAD: ASCII2,
-}
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich.columns import Columns
-    from pip._vendor.rich.panel import Panel
-
-    from . import box as box
-    from .console import Console
-    from .table import Table
-    from .text import Text
-
-    console = Console(record=True)
-
-    BOXES = [
-        "ASCII",
-        "ASCII2",
-        "ASCII_DOUBLE_HEAD",
-        "SQUARE",
-        "SQUARE_DOUBLE_HEAD",
-        "MINIMAL",
-        "MINIMAL_HEAVY_HEAD",
-        "MINIMAL_DOUBLE_HEAD",
-        "SIMPLE",
-        "SIMPLE_HEAD",
-        "SIMPLE_HEAVY",
-        "HORIZONTALS",
-        "ROUNDED",
-        "HEAVY",
-        "HEAVY_EDGE",
-        "HEAVY_HEAD",
-        "DOUBLE",
-        "DOUBLE_EDGE",
-        "MARKDOWN",
-    ]
-
-    console.print(Panel("[bold green]Box Constants", style="green"), justify="center")
-    console.print()
-
-    columns = Columns(expand=True, padding=2)
-    for box_name in sorted(BOXES):
-        table = Table(
-            show_footer=True, style="dim", border_style="not dim", expand=True
-        )
-        table.add_column("Header 1", "Footer 1")
-        table.add_column("Header 2", "Footer 2")
-        table.add_row("Cell", "Cell")
-        table.add_row("Cell", "Cell")
-        table.box = getattr(box, box_name)
-        table.title = Text(f"box.{box_name}", style="magenta")
-        columns.add_renderable(table)
-    console.print(columns)
-
-    # console.save_svg("box.svg")

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

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-from functools import lru_cache
-from typing import Callable
-
-from ._cell_widths import CELL_WIDTHS
-
-# Ranges of unicode ordinals that produce a 1-cell wide character
-# This is non-exhaustive, but covers most common Western characters
-_SINGLE_CELL_UNICODE_RANGES: list[tuple[int, int]] = [
-    (0x20, 0x7E),  # Latin (excluding non-printable)
-    (0xA0, 0xAC),
-    (0xAE, 0x002FF),
-    (0x00370, 0x00482),  # Greek / Cyrillic
-    (0x02500, 0x025FC),  # Box drawing, box elements, geometric shapes
-    (0x02800, 0x028FF),  # Braille
-]
-
-# A set of characters that are a single cell wide
-_SINGLE_CELLS = frozenset(
-    [
-        character
-        for _start, _end in _SINGLE_CELL_UNICODE_RANGES
-        for character in map(chr, range(_start, _end + 1))
-    ]
-)
-
-# When called with a string this will return True if all
-# characters are single-cell, otherwise False
-_is_single_cell_widths: Callable[[str], bool] = _SINGLE_CELLS.issuperset
-
-
-@lru_cache(4096)
-def cached_cell_len(text: str) -> int:
-    """Get the number of cells required to display text.
-
-    This method always caches, which may use up a lot of memory. It is recommended to use
-    `cell_len` over this method.
-
-    Args:
-        text (str): Text to display.
-
-    Returns:
-        int: Get the number of cells required to display text.
-    """
-    if _is_single_cell_widths(text):
-        return len(text)
-    return sum(map(get_character_cell_size, text))
-
-
-def cell_len(text: str, _cell_len: Callable[[str], int] = cached_cell_len) -> int:
-    """Get the number of cells required to display text.
-
-    Args:
-        text (str): Text to display.
-
-    Returns:
-        int: Get the number of cells required to display text.
-    """
-    if len(text) < 512:
-        return _cell_len(text)
-    if _is_single_cell_widths(text):
-        return len(text)
-    return sum(map(get_character_cell_size, text))
-
-
-@lru_cache(maxsize=4096)
-def get_character_cell_size(character: str) -> int:
-    """Get the cell size of a character.
-
-    Args:
-        character (str): A single character.
-
-    Returns:
-        int: Number of cells (0, 1 or 2) occupied by that character.
-    """
-    codepoint = ord(character)
-    _table = CELL_WIDTHS
-    lower_bound = 0
-    upper_bound = len(_table) - 1
-    index = (lower_bound + upper_bound) // 2
-    while True:
-        start, end, width = _table[index]
-        if codepoint < start:
-            upper_bound = index - 1
-        elif codepoint > end:
-            lower_bound = index + 1
-        else:
-            return 0 if width == -1 else width
-        if upper_bound < lower_bound:
-            break
-        index = (lower_bound + upper_bound) // 2
-    return 1
-
-
-def set_cell_size(text: str, total: int) -> str:
-    """Set the length of a string to fit within given number of cells."""
-
-    if _is_single_cell_widths(text):
-        size = len(text)
-        if size < total:
-            return text + " " * (total - size)
-        return text[:total]
-
-    if total <= 0:
-        return ""
-    cell_size = cell_len(text)
-    if cell_size == total:
-        return text
-    if cell_size < total:
-        return text + " " * (total - cell_size)
-
-    start = 0
-    end = len(text)
-
-    # Binary search until we find the right size
-    while True:
-        pos = (start + end) // 2
-        before = text[: pos + 1]
-        before_len = cell_len(before)
-        if before_len == total + 1 and cell_len(before[-1]) == 2:
-            return before[:-1] + " "
-        if before_len == total:
-            return before
-        if before_len > total:
-            end = pos
-        else:
-            start = pos
-
-
-def chop_cells(
-    text: str,
-    width: int,
-) -> list[str]:
-    """Split text into lines such that each line fits within the available (cell) width.
-
-    Args:
-        text: The text to fold such that it fits in the given width.
-        width: The width available (number of cells).
-
-    Returns:
-        A list of strings such that each string in the list has cell width
-        less than or equal to the available width.
-    """
-    _get_character_cell_size = get_character_cell_size
-    lines: list[list[str]] = [[]]
-
-    append_new_line = lines.append
-    append_to_last_line = lines[-1].append
-
-    total_width = 0
-
-    for character in text:
-        cell_width = _get_character_cell_size(character)
-        char_doesnt_fit = total_width + cell_width > width
-
-        if char_doesnt_fit:
-            append_new_line([character])
-            append_to_last_line = lines[-1].append
-            total_width = cell_width
-        else:
-            append_to_last_line(character)
-            total_width += cell_width
-
-    return ["".join(line) for line in lines]
-
-
-if __name__ == "__main__":  # pragma: no cover
-    print(get_character_cell_size("😽"))
-    for line in chop_cells("""这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。""", 8):
-        print(line)
-    for n in range(80, 1, -1):
-        print(set_cell_size("""这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。""", n) + "|")
-        print("x" * n)