morel-theme-pack 0.1.31 → 0.1.321

data/assets/env/lib/python3.10/site-packages/pip/_vendor/rich/padding.py

@@ -1,141 +0,0 @@
-from typing import cast, List, Optional, Tuple, TYPE_CHECKING, Union
-
-if TYPE_CHECKING:
-    from .console import (
-        Console,
-        ConsoleOptions,
-        RenderableType,
-        RenderResult,
-    )
-from .jupyter import JupyterMixin
-from .measure import Measurement
-from .style import Style
-from .segment import Segment
-
-
-PaddingDimensions = Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int, int]]
-
-
-class Padding(JupyterMixin):
-    """Draw space around content.
-
-    Example:
-        >>> print(Padding("Hello", (2, 4), style="on blue"))
-
-    Args:
-        renderable (RenderableType): String or other renderable.
-        pad (Union[int, Tuple[int]]): Padding for top, right, bottom, and left borders.
-            May be specified with 1, 2, or 4 integers (CSS style).
-        style (Union[str, Style], optional): Style for padding characters. Defaults to "none".
-        expand (bool, optional): Expand padding to fit available width. Defaults to True.
-    """
-
-    def __init__(
-        self,
-        renderable: "RenderableType",
-        pad: "PaddingDimensions" = (0, 0, 0, 0),
-        *,
-        style: Union[str, Style] = "none",
-        expand: bool = True,
-    ):
-        self.renderable = renderable
-        self.top, self.right, self.bottom, self.left = self.unpack(pad)
-        self.style = style
-        self.expand = expand
-
-    @classmethod
-    def indent(cls, renderable: "RenderableType", level: int) -> "Padding":
-        """Make padding instance to render an indent.
-
-        Args:
-            renderable (RenderableType): String or other renderable.
-            level (int): Number of characters to indent.
-
-        Returns:
-            Padding: A Padding instance.
-        """
-
-        return Padding(renderable, pad=(0, 0, 0, level), expand=False)
-
-    @staticmethod
-    def unpack(pad: "PaddingDimensions") -> Tuple[int, int, int, int]:
-        """Unpack padding specified in CSS style."""
-        if isinstance(pad, int):
-            return (pad, pad, pad, pad)
-        if len(pad) == 1:
-            _pad = pad[0]
-            return (_pad, _pad, _pad, _pad)
-        if len(pad) == 2:
-            pad_top, pad_right = cast(Tuple[int, int], pad)
-            return (pad_top, pad_right, pad_top, pad_right)
-        if len(pad) == 4:
-            top, right, bottom, left = cast(Tuple[int, int, int, int], pad)
-            return (top, right, bottom, left)
-        raise ValueError(f"1, 2 or 4 integers required for padding; {len(pad)} given")
-
-    def __repr__(self) -> str:
-        return f"Padding({self.renderable!r}, ({self.top},{self.right},{self.bottom},{self.left}))"
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        style = console.get_style(self.style)
-        if self.expand:
-            width = options.max_width
-        else:
-            width = min(
-                Measurement.get(console, options, self.renderable).maximum
-                + self.left
-                + self.right,
-                options.max_width,
-            )
-        render_options = options.update_width(width - self.left - self.right)
-        if render_options.height is not None:
-            render_options = render_options.update_height(
-                height=render_options.height - self.top - self.bottom
-            )
-        lines = console.render_lines(
-            self.renderable, render_options, style=style, pad=True
-        )
-        _Segment = Segment
-
-        left = _Segment(" " * self.left, style) if self.left else None
-        right = (
-            [_Segment(f'{" " * self.right}', style), _Segment.line()]
-            if self.right
-            else [_Segment.line()]
-        )
-        blank_line: Optional[List[Segment]] = None
-        if self.top:
-            blank_line = [_Segment(f'{" " * width}\n', style)]
-            yield from blank_line * self.top
-        if left:
-            for line in lines:
-                yield left
-                yield from line
-                yield from right
-        else:
-            for line in lines:
-                yield from line
-                yield from right
-        if self.bottom:
-            blank_line = blank_line or [_Segment(f'{" " * width}\n', style)]
-            yield from blank_line * self.bottom
-
-    def __rich_measure__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "Measurement":
-        max_width = options.max_width
-        extra_width = self.left + self.right
-        if max_width - extra_width < 1:
-            return Measurement(max_width, max_width)
-        measure_min, measure_max = Measurement.get(console, options, self.renderable)
-        measurement = Measurement(measure_min + extra_width, measure_max + extra_width)
-        measurement = measurement.with_maximum(max_width)
-        return measurement
-
-
-if __name__ == "__main__":  #  pragma: no cover
-    from pip._vendor.rich import print
-
-    print(Padding("Hello, World", (2, 4), style="on blue"))

