Rich

https://rich.readthedocs.io/en/stable/
Admin
Rich is a Python library for writing rich text and beautiful formatting to the terminal, enabling...
Tokens:196,375
Snippets:1,357
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Rich traceback handler

Source: https://rich.readthedocs.io/en/stable/_modules/rich/traceback.html

Example usage of the install function to enable Rich tracebacks with local variable inspection.

```python
if __name__ == "__main__":  # pragma: no cover
    install(show_locals=True)
    import sys

    def bar(
        a: Any,
    ) -> None:  # 这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑
        one = 1
        print(one / a)

    def foo(a: Any) -> None:
        _rich_traceback_guard = True
        zed = {
            "characters": {
                "Paul Atreides",
                "Vladimir Harkonnen",
                "Thufir Hawat",
                "Duncan Idaho",
            },
            "atomic_types": (None, False, True),
        }
        bar(a)

    def error() -> None:
        foo(0)

    error()
```

--------------------------------

### start()

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Starts the progress display.

```APIDOC
## start()

### Description
Starts the progress display if it is not disabled.

### Signature
`def start(self) -> None:`
```

--------------------------------

### Configure and use RichHandler

Source: https://rich.readthedocs.io/en/stable/_modules/rich/logging.html

Example setup for the logging system using RichHandler, demonstrating various log levels, tracebacks, and markup support.

```python
if __name__ == "__main__":  # pragma: no cover
    from time import sleep

    FORMAT = "%(message)s"
    # FORMAT = "%(asctime)-15s - %(levelname)s - %(message)s"
    logging.basicConfig(
        level="NOTSET",
        format=FORMAT,
        datefmt="[%X]",
        handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)],
    )
    log = logging.getLogger("rich")

    log.info("Server starting...")
    log.info("Listening on http://127.0.0.1:8080")
    sleep(1)

    log.info("GET /index.html 200 1298")
    log.info("GET /imgs/backgrounds/back1.jpg 200 54386")
    log.info("GET /css/styles.css 200 54386")
    log.warning("GET /favicon.ico 404 242")
    sleep(1)

    log.debug(
        "JSONRPC request\n--> %r\n<-- %r",
        {
            "version": "1.1",
            "method": "confirmFruitPurchase",
            "params": [["apple", "orange", "mangoes", "pomelo"], 1.123],
            "id": "194521489",
        },
        {"version": "1.1", "result": True, "error": None, "id": "194521489"},
    )
    log.debug(
        "Loading configuration file /adasd/asdasd/qeqwe/qwrqwrqwr/sdgsdgsdg/werwerwer/dfgerert/ertertert/ertetert/werwerwer"
    )
    log.error("Unable to find 'pomelo' in database!")
    log.info("POST /jsonrpc/ 200 65532")
    log.info("POST /admin/ 401 42234")
    log.warning("password was rejected for admin site.")

    def divide() -> None:
        number = 1
        divisor = 0
        foos = ["foo"] * 100
        log.debug("in divide")
        try:
            number / divisor
        except:
            log.exception("An error of some kind occurred!")

    divide()
    sleep(1)
    log.critical("Out of memory!")
    log.info("Server exited with code=-1")
    log.info("[bold]EXITING...[/bold]", extra=dict(markup=True))
```

--------------------------------

### Live.start

Source: https://rich.readthedocs.io/en/stable/_modules/rich/live.html

Starts the live rendering display process.

```APIDOC
## Live.start(refresh=False)

### Description
Starts the live rendering display. This must be called to begin the update loop.

### Parameters
- **refresh** (bool) - Optional - Whether to trigger an immediate refresh upon starting.
```

--------------------------------

### Run Layout Example

Source: https://rich.readthedocs.io/en/stable/layout.html

Execute the built-in Rich layout demonstration from the command line.

```bash
python -m rich.layout
```

--------------------------------

### Run Rich Repr Protocol Example

Source: https://rich.readthedocs.io/en/stable/_sources/pretty.rst.txt

Execute this command to see an example of how Rich can format custom objects using the Rich repr protocol.

```bash
python -m rich.repr
```

--------------------------------

### Prompt Usage Examples

Source: https://rich.readthedocs.io/en/stable/_modules/rich/prompt.html

Basic usage examples for different prompt types provided by the Rich library.

```python
>>> name = Prompt.ask("Enter your name")
```

```python
>>> burrito_count = IntPrompt.ask("How many burritos do you want to order")
```

```python
>>> temperature = FloatPrompt.ask("Enter desired temperature")
```

```python
>>> if Confirm.ask("Continue"):
        run_job()
```

--------------------------------

### Run Rich repr example

Source: https://rich.readthedocs.io/en/stable/pretty.html

Execute the built-in Rich repr demonstration command.

```bash
python -m rich.repr
```

--------------------------------

### Install Rich via pip

Source: https://rich.readthedocs.io/en/stable/introduction.html

Standard installation command for the Rich library.

```bash
pip install rich
```

--------------------------------

### Run prompt examples via CLI

Source: https://rich.readthedocs.io/en/stable/_sources/prompt.rst.txt

Execute the built-in prompt demonstration script from the command line.

```bash
python -m rich.prompt
```

--------------------------------

### Run Pretty Print Example

Source: https://rich.readthedocs.io/en/stable/pretty.html

Execute the built-in Rich pretty print demonstration via the command line.

```bash
python -m rich.pretty
```

--------------------------------

### Panel Usage Example

Source: https://rich.readthedocs.io/en/stable/_modules/rich/panel.html

Demonstrates how to create a Panel with custom styling and print it to the console.

