Refactor content cropping and line width calculation for improved handling of tab and double-width characters

Author: sveinugu

src/omnipy/data/_display/helpers.py

@@ -1,4 +1,5 @@
 from rich._cell_widths import CELL_WIDTHS
+from rich.cells import _is_single_cell_widths
 
 from omnipy.util.range_lookup import RangeLookup
 
@@ -26,6 +27,14 @@ def __getitem__(self, char: str) -> int:
             return 2
         return 1
 
+    @staticmethod
+    def only_single_width_chars(line: str) -> bool:
+        return _is_single_cell_widths(line)
+
+    def __hash__(self) -> int:
+        # No state, so we can use a constant hash
+        return hash('UnicodeCharWidthMap')
+
 
 def soft_wrap_words(words: list[str], max_width: int) -> list[str]:
     """Wrap words into lines that don't exceed max_width.

src/omnipy/data/_display/panel/base.py

@@ -4,7 +4,11 @@
 
 from typing_extensions import TypeIs, TypeVar
 
-from omnipy.data._display.dimensions import Dimensions, DimensionsFit
+from omnipy.data._display.dimensions import (Dimensions,
+                                             DimensionsFit,
+                                             DimensionsWithWidthAndHeight,
+                                             has_height,
+                                             has_width)
 from omnipy.data._display.frame import AnyFrame, empty_frame, Frame
 import omnipy.util._pydantic as pyd
 
@@ -70,12 +74,37 @@ def panel_is_fully_rendered(panel: 'Panel') -> TypeIs['FullyRenderedPanel']:
     return isinstance(panel, FullyRenderedPanel)
 
 
+def dims_if_cropped(
+    dims: DimensionsWithWidthAndHeight,
+    frame: AnyFrame,
+) -> DimensionsWithWidthAndHeight:
+    if has_width(frame.dims):
+        cropped_width = min(frame.dims.width, dims.width)
+    else:
+        cropped_width = dims.width
+
+    if has_height(frame.dims):
+        cropped_height = min(frame.dims.height, dims.height)
+    else:
+        cropped_height = dims.height
+
+    return Dimensions(width=cropped_width, height=cropped_height)
+
+
 class DimensionsAwarePanel(Panel[FrameT], Generic[FrameT]):
     @cached_property
     @abstractmethod
     def dims(self) -> Dimensions[pyd.NonNegativeInt, pyd.NonNegativeInt]:
         ...
 
+    @cached_property
+    def dims_if_cropped(self,) -> DimensionsWithWidthAndHeight:
+        """
+        Returns the dimensions of the panel, cropped to fit within the
+        frame dimensions.
+        """
+        return dims_if_cropped(self.dims, self.frame)
+
     @cached_property
     def within_frame(self) -> DimensionsFit:
         return DimensionsFit(self.dims, self.frame.dims)

src/omnipy/data/_display/panel/draft/layout.py

@@ -182,18 +182,7 @@ def _priority(
     @cache
     def _panel_dims_if_cropped(
             panel: DimensionsAwarePanel[AnyFrame]) -> DimensionsWithWidthAndHeight:
-
-        if has_width(panel.frame.dims):
-            cropped_width = min(panel.frame.dims.width, panel.dims.width)
-        else:
-            cropped_width = panel.dims.width
-
-        if has_height(panel.frame.dims):
-            cropped_height = min(panel.frame.dims.height, panel.dims.height)
-        else:
-            cropped_height = panel.dims.height
-
-        return Dimensions(width=cropped_width, height=cropped_height)
+        return panel.dims_if_cropped
 
     @staticmethod
     @cache

src/omnipy/data/_display/panel/draft/monospaced.py

@@ -1,8 +1,10 @@
 from abc import ABC, abstractmethod
-from functools import cached_property
+from dataclasses import dataclass
+from functools import cached_property, lru_cache
 from typing import ClassVar, Generic
 
-from omnipy.data._display.dimensions import Dimensions, has_width_and_height
+from omnipy.data._display.config import HorizontalOverflowMode, OutputConfig
+from omnipy.data._display.dimensions import Dimensions, has_width, has_width_and_height
 from omnipy.data._display.frame import AnyFrame
 from omnipy.data._display.helpers import UnicodeCharWidthMap
 from omnipy.data._display.panel.base import DimensionsAwarePanel, FrameT
@@ -25,19 +27,17 @@ class MonospacedDraftPanel(
     def _content_lines(self) -> list[str]:
         ...
 
+    def _line_width(self, line):
+        stats = _calc_line_stats(
+            line,
+            self.config.tab_size,
+            self._char_width_map,
+        )
+        return stats.line_width
+
     @cached_property
     def _width(self) -> pyd.NonNegativeInt:
-        def _line_len(line: str) -> int:
-            tab_size = self.config.tab_size
-            line_len = 0
-            for c in line:
-                if c == '\t':
-                    line_len += tab_size - (line_len % tab_size)
-                else:
-                    line_len += self._char_width_map[c]
-            return line_len
-
-        return max((_line_len(line) for line in self._content_lines), default=0)
+        return max((self._line_width(line) for line in self._content_lines), default=0)
 
     @cached_property
     def _height(self) -> pyd.NonNegativeInt:
@@ -48,6 +48,47 @@ def dims(self) -> Dimensions[pyd.NonNegativeInt, pyd.NonNegativeInt]:
         return Dimensions(width=self._width, height=self._height)
 
 
+@dataclass
+class LineStats:
+    line_width: pyd.NonNegativeInt = 0
+    char_count: pyd.NonNegativeInt = 0
+    overflow: bool = False
+
+    def register_char(self, char_width: pyd.NonNegativeInt):
+        self.line_width += char_width
+        self.char_count += 1
+
+
+@lru_cache(maxsize=4096)
+def _calc_line_stats(
+    line: str,
+    tab_size: int,
+    char_width_map: UnicodeCharWidthMap,
+    width_limit: pyd.NonNegativeInt | None = None,
+) -> LineStats:
+    if char_width_map.only_single_width_chars(line):
+        return LineStats(
+            line_width=len(line),
+            char_count=len(line),
+        )
+    else:
+        stats = LineStats()
+        for ch in line:
+            if ch == '\t':
+                char_width = tab_size - (stats.line_width % tab_size)
+            else:
+                char_width = char_width_map[ch]
+
+            if width_limit is not None:
+                if stats.line_width + char_width > width_limit:
+                    stats.overflow = True
+                    return stats
+
+            stats.register_char(char_width)
+
+        return stats
+
+
 def crop_content_lines_for_resizing(
     all_content_lines: list[str],
     frame: AnyFrame,
@@ -71,3 +112,39 @@ def crop_content_lines_for_resizing(
         return all_content_lines[:frame.dims.height]
 
     return all_content_lines
+
+
+def crop_content_with_extra_wide_chars(
+    all_content_lines: list[str],
+    frame: AnyFrame,
+    config: OutputConfig,
+    char_width_map: UnicodeCharWidthMap,
+) -> list[str]:
+    if has_width(frame.dims) \
+            and frame.fixed_width is False \
+            and frame.dims.width > 0:
+
+        ellipsis_if_overflow = config.horizontal_overflow_mode == HorizontalOverflowMode.ELLIPSIS
+
+        for i, line in enumerate(all_content_lines):
+            stats = _calc_line_stats(
+                line,
+                config.tab_size,
+                char_width_map,
+                width_limit=frame.dims.width,
+            )
+
+            cropped_line = line[:stats.char_count]
+
+            if stats.overflow and ellipsis_if_overflow:
+                if stats.line_width == frame.dims.width > 0:
+                    # Exactly at the limit, must remove the last character
+                    # to have space for the ellipsis
+                    cropped_line = cropped_line[:-1]
+                cropped_line += '…'
+
+            cropped_line = cropped_line.rstrip('\t')
+
+            all_content_lines[i] = cropped_line
+
+    return all_content_lines

src/omnipy/data/_display/panel/draft/text.py

@@ -1,11 +1,11 @@
 from functools import cached_property
 import re
-from typing import ClassVar, Generic
+from typing import Generic
 
 from omnipy.data._display.constraints import ConstraintsSatisfaction
-from omnipy.data._display.helpers import UnicodeCharWidthMap
 from omnipy.data._display.panel.base import FrameT, FullyRenderedPanel
 from omnipy.data._display.panel.draft.monospaced import (crop_content_lines_for_resizing,
+                                                         crop_content_with_extra_wide_chars,
                                                          MonospacedDraftPanel)
 import omnipy.util._pydantic as pyd
 
@@ -16,16 +16,20 @@ class ReflowedTextDraftPanel(
         MonospacedDraftPanel[str, FrameT],
         Generic[FrameT],
 ):
-    _char_width_map: ClassVar[UnicodeCharWidthMap] = UnicodeCharWidthMap()
-
     @cached_property
     def _content_lines(self) -> list[str]:
         # Typical repr output should not end with newline. Hence, a regular split on newline is
         # correct behaviour. An empty string is the split into a list of one element. If
         # splitlines() had been used, the list would be empty.
         all_content_lines = self.content.split('\n')
-
-        return crop_content_lines_for_resizing(all_content_lines, self.frame)
+        all_content_lines = crop_content_lines_for_resizing(all_content_lines, self.frame)
+        all_content_lines = crop_content_with_extra_wide_chars(
+            all_content_lines,
+            self.frame,
+            self.config,
+            self._char_width_map,
+        )
+        return all_content_lines
 
     @cached_property
     def max_container_width_across_lines(self) -> pyd.NonNegativeInt:

src/omnipy/data/_display/panel/styling/base.py

@@ -17,11 +17,8 @@
 from typing_extensions import override, TypeVar
 
 from omnipy.data._display.config import ConsoleColorSystem, HorizontalOverflowMode
-from omnipy.data._display.dimensions import (Dimensions,
-                                             DimensionsWithWidthAndHeight,
-                                             has_height,
-                                             has_width)
-from omnipy.data._display.panel.base import FullyRenderedPanel, OutputVariant
+from omnipy.data._display.dimensions import Dimensions, DimensionsWithWidthAndHeight
+from omnipy.data._display.panel.base import dims_if_cropped, FullyRenderedPanel, OutputVariant
 from omnipy.data._display.panel.draft.base import ContentT, FrameT
 from omnipy.data._display.panel.draft.monospaced import MonospacedDraftPanel
 import omnipy.util._pydantic as pyd
@@ -42,19 +39,19 @@ class StylizedMonospacedPanel(
         Generic[PanelT, ContentT, FrameT],
         ABC,
 ):
-    # TODO: Return to _panel_calculated_dims when Pydantic 2.0 is released
+    # TODO: Return to _input_panel_dims_if_cropped when Pydantic 2.0 is released
     #
     # Pydantic 1.10 emits a RuntimeWarning for dataclasses with private
     # fields (starting with '_')
     # See https://github.com/pydantic/pydantic/issues/2816
-    # _panel_calculated_dims: DimensionsWithWidthAndHeight = Dimensions(width=0, height=0)
+    # _input_panel_dims_if_croppeds: DimensionsWithWidthAndHeight = Dimensions(width=0, height=0)
 
-    panel_calculated_dims: DimensionsWithWidthAndHeight = Dimensions(width=0, height=0)
+    input_panel_dims_if_cropped: DimensionsWithWidthAndHeight = Dimensions(width=0, height=0)
 
     def __init__(self, panel: MonospacedDraftPanel[ContentT, FrameT]):
         super().__init__(panel.content, panel.frame, panel.constraints, panel.config)
-        # object.__setattr__(self, '_panel_calculated_dims', panel.dims)
-        object.__setattr__(self, 'panel_calculated_dims', panel.dims)
+        # object.__setattr__(self, '_input_panel_dims_if_cropped', panel.dims_if_cropped)
+        object.__setattr__(self, 'input_panel_dims_if_cropped', panel.dims_if_cropped)
 
     @staticmethod
     def _clean_rich_style_caches():
@@ -98,23 +95,16 @@ def _stylized_content_html_impl(self) -> StylizedRichTypes:
 
     @cached_property
     def _console_dimensions(self) -> DimensionsWithWidthAndHeight:
-        frame_dims = self.frame.dims
-        panel_dims = self.panel_calculated_dims
-
-        console_width = frame_dims.width if has_width(frame_dims) else panel_dims.width
-        console_height = frame_dims.height if has_height(frame_dims) else panel_dims.height
-
-        return self._apply_console_newline_hack(
-            Dimensions(width=console_width, height=console_height))
+        input_panel_dims = self.input_panel_dims_if_cropped
+        return self._apply_console_newline_hack(dims_if_cropped(input_panel_dims, self.frame))
 
     def _apply_console_newline_hack(
             self, console_dims: DimensionsWithWidthAndHeight) -> DimensionsWithWidthAndHeight:
         """
         Hack to allow rich.console to output newline contents when
         width == 0
         """
-        panel_dims = self.panel_calculated_dims
-        if panel_dims.width == 0 and console_dims.width == 0 and console_dims.height > 0:
+        if console_dims.width == 0 and console_dims.height > 0:
             return Dimensions(width=1, height=console_dims.height)
 
         return console_dims
@@ -183,7 +173,6 @@ def _console_html(self) -> rich.console.Console:
     def _content_lines(self) -> list[str]:
         """
         Returns the plain terminal output of the panel as a list of lines.
-        Here, as compared to output should end with a
         """
         return self.plain.terminal.splitlines()