0UT1S's

opt/hc_python/lib/python3.12/site-packages/pip/_vendor/rich/

By Order of Mr.0UT1S

N/A

[DIR] __pycache__

N/A

5.95 KB

8.28 KB

_cell_widths.py

9.97 KB

_emoji_codes.py

136.95 KB

_emoji_replace.py

1.04 KB

_export_format.py

2.08 KB

265 bytes

799 bytes

9.43 KB

3.15 KB

1.21 KB

1.36 KB

6.90 KB

423 bytes

5.34 KB

19.45 KB

351 bytes

417 bytes

_win32_console.py

22.22 KB

1.88 KB

_windows_renderer.py

2.72 KB

3.32 KB

890 bytes

10.22 KB

6.76 KB

3.19 KB

10.58 KB

5.01 KB

17.78 KB

color_triplet.py

1.03 KB

6.96 KB

97.81 KB

1.26 KB

5.37 KB

6.47 KB

default_styles.py

7.97 KB

972 bytes

2.44 KB

642 bytes

1.64 KB

2.43 KB

9.36 KB

4.91 KB

3.18 KB

13.68 KB

13.94 KB

3.58 KB

12.17 KB

8.25 KB

5.18 KB

4.79 KB

828 bytes

3.32 KB

10.97 KB

35.54 KB

58.94 KB

progress_bar.py

7.97 KB

12.16 KB

1.36 KB

0 bytes

166 bytes

4.33 KB

4.49 KB

2.78 KB

1.55 KB

24.16 KB

4.26 KB

4.32 KB

26.43 KB

1.23 KB

34.92 KB

39.16 KB

terminal_theme.py

3.29 KB

46.44 KB

3.68 KB

102 bytes

31.05 KB

9.23 KB

import inspect
from functools import partial
from typing import (
    Any,
    Callable,
    Iterable,
    List,
    Optional,
    Tuple,
    Type,
    TypeVar,
    Union,
    overload,
)

T = TypeVar("T")

Result = Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]
RichReprResult = Result

class ReprError(Exception):
    """An error occurred when attempting to build a repr."""

@overload
def auto(cls: Optional[Type[T]]) -> Type[T]:
    ...

@overload
def auto(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:
    ...

def auto(
    cls: Optional[Type[T]] = None, *, angular: Optional[bool] = None
) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
    """Class decorator to create __repr__ from __rich_repr__"""

def do_replace(cls: Type[T], angular: Optional[bool] = None) -> Type[T]:
        def auto_repr(self: T) -> str:
            """Create repr string from __rich_repr__"""
            repr_str: List[str] = []
            append = repr_str.append

angular: bool = getattr(self.__rich_repr__, "angular", False)  # type: ignore[attr-defined]
            for arg in self.__rich_repr__():  # type: ignore[attr-defined]
                if isinstance(arg, tuple):
                    if len(arg) == 1:
                        append(repr(arg[0]))
                    else:
                        key, value, *default = arg
                        if key is None:
                            append(repr(value))
                        else:
                            if default and default[0] == value:
                                continue
                            append(f"{key}={value!r}")
                else:
                    append(repr(arg))
            if angular:
                return f"<{self.__class__.__name__} {' '.join(repr_str)}>"
            else:
                return f"{self.__class__.__name__}({', '.join(repr_str)})"

def auto_rich_repr(self: Type[T]) -> Result:
            """Auto generate __rich_rep__ from signature of __init__"""
            try:
                signature = inspect.signature(self.__init__)
                for name, param in signature.parameters.items():
                    if param.kind == param.POSITIONAL_ONLY:
                        yield getattr(self, name)
                    elif param.kind in (
                        param.POSITIONAL_OR_KEYWORD,
                        param.KEYWORD_ONLY,
                    ):
                        if param.default is param.empty:
                            yield getattr(self, param.name)
                        else:
                            yield param.name, getattr(self, param.name), param.default
            except Exception as error:
                raise ReprError(
                    f"Failed to auto generate __rich_repr__; {error}"
                ) from None

if not hasattr(cls, "__rich_repr__"):
            auto_rich_repr.__doc__ = "Build a rich repr"
            cls.__rich_repr__ = auto_rich_repr  # type: ignore[attr-defined]

auto_repr.__doc__ = "Return repr(self)"
        cls.__repr__ = auto_repr  # type: ignore[assignment]
        if angular is not None:
            cls.__rich_repr__.angular = angular  # type: ignore[attr-defined]
        return cls

if cls is None:
        return partial(do_replace, angular=angular)
    else:
        return do_replace(cls, angular=angular)

@overload
def rich_repr(cls: Optional[Type[T]]) -> Type[T]:
    ...

@overload
def rich_repr(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:
    ...

def rich_repr(
    cls: Optional[Type[T]] = None, *, angular: bool = False
) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
    if cls is None:
        return auto(angular=angular)
    else:
        return auto(cls)

if __name__ == "__main__":

@auto
    class Foo:
        def __rich_repr__(self) -> Result:
            yield "foo"
            yield "bar", {"shopping": ["eggs", "ham", "pineapple"]}
            yield "buy", "hand sanitizer"

foo = Foo()
    from pip._vendor.rich.console import Console

console = Console()

console.rule("Standard repr")
    console.print(foo)

console.print(foo, width=60)
    console.print(foo, width=30)

console.rule("Angular repr")
    Foo.__rich_repr__.angular = True  # type: ignore[attr-defined]

console.print(foo)

console.print(foo, width=60)
    console.print(foo, width=30)