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

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

@@ -1,309 +0,0 @@
-from .palette import Palette
-
-
-# Taken from https://en.wikipedia.org/wiki/ANSI_escape_code (Windows 10 column)
-WINDOWS_PALETTE = Palette(
-    [
-        (12, 12, 12),
-        (197, 15, 31),
-        (19, 161, 14),
-        (193, 156, 0),
-        (0, 55, 218),
-        (136, 23, 152),
-        (58, 150, 221),
-        (204, 204, 204),
-        (118, 118, 118),
-        (231, 72, 86),
-        (22, 198, 12),
-        (249, 241, 165),
-        (59, 120, 255),
-        (180, 0, 158),
-        (97, 214, 214),
-        (242, 242, 242),
-    ]
-)
-
-# # The standard ansi colors (including bright variants)
-STANDARD_PALETTE = Palette(
-    [
-        (0, 0, 0),
-        (170, 0, 0),
-        (0, 170, 0),
-        (170, 85, 0),
-        (0, 0, 170),
-        (170, 0, 170),
-        (0, 170, 170),
-        (170, 170, 170),
-        (85, 85, 85),
-        (255, 85, 85),
-        (85, 255, 85),
-        (255, 255, 85),
-        (85, 85, 255),
-        (255, 85, 255),
-        (85, 255, 255),
-        (255, 255, 255),
-    ]
-)
-
-
-# The 256 color palette
-EIGHT_BIT_PALETTE = Palette(
-    [
-        (0, 0, 0),
-        (128, 0, 0),
-        (0, 128, 0),
-        (128, 128, 0),
-        (0, 0, 128),
-        (128, 0, 128),
-        (0, 128, 128),
-        (192, 192, 192),
-        (128, 128, 128),
-        (255, 0, 0),
-        (0, 255, 0),
-        (255, 255, 0),
-        (0, 0, 255),
-        (255, 0, 255),
-        (0, 255, 255),
-        (255, 255, 255),
-        (0, 0, 0),
-        (0, 0, 95),
-        (0, 0, 135),
-        (0, 0, 175),
-        (0, 0, 215),
-        (0, 0, 255),
-        (0, 95, 0),
-        (0, 95, 95),
-        (0, 95, 135),
-        (0, 95, 175),
-        (0, 95, 215),
-        (0, 95, 255),
-        (0, 135, 0),
-        (0, 135, 95),
-        (0, 135, 135),
-        (0, 135, 175),
-        (0, 135, 215),
-        (0, 135, 255),
-        (0, 175, 0),
-        (0, 175, 95),
-        (0, 175, 135),
-        (0, 175, 175),
-        (0, 175, 215),
-        (0, 175, 255),
-        (0, 215, 0),
-        (0, 215, 95),
-        (0, 215, 135),
-        (0, 215, 175),
-        (0, 215, 215),
-        (0, 215, 255),
-        (0, 255, 0),
-        (0, 255, 95),
-        (0, 255, 135),
-        (0, 255, 175),
-        (0, 255, 215),
-        (0, 255, 255),
-        (95, 0, 0),
-        (95, 0, 95),
-        (95, 0, 135),
-        (95, 0, 175),
-        (95, 0, 215),
-        (95, 0, 255),
-        (95, 95, 0),
-        (95, 95, 95),
-        (95, 95, 135),
-        (95, 95, 175),
-        (95, 95, 215),
-        (95, 95, 255),
-        (95, 135, 0),
-        (95, 135, 95),
-        (95, 135, 135),
-        (95, 135, 175),
-        (95, 135, 215),
-        (95, 135, 255),
-        (95, 175, 0),
-        (95, 175, 95),
-        (95, 175, 135),
-        (95, 175, 175),
-        (95, 175, 215),
-        (95, 175, 255),
-        (95, 215, 0),
-        (95, 215, 95),
-        (95, 215, 135),
-        (95, 215, 175),
-        (95, 215, 215),
-        (95, 215, 255),
-        (95, 255, 0),
-        (95, 255, 95),
-        (95, 255, 135),
-        (95, 255, 175),
-        (95, 255, 215),
-        (95, 255, 255),
-        (135, 0, 0),
-        (135, 0, 95),
-        (135, 0, 135),
-        (135, 0, 175),
-        (135, 0, 215),
-        (135, 0, 255),
-        (135, 95, 0),
-        (135, 95, 95),
-        (135, 95, 135),
-        (135, 95, 175),
-        (135, 95, 215),
-        (135, 95, 255),
-        (135, 135, 0),
-        (135, 135, 95),
-        (135, 135, 135),
-        (135, 135, 175),
-        (135, 135, 215),
-        (135, 135, 255),
-        (135, 175, 0),
-        (135, 175, 95),
-        (135, 175, 135),
-        (135, 175, 175),
-        (135, 175, 215),
-        (135, 175, 255),
-        (135, 215, 0),
-        (135, 215, 95),
-        (135, 215, 135),
-        (135, 215, 175),
-        (135, 215, 215),
-        (135, 215, 255),
-        (135, 255, 0),
-        (135, 255, 95),
-        (135, 255, 135),
-        (135, 255, 175),
-        (135, 255, 215),
-        (135, 255, 255),
-        (175, 0, 0),
-        (175, 0, 95),
-        (175, 0, 135),
-        (175, 0, 175),
-        (175, 0, 215),
-        (175, 0, 255),
-        (175, 95, 0),
-        (175, 95, 95),
-        (175, 95, 135),
-        (175, 95, 175),
-        (175, 95, 215),
-        (175, 95, 255),
-        (175, 135, 0),
-        (175, 135, 95),
-        (175, 135, 135),
-        (175, 135, 175),
-        (175, 135, 215),
-        (175, 135, 255),
-        (175, 175, 0),
-        (175, 175, 95),
-        (175, 175, 135),
-        (175, 175, 175),
-        (175, 175, 215),
-        (175, 175, 255),
-        (175, 215, 0),
-        (175, 215, 95),
-        (175, 215, 135),
-        (175, 215, 175),
-        (175, 215, 215),
-        (175, 215, 255),
-        (175, 255, 0),
-        (175, 255, 95),
-        (175, 255, 135),
-        (175, 255, 175),
-        (175, 255, 215),
-        (175, 255, 255),
-        (215, 0, 0),
-        (215, 0, 95),
-        (215, 0, 135),
-        (215, 0, 175),
-        (215, 0, 215),
-        (215, 0, 255),
-        (215, 95, 0),
-        (215, 95, 95),
-        (215, 95, 135),
-        (215, 95, 175),
-        (215, 95, 215),
-        (215, 95, 255),
-        (215, 135, 0),
-        (215, 135, 95),
-        (215, 135, 135),
-        (215, 135, 175),
-        (215, 135, 215),
-        (215, 135, 255),
-        (215, 175, 0),
-        (215, 175, 95),
-        (215, 175, 135),
-        (215, 175, 175),
-        (215, 175, 215),
-        (215, 175, 255),
-        (215, 215, 0),
-        (215, 215, 95),
-        (215, 215, 135),
-        (215, 215, 175),
-        (215, 215, 215),
-        (215, 215, 255),
-        (215, 255, 0),
-        (215, 255, 95),
-        (215, 255, 135),
-        (215, 255, 175),
-        (215, 255, 215),
-        (215, 255, 255),
-        (255, 0, 0),
-        (255, 0, 95),
-        (255, 0, 135),
-        (255, 0, 175),
-        (255, 0, 215),
-        (255, 0, 255),
-        (255, 95, 0),
-        (255, 95, 95),
-        (255, 95, 135),
-        (255, 95, 175),
-        (255, 95, 215),
-        (255, 95, 255),
-        (255, 135, 0),
-        (255, 135, 95),
-        (255, 135, 135),
-        (255, 135, 175),
-        (255, 135, 215),
-        (255, 135, 255),
-        (255, 175, 0),
-        (255, 175, 95),
-        (255, 175, 135),
-        (255, 175, 175),
-        (255, 175, 215),
-        (255, 175, 255),
-        (255, 215, 0),
-        (255, 215, 95),
-        (255, 215, 135),
-        (255, 215, 175),
-        (255, 215, 215),
-        (255, 215, 255),
-        (255, 255, 0),
-        (255, 255, 95),
-        (255, 255, 135),
-        (255, 255, 175),
-        (255, 255, 215),
-        (255, 255, 255),
-        (8, 8, 8),
-        (18, 18, 18),
-        (28, 28, 28),
-        (38, 38, 38),
-        (48, 48, 48),
-        (58, 58, 58),
-        (68, 68, 68),
-        (78, 78, 78),
-        (88, 88, 88),
-        (98, 98, 98),
-        (108, 108, 108),
-        (118, 118, 118),
-        (128, 128, 128),
-        (138, 138, 138),
-        (148, 148, 148),
-        (158, 158, 158),
-        (168, 168, 168),
-        (178, 178, 178),
-        (188, 188, 188),
-        (198, 198, 198),
-        (208, 208, 208),
-        (218, 218, 218),
-        (228, 228, 228),
-        (238, 238, 238),
-    ]
-)

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