```python
if __name__ == "__main__":  # pragma: no cover
    from .console import Console

    c = Console()

    from .box import DOUBLE, ROUNDED
    from .padding import Padding

    p = Panel(
        "Hello, World!",
        title="rich.Panel",
        style="white on blue",
        box=DOUBLE,
        padding=1,
    )

    c.print()
    c.print(p)
```

--------------------------------

### Install Rich

Source: https://rich.readthedocs.io/en/stable/_sources/introduction.rst.txt

Install Rich using pip. Use the -U flag to update if already installed.

```bash
pip install rich
```

--------------------------------

### Run Rich markup examples

Source: https://rich.readthedocs.io/en/stable/markup.html

Execute the built-in Rich markup demonstration script.

```bash
python -m rich.markup
```

--------------------------------

### Print theme configuration

Source: https://rich.readthedocs.io/en/stable/_modules/rich/theme.html

Example of printing the current theme configuration to the console.

```python
if __name__ == "__main__":  # pragma: no cover
    theme = Theme()
    print(theme.config)
```

--------------------------------

### rich.pretty.install

Source: https://rich.readthedocs.io/en/stable/_modules/rich/pretty.html

Installs automatic pretty printing in the Python REPL by replacing sys.displayhook.

```APIDOC
## rich.pretty.install(console=None, overflow='ignore', crop=False, indent_guides=False, max_length=None, max_string=None, max_depth=None, expand_all=False)

### Description
Installs automatic pretty printing in the Python REPL. This replaces the default display hook to render objects using Rich.

### Parameters
- **console** (Console, optional) - Console instance or None to use global console. Defaults to None.
- **overflow** (OverflowMethod, optional) - Overflow method. Defaults to "ignore".
- **crop** (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. Defaults to None.
- **max_string** (int, optional) - Maximum length of string before truncating. Defaults to None.
- **max_depth** (int, optional) - Maximum depth of nested data structures. Defaults to None.
- **expand_all** (bool, optional) - Expand all containers. Defaults to False.
```

--------------------------------

### Run Rich demo

Source: https://rich.readthedocs.io/en/stable/introduction.html

Execute the built-in demo to verify installation and view library capabilities.

```bash
python -m rich
```

--------------------------------

### Install Global Traceback Handler

Source: https://rich.readthedocs.io/en/stable/_sources/traceback.rst.txt

Import and call the install function to set Rich as the default handler for uncaught exceptions. Configure with show_locals=True to display local variables.

```python
from rich.traceback import install
install(show_locals=True)
```

--------------------------------

### Columns usage example

Source: https://rich.readthedocs.io/en/stable/_modules/rich/columns.html

Demonstrates how to initialize and print a Columns object with directory file listings.

```python
if __name__ == "__main__":  # pragma: no cover
    import os

    console = Console()

    files = [f"{i} {s}" for i, s in enumerate(sorted(os.listdir()))]
    columns = Columns(files, padding=(0, 1), expand=False, equal=False)
    console.print(columns)
    console.rule()
    columns.column_first = True
    console.print(columns)
    columns.right_to_left = True
    console.rule()
    console.print(columns)
```

--------------------------------

### rich.traceback.install

Source: https://rich.readthedocs.io/en/stable/reference/traceback.html

Installs a global rich traceback handler that intercepts and formats all subsequent exceptions.

```APIDOC
## rich.traceback.install(console=None, width=100, code_width=88, extra_lines=3, theme=None, word_wrap=False, show_locals=False, locals_max_length=10, locals_max_string=80, locals_hide_dunder=True, locals_hide_sunder=None, indent_guides=True, suppress=(), max_frames=100)

### Description
Install a rich traceback handler. Once installed, any tracebacks will be printed with syntax highlighting and rich formatting.

### Returns
- **Callable** - The previous exception handler that was replaced.
```

--------------------------------

### Syntax Highlighting Example

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Demonstrates the use of the Syntax class for rendering code blocks.

```python
    syntax = Syntax(
        '''def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
    """Iterate and generate a tuple with a flag for last value."""
    iter_values = iter(values)
    try:
        previous_value = next(iter_values)
    except StopIteration:
        return
    for value in iter_values:
        yield False, previous_value
        previous_value = value
    yield True, previous_value''',
        "python",
        line_numbers=True,
    )
```

--------------------------------

### Start the Live display

Source: https://rich.readthedocs.io/en/stable/_modules/rich/live.html

Method to initiate the live rendering process, optionally triggering an immediate refresh.

```python
def start(self, refresh: bool = False) -> None:
    """Start live rendering display.

    Args:
        refresh (bool, optional): Also refresh. Defaults to False.
    """
    with self._lock:
        if self._started:
            return
        self._started = True

        if not self.console.set_live(self):
            self._nested = True
            return
```

--------------------------------

### Live Display Demonstration

Source: https://rich.readthedocs.io/en/stable/_modules/rich/live.html

Example usage of the Live class to display a table with updating exchange rates and periodic log messages.

