Narrow Screen.refresh(Region) can discard another widget's repaint #6723

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.13,<3.14"
# dependencies = ["textual==8.2.8", "rich==15.0.0"]
# ///
"""Reproduce a persistent split scroll row with public Textual APIs.

Run `uv run textual_partial_refresh_repro.py` in a terminal, then press c.
The left and right marker numbers on each row should match. Press f to
repair the display. Run with --full-rows as a control: pressing c then
leaves all rows aligned.

This program uses only Textual and Rich. It has no worker thread, background
screen, private Textual calls, network access, or subprocesses.
"""

from __future__ import annotations

import argparse

from rich.segment import Segment
from rich.style import Style
from textual.app import App, ComposeResult
from textual.binding import Binding
from textual.containers import Vertical
from textual.geometry import Region, Size
from textual.screen import ModalScreen
from textual.scroll_view import ScrollView
from textual.strip import Strip
from textual.widgets import Static


def content(rows: int = 500) -> list[Strip]:
    """Put a row number on both sides of the expected repaint boundary."""
    strips = []
    for number in range(rows):
        letter = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[number % 32]
        line = list((" " if number % 3 == 2 else letter) * 128)
        for column in (0, 48, 64, 112):
            marker = f"[{number:04d}:{letter}]"
            line[column:column + len(marker)] = marker
        strips.append(Strip([Segment("".join(line), Style())]))
    return strips


class Reader(ScrollView):
    can_focus = True

    def __init__(self) -> None:
        super().__init__(id="reader")
        self.lines = content()

    def on_mount(self) -> None:
        self.virtual_size = Size(128, len(self.lines))

    def render_line(self, y: int) -> Strip:
        width = self.scrollable_content_region.width
        index = y + self.scroll_offset.y
        if index >= len(self.lines):
            return Strip.blank(width, Style())
        return self.lines[index].crop(
            self.scroll_offset.x, self.scroll_offset.x + width,
        ).extend_cell_length(width, Style())


class ReaderScreen(ModalScreen):
    BINDINGS = [
        Binding("c", "collision", "Trigger split"),
        Binding("f", "redraw", "Redraw"),
        Binding("q", "quit", "Quit"),
    ]

    def compose(self) -> ComposeResult:
        with Vertical(id="dialog"):
            yield Static("c: trigger split | f: redraw | q: quit")
            yield Reader()

    def on_mount(self) -> None:
        self.query_one(Reader).focus()

    def action_collision(self) -> None:
        reader = self.query_one(Reader)
        reader.scroll_to(y=4, animate=False, immediate=True)
        self.set_timer(0.25, self._finish_collision)

    def _finish_collision(self) -> None:
        reader = self.query_one(Reader)
        reader.scroll_to(y=0, animate=False, immediate=True)
        region = (Region(0, reader.region.y, self.size.width, reader.region.height)
                  if self.app.full_rows else Region(2, reader.region.y,
                      self.size.width // 2 - 2, reader.region.height))
        reader.call_later(self.refresh, region)

    def action_redraw(self) -> None:
        self.app.refresh(layout=True)

    def action_quit(self) -> None:
        self.app.exit()


class ReproApp(App):
    CSS = """
    ReaderScreen { align: center middle; background: $background 60%; }
    #dialog { width: 96%; height: 92%; border: heavy $primary;
        background: $surface; padding: 1 2; }
    #reader { height: 1fr; }
    """

    def __init__(self, *, full_rows: bool) -> None:
        super().__init__()
        self.full_rows = full_rows

    def on_mount(self) -> None:
        self.push_screen(ReaderScreen())


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--full-rows", action="store_true")
    args = parser.parse_args()
    ReproApp(full_rows=args.full_rows).run()


if __name__ == "__main__":
    main()