@@ -1,17 +0,0 @@
-from typing import Optional
-
-
-def pick_bool(*values: Optional[bool]) -> bool:
-    """Pick the first non-none bool or return the last value.
-
-    Args:
-        *values (bool): Any number of boolean or None values.
-
-    Returns:
-        bool: First non-none boolean.
-    """
-    assert values, "1 or more values required"
-    for value in values:
-        if value is not None:
-            return value
-    return bool(value)

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

@@ -1,153 +0,0 @@
-from fractions import Fraction
-from math import ceil
-from typing import cast, List, Optional, Sequence, Protocol
-
-
-class Edge(Protocol):
-    """Any object that defines an edge (such as Layout)."""
-
-    size: Optional[int] = None
-    ratio: int = 1
-    minimum_size: int = 1
-
-
-def ratio_resolve(total: int, edges: Sequence[Edge]) -> List[int]:
-    """Divide total space to satisfy size, ratio, and minimum_size, constraints.
-
-    The returned list of integers should add up to total in most cases, unless it is
-    impossible to satisfy all the constraints. For instance, if there are two edges
-    with a minimum size of 20 each and `total` is 30 then the returned list will be
-    greater than total. In practice, this would mean that a Layout object would
-    clip the rows that would overflow the screen height.
-
-    Args:
-        total (int): Total number of characters.
-        edges (List[Edge]): Edges within total space.
-
-    Returns:
-        List[int]: Number of characters for each edge.
-    """
-    # Size of edge or None for yet to be determined
-    sizes = [(edge.size or None) for edge in edges]
-
-    _Fraction = Fraction
-
-    # While any edges haven't been calculated
-    while None in sizes:
-        # Get flexible edges and index to map these back on to sizes list
-        flexible_edges = [
-            (index, edge)
-            for index, (size, edge) in enumerate(zip(sizes, edges))
-            if size is None
-        ]
-        # Remaining space in total
-        remaining = total - sum(size or 0 for size in sizes)
-        if remaining <= 0:
-            # No room for flexible edges
-            return [
-                ((edge.minimum_size or 1) if size is None else size)
-                for size, edge in zip(sizes, edges)
-            ]
-        # Calculate number of characters in a ratio portion
-        portion = _Fraction(
-            remaining, sum((edge.ratio or 1) for _, edge in flexible_edges)
-        )
-
-        # If any edges will be less than their minimum, replace size with the minimum
-        for index, edge in flexible_edges:
-            if portion * edge.ratio <= edge.minimum_size:
-                sizes[index] = edge.minimum_size
-                # New fixed size will invalidate calculations, so we need to repeat the process
-                break
-        else:
-            # Distribute flexible space and compensate for rounding error
-            # Since edge sizes can only be integers we need to add the remainder
-            # to the following line
-            remainder = _Fraction(0)
-            for index, edge in flexible_edges:
-                size, remainder = divmod(portion * edge.ratio + remainder, 1)
-                sizes[index] = size
-            break
-    # Sizes now contains integers only
-    return cast(List[int], sizes)
-
-
-def ratio_reduce(
-    total: int, ratios: List[int], maximums: List[int], values: List[int]
-) -> List[int]:
-    """Divide an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        maximums (List[int]): List of maximums values for each slot.
-        values (List[int]): List of values
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    ratios = [ratio if _max else 0 for ratio, _max in zip(ratios, maximums)]
-    total_ratio = sum(ratios)
-    if not total_ratio:
-        return values[:]
-    total_remaining = total
-    result: List[int] = []
-    append = result.append
-    for ratio, maximum, value in zip(ratios, maximums, values):
-        if ratio and total_ratio > 0:
-            distributed = min(maximum, round(ratio * total_remaining / total_ratio))
-            append(value - distributed)
-            total_remaining -= distributed
-            total_ratio -= ratio
-        else:
-            append(value)
-    return result
-
-
-def ratio_distribute(
-    total: int, ratios: List[int], minimums: Optional[List[int]] = None
-) -> List[int]:
-    """Distribute an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        minimums (List[int]): List of minimum values for each slot.
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    if minimums:
-        ratios = [ratio if _min else 0 for ratio, _min in zip(ratios, minimums)]
-    total_ratio = sum(ratios)
-    assert total_ratio > 0, "Sum of ratios must be > 0"
-
-    total_remaining = total
-    distributed_total: List[int] = []
-    append = distributed_total.append
-    if minimums is None:
-        _minimums = [0] * len(ratios)
-    else:
-        _minimums = minimums
-    for ratio, minimum in zip(ratios, _minimums):
-        if total_ratio > 0:
-            distributed = max(minimum, ceil(ratio * total_remaining / total_ratio))
-        else:
-            distributed = total_remaining
-        append(distributed)
-        total_ratio -= ratio
-        total_remaining -= distributed
-    return distributed_total
-
-
-if __name__ == "__main__":
-    from dataclasses import dataclass
-
-    @dataclass
-    class E:
-        size: Optional[int] = None
-        ratio: int = 1
-        minimum_size: int = 1
-
-    resolved = ratio_resolve(110, [E(None, 1, 1), E(None, 1, 1), E(None, 1, 1)])
-    print(sum(resolved))