```python
if __name__ == "__main__":  # pragma: no cover
    import random
    import time
    from itertools import cycle
    from typing import Dict, List, Tuple

    from .align import Align
    from .console import Console
    from .live import Live as Live
    from .panel import Panel
    from .rule import Rule
    from .syntax import Syntax
    from .table import Table

    console = Console()

    syntax = Syntax(
        '''def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
    """Iterate and generate a tuple with a flag for last value."""
    iter_values = iter(values)
    try:
        previous_value = next(iter_values)
    except StopIteration:
        return
    for value in iter_values:
        yield False, previous_value
        previous_value = value
    yield True, previous_value''',
        "python",
        line_numbers=True,
    )

    table = Table("foo", "bar", "baz")
    table.add_row("1", "2", "3")

    progress_renderables = [
        "You can make the terminal shorter and taller to see the live table hide"
        "Text may be printed while the progress bars are rendering.",
        Panel("In fact, [i]any[/i] renderable will work"),
        "Such as [magenta]tables[/]...",
        table,
        "Pretty printed structures...",
        {"type": "example", "text": "Pretty printed"},
        "Syntax...",
        syntax,
        Rule("Give it a try!"),
    ]

    examples = cycle(progress_renderables)

    exchanges = [
        "SGD",
        "MYR",
        "EUR",
        "USD",
        "AUD",
        "JPY",
        "CNH",
        "HKD",
        "CAD",
        "INR",
        "DKK",
        "GBP",
        "RUB",
        "NZD",
        "MXN",
        "IDR",
        "TWD",
        "THB",
        "VND",
    ]
    with Live(console=console) as live_table:
        exchange_rate_dict: Dict[Tuple[str, str], float] = {}

        for index in range(100):
            select_exchange = exchanges[index % len(exchanges)]

            for exchange in exchanges:
                if exchange == select_exchange:
                    continue
                time.sleep(0.4)
                if random.randint(0, 10) < 1:
                    console.log(next(examples))
                exchange_rate_dict[(select_exchange, exchange)] = 200 / (
                    (random.random() * 320) + 1
                )
                if len(exchange_rate_dict) > len(exchanges) - 1:
                    exchange_rate_dict.pop(list(exchange_rate_dict.keys())[0])
                table = Table(title="Exchange Rates")
```

--------------------------------

### Command Line Interface Setup

Source: https://rich.readthedocs.io/en/stable/_modules/rich/json.html

The module includes a main block for command-line usage, allowing users to pretty-print JSON files or stdin input.

```python
if __name__ == "__main__":
    import argparse
    import sys

    parser = argparse.ArgumentParser(description="Pretty print json")
    parser.add_argument(
        "path",
        metavar="PATH",
        help="path to file, or - for stdin",
    )
    parser.add_argument(
        "-i",
        "--indent",
        metavar="SPACES",
        type=int,
        help="Number of spaces in an indent",
        default=2,
    )
    args = parser.parse_args()

    from rich.console import Console

    console = Console()
    error_console = Console(stderr=True)
```

--------------------------------

### Create a Rich Panel

Source: https://rich.readthedocs.io/en/stable/_sources/introduction.rst.txt

Example of creating a Rich Panel renderable with styling and text content.

```python
from rich.panel import Panel

Panel.fit("[bold yellow]Hi, I'm a Panel", border_style="red")
```

--------------------------------

### Live display lifecycle methods

Source: https://rich.readthedocs.io/en/stable/_modules/rich/live.html

Methods for starting, stopping, and managing the context manager lifecycle of a Live display.

```python
    def stop(self) -> None:
        """Stop live rendering display."""
        with self._lock:
            if not self._started:
                return
            self._started = False
            self.console.clear_live()
            if self._nested:
                if not self.transient:
                    self.console.print(self.renderable)
                return

            if self.auto_refresh and self._refresh_thread is not None:
                self._refresh_thread.stop()
                self._refresh_thread = None
            # allow it to fully render on the last even if overflow
            self.vertical_overflow = "visible"
            with self.console:
                try:
                    if not self._alt_screen and not self.console.is_jupyter:
                        self.refresh()
                finally:
                    self._disable_redirect_io()
                    self.console.pop_render_hook()
                    if not self._alt_screen and self.console.is_terminal:
                        self.console.line()
                    self.console.show_cursor(True)
                    if self._alt_screen:
                        self.console.set_alt_screen(False)
                    if the.transient and not self._alt_screen:
                        self.console.control(self._live_render.restore_cursor())
                    if self.ipy_widget is not None and self.transient:
                        self.ipy_widget.close()  # pragma: no cover



    def __enter__(self) -> Self:
        self.start(refresh=self._renderable is not None)
        return self

    def __exit__(
        self,
        exc_type: Optional[Type[BaseException]],
        exc_val: Optional[BaseException],
        exc_tb: Optional[TracebackType],
    ) -> None:
        self.stop()
```

--------------------------------

### Markup Demonstration Script

Source: https://rich.readthedocs.io/en/stable/_modules/rich/markup.html

Example usage of the markup module to render various styled strings in a table.

```python
if __name__ == "__main__":  # pragma: no cover
    MARKUP = [
        "[red]Hello World[/red]",
        "[magenta]Hello [b]World[/b]",
        "[bold]Bold[italic] bold and italic [/bold]italic[/italic]",
        "Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog",
        ":warning-emoji: [bold red blink] DANGER![/]",
    ]

    from rich import print
    from rich.table import Table

    grid = Table("Markup", "Result", padding=(0, 1))

    for markup in MARKUP:
        grid.add_row(Text(markup), markup)

    print(grid)
```

--------------------------------

### Running Console Markup Examples

Source: https://rich.readthedocs.io/en/stable/_sources/markup.rst.txt

Command to execute a Python module that demonstrates various console markup features.

```bash
python -m rich.markup
```

--------------------------------

### Run Rich Pretty Printing Example

Source: https://rich.readthedocs.io/en/stable/_sources/pretty.rst.txt

Execute this command in your terminal to observe Rich's default pretty printing behavior for containers.

```bash
python -m rich.pretty
```

--------------------------------

### Initialize system exception hook

