Extract _pyrepl content and layout helpers

Add structured prompt, content, and wrapped-row helpers for screen calculation.
Move reader layout bookkeeping onto those helpers before styling changes arrive.

Author: pablogsal

Lib/_pyrepl/completing_reader.py

@@ -263,20 +263,11 @@ def after_command(self, cmd: Command) -> None:
     def calc_screen(self) -> RenderedScreen:
         rendered_screen = super().calc_screen()
         if self.cmpltn_menu_visible:
-            # We display the completions menu below the current prompt
-            ly = self.lxy[1] + 1
-            render_lines = list(rendered_screen.lines)
-            render_lines[ly:ly] = [
-                RenderLine.from_rendered_text(line) for line in self.cmpltn_menu
-            ]
-            rendered_screen = RenderedScreen(tuple(render_lines), self.cxy)
+            rendered_screen = rendered_screen.with_overlay(
+                self.lxy[1] + 1,
+                (RenderLine.from_rendered_text(line) for line in self.cmpltn_menu),
+            )
             self.rendered_screen = rendered_screen
-            # If we're not in the middle of multiline edit, don't append to screeninfo
-            # since that screws up the position calculation in pos2xy function.
-            # This is a hack to prevent the cursor jumping
-            # into the completions menu when pressing left or down arrow.
-            if self.pos != len(self.buffer):
-                self.screeninfo[ly:ly] = [(0, [])]*len(self.cmpltn_menu)
         return rendered_screen
 
     def finish(self) -> None:

Lib/_pyrepl/console.py

@@ -102,7 +102,7 @@ def sync_rendered_screen(
         self._rendered_screen = rendered_screen
         trace(
             "console.sync_rendered_screen lines={lines} cursor={cursor}",
-            lines=len(rendered_screen.lines),
+            lines=len(rendered_screen.composed_lines),
             cursor=posxy,
         )
 
@@ -125,12 +125,6 @@ def begin_redraw_visualization(self) -> str | None:
         )
         return style
 
-    @staticmethod
-    def visualize_redraw_text(text: str, style: str | None) -> str:
-        if style is None or not text:
-            return text
-        return style + text.replace("\x1b[0m", "\x1b[0m" + style) + "\x1b[0m"
-
     @abstractmethod
     def refresh(self, rendered_screen: RenderedScreen) -> None: ...
 

Lib/_pyrepl/content.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .utils import ColorSpan, disp_str, unbracket, wlen
+
+
+@dataclass(frozen=True, slots=True)
+class ContentFragment:
+    text: str
+    width: int
+
+
+@dataclass(frozen=True, slots=True)
+class PromptContent:
+    leading_lines: tuple[ContentFragment, ...]
+    text: str
+    width: int
+
+
+@dataclass(frozen=True, slots=True)
+class SourceLine:
+    lineno: int
+    text: str
+    start_offset: int
+    has_newline: bool
+    cursor_index: int | None = None
+
+    @property
+    def cursor_on_line(self) -> bool:
+        return self.cursor_index is not None
+
+
+@dataclass(frozen=True, slots=True)
+class ContentLine:
+    source: SourceLine
+    prompt: PromptContent
+    body: tuple[ContentFragment, ...]
+
+
+def process_prompt(prompt: str) -> PromptContent:
+    r"""Return prompt content with width measured without zero-width markup."""
+
+    prompt_text = unbracket(prompt, including_content=False)
+    visible_prompt = unbracket(prompt, including_content=True)
+    leading_lines: list[ContentFragment] = []
+
+    while "\n" in prompt_text:
+        leading_text, _, prompt_text = prompt_text.partition("\n")
+        visible_leading, _, visible_prompt = visible_prompt.partition("\n")
+        leading_lines.append(ContentFragment(leading_text, wlen(visible_leading)))
+
+    return PromptContent(tuple(leading_lines), prompt_text, wlen(visible_prompt))
+
+
+def build_body_fragments(
+    buffer: str,
+    colors: list[ColorSpan] | None,
+    start_index: int,
+) -> tuple[ContentFragment, ...]:
+    chars, char_widths = disp_str(buffer, colors, start_index)
+    return tuple(
+        ContentFragment(text, width)
+        for text, width in zip(chars, char_widths)
+    )

