morel-theme-pack 0.1.31 → 0.1.321

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

@@ -1,1010 +0,0 @@
-import builtins
-import collections
-import dataclasses
-import inspect
-import os
-import sys
-from array import array
-from collections import Counter, UserDict, UserList, defaultdict, deque
-from dataclasses import dataclass, fields, is_dataclass
-from inspect import isclass
-from itertools import islice
-from types import MappingProxyType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    DefaultDict,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-)
-
-from pip._vendor.rich.repr import RichReprResult
-
-try:
-    import attr as _attr_module
-
-    _has_attrs = True
-except ImportError:  # pragma: no cover
-    _has_attrs = False
-
-from . import get_console
-from ._loop import loop_last
-from ._pick import pick_bool
-from .abc import RichRenderable
-from .cells import cell_len
-from .highlighter import ReprHighlighter
-from .jupyter import JupyterMixin, JupyterRenderable
-from .measure import Measurement
-from .text import Text
-
-if TYPE_CHECKING:
-    from .console import (
-        Console,
-        ConsoleOptions,
-        HighlighterType,
-        JustifyMethod,
-        OverflowMethod,
-        RenderResult,
-    )
-
-
-JUPYTER_CLASSES_TO_NOT_RENDER = {
-    # Matplotlib "Artists" manage their own rendering in a Jupyter notebook, and we should not try to render them too.
-    # "Typically, all [Matplotlib] visible elements in a figure are subclasses of Artist."
-    "matplotlib.artist.Artist",
-}
-
-
-def _is_attr_object(obj: Any) -> bool:
-    """Check if an object was created with attrs module."""
-    return _has_attrs and _attr_module.has(type(obj))
-
-
-def _get_attr_fields(obj: Any) -> Sequence["_attr_module.Attribute[Any]"]:
-    """Get fields for an attrs object."""
-    return _attr_module.fields(type(obj)) if _has_attrs else []
-
-
-def _is_dataclass_repr(obj: object) -> bool:
-    """Check if an instance of a dataclass contains the default repr.
-
-    Args:
-        obj (object): A dataclass instance.
-
-    Returns:
-        bool: True if the default repr is used, False if there is a custom repr.
-    """
-    # Digging in to a lot of internals here
-    # Catching all exceptions in case something is missing on a non CPython implementation
-    try:
-        return obj.__repr__.__code__.co_filename == dataclasses.__file__
-    except Exception:  # pragma: no coverage
-        return False
-
-
-_dummy_namedtuple = collections.namedtuple("_dummy_namedtuple", [])
-
-
-def _has_default_namedtuple_repr(obj: object) -> bool:
-    """Check if an instance of namedtuple contains the default repr
-
-    Args:
-        obj (object): A namedtuple
-
-    Returns:
-        bool: True if the default repr is used, False if there's a custom repr.
-    """
-    obj_file = None
-    try:
-        obj_file = inspect.getfile(obj.__repr__)
-    except (OSError, TypeError):
-        # OSError handles case where object is defined in __main__ scope, e.g. REPL - no filename available.
-        # TypeError trapped defensively, in case of object without filename slips through.
-        pass
-    default_repr_file = inspect.getfile(_dummy_namedtuple.__repr__)
-    return obj_file == default_repr_file
-
-
-def _ipy_display_hook(
-    value: Any,
-    console: Optional["Console"] = None,
-    overflow: "OverflowMethod" = "ignore",
-    crop: bool = False,
-    indent_guides: bool = False,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-    expand_all: bool = False,
-) -> None:
-    # needed here to prevent circular import:
-    from ._inspect import is_object_one_of_types
-    from .console import ConsoleRenderable
-
-    # always skip rich generated jupyter renderables or None values
-    if _safe_isinstance(value, JupyterRenderable) or value is None:
-        return
-
-    console = console or get_console()
-    if console.is_jupyter:
-        # Delegate rendering to IPython if the object (and IPython) supports it
-        #  https://ipython.readthedocs.io/en/stable/config/integrating.html#rich-display
-        ipython_repr_methods = [
-            "_repr_html_",
-            "_repr_markdown_",
-            "_repr_json_",
-            "_repr_latex_",
-            "_repr_jpeg_",
-            "_repr_png_",
-            "_repr_svg_",
-            "_repr_mimebundle_",
-        ]
-        for repr_method in ipython_repr_methods:
-            method = getattr(value, repr_method, None)
-            if inspect.ismethod(method):
-                # Calling the method ourselves isn't ideal. The interface for the `_repr_*_` methods
-                #  specifies that if they return None, then they should not be rendered
-                #  by the notebook.
-                try:
-                    repr_result = method()
-                except Exception:
-                    continue  # If the method raises, treat it as if it doesn't exist, try any others
-                if repr_result is not None:
-                    return  # Delegate rendering to IPython
-
-        # When in a Jupyter notebook let's avoid the display of some specific classes,
-        # as they result in the rendering of useless and noisy lines such as `<Figure size 432x288 with 1 Axes>`.
-        # What does this do?
-        # --> if the class has "matplotlib.artist.Artist" in its hierarchy for example, we don't render it.
-        if is_object_one_of_types(value, JUPYTER_CLASSES_TO_NOT_RENDER):
-            return
-
-    # certain renderables should start on a new line
-    if _safe_isinstance(value, ConsoleRenderable):
-        console.line()
-
-    console.print(
-        value
-        if _safe_isinstance(value, RichRenderable)
-        else Pretty(
-            value,
-            overflow=overflow,
-            indent_guides=indent_guides,
-            max_length=max_length,
-            max_string=max_string,
-            expand_all=expand_all,
-            margin=12,
-        ),
-        crop=crop,
-        new_line_start=True,
-    )
-
-
-def _safe_isinstance(
-    obj: object, class_or_tuple: Union[type, Tuple[type, ...]]
-) -> bool:
-    """isinstance can fail in rare cases, for example types with no __class__"""
-    try:
-        return isinstance(obj, class_or_tuple)
-    except Exception:
-        return False
-
-
-def install(
-    console: Optional["Console"] = None,
-    overflow: "OverflowMethod" = "ignore",
-    crop: bool = False,
-    indent_guides: bool = False,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-    expand_all: bool = False,
-) -> None:
-    """Install automatic pretty printing in the Python REPL.
-
-    Args:
-        console (Console, optional): Console instance or ``None`` to use global console. Defaults to None.
-        overflow (Optional[OverflowMethod], optional): Overflow method. Defaults to "ignore".
-        crop (Optional[bool], optional): Enable cropping of long lines. Defaults to False.
-        indent_guides (bool, optional): Enable indentation guides. Defaults to False.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.
-        expand_all (bool, optional): Expand all containers. Defaults to False.
-        max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.
-    """
-    from pip._vendor.rich import get_console
-
-    console = console or get_console()
-    assert console is not None
-
-    def display_hook(value: Any) -> None:
-        """Replacement sys.displayhook which prettifies objects with Rich."""
-        if value is not None:
-            assert console is not None
-            builtins._ = None  # type: ignore[attr-defined]
-            console.print(
-                value
-                if _safe_isinstance(value, RichRenderable)
-                else Pretty(
-                    value,
-                    overflow=overflow,
-                    indent_guides=indent_guides,
-                    max_length=max_length,
-                    max_string=max_string,
-                    expand_all=expand_all,
-                ),
-                crop=crop,
-            )
-            builtins._ = value  # type: ignore[attr-defined]
-
-    try:  # pragma: no cover
-        ip = get_ipython()  # type: ignore[name-defined]
-        from IPython.core.formatters import BaseFormatter
-
-        class RichFormatter(BaseFormatter):  # type: ignore[misc]
-            pprint: bool = True
-
-            def __call__(self, value: Any) -> Any:
-                if self.pprint:
-                    return _ipy_display_hook(
-                        value,
-                        console=get_console(),
-                        overflow=overflow,
-                        indent_guides=indent_guides,
-                        max_length=max_length,
-                        max_string=max_string,
-                        expand_all=expand_all,
-                    )
-                else:
-                    return repr(value)
-
-        # replace plain text formatter with rich formatter
-        rich_formatter = RichFormatter()
-        ip.display_formatter.formatters["text/plain"] = rich_formatter
-    except Exception:
-        sys.displayhook = display_hook
-
-
-class Pretty(JupyterMixin):
-    """A rich renderable that pretty prints an object.
-
-    Args:
-        _object (Any): An object to pretty print.
-        highlighter (HighlighterType, optional): Highlighter object to apply to result, or None for ReprHighlighter. Defaults to None.
-        indent_size (int, optional): Number of spaces in indent. Defaults to 4.
-        justify (JustifyMethod, optional): Justify method, or None for default. Defaults to None.
-        overflow (OverflowMethod, optional): Overflow method, or None for default. Defaults to None.
-        no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to False.
-        indent_guides (bool, optional): Enable indentation guides. Defaults to False.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.
-        max_depth (int, optional): Maximum depth of nested data structures, or None for no maximum. Defaults to None.
-        expand_all (bool, optional): Expand all containers. Defaults to False.
-        margin (int, optional): Subtrace a margin from width to force containers to expand earlier. Defaults to 0.
-        insert_line (bool, optional): Insert a new line if the output has multiple new lines. Defaults to False.
-    """
-
-    def __init__(
-        self,
-        _object: Any,
-        highlighter: Optional["HighlighterType"] = None,
-        *,
-        indent_size: int = 4,
-        justify: Optional["JustifyMethod"] = None,
-        overflow: Optional["OverflowMethod"] = None,
-        no_wrap: Optional[bool] = False,
-        indent_guides: bool = False,
-        max_length: Optional[int] = None,
-        max_string: Optional[int] = None,
-        max_depth: Optional[int] = None,
-        expand_all: bool = False,
-        margin: int = 0,
-        insert_line: bool = False,
-    ) -> None:
-        self._object = _object
-        self.highlighter = highlighter or ReprHighlighter()
-        self.indent_size = indent_size
-        self.justify: Optional["JustifyMethod"] = justify
-        self.overflow: Optional["OverflowMethod"] = overflow
-        self.no_wrap = no_wrap
-        self.indent_guides = indent_guides
-        self.max_length = max_length
-        self.max_string = max_string
-        self.max_depth = max_depth
-        self.expand_all = expand_all
-        self.margin = margin
-        self.insert_line = insert_line
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        pretty_str = pretty_repr(
-            self._object,
-            max_width=options.max_width - self.margin,
-            indent_size=self.indent_size,
-            max_length=self.max_length,
-            max_string=self.max_string,
-            max_depth=self.max_depth,
-            expand_all=self.expand_all,
-        )
-        pretty_text = Text(
-            pretty_str,
-            justify=self.justify or options.justify,
-            overflow=self.overflow or options.overflow,
-            no_wrap=pick_bool(self.no_wrap, options.no_wrap),
-            style="pretty",
-        )
-        pretty_text = (
-            self.highlighter(pretty_text)
-            if pretty_text
-            else Text(
-                f"{type(self._object)}.__repr__ returned empty string",
-                style="dim italic",
-            )
-        )
-        if self.indent_guides and not options.ascii_only:
-            pretty_text = pretty_text.with_indent_guides(
-                self.indent_size, style="repr.indent"
-            )
-        if self.insert_line and "\n" in pretty_text:
-            yield ""
-        yield pretty_text
-
-    def __rich_measure__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "Measurement":
-        pretty_str = pretty_repr(
-            self._object,
-            max_width=options.max_width,
-            indent_size=self.indent_size,
-            max_length=self.max_length,
-            max_string=self.max_string,
-            expand_all=self.expand_all,
-        )
-        text_width = (
-            max(cell_len(line) for line in pretty_str.splitlines()) if pretty_str else 0
-        )
-        return Measurement(text_width, text_width)
-
-
-def _get_braces_for_defaultdict(_object: DefaultDict[Any, Any]) -> Tuple[str, str, str]:
-    return (
-        f"defaultdict({_object.default_factory!r}, {{",
-        "})",
-        f"defaultdict({_object.default_factory!r}, {{}})",
-    )
-
-
-def _get_braces_for_array(_object: "array[Any]") -> Tuple[str, str, str]:
-    return (f"array({_object.typecode!r}, [", "])", f"array({_object.typecode!r})")
-
-
-_BRACES: Dict[type, Callable[[Any], Tuple[str, str, str]]] = {
-    os._Environ: lambda _object: ("environ({", "})", "environ({})"),
-    array: _get_braces_for_array,
-    defaultdict: _get_braces_for_defaultdict,
-    Counter: lambda _object: ("Counter({", "})", "Counter()"),
-    deque: lambda _object: ("deque([", "])", "deque()"),
-    dict: lambda _object: ("{", "}", "{}"),
-    UserDict: lambda _object: ("{", "}", "{}"),
-    frozenset: lambda _object: ("frozenset({", "})", "frozenset()"),
-    list: lambda _object: ("[", "]", "[]"),
-    UserList: lambda _object: ("[", "]", "[]"),
-    set: lambda _object: ("{", "}", "set()"),
-    tuple: lambda _object: ("(", ")", "()"),
-    MappingProxyType: lambda _object: ("mappingproxy({", "})", "mappingproxy({})"),
-}
-_CONTAINERS = tuple(_BRACES.keys())
-_MAPPING_CONTAINERS = (dict, os._Environ, MappingProxyType, UserDict)
-
-
-def is_expandable(obj: Any) -> bool:
-    """Check if an object may be expanded by pretty print."""
-    return (
-        _safe_isinstance(obj, _CONTAINERS)
-        or (is_dataclass(obj))
-        or (hasattr(obj, "__rich_repr__"))
-        or _is_attr_object(obj)
-    ) and not isclass(obj)
-
-
-@dataclass
-class Node:
-    """A node in a repr tree. May be atomic or a container."""
-
-    key_repr: str = ""
-    value_repr: str = ""
-    open_brace: str = ""
-    close_brace: str = ""
-    empty: str = ""
-    last: bool = False
-    is_tuple: bool = False
-    is_namedtuple: bool = False
-    children: Optional[List["Node"]] = None
-    key_separator = ": "
-    separator: str = ", "
-
-    def iter_tokens(self) -> Iterable[str]:
-        """Generate tokens for this node."""
-        if self.key_repr:
-            yield self.key_repr
-            yield self.key_separator
-        if self.value_repr:
-            yield self.value_repr
-        elif self.children is not None:
-            if self.children:
-                yield self.open_brace
-                if self.is_tuple and not self.is_namedtuple and len(self.children) == 1:
-                    yield from self.children[0].iter_tokens()
-                    yield ","
-                else:
-                    for child in self.children:
-                        yield from child.iter_tokens()
-                        if not child.last:
-                            yield self.separator
-                yield self.close_brace
-            else:
-                yield self.empty
-
-    def check_length(self, start_length: int, max_length: int) -> bool:
-        """Check the length fits within a limit.
-
-        Args:
-            start_length (int): Starting length of the line (indent, prefix, suffix).
-            max_length (int): Maximum length.
-
-        Returns:
-            bool: True if the node can be rendered within max length, otherwise False.
-        """
-        total_length = start_length
-        for token in self.iter_tokens():
-            total_length += cell_len(token)
-            if total_length > max_length:
-                return False
-        return True
-
-    def __str__(self) -> str:
-        repr_text = "".join(self.iter_tokens())
-        return repr_text
-
-    def render(
-        self, max_width: int = 80, indent_size: int = 4, expand_all: bool = False
-    ) -> str:
-        """Render the node to a pretty repr.
-
-        Args:
-            max_width (int, optional): Maximum width of the repr. Defaults to 80.
-            indent_size (int, optional): Size of indents. Defaults to 4.
-            expand_all (bool, optional): Expand all levels. Defaults to False.
-
-        Returns:
-            str: A repr string of the original object.
-        """
-        lines = [_Line(node=self, is_root=True)]
-        line_no = 0
-        while line_no < len(lines):
-            line = lines[line_no]
-            if line.expandable and not line.expanded:
-                if expand_all or not line.check_length(max_width):
-                    lines[line_no : line_no + 1] = line.expand(indent_size)
-            line_no += 1
-
-        repr_str = "\n".join(str(line) for line in lines)
-        return repr_str
-
-
-@dataclass
-class _Line:
-    """A line in repr output."""
-
-    parent: Optional["_Line"] = None
-    is_root: bool = False
-    node: Optional[Node] = None
-    text: str = ""
-    suffix: str = ""
-    whitespace: str = ""
-    expanded: bool = False
-    last: bool = False
-
-    @property
-    def expandable(self) -> bool:
-        """Check if the line may be expanded."""
-        return bool(self.node is not None and self.node.children)
-
-    def check_length(self, max_length: int) -> bool:
-        """Check this line fits within a given number of cells."""
-        start_length = (
-            len(self.whitespace) + cell_len(self.text) + cell_len(self.suffix)
-        )
-        assert self.node is not None
-        return self.node.check_length(start_length, max_length)
-
-    def expand(self, indent_size: int) -> Iterable["_Line"]:
-        """Expand this line by adding children on their own line."""
-        node = self.node
-        assert node is not None
-        whitespace = self.whitespace
-        assert node.children
-        if node.key_repr:
-            new_line = yield _Line(
-                text=f"{node.key_repr}{node.key_separator}{node.open_brace}",
-                whitespace=whitespace,
-            )
-        else:
-            new_line = yield _Line(text=node.open_brace, whitespace=whitespace)
-        child_whitespace = self.whitespace + " " * indent_size
-        tuple_of_one = node.is_tuple and len(node.children) == 1
-        for last, child in loop_last(node.children):
-            separator = "," if tuple_of_one else node.separator
-            line = _Line(
-                parent=new_line,
-                node=child,
-                whitespace=child_whitespace,
-                suffix=separator,
-                last=last and not tuple_of_one,
-            )
-            yield line
-
-        yield _Line(
-            text=node.close_brace,
-            whitespace=whitespace,
-            suffix=self.suffix,
-            last=self.last,
-        )
-
-    def __str__(self) -> str:
-        if self.last:
-            return f"{self.whitespace}{self.text}{self.node or ''}"
-        else:
-            return (
-                f"{self.whitespace}{self.text}{self.node or ''}{self.suffix.rstrip()}"
-            )
-
-
-def _is_namedtuple(obj: Any) -> bool:
-    """Checks if an object is most likely a namedtuple. It is possible
-    to craft an object that passes this check and isn't a namedtuple, but
-    there is only a minuscule chance of this happening unintentionally.
-
-    Args:
-        obj (Any): The object to test
-
-    Returns:
-        bool: True if the object is a namedtuple. False otherwise.
-    """
-    try:
-        fields = getattr(obj, "_fields", None)
-    except Exception:
-        # Being very defensive - if we cannot get the attr then its not a namedtuple
-        return False
-    return isinstance(obj, tuple) and isinstance(fields, tuple)
-
-
-def traverse(
-    _object: Any,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-    max_depth: Optional[int] = None,
-) -> Node:
-    """Traverse object and generate a tree.
-
-    Args:
-        _object (Any): Object to be traversed.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of string before truncating, or None to disable truncating.
-            Defaults to None.
-        max_depth (int, optional): Maximum depth of data structures, or None for no maximum.
-            Defaults to None.
-
-    Returns:
-        Node: The root of a tree structure which can be used to render a pretty repr.
-    """
-
-    def to_repr(obj: Any) -> str:
-        """Get repr string for an object, but catch errors."""
-        if (
-            max_string is not None
-            and _safe_isinstance(obj, (bytes, str))
-            and len(obj) > max_string
-        ):
-            truncated = len(obj) - max_string
-            obj_repr = f"{obj[:max_string]!r}+{truncated}"
-        else:
-            try:
-                obj_repr = repr(obj)
-            except Exception as error:
-                obj_repr = f"<repr-error {str(error)!r}>"
-        return obj_repr
-
-    visited_ids: Set[int] = set()
-    push_visited = visited_ids.add
-    pop_visited = visited_ids.remove
-
-    def _traverse(obj: Any, root: bool = False, depth: int = 0) -> Node:
-        """Walk the object depth first."""
-
-        obj_type = type(obj)
-        py_version = (sys.version_info.major, sys.version_info.minor)
-        children: List[Node]
-        reached_max_depth = max_depth is not None and depth >= max_depth
-
-        def iter_rich_args(rich_args: Any) -> Iterable[Union[Any, Tuple[str, Any]]]:
-            for arg in rich_args:
-                if _safe_isinstance(arg, tuple):
-                    if len(arg) == 3:
-                        key, child, default = arg
-                        if default == child:
-                            continue
-                        yield key, child
-                    elif len(arg) == 2:
-                        key, child = arg
-                        yield key, child
-                    elif len(arg) == 1:
-                        yield arg[0]
-                else:
-                    yield arg
-
-        try:
-            fake_attributes = hasattr(
-                obj, "awehoi234_wdfjwljet234_234wdfoijsdfmmnxpi492"
-            )
-        except Exception:
-            fake_attributes = False
-
-        rich_repr_result: Optional[RichReprResult] = None
-        if not fake_attributes:
-            try:
-                if hasattr(obj, "__rich_repr__") and not isclass(obj):
-                    rich_repr_result = obj.__rich_repr__()
-            except Exception:
-                pass
-
-        if rich_repr_result is not None:
-            angular = getattr(obj.__rich_repr__, "angular", False)
-            args = list(iter_rich_args(rich_repr_result))
-            class_name = obj.__class__.__name__
-
-            if args:
-                children = []
-                append = children.append
-
-                if reached_max_depth:
-                    node = Node(value_repr=f"...")
-                else:
-                    if angular:
-                        node = Node(
-                            open_brace=f"<{class_name} ",
-                            close_brace=">",
-                            children=children,
-                            last=root,
-                            separator=" ",
-                        )
-                    else:
-                        node = Node(
-                            open_brace=f"{class_name}(",
-                            close_brace=")",
-                            children=children,
-                            last=root,
-                        )
-                    for last, arg in loop_last(args):
-                        if _safe_isinstance(arg, tuple):
-                            key, child = arg
-                            child_node = _traverse(child, depth=depth + 1)
-                            child_node.last = last
-                            child_node.key_repr = key
-                            child_node.key_separator = "="
-                            append(child_node)
-                        else:
-                            child_node = _traverse(arg, depth=depth + 1)
-                            child_node.last = last
-                            append(child_node)
-            else:
-                node = Node(
-                    value_repr=f"<{class_name}>" if angular else f"{class_name}()",
-                    children=[],
-                    last=root,
-                )
-        elif _is_attr_object(obj) and not fake_attributes:
-            children = []
-            append = children.append
-
-            attr_fields = _get_attr_fields(obj)
-            if attr_fields:
-                if reached_max_depth:
-                    node = Node(value_repr=f"...")
-                else:
-                    node = Node(
-                        open_brace=f"{obj.__class__.__name__}(",
-                        close_brace=")",
-                        children=children,
-                        last=root,
-                    )
-
-                    def iter_attrs() -> Iterable[
-                        Tuple[str, Any, Optional[Callable[[Any], str]]]
-                    ]:
-                        """Iterate over attr fields and values."""
-                        for attr in attr_fields:
-                            if attr.repr:
-                                try:
-                                    value = getattr(obj, attr.name)
-                                except Exception as error:
-                                    # Can happen, albeit rarely
-                                    yield (attr.name, error, None)
-                                else:
-                                    yield (
-                                        attr.name,
-                                        value,
-                                        attr.repr if callable(attr.repr) else None,
-                                    )
-
-                    for last, (name, value, repr_callable) in loop_last(iter_attrs()):
-                        if repr_callable:
-                            child_node = Node(value_repr=str(repr_callable(value)))
-                        else:
-                            child_node = _traverse(value, depth=depth + 1)
-                        child_node.last = last
-                        child_node.key_repr = name
-                        child_node.key_separator = "="
-                        append(child_node)
-            else:
-                node = Node(
-                    value_repr=f"{obj.__class__.__name__}()", children=[], last=root
-                )
-
-        elif (
-            is_dataclass(obj)
-            and not _safe_isinstance(obj, type)
-            and not fake_attributes
-            and (_is_dataclass_repr(obj) or py_version == (3, 6))
-        ):
-            obj_id = id(obj)
-            if obj_id in visited_ids:
-                # Recursion detected
-                return Node(value_repr="...")
-            push_visited(obj_id)
-
-            children = []
-            append = children.append
-            if reached_max_depth:
-                node = Node(value_repr=f"...")
-            else:
-                node = Node(
-                    open_brace=f"{obj.__class__.__name__}(",
-                    close_brace=")",
-                    children=children,
-                    last=root,
-                )
-
-                for last, field in loop_last(
-                    field for field in fields(obj) if field.repr
-                ):
-                    child_node = _traverse(getattr(obj, field.name), depth=depth + 1)
-                    child_node.key_repr = field.name
-                    child_node.last = last
-                    child_node.key_separator = "="
-                    append(child_node)
-
-                pop_visited(obj_id)
-        elif _is_namedtuple(obj) and _has_default_namedtuple_repr(obj):
-            if reached_max_depth:
-                node = Node(value_repr="...")
-            else:
-                children = []
-                class_name = obj.__class__.__name__
-                node = Node(
-                    open_brace=f"{class_name}(",
-                    close_brace=")",
-                    children=children,
-                    empty=f"{class_name}()",
-                )
-                append = children.append
-                for last, (key, value) in loop_last(obj._asdict().items()):
-                    child_node = _traverse(value, depth=depth + 1)
-                    child_node.key_repr = key
-                    child_node.last = last
-                    child_node.key_separator = "="
-                    append(child_node)
-        elif _safe_isinstance(obj, _CONTAINERS):
-            for container_type in _CONTAINERS:
-                if _safe_isinstance(obj, container_type):
-                    obj_type = container_type
-                    break
-
-            obj_id = id(obj)
-            if obj_id in visited_ids:
-                # Recursion detected
-                return Node(value_repr="...")
-            push_visited(obj_id)
-
-            open_brace, close_brace, empty = _BRACES[obj_type](obj)
-
-            if reached_max_depth:
-                node = Node(value_repr=f"...", last=root)
-            elif obj_type.__repr__ != type(obj).__repr__:
-                node = Node(value_repr=to_repr(obj), last=root)
-            elif obj:
-                children = []
-                node = Node(
-                    open_brace=open_brace,
-                    close_brace=close_brace,
-                    children=children,
-                    last=root,
-                )
-                append = children.append
-                num_items = len(obj)
-                last_item_index = num_items - 1
-
-                if _safe_isinstance(obj, _MAPPING_CONTAINERS):
-                    iter_items = iter(obj.items())
-                    if max_length is not None:
-                        iter_items = islice(iter_items, max_length)
-                    for index, (key, child) in enumerate(iter_items):
-                        child_node = _traverse(child, depth=depth + 1)
-                        child_node.key_repr = to_repr(key)
-                        child_node.last = index == last_item_index
-                        append(child_node)
-                else:
-                    iter_values = iter(obj)
-                    if max_length is not None:
-                        iter_values = islice(iter_values, max_length)
-                    for index, child in enumerate(iter_values):
-                        child_node = _traverse(child, depth=depth + 1)
-                        child_node.last = index == last_item_index
-                        append(child_node)
-                if max_length is not None and num_items > max_length:
-                    append(Node(value_repr=f"... +{num_items - max_length}", last=True))
-            else:
-                node = Node(empty=empty, children=[], last=root)
-
-            pop_visited(obj_id)
-        else:
-            node = Node(value_repr=to_repr(obj), last=root)
-        node.is_tuple = _safe_isinstance(obj, tuple)
-        node.is_namedtuple = _is_namedtuple(obj)
-        return node
-
-    node = _traverse(_object, root=True)
-    return node
-
-
-def pretty_repr(
-    _object: Any,
-    *,
-    max_width: int = 80,
-    indent_size: int = 4,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-    max_depth: Optional[int] = None,
-    expand_all: bool = False,
-) -> str:
-    """Prettify repr string by expanding on to new lines to fit within a given width.
-
-    Args:
-        _object (Any): Object to repr.
-        max_width (int, optional): Desired maximum width of repr string. Defaults to 80.
-        indent_size (int, optional): Number of spaces to indent. Defaults to 4.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of string before truncating, or None to disable truncating.
-            Defaults to None.
-        max_depth (int, optional): Maximum depth of nested data structure, or None for no depth.
-            Defaults to None.
-        expand_all (bool, optional): Expand all containers regardless of available width. Defaults to False.
-
-    Returns:
-        str: A possibly multi-line representation of the object.
-    """
-
-    if _safe_isinstance(_object, Node):
-        node = _object
-    else:
-        node = traverse(
-            _object, max_length=max_length, max_string=max_string, max_depth=max_depth
-        )
-    repr_str: str = node.render(
-        max_width=max_width, indent_size=indent_size, expand_all=expand_all
-    )
-    return repr_str
-
-
-def pprint(
-    _object: Any,
-    *,
-    console: Optional["Console"] = None,
-    indent_guides: bool = True,
-    max_length: Optional[int] = None,
-    max_string: Optional[int] = None,
-    max_depth: Optional[int] = None,
-    expand_all: bool = False,
-) -> None:
-    """A convenience function for pretty printing.
-
-    Args:
-        _object (Any): Object to pretty print.
-        console (Console, optional): Console instance, or None to use default. Defaults to None.
-        max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.
-            Defaults to None.
-        max_string (int, optional): Maximum length of strings before truncating, or None to disable. Defaults to None.
-        max_depth (int, optional): Maximum depth for nested data structures, or None for unlimited depth. Defaults to None.
-        indent_guides (bool, optional): Enable indentation guides. Defaults to True.
-        expand_all (bool, optional): Expand all containers. Defaults to False.
-    """
-    _console = get_console() if console is None else console
-    _console.print(
-        Pretty(
-            _object,
-            max_length=max_length,
-            max_string=max_string,
-            max_depth=max_depth,
-            indent_guides=indent_guides,
-            expand_all=expand_all,
-            overflow="ignore",
-        ),
-        soft_wrap=True,
-    )
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    class BrokenRepr:
-        def __repr__(self) -> str:
-            1 / 0
-            return "this will fail"
-
-    from typing import NamedTuple
-
-    class StockKeepingUnit(NamedTuple):
-        name: str
-        description: str
-        price: float
-        category: str
-        reviews: List[str]
-
-    d = defaultdict(int)
-    d["foo"] = 5
-    data = {
-        "foo": [
-            1,
-            "Hello World!",
-            100.123,
-            323.232,
-            432324.0,
-            {5, 6, 7, (1, 2, 3, 4), 8},
-        ],
-        "bar": frozenset({1, 2, 3}),
-        "defaultdict": defaultdict(
-            list, {"crumble": ["apple", "rhubarb", "butter", "sugar", "flour"]}
-        ),
-        "counter": Counter(
-            [
-                "apple",
-                "orange",
-                "pear",
-                "kumquat",
-                "kumquat",
-                "durian" * 100,
-            ]
-        ),
-        "atomic": (False, True, None),
-        "namedtuple": StockKeepingUnit(
-            "Sparkling British Spring Water",
-            "Carbonated spring water",
-            0.9,
-            "water",
-            ["its amazing!", "its terrible!"],
-        ),
-        "Broken": BrokenRepr(),
-    }
-    data["foo"].append(data)  # type: ignore[attr-defined]
-
-    from pip._vendor.rich import print
-
-    print(Pretty(data, indent_guides=True, max_string=20))