Source: https://rich.readthedocs.io/en/stable/_modules/rich/traceback.html

Attempts to install the Rich traceback hook, falling back to the default system hook if necessary.

```python
try:  # pragma: no cover
    # if within ipython, use customized traceback
    ip = get_ipython()  # type: ignore[name-defined]
    ipy_excepthook_closure(ip)
    return sys.excepthook
except Exception:
    # otherwise use default system hook
    old_excepthook = sys.excepthook
    sys.excepthook = excepthook
    return old_excepthook
```

--------------------------------

### Demonstrate text justification

Source: https://rich.readthedocs.io/en/stable/_modules/rich/text.html

Example usage of the Text class to highlight words and print text with different justification settings.

```python
if __name__ == "__main__":  # pragma: no cover
    from rich.console import Console

    text = Text(
        ""\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n"""
    )
    text.highlight_words(["Lorem"], "bold")
    text.highlight_words(["ipsum"], "italic")

    console = Console()

    console.rule("justify='left'")
    console.print(text, style="red")
    console.print()

    console.rule("justify='center'")
    console.print(text, style="green", justify="center")
    console.print()

    console.rule("justify='right'")
    console.print(text, style="blue", justify="right")
    console.print()
```

--------------------------------

### Run Live Display Demonstration

Source: https://rich.readthedocs.io/en/stable/_sources/live.rst.txt

Execute the built-in demonstration of the Live class via the command line.

```bash
python -m rich.live
```

--------------------------------

### Table Usage and Configuration Examples

Source: https://rich.readthedocs.io/en/stable/_modules/rich/table.html

A demonstration script showing how to create a table, add columns and rows, and apply various layout properties like expand, width, row_styles, and leading.

```python
if __name__ == "__main__":  # pragma: no cover
    from rich.console import Console
    from rich.highlighter import ReprHighlighter

    from ._timer import timer

    with timer("Table render"):
        table = Table(
            title="Star Wars Movies",
            caption="Rich example table",
            caption_justify="right",
        )

        table.add_column(
            "Released", header_style="bright_cyan", style="cyan", no_wrap=True
        )
        table.add_column("Title", style="magenta")
        table.add_column("Box Office", justify="right", style="green")

        table.add_row(
            "Dec 20, 2019",
            "Star Wars: The Rise of Skywalker",
            "$952,110,690",
        )
        table.add_row("May 25, 2018", "Solo: A Star Wars Story", "$393,151,347")
        table.add_row(
            "Dec 15, 2017",
            "Star Wars Ep. V111: The Last Jedi",
            "$1,332,539,889",
            style="on black",
            end_section=True,
        )
        table.add_row(
            "Dec 16, 2016",
            "Rogue One: A Star Wars Story",
            "$1,332,439,889",
        )

        def header(text: str) -> None:
            console.print()
            console.rule(highlight(text))
            console.print()

        console = Console()
        highlight = ReprHighlighter()
        header("Example Table")
        console.print(table, justify="center")

        table.expand = True
        header("expand=True")
        console.print(table)

        table.width = 50
        header("width=50")

        console.print(table, justify="center")

        table.width = None
        table.expand = False
        table.row_styles = ["dim", "none"]
        header("row_styles=['dim', 'none']")

        console.print(table, justify="center")

        table.width = None
        table.expand = False
        table.row_styles = ["dim", "none"]
        table.leading = 1
        header("leading=1, row_styles=['dim', 'none']")
        console.print(table, justify="center")

        table.width = None
        table.expand = False
        table.row_styles = ["dim", "none"]
        table.show_lines = True
        table.leading = 0
        header("show_lines=True, row_styles=['dim', 'none']")
        console.print(table, justify="center")
```

--------------------------------

### install

Source: https://rich.readthedocs.io/en/stable/_modules/rich/traceback.html

Installs a rich traceback handler that overrides the default Python exception hook. Once installed, all subsequent unhandled exceptions will be rendered with syntax highlighting and rich formatting.

```APIDOC
## install

### Description
Installs a rich traceback handler. Once installed, any tracebacks will be printed with syntax highlighting and rich formatting.

### Signature
`rich.traceback.install(*, console=None, width=100, code_width=88, extra_lines=3, theme=None, word_wrap=False, show_locals=False, locals_max_length=10, locals_max_string=80, locals_hide_dunder=True, locals_hide_sunder=None, indent_guides=True, suppress=(), max_frames=100)`

### Parameters
- **console** (Optional[Console]) - Console to write exception to. Default uses internal Console instance.
- **width** (Optional[int]) - Width (in characters) of traceback. Defaults to 100.
- **code_width** (Optional[int]) - Code width (in characters) of traceback. Defaults to 88.
- **extra_lines** (int) - Extra lines of code. Defaults to 3.
- **theme** (Optional[str]) - Pygments theme to use in traceback. Defaults to None.
- **word_wrap** (bool) - Enable word wrapping of long lines. Defaults to False.
- **show_locals** (bool) - Enable display of local variables. Defaults to False.
- **locals_max_length** (int) - Maximum length of containers before abbreviating. Defaults to 10.
- **locals_max_string** (int) - Maximum length of string before truncating. Defaults to 80.
- **locals_hide_dunder** (bool) - Hide locals prefixed with double underscore. Defaults to True.
- **locals_hide_sunder** (Optional[bool]) - Hide locals prefixed with single underscore. Defaults to False.
- **indent_guides** (bool) - Enable indent guides in code and locals. Defaults to True.
- **suppress** (Iterable[Union[str, ModuleType]]) - Optional sequence of modules or paths to exclude from traceback.
- **max_frames** (int) - Maximum number of frames to show. Defaults to 100.

### Returns
- **Callable** - The previous exception handler that was replaced.
```

