@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/pip/_vendor/rich/style.py

@@ -1,785 +0,0 @@
-import sys
-from functools import lru_cache
-from marshal import loads, dumps
-from random import randint
-from typing import Any, cast, Dict, Iterable, List, Optional, Type, Union
-
-from . import errors
-from .color import Color, ColorParseError, ColorSystem, blend_rgb
-from .repr import rich_repr, Result
-from .terminal_theme import DEFAULT_TERMINAL_THEME, TerminalTheme
-
-
-# Style instances and style definitions are often interchangeable
-StyleType = Union[str, "Style"]
-
-
-class _Bit:
-    """A descriptor to get/set a style attribute bit."""
-
-    __slots__ = ["bit"]
-
-    def __init__(self, bit_no: int) -> None:
-        self.bit = 1 << bit_no
-
-    def __get__(self, obj: "Style", objtype: Type["Style"]) -> Optional[bool]:
-        if obj._set_attributes & self.bit:
-            return obj._attributes & self.bit != 0
-        return None
-
-
-@rich_repr
-class Style:
-    """A terminal style.
-
-    A terminal style consists of a color (`color`), a background color (`bgcolor`), and a number of attributes, such
-    as bold, italic etc. The attributes have 3 states: they can either be on
-    (``True``), off (``False``), or not set (``None``).
-
-    Args:
-        color (Union[Color, str], optional): Color of terminal text. Defaults to None.
-        bgcolor (Union[Color, str], optional): Color of terminal background. Defaults to None.
-        bold (bool, optional): Enable bold text. Defaults to None.
-        dim (bool, optional): Enable dim text. Defaults to None.
-        italic (bool, optional): Enable italic text. Defaults to None.
-        underline (bool, optional): Enable underlined text. Defaults to None.
-        blink (bool, optional): Enabled blinking text. Defaults to None.
-        blink2 (bool, optional): Enable fast blinking text. Defaults to None.
-        reverse (bool, optional): Enabled reverse text. Defaults to None.
-        conceal (bool, optional): Enable concealed text. Defaults to None.
-        strike (bool, optional): Enable strikethrough text. Defaults to None.
-        underline2 (bool, optional): Enable doubly underlined text. Defaults to None.
-        frame (bool, optional): Enable framed text. Defaults to None.
-        encircle (bool, optional): Enable encircled text. Defaults to None.
-        overline (bool, optional): Enable overlined text. Defaults to None.
-        link (str, link): Link URL. Defaults to None.
-
-    """
-
-    _color: Optional[Color]
-    _bgcolor: Optional[Color]
-    _attributes: int
-    _set_attributes: int
-    _hash: int
-    _null: bool
-    _meta: Optional[bytes]
-
-    __slots__ = [
-        "_color",
-        "_bgcolor",
-        "_attributes",
-        "_set_attributes",
-        "_link",
-        "_link_id",
-        "_ansi",
-        "_style_definition",
-        "_hash",
-        "_null",
-        "_meta",
-    ]
-
-    # maps bits on to SGR parameter
-    _style_map = {
-        0: "1",
-        1: "2",
-        2: "3",
-        3: "4",
-        4: "5",
-        5: "6",
-        6: "7",
-        7: "8",
-        8: "9",
-        9: "21",
-        10: "51",
-        11: "52",
-        12: "53",
-    }
-
-    STYLE_ATTRIBUTES = {
-        "dim": "dim",
-        "d": "dim",
-        "bold": "bold",
-        "b": "bold",
-        "italic": "italic",
-        "i": "italic",
-        "underline": "underline",
-        "u": "underline",
-        "blink": "blink",
-        "blink2": "blink2",
-        "reverse": "reverse",
-        "r": "reverse",
-        "conceal": "conceal",
-        "c": "conceal",
-        "strike": "strike",
-        "s": "strike",
-        "underline2": "underline2",
-        "uu": "underline2",
-        "frame": "frame",
-        "encircle": "encircle",
-        "overline": "overline",
-        "o": "overline",
-    }
-
-    def __init__(
-        self,
-        *,
-        color: Optional[Union[Color, str]] = None,
-        bgcolor: Optional[Union[Color, str]] = None,
-        bold: Optional[bool] = None,
-        dim: Optional[bool] = None,
-        italic: Optional[bool] = None,
-        underline: Optional[bool] = None,
-        blink: Optional[bool] = None,
-        blink2: Optional[bool] = None,
-        reverse: Optional[bool] = None,
-        conceal: Optional[bool] = None,
-        strike: Optional[bool] = None,
-        underline2: Optional[bool] = None,
-        frame: Optional[bool] = None,
-        encircle: Optional[bool] = None,
-        overline: Optional[bool] = None,
-        link: Optional[str] = None,
-        meta: Optional[Dict[str, Any]] = None,
-    ):
-        self._ansi: Optional[str] = None
-        self._style_definition: Optional[str] = None
-
-        def _make_color(color: Union[Color, str]) -> Color:
-            return color if isinstance(color, Color) else Color.parse(color)
-
-        self._color = None if color is None else _make_color(color)
-        self._bgcolor = None if bgcolor is None else _make_color(bgcolor)
-        self._set_attributes = sum(
-            (
-                bold is not None,
-                dim is not None and 2,
-                italic is not None and 4,
-                underline is not None and 8,
-                blink is not None and 16,
-                blink2 is not None and 32,
-                reverse is not None and 64,
-                conceal is not None and 128,
-                strike is not None and 256,
-                underline2 is not None and 512,
-                frame is not None and 1024,
-                encircle is not None and 2048,
-                overline is not None and 4096,
-            )
-        )
-        self._attributes = (
-            sum(
-                (
-                    bold and 1 or 0,
-                    dim and 2 or 0,
-                    italic and 4 or 0,
-                    underline and 8 or 0,
-                    blink and 16 or 0,
-                    blink2 and 32 or 0,
-                    reverse and 64 or 0,
-                    conceal and 128 or 0,
-                    strike and 256 or 0,
-                    underline2 and 512 or 0,
-                    frame and 1024 or 0,
-                    encircle and 2048 or 0,
-                    overline and 4096 or 0,
-                )
-            )
-            if self._set_attributes
-            else 0
-        )
-
-        self._link = link
-        self._link_id = f"{randint(0, 999999)}" if link else ""
-        self._meta = None if meta is None else dumps(meta)
-        self._hash = hash(
-            (
-                self._color,
-                self._bgcolor,
-                self._attributes,
-                self._set_attributes,
-                link,
-                self._meta,
-            )
-        )
-        self._null = not (self._set_attributes or color or bgcolor or link or meta)
-
-    @classmethod
-    def null(cls) -> "Style":
-        """Create an 'null' style, equivalent to Style(), but more performant."""
-        return NULL_STYLE
-
-    @classmethod
-    def from_color(
-        cls, color: Optional[Color] = None, bgcolor: Optional[Color] = None
-    ) -> "Style":
-        """Create a new style with colors and no attributes.
-
-        Returns:
-            color (Optional[Color]): A (foreground) color, or None for no color. Defaults to None.
-            bgcolor (Optional[Color]): A (background) color, or None for no color. Defaults to None.
-        """
-        style: Style = cls.__new__(Style)
-        style._ansi = None
-        style._style_definition = None
-        style._color = color
-        style._bgcolor = bgcolor
-        style._set_attributes = 0
-        style._attributes = 0
-        style._link = None
-        style._link_id = ""
-        style._meta = None
-        style._hash = hash(
-            (
-                color,
-                bgcolor,
-                None,
-                None,
-                None,
-                None,
-            )
-        )
-        style._null = not (color or bgcolor)
-        return style
-
-    @classmethod
-    def from_meta(cls, meta: Optional[Dict[str, Any]]) -> "Style":
-        """Create a new style with meta data.
-
-        Returns:
-            meta (Optional[Dict[str, Any]]): A dictionary of meta data. Defaults to None.
-        """
-        style: Style = cls.__new__(Style)
-        style._ansi = None
-        style._style_definition = None
-        style._color = None
-        style._bgcolor = None
-        style._set_attributes = 0
-        style._attributes = 0
-        style._link = None
-        style._link_id = ""
-        style._meta = dumps(meta)
-        style._hash = hash(
-            (
-                None,
-                None,
-                None,
-                None,
-                None,
-                style._meta,
-            )
-        )
-        style._null = not (meta)
-        return style
-
-    @classmethod
-    def on(cls, meta: Optional[Dict[str, Any]] = None, **handlers: Any) -> "Style":
-        """Create a blank style with meta information.
-
-        Example:
-            style = Style.on(click=self.on_click)
-
-        Args:
-            meta (Optiona[Dict[str, Any]], optional): An optional dict of meta information.
-            **handlers (Any): Keyword arguments are translated in to handlers.
-
-        Returns:
-            Style: A Style with meta information attached.
-        """
-        meta = {} if meta is None else meta
-        meta.update({f"@{key}": value for key, value in handlers.items()})
-        return cls.from_meta(meta)
-
-    bold = _Bit(0)
-    dim = _Bit(1)
-    italic = _Bit(2)
-    underline = _Bit(3)
-    blink = _Bit(4)
-    blink2 = _Bit(5)
-    reverse = _Bit(6)
-    conceal = _Bit(7)
-    strike = _Bit(8)
-    underline2 = _Bit(9)
-    frame = _Bit(10)
-    encircle = _Bit(11)
-    overline = _Bit(12)
-
-    @property
-    def link_id(self) -> str:
-        """Get a link id, used in ansi code for links."""
-        return self._link_id
-
-    def __str__(self) -> str:
-        """Re-generate style definition from attributes."""
-        if self._style_definition is None:
-            attributes: List[str] = []
-            append = attributes.append
-            bits = self._set_attributes
-            if bits & 0b0000000001111:
-                if bits & 1:
-                    append("bold" if self.bold else "not bold")
-                if bits & (1 << 1):
-                    append("dim" if self.dim else "not dim")
-                if bits & (1 << 2):
-                    append("italic" if self.italic else "not italic")
-                if bits & (1 << 3):
-                    append("underline" if self.underline else "not underline")
-            if bits & 0b0000111110000:
-                if bits & (1 << 4):
-                    append("blink" if self.blink else "not blink")
-                if bits & (1 << 5):
-                    append("blink2" if self.blink2 else "not blink2")
-                if bits & (1 << 6):
-                    append("reverse" if self.reverse else "not reverse")
-                if bits & (1 << 7):
-                    append("conceal" if self.conceal else "not conceal")
-                if bits & (1 << 8):
-                    append("strike" if self.strike else "not strike")
-            if bits & 0b1111000000000:
-                if bits & (1 << 9):
-                    append("underline2" if self.underline2 else "not underline2")
-                if bits & (1 << 10):
-                    append("frame" if self.frame else "not frame")
-                if bits & (1 << 11):
-                    append("encircle" if self.encircle else "not encircle")
-                if bits & (1 << 12):
-                    append("overline" if self.overline else "not overline")
-            if self._color is not None:
-                append(self._color.name)
-            if self._bgcolor is not None:
-                append("on")
-                append(self._bgcolor.name)
-            if self._link:
-                append("link")
-                append(self._link)
-            self._style_definition = " ".join(attributes) or "none"
-        return self._style_definition
-
-    def __bool__(self) -> bool:
-        """A Style is false if it has no attributes, colors, or links."""
-        return not self._null
-
-    def _make_ansi_codes(self, color_system: ColorSystem) -> str:
-        """Generate ANSI codes for this style.
-
-        Args:
-            color_system (ColorSystem): Color system.
-
-        Returns:
-            str: String containing codes.
-        """
-        if self._ansi is None:
-            sgr: List[str] = []
-            append = sgr.append
-            _style_map = self._style_map
-            attributes = self._attributes & self._set_attributes
-            if attributes:
-                if attributes & 1:
-                    append(_style_map[0])
-                if attributes & 2:
-                    append(_style_map[1])
-                if attributes & 4:
-                    append(_style_map[2])
-                if attributes & 8:
-                    append(_style_map[3])
-                if attributes & 0b0000111110000:
-                    for bit in range(4, 9):
-                        if attributes & (1 << bit):
-                            append(_style_map[bit])
-                if attributes & 0b1111000000000:
-                    for bit in range(9, 13):
-                        if attributes & (1 << bit):
-                            append(_style_map[bit])
-            if self._color is not None:
-                sgr.extend(self._color.downgrade(color_system).get_ansi_codes())
-            if self._bgcolor is not None:
-                sgr.extend(
-                    self._bgcolor.downgrade(color_system).get_ansi_codes(
-                        foreground=False
-                    )
-                )
-            self._ansi = ";".join(sgr)
-        return self._ansi
-
-    @classmethod
-    @lru_cache(maxsize=1024)
-    def normalize(cls, style: str) -> str:
-        """Normalize a style definition so that styles with the same effect have the same string
-        representation.
-
-        Args:
-            style (str): A style definition.
-
-        Returns:
-            str: Normal form of style definition.
-        """
-        try:
-            return str(cls.parse(style))
-        except errors.StyleSyntaxError:
-            return style.strip().lower()
-
-    @classmethod
-    def pick_first(cls, *values: Optional[StyleType]) -> StyleType:
-        """Pick first non-None style."""
-        for value in values:
-            if value is not None:
-                return value
-        raise ValueError("expected at least one non-None style")
-
-    def __rich_repr__(self) -> Result:
-        yield "color", self.color, None
-        yield "bgcolor", self.bgcolor, None
-        yield "bold", self.bold, None,
-        yield "dim", self.dim, None,
-        yield "italic", self.italic, None
-        yield "underline", self.underline, None,
-        yield "blink", self.blink, None
-        yield "blink2", self.blink2, None
-        yield "reverse", self.reverse, None
-        yield "conceal", self.conceal, None
-        yield "strike", self.strike, None
-        yield "underline2", self.underline2, None
-        yield "frame", self.frame, None
-        yield "encircle", self.encircle, None
-        yield "link", self.link, None
-        if self._meta:
-            yield "meta", self.meta
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Style):
-            return NotImplemented
-        return (
-            self._color == other._color
-            and self._bgcolor == other._bgcolor
-            and self._set_attributes == other._set_attributes
-            and self._attributes == other._attributes
-            and self._link == other._link
-            and self._meta == other._meta
-        )
-
-    def __hash__(self) -> int:
-        return self._hash
-
-    @property
-    def color(self) -> Optional[Color]:
-        """The foreground color or None if it is not set."""
-        return self._color
-
-    @property
-    def bgcolor(self) -> Optional[Color]:
-        """The background color or None if it is not set."""
-        return self._bgcolor
-
-    @property
-    def link(self) -> Optional[str]:
-        """Link text, if set."""
-        return self._link
-
-    @property
-    def transparent_background(self) -> bool:
-        """Check if the style specified a transparent background."""
-        return self.bgcolor is None or self.bgcolor.is_default
-
-    @property
-    def background_style(self) -> "Style":
-        """A Style with background only."""
-        return Style(bgcolor=self.bgcolor)
-
-    @property
-    def meta(self) -> Dict[str, Any]:
-        """Get meta information (can not be changed after construction)."""
-        return {} if self._meta is None else cast(Dict[str, Any], loads(self._meta))
-
-    @property
-    def without_color(self) -> "Style":
-        """Get a copy of the style with color removed."""
-        if self._null:
-            return NULL_STYLE
-        style: Style = self.__new__(Style)
-        style._ansi = None
-        style._style_definition = None
-        style._color = None
-        style._bgcolor = None
-        style._attributes = self._attributes
-        style._set_attributes = self._set_attributes
-        style._link = self._link
-        style._link_id = f"{randint(0, 999999)}" if self._link else ""
-        style._hash = self._hash
-        style._null = False
-        style._meta = None
-        return style
-
-    @classmethod
-    @lru_cache(maxsize=4096)
-    def parse(cls, style_definition: str) -> "Style":
-        """Parse a style definition.
-
-        Args:
-            style_definition (str): A string containing a style.
-
-        Raises:
-            errors.StyleSyntaxError: If the style definition syntax is invalid.
-
-        Returns:
-            `Style`: A Style instance.
-        """
-        if style_definition.strip() == "none" or not style_definition:
-            return cls.null()
-
-        STYLE_ATTRIBUTES = cls.STYLE_ATTRIBUTES
-        color: Optional[str] = None
-        bgcolor: Optional[str] = None
-        attributes: Dict[str, Optional[Any]] = {}
-        link: Optional[str] = None
-
-        words = iter(style_definition.split())
-        for original_word in words:
-            word = original_word.lower()
-            if word == "on":
-                word = next(words, "")
-                if not word:
-                    raise errors.StyleSyntaxError("color expected after 'on'")
-                try:
-                    Color.parse(word) is None
-                except ColorParseError as error:
-                    raise errors.StyleSyntaxError(
-                        f"unable to parse {word!r} as background color; {error}"
-                    ) from None
-                bgcolor = word
-
-            elif word == "not":
-                word = next(words, "")
-                attribute = STYLE_ATTRIBUTES.get(word)
-                if attribute is None:
-                    raise errors.StyleSyntaxError(
-                        f"expected style attribute after 'not', found {word!r}"
-                    )
-                attributes[attribute] = False
-
-            elif word == "link":
-                word = next(words, "")
-                if not word:
-                    raise errors.StyleSyntaxError("URL expected after 'link'")
-                link = word
-
-            elif word in STYLE_ATTRIBUTES:
-                attributes[STYLE_ATTRIBUTES[word]] = True
-
-            else:
-                try:
-                    Color.parse(word)
-                except ColorParseError as error:
-                    raise errors.StyleSyntaxError(
-                        f"unable to parse {word!r} as color; {error}"
-                    ) from None
-                color = word
-        style = Style(color=color, bgcolor=bgcolor, link=link, **attributes)
-        return style
-
-    @lru_cache(maxsize=1024)
-    def get_html_style(self, theme: Optional[TerminalTheme] = None) -> str:
-        """Get a CSS style rule."""
-        theme = theme or DEFAULT_TERMINAL_THEME
-        css: List[str] = []
-        append = css.append
-
-        color = self.color
-        bgcolor = self.bgcolor
-        if self.reverse:
-            color, bgcolor = bgcolor, color
-        if self.dim:
-            foreground_color = (
-                theme.foreground_color if color is None else color.get_truecolor(theme)
-            )
-            color = Color.from_triplet(
-                blend_rgb(foreground_color, theme.background_color, 0.5)
-            )
-        if color is not None:
-            theme_color = color.get_truecolor(theme)
-            append(f"color: {theme_color.hex}")
-            append(f"text-decoration-color: {theme_color.hex}")
-        if bgcolor is not None:
-            theme_color = bgcolor.get_truecolor(theme, foreground=False)
-            append(f"background-color: {theme_color.hex}")
-        if self.bold:
-            append("font-weight: bold")
-        if self.italic:
-            append("font-style: italic")
-        if self.underline:
-            append("text-decoration: underline")
-        if self.strike:
-            append("text-decoration: line-through")
-        if self.overline:
-            append("text-decoration: overline")
-        return "; ".join(css)
-
-    @classmethod
-    def combine(cls, styles: Iterable["Style"]) -> "Style":
-        """Combine styles and get result.
-
-        Args:
-            styles (Iterable[Style]): Styles to combine.
-
-        Returns:
-            Style: A new style instance.
-        """
-        iter_styles = iter(styles)
-        return sum(iter_styles, next(iter_styles))
-
-    @classmethod
-    def chain(cls, *styles: "Style") -> "Style":
-        """Combine styles from positional argument in to a single style.
-
-        Args:
-            *styles (Iterable[Style]): Styles to combine.
-
-        Returns:
-            Style: A new style instance.
-        """
-        iter_styles = iter(styles)
-        return sum(iter_styles, next(iter_styles))
-
-    def copy(self) -> "Style":
-        """Get a copy of this style.
-
-        Returns:
-            Style: A new Style instance with identical attributes.
-        """
-        if self._null:
-            return NULL_STYLE
-        style: Style = self.__new__(Style)
-        style._ansi = self._ansi
-        style._style_definition = self._style_definition
-        style._color = self._color
-        style._bgcolor = self._bgcolor
-        style._attributes = self._attributes
-        style._set_attributes = self._set_attributes
-        style._link = self._link
-        style._link_id = f"{randint(0, 999999)}" if self._link else ""
-        style._hash = self._hash
-        style._null = False
-        style._meta = self._meta
-        return style
-
-    def update_link(self, link: Optional[str] = None) -> "Style":
-        """Get a copy with a different value for link.
-
-        Args:
-            link (str, optional): New value for link. Defaults to None.
-
-        Returns:
-            Style: A new Style instance.
-        """
-        style: Style = self.__new__(Style)
-        style._ansi = self._ansi
-        style._style_definition = self._style_definition
-        style._color = self._color
-        style._bgcolor = self._bgcolor
-        style._attributes = self._attributes
-        style._set_attributes = self._set_attributes
-        style._link = link
-        style._link_id = f"{randint(0, 999999)}" if link else ""
-        style._hash = self._hash
-        style._null = False
-        style._meta = self._meta
-        return style
-
-    def render(
-        self,
-        text: str = "",
-        *,
-        color_system: Optional[ColorSystem] = ColorSystem.TRUECOLOR,
-        legacy_windows: bool = False,
-    ) -> str:
-        """Render the ANSI codes for the style.
-
-        Args:
-            text (str, optional): A string to style. Defaults to "".
-            color_system (Optional[ColorSystem], optional): Color system to render to. Defaults to ColorSystem.TRUECOLOR.
-
-        Returns:
-            str: A string containing ANSI style codes.
-        """
-        if not text or color_system is None:
-            return text
-        attrs = self._make_ansi_codes(color_system)
-        rendered = f"\x1b[{attrs}m{text}\x1b[0m" if attrs else text
-        if self._link and not legacy_windows:
-            rendered = (
-                f"\x1b]8;id={self._link_id};{self._link}\x1b\\{rendered}\x1b]8;;\x1b\\"
-            )
-        return rendered
-
-    def test(self, text: Optional[str] = None) -> None:
-        """Write text with style directly to terminal.
-
-        This method is for testing purposes only.
-
-        Args:
-            text (Optional[str], optional): Text to style or None for style name.
-
-        """
-        text = text or str(self)
-        sys.stdout.write(f"{self.render(text)}\n")
-
-    def __add__(self, style: Optional["Style"]) -> "Style":
-        if not (isinstance(style, Style) or style is None):
-            return NotImplemented
-        if style is None or style._null:
-            return self
-        if self._null:
-            return style
-        new_style: Style = self.__new__(Style)
-        new_style._ansi = None
-        new_style._style_definition = None
-        new_style._color = style._color or self._color
-        new_style._bgcolor = style._bgcolor or self._bgcolor
-        new_style._attributes = (self._attributes & ~style._set_attributes) | (
-            style._attributes & style._set_attributes
-        )
-        new_style._set_attributes = self._set_attributes | style._set_attributes
-        new_style._link = style._link or self._link
-        new_style._link_id = style._link_id or self._link_id
-        new_style._hash = style._hash
-        new_style._null = self._null or style._null
-        if self._meta and style._meta:
-            new_style._meta = dumps({**self.meta, **style.meta})
-        else:
-            new_style._meta = self._meta or style._meta
-        return new_style
-
-
-NULL_STYLE = Style()
-
-
-class StyleStack:
-    """A stack of styles."""
-
-    __slots__ = ["_stack"]
-
-    def __init__(self, default_style: "Style") -> None:
-        self._stack: List[Style] = [default_style]
-
-    def __repr__(self) -> str:
-        return f"<stylestack {self._stack!r}>"
-
-    @property
-    def current(self) -> Style:
-        """Get the Style at the top of the stack."""
-        return self._stack[-1]
-
-    def push(self, style: Style) -> None:
-        """Push a new style on to the stack.
-
-        Args:
-            style (Style): New style to combine with current style.
-        """
-        self._stack.append(self._stack[-1] + style)
-
-    def pop(self) -> Style:
-        """Pop last style and discard.
-
-        Returns:
-            Style: New current style (also available as stack.current)
-        """
-        self._stack.pop()
-        return self._stack[-1]