Lib/_pyrepl/layout.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .content import ContentFragment, ContentLine
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutRow:
+    prompt_width: int
+    char_widths: tuple[int, ...]
+    suffix_width: int = 0
+    buffer_advance: int = 0
+
+    @property
+    def width(self) -> int:
+        return self.prompt_width + sum(self.char_widths) + self.suffix_width
+
+    @property
+    def screeninfo(self) -> tuple[int, list[int]]:
+        widths = list(self.char_widths)
+        if self.suffix_width:
+            widths.append(self.suffix_width)
+        return self.prompt_width, widths
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutMap:
+    rows: tuple[LayoutRow, ...]
+
+    @classmethod
+    def empty(cls) -> LayoutMap:
+        return cls((LayoutRow(0, ()),))
+
+    @property
+    def screeninfo(self) -> list[tuple[int, list[int]]]:
+        return [row.screeninfo for row in self.rows]
+
+    def max_column(self, y: int) -> int:
+        return self.rows[y].width
+
+    def max_row(self) -> int:
+        return len(self.rows) - 1
+
+    def pos_to_xy(self, pos: int) -> tuple[int, int]:
+        if not self.rows:
+            return 0, 0
+
+        remaining = pos
+        for y, row in enumerate(self.rows):
+            if remaining <= len(row.char_widths):
+                x = row.prompt_width
+                for width in row.char_widths[:remaining]:
+                    x += width
+                return x, y
+            remaining -= row.buffer_advance
+        last_row = self.rows[-1]
+        return last_row.width - last_row.suffix_width, len(self.rows) - 1
+
+    def xy_to_pos(self, x: int, y: int) -> int:
+        pos = 0
+        for row in self.rows[:y]:
+            pos += row.buffer_advance
+
+        row = self.rows[y]
+        cur_x = row.prompt_width
+        for width in row.char_widths:
+            if cur_x >= x:
+                break
+            if width == 0:
+                pos += 1
+                continue
+            cur_x += width
+            pos += 1
+        return pos
+
+
+@dataclass(frozen=True, slots=True)
+class WrappedRow:
+    prompt_text: str = ""
+    prompt_width: int = 0
+    fragments: tuple[ContentFragment, ...] = ()
+    layout_widths: tuple[int, ...] = ()
+    suffix: str = ""
+    suffix_width: int = 0
+    buffer_advance: int = 0
+    line_end_offset: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutResult:
+    wrapped_rows: tuple[WrappedRow, ...]
+    layout_map: LayoutMap
+    line_end_offsets: tuple[int, ...]
+
+
+def layout_content_lines(
+    lines: tuple[ContentLine, ...],
+    width: int,
+    start_offset: int,
+) -> LayoutResult:
+    offset = start_offset
+    wrapped_rows: list[WrappedRow] = []
+    layout_rows: list[LayoutRow] = []
+    line_end_offsets: list[int] = []
+
+    for line in lines:
+        for leading in line.prompt.leading_lines:
+            line_end_offsets.append(offset)
+            wrapped_rows.append(
+                WrappedRow(
+                    fragments=(leading,),
+                    line_end_offset=offset,
+                )
+            )
+            layout_rows.append(LayoutRow(0, (), buffer_advance=0))
+
+        prompt_text = line.prompt.text
+        prompt_width = line.prompt.width
+        remaining = list(line.body)
+        remaining_widths = [fragment.width for fragment in remaining]
+
+        if not remaining_widths or (sum(remaining_widths) + prompt_width) // width == 0:
+            offset += len(remaining) + (1 if line.source.has_newline else 0)
+            line_end_offsets.append(offset)
+            wrapped_rows.append(
+                WrappedRow(
+                    prompt_text=prompt_text,
+                    prompt_width=prompt_width,
+                    fragments=tuple(remaining),
+                    layout_widths=tuple(remaining_widths),
+                    buffer_advance=len(remaining) + (1 if line.source.has_newline else 0),
+                    line_end_offset=offset,
+                )
+            )
+            layout_rows.append(
+                LayoutRow(
+                    prompt_width,
+                    tuple(remaining_widths),
+                    buffer_advance=len(remaining) + (1 if line.source.has_newline else 0),
+                )
+            )
+            continue
+
+        current_prompt = prompt_text
+        current_prompt_width = prompt_width
+        while True:
+            index_to_wrap_before = 0
+            column = 0
+            for char_width in remaining_widths:
+                if column + char_width + current_prompt_width >= width:
+                    break
+                index_to_wrap_before += 1
+                column += char_width
+
+            at_line_end = len(remaining) <= index_to_wrap_before
+            if at_line_end:
+                offset += index_to_wrap_before + (1 if line.source.has_newline else 0)
+                suffix = ""
+                suffix_width = 0
+                buffer_advance = index_to_wrap_before + (1 if line.source.has_newline else 0)
+            else:
+                offset += index_to_wrap_before
+                suffix = "\\"
+                suffix_width = 1
+                buffer_advance = index_to_wrap_before
+
+            row_fragments = tuple(remaining[:index_to_wrap_before])
+            row_widths = tuple(remaining_widths[:index_to_wrap_before])
+            line_end_offsets.append(offset)
+            wrapped_rows.append(
+                WrappedRow(
+                    prompt_text=current_prompt,
+                    prompt_width=current_prompt_width,
+                    fragments=row_fragments,
+                    layout_widths=row_widths,
+                    suffix=suffix,
+                    suffix_width=suffix_width,
+                    buffer_advance=buffer_advance,
+                    line_end_offset=offset,
+                )
+            )
+            layout_rows.append(
+                LayoutRow(
+                    current_prompt_width,
+                    row_widths,
+                    suffix_width=suffix_width,
+                    buffer_advance=buffer_advance,
+                )
+            )
+
+            remaining = remaining[index_to_wrap_before:]
+            remaining_widths = remaining_widths[index_to_wrap_before:]
+            current_prompt = ""
+            current_prompt_width = 0
+            if at_line_end:
+                break
+
+    return LayoutResult(
+        tuple(wrapped_rows),
+        LayoutMap(tuple(layout_rows)),
+        tuple(line_end_offsets),
+    )