--------------------------------

### Output of print example

Source: https://rich.readthedocs.io/en/stable/introduction.html

The terminal output resulting from the print example.

```text
Hello World!
{
    '__annotations__': {},
    '__builtins__': <module 'builtins' (built-in)>,
    '__doc__': None,
    '__loader__': <class '_frozen_importlib.BuiltinImporter'>,
    '__name__': '__main__',
    '__package__': None,
    '__spec__': None,
    'print': <function print at 0x1027fd4c0>,
}
```

--------------------------------

### Run progress display demo

Source: https://rich.readthedocs.io/en/stable/_sources/progress.rst.txt

Execute the built-in progress display demonstration from the command line.

```bash
python -m rich.progress
```

--------------------------------

### Live.__init__

Source: https://rich.readthedocs.io/en/stable/_modules/rich/live.html

Initializes a new Live display instance to render auto-updating content.

```APIDOC
## Live(renderable=None, console=None, screen=False, auto_refresh=True, refresh_per_second=4, transient=False, redirect_stdout=True, redirect_stderr=True, vertical_overflow="ellipsis", get_renderable=None)

### Description
Initializes the Live display object. This class manages the rendering of a live-updating component in the terminal.

### Parameters
- **renderable** (RenderableType) - Optional - The renderable to display.
- **console** (Console) - Optional - Console instance to use.
- **screen** (bool) - Optional - Enable alternate screen mode.
- **auto_refresh** (bool) - Optional - Enable automatic refreshing.
- **refresh_per_second** (float) - Optional - Refresh frequency.
- **transient** (bool) - Optional - Clear renderable on exit.
- **redirect_stdout** (bool) - Optional - Redirect stdout.
- **redirect_stderr** (bool) - Optional - Redirect stderr.
- **vertical_overflow** (VerticalOverflowMethod) - Optional - Handling for tall renderables.
- **get_renderable** (Callable) - Optional - Callable to retrieve the renderable.
```

--------------------------------

### Start Task

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Manually starts a task, which is necessary if the task was initialized with start=False.

```python
def start_task(self, task_id: TaskID) -> None:
    """Start a task.

    Starts a task (used when calculating elapsed time). You may need to call this manually,
    if you called ``add_task`` with ``start=False``.

    Args:
        task_id (TaskID): ID of task.
    """
    with self._lock:
        task = self._tasks[task_id]
        if task.start_time is None:
            task.start_time = self.get_time()
```

--------------------------------

### Install Rich with Jupyter Support

Source: https://rich.readthedocs.io/en/stable/_sources/introduction.rst.txt

Install Rich with additional dependencies for Jupyter notebook integration.

```bash
pip install "rich[jupyter]"
```

--------------------------------

### Terminal Title Example

Source: https://rich.readthedocs.io/en/stable/_modules/rich/control.html

Example usage of setting the terminal window title within a loop.

```python
if __name__ == "__main__":  # pragma: no cover
    from rich.console import Console

    console = Console()
    console.print("Look at the title of your terminal window ^")
    # console.print(Control((ControlType.SET_WINDOW_TITLE, "Hello, world!")))
    for i in range(10):
        console.set_window_title("🚀 Loading" + "." * i)
        time.sleep(0.5)
```

--------------------------------

### Rule Usage Example

Source: https://rich.readthedocs.io/en/stable/_modules/rich/rule.html

Example usage of the Rule class within a main block to demonstrate printing rules to the console.

```python
if __name__ == "__main__":  # pragma: no cover
    import sys

    from rich.console import Console

    try:
        text = sys.argv[1]
    except IndexError:
        text = "Hello, World"
    console = Console()
    console.print(Rule(title=text))

    console = Console()
    console.print(Rule("foo"), width=4)
```

--------------------------------

### Add indentation guides

Source: https://rich.readthedocs.io/en/stable/_modules/rich/text.html

Creates a new Text object with visual indentation guides applied based on the detected or provided indentation size.

```python
    def with_indent_guides(
        self,
        indent_size: Optional[int] = None,
        *,
        character: str = "│",
        style: StyleType = "dim green",
    ) -> "Text":
        """Adds indent guide lines to text.

        Args:
            indent_size (Optional[int]): Size of indentation, or None to auto detect. Defaults to None.
            character (str, optional): Character to use for indentation. Defaults to "│".
            style (Union[Style, str], optional): Style of indent guides.

        Returns:
            Text: New text with indentation guides.
        """

        _indent_size = self.detect_indentation() if indent_size is None else indent_size

        text = self.copy()
        text.expand_tabs()
        indent_line = f"{character}{' ' * (_indent_size - 1)}"

        re_indent = re.compile(r"^( *)(.*)$")
        new_lines: List[Text] = []
        add_line = new_lines.append
        blank_lines = 0
        for line in text.split(allow_blank=True):
            match = re_indent.match(line.plain)
            if not match or not match.group(2):
                blank_lines += 1
                continue
            indent = match.group(1)
            full_indents, remaining_space = divmod(len(indent), _indent_size)
            new_indent = f"{indent_line * full_indents}{' ' * remaining_space}"
            line.plain = new_indent + line.plain[len(new_indent) :]
            line.stylize(style, 0, len(new_indent))
            if blank_lines:
                new_lines.extend([Text(new_indent, style=style)] * blank_lines)
                blank_lines = 0
            add_line(line)
        if blank_lines:
            new_lines.extend([Text("", style=style)] * blank_lines)

        new_text = text.blank_copy("\n").join(new_lines)
        return new_text
```