data/assets/env/lib/python3.10/site-packages/pip/_vendor/rich/pager.py

@@ -1,34 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class Pager(ABC):
-    """Base class for a pager."""
-
-    @abstractmethod
-    def show(self, content: str) -> None:
-        """Show content in pager.
-
-        Args:
-            content (str): Content to be displayed.
-        """
-
-
-class SystemPager(Pager):
-    """Uses the pager installed on the system."""
-
-    def _pager(self, content: str) -> Any:  #  pragma: no cover
-        return __import__("pydoc").pager(content)
-
-    def show(self, content: str) -> None:
-        """Use the same pager used by pydoc."""
-        self._pager(content)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from .__main__ import make_test_card
-    from .console import Console
-
-    console = Console()
-    with console.pager(styles=True):
-        console.print(make_test_card())

data/assets/env/lib/python3.10/site-packages/pip/_vendor/rich/palette.py

@@ -1,100 +0,0 @@
-from math import sqrt
-from functools import lru_cache
-from typing import Sequence, Tuple, TYPE_CHECKING
-
-from .color_triplet import ColorTriplet
-
-if TYPE_CHECKING:
-    from pip._vendor.rich.table import Table
-
-
-class Palette:
-    """A palette of available colors."""
-
-    def __init__(self, colors: Sequence[Tuple[int, int, int]]):
-        self._colors = colors
-
-    def __getitem__(self, number: int) -> ColorTriplet:
-        return ColorTriplet(*self._colors[number])
-
-    def __rich__(self) -> "Table":
-        from pip._vendor.rich.color import Color
-        from pip._vendor.rich.style import Style
-        from pip._vendor.rich.text import Text
-        from pip._vendor.rich.table import Table
-
-        table = Table(
-            "index",
-            "RGB",
-            "Color",
-            title="Palette",
-            caption=f"{len(self._colors)} colors",
-            highlight=True,
-            caption_justify="right",
-        )
-        for index, color in enumerate(self._colors):
-            table.add_row(
-                str(index),
-                repr(color),
-                Text(" " * 16, style=Style(bgcolor=Color.from_rgb(*color))),
-            )
-        return table
-
-    # This is somewhat inefficient and needs caching
-    @lru_cache(maxsize=1024)
-    def match(self, color: Tuple[int, int, int]) -> int:
-        """Find a color from a palette that most closely matches a given color.
-
-        Args:
-            color (Tuple[int, int, int]): RGB components in range 0 > 255.
-
-        Returns:
-            int: Index of closes matching color.
-        """
-        red1, green1, blue1 = color
-        _sqrt = sqrt
-        get_color = self._colors.__getitem__
-
-        def get_color_distance(index: int) -> float:
-            """Get the distance to a color."""
-            red2, green2, blue2 = get_color(index)
-            red_mean = (red1 + red2) // 2
-            red = red1 - red2
-            green = green1 - green2
-            blue = blue1 - blue2
-            return _sqrt(
-                (((512 + red_mean) * red * red) >> 8)
-                + 4 * green * green
-                + (((767 - red_mean) * blue * blue) >> 8)
-            )
-
-        min_index = min(range(len(self._colors)), key=get_color_distance)
-        return min_index
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import colorsys
-    from typing import Iterable
-    from pip._vendor.rich.color import Color
-    from pip._vendor.rich.console import Console, ConsoleOptions
-    from pip._vendor.rich.segment import Segment
-    from pip._vendor.rich.style import Style
-
-    class ColorBox:
-        def __rich_console__(
-            self, console: Console, options: ConsoleOptions
-        ) -> Iterable[Segment]:
-            height = console.size.height - 3
-            for y in range(0, height):
-                for x in range(options.max_width):
-                    h = x / options.max_width
-                    l = y / (height + 1)
-                    r1, g1, b1 = colorsys.hls_to_rgb(h, l, 1.0)
-                    r2, g2, b2 = colorsys.hls_to_rgb(h, l + (1 / height / 2), 1.0)
-                    bgcolor = Color.from_rgb(r1 * 255, g1 * 255, b1 * 255)
-                    color = Color.from_rgb(r2 * 255, g2 * 255, b2 * 255)
-                    yield Segment("▄", Style(color=color, bgcolor=bgcolor))
-                yield Segment.line()
-
-    console = Console()
-    console.print(ColorBox())

