Allow Live to stop without emitting a final newline

[darlingm]

Allow Live to stop without emitting a final newline

Summary

Live.stop() currently emits a final newline after the last refresh when the live render has a height:

if (
    not self._alt_screen
    and self.console.is_terminal
    and self._live_render.last_render_height
):
    self.console.line()

That default is useful for most CLIs because subsequent output starts below the live display. Some CLIs, however, intentionally reserve and manage their own trailing line so the shell prompt can land there without causing the table/display to scroll at program exit.

Proposal

Add a final_newline: bool = True option to Live.

• True keeps the current behavior.
• False suppresses the final console.line() in Live.stop().
• The option has no effect on normal refresh behavior; it only affects stop/finalization.

Use case

A live table can reserve a prompt landing line below itself, backfill/update in place, and then leave the cursor on that existing line. Without an opt-out, Rich’s final newline can create an extra line at stop time and scroll the table even though the application has already reserved space.

Demo

The following short demo script can be run with or without the proposed implementation. By default, it displays a small live table, simulates the table updating for a moment, and then closes. With current Rich behavior, the final newline can make the table scroll by one line as the program exits.

On the prepared branch linked below, run the same script with --final-newline false to see the display stop without Rich adding that final newline.

This is not a big deal for interactive programs where the user explicitly quits the live display. It is more noticeable for slow-updating output that automatically closes, because the display can move while someone is still reading it.

live_final_newline_demo.py

"""Demo for Rich Live's optional final newline behavior.

Run with released Rich:

    python live_final_newline_demo.py

Run with the patched Rich branch:

    python live_final_newline_demo.py --final-newline false

The program intentionally prints nothing after the Live display exits. The
observable behavior is where the shell prompt appears after the final table.
"""

from __future__ import annotations

import argparse
import inspect
from time import sleep

from rich.console import Console, Group
from rich.live import Live
from rich.table import Table
from rich.text import Text


def build_table(phase: str, final_newline: str, supported: bool) -> Table:
    table = Table(title="Live final newline demo")
    table.add_column("Field")
    table.add_column("Value")
    table.add_row("phase", phase)
    table.add_row("final_newline", final_newline)
    table.add_row("supported", "yes" if supported else "no")
    return table


def build_renderable(phase: str, final_newline: str, supported: bool) -> Group:
    return Group(build_table(phase, final_newline, supported), Text(""))


def supports_final_newline() -> bool:
    return "final_newline" in inspect.signature(Live).parameters


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Display a short Live table, update it once, and exit without printing after the table.",
    )
    parser.add_argument(
        "--final-newline",
        choices=("default", "true", "false"),
        default="default",
        help=(
            "Live final newline mode. 'default' passes no argument and works on released Rich; "
            "'false' demonstrates the patched behavior when supported."
        ),
    )
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    console = Console()
    supported = supports_final_newline()
    final_newline_label = args.final_newline

    live_options = {
        "console": console,
        "refresh_per_second": 12,
        "transient": False,
    }
    if args.final_newline != "default":
        if supported:
            live_options["final_newline"] = args.final_newline == "true"
        else:
            final_newline_label = f"{args.final_newline} requested, unsupported"

    with Live(build_renderable("initial", final_newline_label, supported), **live_options) as live:
        sleep(1)
        live.update(build_renderable("updated", final_newline_label, supported), refresh=True)

    if console.is_terminal:
        console.file.write("\r\x1b[2K")
        console.file.flush()

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Compatibility

This would be backward compatible because the default remains True.

Prepared branch

I have a small implementation ready on my fork:

https://github.com/darlingm/rich/tree/feature/live/optional-final-newline

If this approach is approved, I am ready to open an issue and a pull request that addresses it.

AI disclosure

This discussion text was drafted with OpenAI Codex.

[willmcgugan]

Please write this in your own words. Otherwise I'll assume it's not important to you.