--------------------------------

### Status.start

Source: https://rich.readthedocs.io/en/stable/_modules/rich/status.html

Starts the status animation.

```APIDOC
## Status.start()

### Description
Starts the status animation.
```

--------------------------------

### Get shape

Source: https://rich.readthedocs.io/en/stable/_modules/rich/segment.html

Determines the width and height of a list of lines.

```python
@classmethod
def get_shape(cls, lines: List[List["Segment"]]) -> Tuple[int, int]:
    """Get the shape (enclosing rectangle) of a list of lines.

    Args:
        lines (List[List[Segment]]): A list of lines (no '\\n' characters).

    Returns:
        Tuple[int, int]: Width and height in characters.
    """
    get_line_length = cls.get_line_length
    max_width = max(get_line_length(line) for line in lines) if lines else 0
    return (max_width, len(lines))
```

--------------------------------

### Construct Tables with Columns

Source: https://rich.readthedocs.io/en/stable/_sources/tables.rst.txt

Demonstrates different ways to define columns during table initialization.

```python
table = Table("Released", "Title", "Box Office", title="Star Wars Movies")
```

```python
from rich.table import Column, Table
table = Table(
    "Released",
    "Title",
    Column(header="Box Office", justify="right"),
    title="Star Wars Movies"
)
```

--------------------------------

### Log and Print Data with Console

Source: https://rich.readthedocs.io/en/stable/_modules/rich/console.html

Demonstrates initializing a Console with recording enabled and logging various data structures including JSON-like dictionaries.

```python
if __name__ == "__main__":  # pragma: no cover
    console = Console(record=True)

    console.log(
        "JSONRPC [i]request[/i]",
        5,
        1.3,
        True,
        False,
        None,
        {
            "jsonrpc": "2.0",
            "method": "subtract",
            "params": {"minuend": 42, "subtrahend": 23},
            "id": 3,
        },
    )

    console.log("Hello, World!", "{'a': 1}", repr(console))

    console.print(
        {
            "name": None,
            "empty": [],
            "quiz": {
                "sport": {
                    "answered": True,
                    "q1": {
                        "question": "Which one is correct team name in NBA?",
                        "options": [
                            "New York Bulls",
                            "Los Angeles Kings",
                            "Golden State Warriors",
                            "Huston Rocket",
                        ],
                        "answer": "Huston Rocket",
                    },
                },
                "maths": {
                    "answered": False,
                    "q1": {
                        "question": "5 + 7 = ?",
                        "options": [10, 11, 12, 13],
                        "answer": 12,
                    },
                    "q2": {
                        "question": "12 - 8 = ?",
                        "options": [1, 2, 3, 4],
                        "answer": 4,
                    },
                },
            },
        }
    )
```

--------------------------------

### Progress.start_task

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Manually starts a task, which is useful if the task was created with start=False.

```APIDOC
## Method: start_task

### Description
Starts a task, which begins calculating elapsed time.

### Parameters
- **task_id** (TaskID) - Required - The ID of the task to start.
```

--------------------------------

### Table output example

Source: https://rich.readthedocs.io/en/stable/tables.html

The visual representation of the rendered table in the terminal.

```text
                           Star Wars Movies                           
┏━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓
┃     Released ┃ Title                             ┃     Box Office ┃
┡━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━┩
│ Dec 20, 2019 │ Star Wars: The Rise of Skywalker  │   $952,110,690 │
│ May 25, 2018 │ Solo: A Star Wars Story           │   $393,151,347 │
│ Dec 15, 2017 │ Star Wars Ep. V111: The Last Jedi │ $1,332,539,889 │
│ Dec 16, 2016 │ Rogue One: A Star Wars Story      │ $1,332,439,889 │
└──────────────┴───────────────────────────────────┴────────────────┘
```

--------------------------------

### Get Console Properties

Source: https://rich.readthedocs.io/en/stable/_modules/rich/console.html

Properties to retrieve the current color system and encoding.

```python
@property
def color_system(self) -> Optional[str]:
    """Get color system string.

    Returns:
        Optional[str]: "standard", "256" or "truecolor".
    """

    if self._color_system is not None:
        return _COLOR_SYSTEMS_NAMES[self._color_system]
    else:
        return None

@property
def encoding(self) -> str:
    """Get the encoding of the console file, e.g. ``"utf-8"``."""
```

--------------------------------

### Install Global Traceback Handler

Source: https://rich.readthedocs.io/en/stable/traceback.html

Configure Rich as the default handler for all uncaught exceptions.

```python
from rich.traceback import install
install(show_locals=True)
```

--------------------------------

### Create Basic Live Display

Source: https://rich.readthedocs.io/en/stable/_sources/live.rst.txt

Construct a Live object as a context manager to update a renderable over time.

```python
import time

from rich.live import Live
from rich.table import Table

table = Table()
table.add_column("Row ID")
table.add_column("Description")
table.add_column("Level")

with Live(table, refresh_per_second=4):  # update 4 times a second to feel fluid
    for row in range(12):
        time.sleep(0.4)  # arbitrary delay
        # update the renderable internally
        table.add_row(f"{row}", f"description {row}", "[red]ERROR")
```

--------------------------------

### Run Rich Tree Demonstration

Source: https://rich.readthedocs.io/en/stable/_sources/tree.rst.txt

Execute this command in your terminal to see a pre-built demonstration of the Rich tree view.

```bash
python -m rich.tree
```

--------------------------------

### Create Style Object and Apply

