rich_4070

{"status": "ok", "stdout": "rich/:\n__init__.py\n__main__.py\n_emoji_codes.py\n_emoji_replace.py\n_export_format.py\n_extension.py\n_fileno.py\n_inspect.py\n_log_render.py\n_loop.py\n_null_file.py\n_palettes.py\n_pick.py\n_ratio.py\n_spinners.py\n_stack.py\n_timer.py\n_unicode_data\n_win32_console.py\n_windows.py\n_windows_renderer.py\n_wrap.py\nabc.py\nalign.py\nansi.py\nbar.py\nbox.py\ncells.py\ncolor.py\ncolor_triplet.py\ncolumns.py\nconsole.py\nconstrain.py\ncontainers.py\ncontrol.py\ndefault_styles.py\ndiagnose.py\nemoji.py\nerrors.py\nfile_proxy.py\nfilesize.py\nhighlighter.py\njson.py\njupyter.py\nlayout.py\nlive.py\nlive_render.py\nlogging.py\nmarkdown.py\nmarkup.py\nmeasure.py\npadding.py\npager.py\npalette.py\npanel.py\npretty.py\nprogress.py\nprogress_bar.py\nprompt.py\nprotocol.py\npy.typed\nregion.py\nrepr.py\nrule.py\nscope.py\nscreen.py\nsegment.py\nspinner.py\nstatus.py\nstyle.py\nstyled.py\nsyntax.py\ntable.py\nterminal_theme.py\ntext.py\ntheme.py\nthemes.py\ntraceback.py\ntree.py\n\nrich/_unicode_data:\n__init__.py\n_versions.py\nunicode10-0-0.py\nunicode11-0-0.py\nunicode12-0-0.py\nunicode12-1-0.py\nunicode13-0-0.py\nunicode14-0-0.py\nunicode15-0-0.py\nunicode15-1-0.py\nunicode16-0-0.py\nunicode17-0-0.py\nunicode4-1-0.py\nunicode5-0-0.py\nunicode5-1-0.py\nunicode5-2-0.py\nunicode6-0-0.py\nunicode6-1-0.py\nunicode6-2-0.py\nunicode6-3-0.py\nunicode7-0-0.py\nunicode8-0-0.py\nunicode9-0-0.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "rich/logging.py:1:import logging\nrich/logging.py:2:from datetime import datetime\nrich/logging.py:3:from logging import Handler, LogRecord\nrich/logging.py:4:from pathlib import Path\nrich/logging.py:5:from types import ModuleType\nrich/logging.py:6:from typing import ClassVar, Iterable, List, Optional, Type, Union\nrich/logging.py:8:from rich._null_file import NullFile\nrich/logging.py:10:from . import get_console\nrich/logging.py:11:from ._log_render import FormatTimeCallable, LogRender\nrich/logging.py:12:from .console import Console, ConsoleRenderable\nrich/logging.py:13:from .highlighter import Highlighter, ReprHighlighter\nrich/logging.py:14:from .text import Text\nrich/logging.py:15:from .traceback import Traceback\nrich/logging.py:243:    from time import sleep\nrich/console.py:1:import inspect\nrich/console.py:2:import os\nrich/console.py:3:import sys\nrich/console.py:4:import threading\nrich/console.py:5:import zlib\nrich/console.py:6:from abc import ABC, abstractmethod\nrich/console.py:7:from dataclasses import dataclass, field\nrich/console.py:8:from datetime import datetime\nrich/console.py:9:from functools import wraps\nrich/console.py:10:from getpass import getpass\nrich/console.py:11:from html import escape\nrich/console.py:12:from inspect import isclass\nrich/console.py:13:from itertools import islice\nrich/console.py:14:from math import ceil\nrich/console.py:15:from time import monotonic\nrich/console.py:16:from types import FrameType, ModuleType, TracebackType\nrich/console.py:17:from typing import (\nrich/console.py:38:from rich._null_file import NULL_FILE\nrich/console.py:40:from . import errors, themes\nrich/console.py:41:from ._emoji_replace import _emoji_replace\nrich/console.py:42:from ._export_format import CONSOLE_HTML_FORMAT, CONSOLE_SVG_FORMAT\nrich/console.py:43:from ._fileno import get_fileno\nrich/console.py:44:from ._log_render import FormatTimeCallable, LogRender\nrich/console.py:45:from .align import Al

{"status": "ok", "stdout": "import logging\nfrom datetime import datetime\nfrom logging import Handler, LogRecord\nfrom pathlib import Path\nfrom types import ModuleType\nfrom typing import ClassVar, Iterable, List, Optional, Type, Union\n\nfrom rich._null_file import NullFile\n\nfrom . import get_console\nfrom ._log_render import FormatTimeCallable, LogRender\nfrom .console import Console, ConsoleRenderable\nfrom .highlighter import Highlighter, ReprHighlighter\nfrom .text import Text\nfrom .traceback import Traceback\n\n\nclass RichHandler(Handler):\n    \"\"\"A logging handler that renders output with Rich. The time / level / message and file are displayed in columns.\n    The level is color coded, and the message is syntax highlighted.\n\n    Note:\n        Be careful when enabling console markup in log messages if you have configured logging for libraries not\n        under your control. If a dependency writes messages containing square brackets, it may not produce the intended output.\n\n    Args:\n        level (Union[int, str], optional): Log level. Defaults to logging.NOTSET.\n        console (:class:`~rich.console.Console`, optional): Optional console instance to write logs.\n            Default will use a global console instance writing to stdout.\n        show_time (bool, optional): Show a column for the time. Defaults to True.\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import inspect\nimport os\nimport sys\nimport threading\nimport zlib\nfrom abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom functools import wraps\nfrom getpass import getpass\nfrom html import escape\nfrom inspect import isclass\nfrom itertools import islice\nfrom math import ceil\nfrom time import monotonic\nfrom types import FrameType, ModuleType, TracebackType\nfrom typing import (\n    IO,\n    TYPE_CHECKING,\n    Any,\n    Callable,\n    Dict,\n    Iterable,\n    List,\n    Literal,\n    Mapping,\n    NamedTuple,\n    Optional,\n    Protocol,\n    TextIO,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from enum import IntEnum\nfrom functools import lru_cache\nfrom itertools import filterfalse\nfrom logging import getLogger\nfrom operator import attrgetter\nfrom typing import (\n    TYPE_CHECKING,\n    Dict,\n    Iterable,\n    List,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import configparser\nfrom typing import IO, Dict, List, Mapping, Optional\n\nfrom .default_styles import DEFAULT_STYLES\nfrom .style import Style, StyleType\n\n\nclass Theme:\n    \"\"\"A container for style information, used by :class:`~rich.console.Console`.\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from __future__ import annotations\n\nimport os.path\nimport re\nimport sys\nimport textwrap\nfrom abc import ABC, abstractmethod\nfrom pathlib import Path\nfrom typing import (\n    Any,\n    Dict,\n    Iterable,\n    List,\n    NamedTuple,\n    Optional,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n)\n\nfrom pygments.lexer import Lexer\nfrom pygments.lexers import get_lexer_by_name, guess_lexer_for_filename\nfrom pygments.style import Style as PygmentsStyle\nfrom pygments.styles import get_style_by_name\nfrom pygments.token import (\n    Comment,\n    Error,\n    Generic,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "47:from .console import Console, ConsoleOptions, JustifyMethod, RenderResult\n599:    def _get_number_styles(self, console: Console) -> Tuple[Style, Style, Style]:\n623:        self, console: \"Console\", options: \"ConsoleOptions\"\n641:        self, console: Console, options: ConsoleOptions\n651:        console: Console,\n652:        options: ConsoleOptions,\n956:    from rich.console import Console\n958:    console = Console(force_terminal=args.force_color, width=args.width)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from typing import Any, cast, Set, TYPE_CHECKING\nfrom inspect import isclass\n\nif TYPE_CHECKING:\n    from rich.console import RenderableType\n\n_GIBBERISH = \"\"\"aihwerij235234ljsdnp34ksodfipwoe234234jlskjdf\"\"\"\n\n\ndef is_renderable(check_object: Any) -> bool:\n    \"\"\"Check if an object may be rendered by Rich.\"\"\"\n    return (\n        isinstance(check_object, str)\n        or hasattr(check_object, \"__rich__\")\n        or hasattr(check_object, \"__rich_console__\")\n    )\n\n\ndef rich_cast(renderable: object) -> \"RenderableType\":\n    \"\"\"Cast an object to a renderable by calling __rich__ if present.\n\n    Args:\n        renderable (object): A potentially renderable object\n\n    Returns:\n        object: The result of recursively calling __rich__.\n    \"\"\"\n    from rich.console import RenderableType\n\n    rich_visited_set: Set[type] = set()  # Prevent potential infinite loop\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import inspect\nfrom functools import partial\nfrom typing import (\n    Any,\n    Callable,\n    Iterable,\n    List,\n    Optional,\n    Tuple,\n    Type,\n    TypeVar,\n    Union,\n    overload,\n)\n\nT = TypeVar(\"T\")\n\n\nResult = Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]\nRichReprResult = Result\n\n\nclass ReprError(Exception):\n    \"\"\"An error occurred when attempting to build a repr.\"\"\"\n\n\n@overload\ndef auto(cls: Optional[Type[T]]) -> Type[T]:\n    ...\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "132:    def emit(self, record: LogRecord) -> None:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "37:        rich_tracebacks (bool, optional): Enable rich tracebacks with syntax highlighting and formatting. Defaults to False.\n77:        rich_tracebacks: bool = False,\n104:        self.rich_tracebacks = rich_tracebacks\n137:            self.rich_tracebacks\n251:        handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)],\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "4:from pathlib import Path\n224:        path = Path(record.pathname).name\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "12:from inspect import isclass\n1324:        if hasattr(renderable, \"__rich_console__\") and not isclass(renderable):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1904:        currentframe: Callable[[], Optional[FrameType]] = inspect.currentframe,\n1910:            currentframe (Callable[[], Optional[FrameType]], optional): the callable to use to\n1911:                retrieve the current frame. Defaults to ``inspect.currentframe``.\n1923:        frame = currentframe()\n1925:            # Use the faster currentframe where implemented\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "53:from .pretty import Pretty, is_expandable\n1625:        :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1946:        log_locals: bool = False,\n1960:            log_locals (bool, optional): Boolean to enable logging of locals where ``log()``\n1985:            if log_locals:\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "2149:        password: bool = False,\n2160:            password: (bool, optional): Hide typed text. Defaults to False.\n2168:        if password:\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "11:from html import escape\n942:                understanding escape sequences, otherwise False.\n2182:            styles (bool, optional): If ``True``, ansi escape codes will be included. ``False`` for plain text.\n2260:                    text = escape(text)\n2272:                    text = escape(text)\n2420:        def escape_text(text: str) -> str:\n2421:            \"\"\"HTML escape text and replace spaces with nbsp.\"\"\"\n2422:            return escape(text).replace(\" \", \" \")\n2504:                            escape_text(text),\n2546:                escape_text(title),\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "5:import zlib\n2451:                zlib.adler32(\n2628:    return str(zlib.adler32(svg_main_code.encode()))\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "2619:def _svg_hash(svg_main_code: str) -> str:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1:import configparser\n52:        config = configparser.ConfigParser()\n65:            path (str): Path to a config file readable by Python configparser module.\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "47:from .console import Console, ConsoleOptions, JustifyMethod, RenderResult\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "2:from inspect import isclass\n31:    while hasattr(renderable, \"__rich__\") and not isclass(renderable):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1:import inspect\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "68:        def auto_rich_repr(self: Type[T]) -> Result:\n89:            auto_rich_repr.__doc__ = \"Build a rich repr\"\n90:            cls.__rich_repr__ = auto_rich_repr  # type: ignore[attr-defined]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "4:from logging import getLogger\n32:log = getLogger(\"rich\")\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "32:log = getLogger(\"rich\")\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "4:from logging import getLogger\n32:log = getLogger(\"rich\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import logging\nfrom datetime import datetime\nfrom logging import Handler, LogRecord\nfrom pathlib import Path\nfrom types import ModuleType\nfrom typing import ClassVar, Iterable, List, Optional, Type, Union\n\nfrom rich._null_file import NullFile\n\nfrom . import get_console\nfrom ._log_render import FormatTimeCallable, LogRender\nfrom .console import Console, ConsoleRenderable\nfrom .highlighter import Highlighter, ReprHighlighter\nfrom .text import Text\nfrom .traceback import Traceback\n\n\nclass RichHandler(Handler):\n    \"\"\"A logging handler that renders output with Rich. The time / level / message and file are displayed in columns.\n    The level is color coded, and the message is syntax highlighted.\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import logging\nfrom datetime import datetime\nfrom logging import Handler, LogRecord\nfrom pathlib import Path\nfrom types import ModuleType\nfrom typing import ClassVar, Iterable, List, Optional, Type, Union\n\nfrom rich._null_file import NullFile\n\nfrom . import get_console\nfrom ._log_render import FormatTimeCallable, LogRender\nfrom .console import Console, ConsoleRenderable\nfrom .highlighter import Highlighter, ReprHighlighter\nfrom .text import Text\nfrom .traceback import Traceback\n\n\nclass RichHandler(Handler):\n    \"\"\"A logging handler that renders output with Rich. The time / level / message and file are displayed in columns.\n    The level is color coded, and the message is syntax highlighted.\n\n    Note:\n        Be careful when enabling console markup in log messages if you have configured logging for libraries not\n        under your control. If a dependency writes messages containing square brackets, it may not produce the intended output.\n\n    Args:\n        level (Union[int, str], optional): Log level. Defaults to logging.NOTSET.\n        console (:class:`~rich.console.Console`, optional): Optional console instance to write logs.\n            Default will use a global console instance writing to stdout.\n        show_time (bool, optional): Show a column for the time. Defaults to True.\n        omit_repeated_times (bool, optional): Omit repetition of the same time. Defaults to True.\n        show_level (bool, optional): Show a column for the level. Defaults to True.\n        show_path (bool, optional): Show the path to the original log call. Defaults to True.\n        enable_link_path (bool, optional): Enable terminal link of path column to file. Defaults to True.\n        highlighter (Highlighter, optional): Highlighter to style log messages, or None to use ReprHighlighter. Defaults to None.\n        markup (bool, optional): Enable console markup in log messages. Defaults to False.\n        rich_tracebacks (boo

{"status": "ok", "stdout": "        return level_text\n\n    def emit(self, record: LogRecord) -> None:\n        \"\"\"Invoked by logging.\"\"\"\n        message = self.format(record)\n        traceback = None\n        if (\n            self.rich_tracebacks\n            and record.exc_info\n            and record.exc_info != (None, None, None)\n        ):\n            exc_type, exc_value, exc_traceback = record.exc_info\n            assert exc_type is not None\n            assert exc_value is not None\n            traceback = Traceback.from_exception(\n                exc_type,\n                exc_value,\n                exc_traceback,\n                width=self.tracebacks_width,\n                code_width=self.tracebacks_code_width,\n                extra_lines=self.tracebacks_extra_lines,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n        Returns:\n            ConsoleRenderable: Renderable to display log.\n        \"\"\"\n        path = Path(record.pathname).name\n        level = self.get_level_text(record)\n        time_format = None if self.formatter is None else self.formatter.datefmt\n        log_time = datetime.fromtimestamp(record.created)\n\n        log_renderable = self._log_render(\n            self.console,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import inspect\nimport os\nimport sys\nimport threading\nimport zlib\nfrom abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom functools import wraps\nfrom getpass import getpass\nfrom html import escape\nfrom inspect import isclass\nfrom itertools import islice\nfrom math import ceil\nfrom time import monotonic\nfrom types import FrameType, ModuleType, TracebackType\nfrom typing import (\n    IO,\n    TYPE_CHECKING,\n    Any,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    @staticmethod\n    def _caller_frame_info(\n        offset: int,\n        currentframe: Callable[[], Optional[FrameType]] = inspect.currentframe,\n    ) -> Tuple[str, int, Dict[str, Any]]:\n        \"\"\"Get caller frame information.\n\n        Args:\n            offset (int): the caller offset within the current frame stack.\n            currentframe (Callable[[], Optional[FrameType]], optional): the callable to use to\n                retrieve the current frame. Defaults to ``inspect.currentframe``.\n\n        Returns:\n            Tuple[str, int, Dict[str, Any]]: A tuple containing the filename, the line number and\n                the dictionary of local variables associated with the caller frame.\n\n        Raises:\n            RuntimeError: If the stack offset is invalid.\n        \"\"\"\n        # Ignore the frame of this local helper\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                renderables = [Styled(renderable, style) for renderable in renderables]\n\n            filename, line_no, locals = self._caller_frame_info(_stack_offset)\n            link_path = None if filename.startswith(\"<\") else os.path.abspath(filename)\n            path = filename.rpartition(os.sep)[-1]\n            if log_locals:\n                locals_map = {\n                    key: value\n                    for key, value in locals.items()\n                    if not key.startswith(\"__\")\n                }\n                renderables.append(render_scope(locals_map, title=\"[i]locals\"))\n\n            renderables = [\n                self._log_render(\n                    self,\n                    renderables,\n                    log_time=self.get_datetime(),\n                    path=path,\n                    line_no=line_no,\n                    link_path=link_path,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        rendered = \"\".join(output)\n        return rendered\n\n    def input(\n        self,\n        prompt: TextType = \"\",\n        *,\n        markup: bool = True,\n        emoji: bool = True,\n        password: bool = False,\n        stream: Optional[TextIO] = None,\n    ) -> str:\n        \"\"\"Displays a prompt and waits for input from the user. The prompt may contain color / style.\n\n        It works in the same way as Python's builtin :func:`input` function and provides elaborate line editing and history features if Python's builtin :mod:`readline` module is previously loaded.\n\n        Args:\n            prompt (Union[str, Text]): Text to render in the prompt.\n            markup (bool, optional): Enable console markup (requires a str prompt). Defaults to True.\n            emoji (bool, optional): Enable emoji (requires a str prompt). Defaults to True.\n            password: (bool, optional): Hide typed text. Defaults to False.\n            stream: (TextIO, optional): Optional file to read input from (rather than stdin). Defaults to None.\n\n        Returns:\n            str: Text read from stdin.\n        \"\"\"\n        if prompt:\n            self.print(prompt, markup=markup, emoji=emoji, end=\"\")\n        if password:\n            result = getpass(\"\", stream=stream)\n        else:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        _theme = theme or DEFAULT_TERMINAL_THEME\n        stylesheet = \"\"\n\n        render_code_format = CONSOLE_HTML_FORMAT if code_format is None else code_format\n\n        with self._record_buffer_lock:\n            if inline_styles:\n                for text, style, _ in Segment.filter_control(\n                    Segment.simplify(self._record_buffer)\n                ):\n                    text = escape(text)\n                    if style:\n                        rule = style.get_html_style(_theme)\n                        if style.link:\n                            text = f'<a href=\"{style.link}\">{text}</a>'\n                        text = f'<span style=\"{rule}\">{text}</span>' if rule else text\n                    append(text)\n            else:\n                styles: Dict[str, int] = {}\n                for text, style, _ in Segment.filter_control(\n                    Segment.simplify(self._record_buffer)\n                ):\n                    text = escape(text)\n                    if style:\n                        rule = style.get_html_style(_theme)\n                        style_number = styles.setdefault(rule, len(styles) + 1)\n                        if style.link:\n                            text = f'<a class=\"r{style_number}\" href=\"{style.link}\">{text}</a>'\n                        else:\n                            text = f'<span class=\"r{style_number}\">{text}</span>'\n                    append(text)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        padding_width = padding_left + padding_right\n        padding_height = padding_top + padding_bottom\n        margin_width = margin_left + margin_right\n        margin_height = margin_top + margin_bottom\n\n        text_backgrounds: List[str] = []\n        text_group: List[str] = []\n        classes: Dict[str, int] = {}\n        style_no = 1\n\n        def escape_text(text: str) -> str:\n            \"\"\"HTML escape text and replace spaces with nbsp.\"\"\"\n            return escape(text).replace(\" \", \" \")\n\n        def make_tag(\n            name: str, content: Optional[str] = None, **attribs: object\n        ) -> str:\n            \"\"\"Make a tag from name, content, and attributes.\"\"\"\n\n            def stringify(value: object) -> str:\n                if isinstance(value, (float)):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                if content\n                else f\"<{name} {tag_attribs}/>\"\n            )\n\n        with self._record_buffer_lock:\n            segments = list(Segment.filter_control(self._record_buffer))\n            if clear:\n                self._record_buffer.clear()\n\n        if unique_id is None:\n            unique_id = \"terminal-\" + str(\n                zlib.adler32(\n                    (\"\".join(repr(segment) for segment in segments)).encode(\n                        \"utf-8\",\n                        \"ignore\",\n                    )\n                    + title.encode(\"utf-8\", \"ignore\")\n                )\n            )\n        y = 0\n        for y, line in enumerate(Segment.split_and_crop_lines(segments, length=width)):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            clear=clear,\n            code_format=code_format,\n            font_aspect_ratio=font_aspect_ratio,\n            unique_id=unique_id,\n        )\n        with open(path, \"w\", encoding=\"utf-8\") as write_file:\n            write_file.write(svg)\n\n\ndef _svg_hash(svg_main_code: str) -> str:\n    \"\"\"Returns a unique hash for the given SVG main code.\n\n    Args:\n        svg_main_code (str): The content we're going to inject in the SVG envelope.\n\n    Returns:\n        str: a hash of the given content\n    \"\"\"\n    return str(zlib.adler32(svg_main_code.encode()))\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from .markup import render as render_markup\nfrom .measure import Measurement, measure_renderables\nfrom .pager import Pager, SystemPager\nfrom .pretty import Pretty, is_expandable\nfrom .protocol import rich_cast\nfrom .region import Region\nfrom .scope import render_scope\nfrom .screen import Screen\nfrom .segment import Segment\nfrom .style import Style, StyleType\nfrom .styled import Styled\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        end: str = \"\\n\",\n        style: Optional[Union[str, Style]] = None,\n        highlight: Optional[bool] = None,\n    ) -> None:\n        \"\"\"Output to the terminal. This is a low-level way of writing to the terminal which unlike\n        :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will\n        optionally apply highlighting and a basic style.\n\n        Args:\n            sep (str, optional): String to write between print data. Defaults to \" \".\n            end (str, optional): String to write at end of print data. Defaults to \"\\\\\\\\n\".\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1648:    def print(\n1751:    def print_json(\n1866:    def print_exception(\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 10 tool call(s) remaining (50/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "            emoji=False,\n            markup=False,\n            no_wrap=True,\n            overflow=\"ignore\",\n            crop=False,\n            end=end,\n        )\n\n    def print(\n        self,\n        *objects: Any,\n        sep: str = \" \",\n        end: str = \"\\n\",\n        style: Optional[Union[str, Style]] = None,\n        justify: Optional[JustifyMethod] = None,\n        overflow: Optional[OverflowMethod] = None,\n        no_wrap: Optional[bool] = None,\n        emoji: Optional[bool] = None,\n        markup: Optional[bool] = None,\n        highlight: Optional[bool] = None,\n        width: Optional[int] = None,\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 9 tool call(s) remaining (51/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "        width: Optional[int] = None,\n        height: Optional[int] = None,\n        crop: bool = True,\n        soft_wrap: Optional[bool] = None,\n        new_line_start: bool = False,\n    ) -> None:\n        \"\"\"Print to the console.\n\n        Args:\n            objects (positional args): Objects to log to the terminal.\n            sep (str, optional): String to write between print data. Defaults to \" \".\n            end (str, optional): String to write at end of print data. Defaults to \"\\\\\\\\n\".\n            style (Union[str, Style], optional): A style to apply to output. Defaults to None.\n            justify (str, optional): Justify method: \"default\", \"left\", \"right\", \"center\", or \"full\". Defaults to ``None``.\n            overflow (str, optional): Overflow method: \"ignore\", \"crop\", \"fold\", or \"ellipsis\". Defaults to None.\n            no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to None.\n            emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to ``None``.\n            markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to ``None``.\n            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``.\n            width (Optional[int], optional): Width of output, or ``None`` to auto-detect. Defaults to ``None``.\n            crop (Optional[bool], optional): Crop output to width of terminal. Defaults to True.\n            soft_wrap (bool, optional): Enable soft wrap mode which disables word wrapping and cropping of text or ``None`` for\n                Console default. Defaults to ``None``.\n            new_line_start (bool, False): Insert a new line at the start if the output contains more than one line. Defaults to ``False``.\n        \"\"\"\n        if not objects:\n            objects = (NewLine(),)\n\n        if 

{"status": "ok", "stdout": "                sep,\n                end,\n                justify=justify,\n                emoji=emoji,\n                markup=markup,\n                highlight=highlight,\n            )\n            for hook in render_hooks:\n                renderables = hook.process_renderables(renderables)\n            render_options = self.options.update(\n                justify=justify,\n                overflow=overflow,\n                width=min(width, self.width) if width is not None else NO_CHANGE,\n                height=height,\n                no_wrap=no_wrap,\n                markup=markup,\n                highlight=highlight,\n            )\n\n            new_segments: List[Segment] = []\n            extend = new_segments.extend\n            render = self.render\n            if style is None:\n                for renderable in renderables:\n                    extend(render(renderable, render_options))\n            else:\n                render_style = self.get_style(style)\n                new_line = Segment.line()\n                for renderable in renderables:\n                    for line, add_new_line in Segment.split_lines_terminator(\n                        render(renderable, render_options)\n                    ):\n                        extend(Segment.apply_style(line, render_style))\n                        if add_new_line:\n                            new_segments.append(new_line)\n\n            if new_line_start:\n                if (\n                    len(\"\".join(segment.text for segment in new_segments).splitlines())\n                    > 1\n                ):\n                    new_segments.insert(0, Segment.line())\n            if crop:\n                buffer_extend = self._buffer.extend\n                for line in Segment.split_and_crop_lines(\n                    new_segments, self.width, pad=False\n                ):\n                    buffer_extend(line)\n            else:\n                self._buf

{"status": "ok", "stdout": "\n    def print_json(\n        self,\n        json: Optional[str] = None,\n        *,\n        data: Any = None,\n        indent: Union[None, int, str] = 2,\n        highlight: bool = True,\n        skip_keys: bool = False,\n        ensure_ascii: bool = False,\n        check_circular: bool = True,\n        allow_nan: bool = True,\n        default: Optional[Callable[[Any], Any]] = None,\n        sort_keys: bool = False,\n    ) -> None:\n        \"\"\"Pretty prints JSON. Output will be valid JSON.\n\n        Args:\n            json (Optional[str]): A string containing JSON.\n            data (Any): If json is not supplied, then encode this data.\n            indent (Union[None, int, str], optional): Number of spaces to indent. Defaults to 2.\n            highlight (bool, optional): Enable highlighting of output: Defaults to True.\n            skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.\n            ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.\n            check_circular (bool, optional): Check for circular references. Defaults to True.\n            allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.\n            default (Callable, optional): A callable that converts values that can not be encoded\n                in to something that can be JSON encoded. Defaults to None.\n            sort_keys (bool, optional): Sort dictionary keys. Defaults to False.\n        \"\"\"\n        from rich.json import JSON\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 6 tool call(s) remaining (54/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "        end: str = \"\\n\",\n        style: Optional[Union[str, Style]] = None,\n        justify: Optional[JustifyMethod] = None,\n        emoji: Optional[bool] = None,\n        markup: Optional[bool] = None,\n        highlight: Optional[bool] = None,\n        log_locals: bool = False,\n        _stack_offset: int = 1,\n    ) -> None:\n        \"\"\"Log rich content to the terminal.\n\n        Args:\n            objects (positional args): Objects to log to the terminal.\n            sep (str, optional): String to write between print data. Defaults to \" \".\n            end (str, optional): String to write at end of print data. Defaults to \"\\\\\\\\n\".\n            style (Union[str, Style], optional): A style to apply to output. Defaults to None.\n            justify (str, optional): One of \"left\", \"right\", \"center\", or \"full\". Defaults to ``None``.\n            emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to None.\n            markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to None.\n            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to None.\n            log_locals (bool, optional): Boolean to enable logging of locals where ``log()``\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 5 tool call(s) remaining (55/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "                renderables = [Styled(renderable, style) for renderable in renderables]\n\n            filename, line_no, locals = self._caller_frame_info(_stack_offset)\n            link_path = None if filename.startswith(\"<\") else os.path.abspath(filename)\n            path = filename.rpartition(os.sep)[-1]\n            if log_locals:\n                locals_map = {\n                    key: value\n                    for key, value in locals.items()\n                    if not key.startswith(\"__\")\n                }\n                renderables.append(render_scope(locals_map, title=\"[i]locals\"))\n\n            renderables = [\n                self._log_render(\n                    self,\n                    renderables,\n                    log_time=self.get_datetime(),\n                    path=path,\n                    line_no=line_no,\n                    link_path=link_path,\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 4 tool call(s) remaining (56/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "from .markup import render as render_markup\nfrom .measure import Measurement, measure_renderables\nfrom .pager import Pager, SystemPager\nfrom .pretty import Pretty, is_expandable\nfrom .protocol import rich_cast\nfrom .region import Region\nfrom .scope import render_scope\nfrom .screen import Screen\nfrom .segment import Segment\nfrom .style import Style, StyleType\nfrom .styled import Styled\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 3 tool call(s) remaining (57/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "from .scope import render_scope\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 2 tool call(s) remaining (58/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "from .pretty import Pretty, is_expandable\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 1 tool call(s) remaining (59/60 used). Finalize your edits and call submit_patch soon."}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0, "budget_warning": "Only 0 tool call(s) remaining (60/60 used). Finalize your edits and call submit_patch soon."}