data/assets/env/lib/python3.10/site-packages/pip/_vendor/rich/panel.py

@@ -1,251 +0,0 @@
-from typing import TYPE_CHECKING, Optional
-
-from .align import AlignMethod
-from .box import ROUNDED, Box
-from .jupyter import JupyterMixin
-from .measure import Measurement, measure_renderables
-from .padding import Padding, PaddingDimensions
-from .segment import Segment
-from .style import StyleType
-from .text import Text, TextType
-
-if TYPE_CHECKING:
-    from .console import Console, ConsoleOptions, RenderableType, RenderResult
-
-
-class Panel(JupyterMixin):
-    """A console renderable that draws a border around its contents.
-
-    Example:
-        >>> console.print(Panel("Hello, World!"))
-
-    Args:
-        renderable (RenderableType): A console renderable object.
-        box (Box, optional): A Box instance that defines the look of the border (see :ref:`appendix_box`.
-            Defaults to box.ROUNDED.
-        safe_box (bool, optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
-        expand (bool, optional): If True the panel will stretch to fill the console
-            width, otherwise it will be sized to fit the contents. Defaults to True.
-        style (str, optional): The style of the panel (border and contents). Defaults to "none".
-        border_style (str, optional): The style of the border. Defaults to "none".
-        width (Optional[int], optional): Optional width of panel. Defaults to None to auto-detect.
-        height (Optional[int], optional): Optional height of panel. Defaults to None to auto-detect.
-        padding (Optional[PaddingDimensions]): Optional padding around renderable. Defaults to 0.
-        highlight (bool, optional): Enable automatic highlighting of panel title (if str). Defaults to False.
-    """
-
-    def __init__(
-        self,
-        renderable: "RenderableType",
-        box: Box = ROUNDED,
-        *,
-        title: Optional[TextType] = None,
-        title_align: AlignMethod = "center",
-        subtitle: Optional[TextType] = None,
-        subtitle_align: AlignMethod = "center",
-        safe_box: Optional[bool] = None,
-        expand: bool = True,
-        style: StyleType = "none",
-        border_style: StyleType = "none",
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-        padding: PaddingDimensions = (0, 1),
-        highlight: bool = False,
-    ) -> None:
-        self.renderable = renderable
-        self.box = box
-        self.title = title
-        self.title_align: AlignMethod = title_align
-        self.subtitle = subtitle
-        self.subtitle_align = subtitle_align
-        self.safe_box = safe_box
-        self.expand = expand
-        self.style = style
-        self.border_style = border_style
-        self.width = width
-        self.height = height
-        self.padding = padding
-        self.highlight = highlight
-
-    @classmethod
-    def fit(
-        cls,
-        renderable: "RenderableType",
-        box: Box = ROUNDED,
-        *,
-        title: Optional[TextType] = None,
-        title_align: AlignMethod = "center",
-        subtitle: Optional[TextType] = None,
-        subtitle_align: AlignMethod = "center",
-        safe_box: Optional[bool] = None,
-        style: StyleType = "none",
-        border_style: StyleType = "none",
-        width: Optional[int] = None,
-        padding: PaddingDimensions = (0, 1),
-    ) -> "Panel":
-        """An alternative constructor that sets expand=False."""
-        return cls(
-            renderable,
-            box,
-            title=title,
-            title_align=title_align,
-            subtitle=subtitle,
-            subtitle_align=subtitle_align,
-            safe_box=safe_box,
-            style=style,
-            border_style=border_style,
-            width=width,
-            padding=padding,
-            expand=False,
-        )
-
-    @property
-    def _title(self) -> Optional[Text]:
-        if self.title:
-            title_text = (
-                Text.from_markup(self.title)
-                if isinstance(self.title, str)
-                else self.title.copy()
-            )
-            title_text.end = ""
-            title_text.plain = title_text.plain.replace("\n", " ")
-            title_text.no_wrap = True
-            title_text.expand_tabs()
-            title_text.pad(1)
-            return title_text
-        return None
-
-    @property
-    def _subtitle(self) -> Optional[Text]:
-        if self.subtitle:
-            subtitle_text = (
-                Text.from_markup(self.subtitle)
-                if isinstance(self.subtitle, str)
-                else self.subtitle.copy()
-            )
-            subtitle_text.end = ""
-            subtitle_text.plain = subtitle_text.plain.replace("\n", " ")
-            subtitle_text.no_wrap = True
-            subtitle_text.expand_tabs()
-            subtitle_text.pad(1)
-            return subtitle_text
-        return None
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        _padding = Padding.unpack(self.padding)
-        renderable = (
-            Padding(self.renderable, _padding) if any(_padding) else self.renderable
-        )
-        style = console.get_style(self.style)
-        border_style = style + console.get_style(self.border_style)
-        width = (
-            options.max_width
-            if self.width is None
-            else min(options.max_width, self.width)
-        )
-
-        safe_box: bool = console.safe_box if self.safe_box is None else self.safe_box
-        box = self.box.substitute(options, safe=safe_box)
-
-        title_text = self._title
-        if title_text is not None:
-            title_text.style = border_style
-
-        child_width = (
-            width - 2
-            if self.expand
-            else console.measure(
-                renderable, options=options.update_width(width - 2)
-            ).maximum
-        )
-        child_height = self.height or options.height or None
-        if child_height:
-            child_height -= 2
-        if title_text is not None:
-            child_width = min(
-                options.max_width - 2, max(child_width, title_text.cell_len + 2)
-            )
-
-        width = child_width + 2
-        child_options = options.update(
-            width=child_width, height=child_height, highlight=self.highlight
-        )
-        lines = console.render_lines(renderable, child_options, style=style)
-
-        line_start = Segment(box.mid_left, border_style)
-        line_end = Segment(f"{box.mid_right}", border_style)
-        new_line = Segment.line()
-        if title_text is None or width <= 4:
-            yield Segment(box.get_top([width - 2]), border_style)
-        else:
-            title_text.align(self.title_align, width - 4, character=box.top)
-            yield Segment(box.top_left + box.top, border_style)
-            yield from console.render(title_text, child_options.update_width(width - 4))
-            yield Segment(box.top + box.top_right, border_style)
-
-        yield new_line
-        for line in lines:
-            yield line_start
-            yield from line
-            yield line_end
-            yield new_line
-
-        subtitle_text = self._subtitle
-        if subtitle_text is not None:
-            subtitle_text.style = border_style
-
-        if subtitle_text is None or width <= 4:
-            yield Segment(box.get_bottom([width - 2]), border_style)
-        else:
-            subtitle_text.align(self.subtitle_align, width - 4, character=box.bottom)
-            yield Segment(box.bottom_left + box.bottom, border_style)
-            yield from console.render(
-                subtitle_text, child_options.update_width(width - 4)
-            )
-            yield Segment(box.bottom + box.bottom_right, border_style)
-
-        yield new_line
-
-    def __rich_measure__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "Measurement":
-        _title = self._title
-        _, right, _, left = Padding.unpack(self.padding)
-        padding = left + right
-        renderables = [self.renderable, _title] if _title else [self.renderable]
-
-        if self.width is None:
-            width = (
-                measure_renderables(
-                    console,
-                    options.update_width(options.max_width - padding - 2),
-                    renderables,
-                ).maximum
-                + padding
-                + 2
-            )
-        else:
-            width = self.width
-        return Measurement(width, width)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from .console import Console
-
-    c = Console()
-
-    from .box import DOUBLE, ROUNDED
-    from .padding import Padding
-
-    p = Panel(
-        "Hello, World!",
-        title="rich.Panel",
-        style="white on blue",
-        box=DOUBLE,
-        padding=1,
-    )
-
-    c.print()
-    c.print(p)