Source: https://rich.readthedocs.io/en/stable/_sources/style.rst.txt

Instantiate a Style object directly with color and attributes, then pass it to console.print.

```python
from rich.style import Style
danger_style = Style(color="red", blink=True, bold=True)
console.print("Danger, Will Robinson!", style=danger_style)
```

--------------------------------

### Initialize Layout

Source: https://rich.readthedocs.io/en/stable/layout.html

Construct and display a basic Layout object.

```python
from rich import print
from rich.layout import Layout

layout = Layout()
print(layout)
```

--------------------------------

### Rich object representation output

Source: https://rich.readthedocs.io/en/stable/_sources/pretty.rst.txt

Example of how Rich formats nested objects and collections.

```text
{
    'gull': Bird(
        'gull',
        eats=['fish', 'chips', 'ice cream', 'sausage rolls']
    ),
    'penguin': Bird('penguin', eats=['fish'], fly=False),
    'dodo': Bird('dodo', eats=['fruit'], fly=False, extinct=True)
}
```

```text
{
    'gull': Bird(
        'gull',
        eats=[
            'fish',
            'chips',
            'ice cream',
            'sausage rolls'
        ]
    ),
    'penguin': Bird(
        'penguin',
        eats=['fish'],
        fly=False
    ),
    'dodo': Bird(
        'dodo',
        eats=['fruit'],
        fly=False,
        extinct=True
    )
}
```

--------------------------------

### ProgressBar.__init__

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress_bar.html

Initializes a new ProgressBar instance with configuration for total steps, completion status, and visual styling.

```APIDOC
## ProgressBar(total=100.0, completed=0, width=None, pulse=False, style="bar.back", complete_style="bar.complete", finished_style="bar.finished", pulse_style="bar.pulse", animation_time=None)

### Description
Initializes a progress bar component. If total is set to None, the bar will render a pulsing animation.

### Parameters
- **total** (float) - Optional - Number of steps in the bar. Defaults to 100.
- **completed** (float) - Optional - Number of steps completed. Defaults to 0.
- **width** (int) - Optional - Width of the bar, or None for maximum width.
- **pulse** (bool) - Optional - Enable pulse effect. Defaults to False.
- **style** (StyleType) - Optional - Style for the bar background.
- **complete_style** (StyleType) - Optional - Style for the completed bar.
- **finished_style** (StyleType) - Optional - Style for a finished bar.
- **pulse_style** (StyleType) - Optional - Style for pulsing bars.
- **animation_time** (float) - Optional - Time in seconds to use for animation, or None to use system time.
```

--------------------------------

### Implementing Progress with Multiple Renderables

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Demonstrates configuring a Progress instance with custom columns and logging various renderables like Tables, Panels, and Syntax during task execution.

```python
    table = Table("foo", "bar", "baz")
    table.add_row("1", "2", "3")

    progress_renderables = [
        "Text may be printed while the progress bars are rendering.",
        Panel("In fact, [i]any[/i] renderable will work"),
        "Such as [magenta]tables[/]...",
        table,
        "Pretty printed structures...",
        {"type": "example", "text": "Pretty printed"},
        "Syntax...",
        syntax,
        Rule("Give it a try!"),
    ]

    from itertools import cycle

    examples = cycle(progress_renderables)

    console = Console(record=True)

    with Progress(
        SpinnerColumn(),
        *Progress.get_default_columns(),
        TimeElapsedColumn(),
        console=console,
        transient=False,
    ) as progress:
        task1 = progress.add_task("[red]Downloading", total=1000)
        task2 = progress.add_task("[green]Processing", total=1000)
        task3 = progress.add_task("[yellow]Thinking", total=None)

        while not progress.finished:
            progress.update(task1, advance=0.5)
            progress.update(task2, advance=0.3)
            time.sleep(0.01)
            if random.randint(0, 100) < 1:
                progress.log(next(examples))
```

--------------------------------

### Get Console Options

Source: https://rich.readthedocs.io/en/stable/_modules/rich/console.html

Constructs a ConsoleOptions object based on current console state.

```python
size = self.size
return ConsoleOptions(
    max_height=size.height,
    size=size,
    legacy_windows=self.legacy_windows,
    min_width=1,
    max_width=size.width,
    encoding=self.encoding,
    is_terminal=self.is_terminal,
)
```

--------------------------------

### Confirm user input

Source: https://rich.readthedocs.io/en/stable/reference/prompt.html

Use Confirm to get a boolean yes/no response from the user.

```python
>>> if Confirm.ask("Continue"):
        run_job()
```

--------------------------------

### Panel.__init__

Source: https://rich.readthedocs.io/en/stable/_modules/rich/panel.html

Initializes a new Panel instance to render content with a border.

```APIDOC
## Panel(renderable, box=ROUNDED, title=None, title_align='center', subtitle=None, subtitle_align='center', safe_box=None, expand=True, style='none', border_style='none', width=None, height=None, padding=(0, 1), highlight=False)

### Description
A console renderable that draws a border around its contents.

### Parameters
- **renderable** (RenderableType) - Required - A console renderable object.
- **box** (Box) - Optional - A Box instance that defines the look of the border. Defaults to box.ROUNDED.
- **title** (Optional[TextType]) - Optional - Optional title displayed in panel header.
- **title_align** (AlignMethod) - Optional - Alignment of title. Defaults to 'center'.
- **subtitle** (Optional[TextType]) - Optional - Optional subtitle displayed in panel footer.
- **subtitle_align** (AlignMethod) - Optional - Alignment of subtitle. Defaults to 'center'.
- **safe_box** (bool) - Optional - Disable box characters that don't display on windows legacy terminal with raster fonts. Defaults to True.
- **expand** (bool) - Optional - If True the panel will stretch to fill the console width, otherwise it will be sized to fit the contents. Defaults to True.
- **style** (str) - Optional - The style of the panel (border and contents). Defaults to 'none'.
- **border_style** (str) - Optional - The style of the border. Defaults to 'none'.
- **width** (Optional[int]) - Optional - Optional width of panel. Defaults to None to auto-detect.
- **height** (Optional[int]) - Optional - Optional height of panel. Defaults to None to auto-detect.
- **padding** (Optional[PaddingDimensions]) - Optional - Optional padding around renderable. Defaults to 0.
- **highlight** (bool) - Optional - Enable automatic highlighting of panel title (if str). Defaults to False.
```

--------------------------------

### Get Default Color

Source: https://rich.readthedocs.io/en/stable/_modules/rich/color.html

Returns a Color instance representing the default terminal color.

```python
@classmethod
def default(cls) -> "Color":
    """Get a Color instance representing the default color.

    Returns:
        Color: Default color.
    """
    return cls(name="default", type=ColorType.DEFAULT)
```

--------------------------------

### Get Named Layout

Source: https://rich.readthedocs.io/en/stable/_modules/rich/layout.html

Retrieves a child layout by name, returning None if not found.

```python
    def get(self, name: str) -> Optional["Layout"]:
        """Get a named layout, or None if it doesn't exist.

        Args:
            name (str): Name of layout.

        Returns:
            Optional[Layout]: Layout instance or None if no layout was found.
        """
        if self.name == name:
            return self
        else:
            for child in self._children:
                named_layout = child.get(name)
                if named_layout is not None:
                    return named_layout
        return None
```

--------------------------------

### Get Level Text

Source: https://rich.readthedocs.io/en/stable/_modules/rich/logging.html

Formats the log level name into a styled Text object.

```python
    def get_level_text(self, record: LogRecord) -> Text:
        """Get the level name from the record.

        Args:
            record (LogRecord): LogRecord instance.

        Returns:
            Text: A tuple of the style and level name.
        """
        level_name = record.levelname
        level_text = Text.styled(
            level_name.ljust(8), f"logging.level.{level_name.lower()}"
        )
        return level_text
```

--------------------------------

### Initialize Progress with Custom Columns

Source: https://rich.readthedocs.io/en/stable/_modules/rich/progress.html

Demonstrates how to instantiate a Progress object by combining custom columns with the default column set.

```python
progress = Progress(
    SpinnerColumn(),
    *Progress.get_default_columns(),
    "Elapsed:",
    TimeElapsedColumn(),
)
```

--------------------------------

### Render a basic table with Rich

Source: https://rich.readthedocs.io/en/stable/_sources/tables.rst.txt

Construct a Table object, define columns, add rows, and print to the console.

```python
from rich.console import Console
from rich.table import Table

table = Table(title="Star Wars Movies")

table.add_column("Released", justify="right", style="cyan", no_wrap=True)
table.add_column("Title", style="magenta")
table.add_column("Box Office", justify="right", style="green")

table.add_row("Dec 20, 2019", "Star Wars: The Rise of Skywalker", "$952,110,690")
table.add_row("May 25, 2018", "Solo: A Star Wars Story", "$393,151,347")
table.add_row("Dec 15, 2017", "Star Wars Ep. V111: The Last Jedi", "$1,332,539,889")
table.add_row("Dec 16, 2016", "Rogue One: A Star Wars Story", "$1,332,439,889")

console = Console()
console.print(table)
```

--------------------------------

### Syntax Highlighting from Path

Source: https://rich.readthedocs.io/en/stable/_sources/syntax.rst.txt

Use the from_path constructor to load code from disk and auto-detect the file type.

```python
from rich.console import Console
from rich.syntax import Syntax

console = Console()
syntax = Syntax.from_path("syntax.py")
console.print(syntax)
```

--------------------------------

### Capture Console Output

Source: https://rich.readthedocs.io/en/stable/_modules/rich/console.html

Methods to start and end output capture, returning the captured string.

```python
def begin_capture(self) -> None:
    """Begin capturing console output. Call :meth:`end_capture` to exit capture mode and return output."""
    self._enter_buffer()

def end_capture(self) -> str:
    """End capture mode and return captured string.

    Returns:
        str: Console output.
    """
    render_result = self._render_buffer(self._buffer)
    del self._buffer[:]
    self._exit_buffer()
    return render_result
```

--------------------------------

### Run Rich Traceback Module

Source: https://rich.readthedocs.io/en/stable/_sources/traceback.rst.txt

Execute this command in your terminal to see an example of a Rich traceback.

```bash
python -m rich.traceback
```

--------------------------------

### Define and apply a Theme

Source: https://rich.readthedocs.io/en/stable/style.html

Create a Theme instance to define semantic styles and pass it to the Console constructor.

```python
from rich.console import Console
from rich.theme import Theme
custom_theme = Theme({
    "info": "dim cyan",
    "warning": "magenta",
    "danger": "bold red"
})
console = Console(theme=custom_theme)
console.print("This is information", style="info")
console.print("[warning]The pod bay doors are locked[/warning]")
console.print("Something terrible happened!", style="danger")
```

--------------------------------

### Basic script entry point

Source: https://rich.readthedocs.io/en/stable/_modules/rich.html

A simple main block demonstrating basic console output.

```python
if __name__ == "__main__":  # pragma: no cover
    print("Hello, **World**")
```
Tokens:
Raw